Yes, you can do that. With Feign, we usually declare our interface with the method returning our class and Feign will automatically de-serialise the response from JSON into our POJO.

Here is the interface (operation):

@FeignClient(name = "library-book-service")
@RequestMapping("books")
public interface BookClient {

    @GetMapping
    public List<Book> getBooks(
        @RequestParam("page") Integer pageNum,
        @RequestParam("size") Integer pageSize,
        @RequestParam("reader") Long readerId);
}

And then you can use the feign client like this:

@Service
@RequiredArgsConstructor
public class BookService {
    private final @NonNull BookClient bookClient;

    public List<Book> retrieveBooks(
        Integer pageNum, 
        Integer pageSize, 
        Long readerId) {

            return bookClient.getBooks(pageNum, pageSize, readerId);
    }

However, in order to have access to the response headers, you need to declare your methods to return feign.Response.

import feign.Response;

@FeignClient(name = "library-book-service")
@RequestMapping("books")
public interface BookClient {

    @GetMapping
    public Response getBooks(
        @RequestParam("page") Integer pageNum,
        @RequestParam("size") Integer pageSize,
        @RequestParam("reader") Long readerId);
}

This way you can have access to the response body and headers:

@Service
@RequiredArgsConstructor
public class BookService {
    private final @NonNull BookClient bookClient;
    private final @NonNull ObjectMapper objectMapper;

    public List<Book> retrieveBooks(
        Integer pageNum, 
        Integer pageSize, 
        Long readerId) {

          var response = bookClient.getBooks(pageNum, pageSize, readerId);
          if (response == null) {
            return Collections.emptyList();
          }

          // retrieve body
          var books = objectMapper.readValue(
            new BufferedReader(new InputStreamReader(response.body().asInputStream(), StandardCharsets.UTF_8)),
            new TypeReference<List<Book>>(){});

          // retrieve headers
          Map<String, Collection<String>> headers = response.headers();
          // ... do whatever you need with the headers

          return books;
    }

Custom decoder

You could use a custom decoder:

public class CustomDecoder extends GsonDecoder {

    private Map<String, Collection<String>> headers;

    @Override
    public Object decode(Response response, Type type) throws IOException {
        headers = response.headers();
        return super.decode(response, type);
    }

    public Map<String, Collection<String>> getHeaders() {
        return headers;
    }
}

Return Response

Other solution could be return Response instead of List<Dto>:

@Headers({
    "Content-Type: " + MediaType.APPLICATION_JSON_UTF8_VALUE
})
@RequestLine("GET Dto/")
Response search();

Then deserialize body and get headers:

Response response = Client.search();
response.headers();
Gson gson = new Gson();
gson.fromJson(response.body().asReader(), Dto.class);

The solution is to use @RequestHeader annotation instead of feign specific annotations

@FeignClient(name="Simple-Gateway")
interface GatewayClient {    
    @RequestMapping(method = RequestMethod.GET, value = "/gateway/test")
    String getSessionId(@RequestHeader("X-Auth-Token") String token);
}

I have done this before using a RequestInterceptor as follows:

@Component
public class MyRequestInterceptor implements RequestInterceptor {
  @Override
  public void apply(RequestTemplate template) {
    template.headers(getHeadersFromWherever());
  }
}

You can find some more useful information here:

https://github.com/Netflix/feign#user-content-setting-headers-per-target

You can create an interceptor that'd inject headers in all requests as below:

@Bean
public RequestInterceptor requestInterceptor() {
  return requestTemplate -> {
      requestTemplate.header("user", username);
      requestTemplate.header("password", password);
      requestTemplate.header("Accept", ContentType.APPLICATION_JSON.getMimeType());
  };
}

Also it provides a way to set interceptor using property files as below:

feign:
  client:
    config:
      default:
        requestInterceptors:
          com.baeldung.cloud.openfeign.JSONPlaceHolderInterceptor

we can create the configuration with default as the client name to configure all @FeignClient objects, or we can declare the feign client name for a configuration

Reference: https://www.baeldung.com/spring-cloud-openfeign

EDIT: Another way is to set headers in yml as below:

feign:
  client:
    config:
      default:
        defaultRequestHeaders:
          Authorization:
            - Basic dXNlcjpwYXNzd29yZA==
          SomeOtherHeader:
            - Value1
            - Value2