Spring RestTemplate，在解析为Json之前拦截响应

Question

I have a REST api that responds with some additional non JSON data in the body content. This breaks the use of RestTemplate and jackson. Can I intercept the http response body prior to the parsing?

I am using RestTemplate.getForObject.

I've taken a look at the RestTemplate and couldn't see an appropriate method.

Answer 1

You can try to implement ClientHttpRequestInterceptor and assign it to restTemplate . Implement intercept method:

@Override
public ClientHttpResponse intercept(HttpRequest httpRequest, byte[] bytes,
        ClientHttpRequestExecution clientHttpRequestExecution) throws IOException {

         ClientHttpResponse  response=clientHttpRequestExecution.execute(httpRequest, bytes);
         //...do magic with response body from getBody method
         return response;
}

You might have to extend AbstractClientHttpResponse with your own implementation to do that.

Another option could be to treat the response from the REST API as String, then format the string as needed and explicitly map it to object using ObjectMapper.

Then in your restTemplate you would have:

 String result = restTemplate.getForObject(url, String.class, host);
 //..trim the extra stuff
 MyClass object=objectMapper.readValue(result, MyClass.class);

Yet another option would be to implement your own HttpMessageConverter which extends AbstractJackson2HttpMessageConverter and register it with restTemplate . In my opinion that would be the cleaneast from the Spring point of view

Answer 2

Another way would be to unwrap the response by implementing a ClientHttpRequestInterceptor along with a ClientHttpResponse .

    @Component
    public class MyInterceptor implements ClientHttpRequestInterceptor {
       
    @Autowired
    Function<ClientHttpResponse, MyResponseWrapper> responseWrapperBeanFactory;
    
    @Autowired
    MyRequestAdvice requestAdvice;
          
    @Override
    public ClientHttpResponse intercept(HttpRequest httpRequest, byte[] bytes, ClientHttpRequestExecution clientHttpRequestExecution) throws IOException {
        byte[] wrappedBody = requestAdvice.wrapRequest(bytes);
        ClientHttpResponse res = clientHttpRequestExecution.execute(httpRequest, wrappedBody);
        return responseWrapperBeanFactory.apply(res);
    }    
}

Here's the bean config for the MyResponseWrapper :

@Bean
Function<ClientHttpResponse, MyResponseWrapper> responseWrapperBeanFactory() {
    return this::getMyResponseWrapper;
}

@Bean
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
public MyResponseWrapper getMyResponseWrapper(ClientHttpResponse originalResponse) {
    return new MyResponseWrapper(originalResponse);
}

@Bean
public RestTemplate restTemplate(@Autowired MyInterceptor interceptor) {
    RestTemplate t = new RestTemplate();
    t.setInterceptors(Arrays.asList(interceptor));
    // other setup code

    return t;
}

And here's the ClientHttpResponse implementation:

public class MyResponseWrapper implements ClientHttpResponse {
  
    private byte[] filteredContent;
    private ByteArrayInputStream responseInputStream;


    private ClientHttpResponse originalResponse;

    public MyResponseWrapper(ClientHttpResponse originalResponse) {
        this.originalResponse = originalResponse;

        try {
            filteredContent = MyContentUnwrapper.unwrapResponse(originalResponse.getBody().readAllBytes());
        } catch (Exception e) {
            throw new RuntimeException("There was a problem reading/decoding the response coming from the service ", e);
        }
    }

    @Override
    public HttpStatus getStatusCode() throws IOException {
        return originalResponse.getStatusCode();
    }

    @Override
    public int getRawStatusCode() throws IOException {
        return originalResponse.getRawStatusCode();
    }

    @Override
    public String getStatusText() throws IOException {
        return originalResponse.getStatusText();
    }

    @Override
    public void close() {
        if (responseInputStream != null) {
            try {
                responseInputStream.close();
            } catch (IOException e) { /* so long */}
        }
    }

    @Override
    public InputStream getBody() throws IOException {
        if (responseInputStream == null) {
            responseInputStream = new ByteArrayInputStream(filteredContent);
        }
        return responseInputStream;
    }

    @Override
    public HttpHeaders getHeaders() {
        return originalResponse.getHeaders();
    }
}

Answer 3

从您的控制器中，您可以尝试返回一个 ResponseEntity 并手动操作实体对象

Answer 4

If you don't need these extra properties you may add:

    @JsonIgnoreProperties(ignoreUnknown = true)

to your mapping class.

From docs :

Property that defines whether it is ok to just ignore any unrecognized properties during deserialization. If true, all properties that are unrecognized -- that is, there are no setters or creators that accept them -- are ignored without warnings (although handlers for unknown properties, if any, will still be called) without exception. Does not have any effect on serialization.