How to serialise Date of request body in a specific format in Feign Client?

I try to send a request to a third party api using feign client. When I check the request body, it looks like below:

{
  "requestTime": "2023-06-07T12:18:00.916+00:00"
}

but the api only accept the date format yyyy-MM-dd'T'mm:hh:ss.SSSZ, so the valid request body would be something similar below:

{
  "requestTime": "2023-06-17T14:53:47.402Z"
}

How do I config the serialisation of date format in Feign Client?

My codes:

@FeignClient(value = "myfeign", url = "https://myfeign.com/")
public interface MyFeignClient {

    @PostMapping(value = "/myfeign/", produces = APPLICATION_JSON_VALUE, consumes = APPLICATION_JSON_VALUE)
    MyResponse sendRequest(MyRequest request);
}

And MyRequest is generated from openapi-generator.

public class MyRequest {
   @JsonProperty("requestTime")
   @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME)
   private Date requestTime;
   // getter...
}

Edit: My approach below doesn't work as the request object still use "2023-06-07T12:18:00.916+00:00" format.

public class MyFeignConfig {

    @Bean
    public Encoder feignEncoder() {
        HttpMessageConverter<Object> jacksonConverter = new MappingJackson2HttpMessageConverter(objectMapper());

        HttpMessageConverters httpMessageConverters = new HttpMessageConverters(jacksonConverter);
        ObjectFactory<HttpMessageConverters> objectFactory = () -> httpMessageConverters;


        return new SpringEncoder(objectFactory);
    }

    private ObjectMapper objectMapper() {
        final String DATE_FORMAT = "yyyy-MM-dd'T'mm:hh:ss.SSSZ";
        SimpleDateFormat dateFormat = new SimpleDateFormat((DATE_FORMAT));
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setDateFormat(dateFormat);
    }

add configuration in the client

@FeignClient(value = "myfeign", url = "https://myfeign.com/",  configuration = "MyFeignConfig.class")
public interface MyFeignClient {

    @PostMapping(value = "/myfeign/", produces = APPLICATION_JSON_VALUE, consumes = APPLICATION_JSON_VALUE)
    MyResponse sendRequest(MyRequest request);
}

> My approach below doesn't work

Without knowing what "doesn't work" means, I can at least see that jackson/databind ObjectMapper#setDateFormat() takes a DateFormat class, not a string.

See also "Jackson Date" by Eugen Baeldung for illustration.

Something like:

public class MyFeignConfig {

    private static final String DATE_FORMAT = "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'";

    @Bean
    public Encoder feignEncoder() {
        ObjectMapper objectMapper = objectMapper();
        HttpMessageConverter<Object> jacksonConverter = new MappingJackson2HttpMessageConverter(objectMapper);

        HttpMessageConverters httpMessageConverters = new HttpMessageConverters(jacksonConverter);
        ObjectFactory<HttpMessageConverters> objectFactory = () -> httpMessageConverters;

        return new SpringEncoder(objectFactory);
    }

    private ObjectMapper objectMapper() {
        SimpleDateFormat dateFormat = new SimpleDateFormat(DATE_FORMAT);
        dateFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setDateFormat(dateFormat);
        return objectMapper;
    }
}

Note the date format string: it is changed to "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'", because mm and hh in Java's date format stands for minute and hour in am/pm, you should use HH for hour of day (0 - 23) and mm for minute in hour.

As noted by Olivier in the comments, 'Z' will output a literal Z in the output, as opposed to Z, which prints the timezone offset to UTC, as illustrated in this question.

Then, you apply this configuration to your feign client:

@FeignClient(value = "myfeign", url = "https://myfeign.com/", configuration = MyFeignConfig.class)
public interface MyFeignClient {

    @PostMapping(value = "/myfeign/", produces = APPLICATION_JSON_VALUE, consumes = APPLICATION_JSON_VALUE)
    MyResponse sendRequest(MyRequest request);
}

This should configure your Feign client to use your custom ObjectMapper which uses the correct date format. The time zone has been set to UTC in the SimpleDateFormat to make sure the serialized date string ends with a Z to indicate UTC.

> I updated my approach for missing codes. So, I don't understand why my approach still send as "2023-06-07T12:18:00.916+00:00".
What I expected actually is fail to serialize and throw error. Could you explain this to me?

When Spring Boot starts up, it creates a default ObjectMapper bean with standard configuration. If you define an ObjectMapper in your own configuration (like you could have done in MyFeignConfig), Spring does not replace the default one - it simply adds your ObjectMapper as another bean.

Since SpringEncoder (the class used by Feign for encoding requests) is configured to use an ObjectMapper bean, it will inject one from the application context. But if there are multiple ObjectMapper beans, the one it gets might not be the one you have configured. This could explain why you are seeing the default date format instead of the one you have set.

One way to ensure your ObjectMapper is used is by marking it as @Primary. This tells Spring that when multiple beans of the same type are present, this is the one that should be used.

You can update your MyFeignConfig class as follows:

public class MyFeignConfig {

    private static final String DATE_FORMAT = "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'";

    @Bean
    @Primary
    public ObjectMapper objectMapper() {
        SimpleDateFormat dateFormat = new SimpleDateFormat(DATE_FORMAT);
        dateFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setDateFormat(dateFormat);
        return objectMapper;
    }

    @Bean
    public Encoder feignEncoder(ObjectMapper objectMapper) {
        HttpMessageConverter<Object> jacksonConverter = new MappingJackson2HttpMessageConverter(objectMapper);

        HttpMessageConverters httpMessageConverters = new HttpMessageConverters(jacksonConverter);
        ObjectFactory<HttpMessageConverters> objectFactory = () -> httpMessageConverters;

        return new SpringEncoder(objectFactory);
    }
}

Note that the ObjectMapper bean is now annotated with @Primary, and the feignEncoder method now takes an ObjectMapper parameter. This ensures that the ObjectMapper used in feignEncoder is the same one that you have configured.
See "Spring Boot: Customize the Jackson ObjectMapper", again by Eugen Baeldung.

Warning: Marking a bean as @Primary will affect all places in your application where an ObjectMapper bean is injected.
If you want to use different ObjectMapper configurations in different parts of your application, you will need a different solution. In that case, you might need to create a custom Encoder or Decoder that uses your specific ObjectMapper, or use Feign's request/response interceptors to manually handle the serialization.

For more, the Spring Cloud OpenFeign documentation explains how you can take full control of the feign client by declaring additional configuration using @FeignClient. In this case, the client is composed from the components already in FeignClientsConfiguration together with any in your custom configuration (where the latter will override the former). The FeignClientsConfiguration class provides default beans for feign including feign.Encoder which is SpringEncoder by default.

If there are multiple ObjectMapper beans in the application context, the one that SpringEncoder (used by Feign for encoding requests) gets might not be the one you have configured. This situation might arise if the custom configuration is included in a @ComponentScan that would otherwise include this configuration as it will become the default source for feign.Decoder, feign.Encoder, feign.Contract, etc., when specified. This can be avoided by putting it in a separate, non-overlapping package from any @ComponentScan or @SpringBootApplication, or it can be explicitly excluded in @ComponentScan.

From the source code of JacksonEncoder, which is an implementation of Encoder, you can see that an ObjectMapper is used to encode the request body. It uses the ObjectMapper to write the object as bytes and sets it as the body of the RequestTemplate. This suggests that ObjectMapper plays an important role in the encoding process, and if the ObjectMapper is not properly configured, it can lead to unexpected results, such as the one you are experiencing.

To configure the serialization of the date format in Feign Client, you can follow these steps:

Create a configuration class, let's call it FeignConfig, and annotate it with @Configuration.

@Configuration
public class FeignConfig {
    // Configuration code will go here
}

Define a bean for the ObjectMapper in the FeignConfig class. This bean will be responsible for configuring the date format serialization.

@Bean
public ObjectMapper objectMapper() {
    SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
    dateFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
    
    ObjectMapper objectMapper = new ObjectMapper();
    objectMapper.setDateFormat(dateFormat);
    
    return objectMapper;
}

Here, we're setting the desired date format and ensuring that it uses the UTC time zone.

Create a bean for the Encoder in the FeignConfig class. This bean will use the customized ObjectMapper for serialization.

@Bean
public Encoder feignEncoder() {
    HttpMessageConverter<Object> jacksonConverter = new MappingJackson2HttpMessageConverter(objectMapper());

    return new SpringEncoder(() -> new HttpMessageConverters(jacksonConverter));
}
Apply the FeignConfig to your Feign client by specifying the configuration attribute in the @FeignClient annotation.
@FeignClient(value = "myfeign", url = "https://myfeign.com/", configuration = FeignConfig.class)
public interface MyFeignClient {
    // Feign client methods
}

By doing this, the Feign client will use the customized ObjectMapper with the specified date format for serialization, ensuring that the request body is formatted correctly before sending the request to the third-party API.