Why does the HttpExchange (declarative HttpClient) in Spring 6 use Jackson when trying to send multipart form-data?

i am trying to implement a REST API client using the new declarative HttpClient in Spring 6.

I have defined my client like that:

@HttpExchange(
        url = "/publicapi",
        contentType = MediaType.MULTIPART_FORM_DATA_VALUE,
        accept = MediaType.TEXT_XML_VALUE
)
public interface MyClient {
    @PostExchange(url = "/submit/file",
                  contentType = MediaType.MULTIPART_FORM_DATA_VALUE)
    ResponseEntity<Void> uploadFile(@RequestPart String apiKey,
                                    @RequestPart(value = "file") MultipartFile file);
}

Then i have declared a Bean for that client:

    @Bean
    MyClient myClient(MyClientProperties properties) {
        WebClient webClient = WebClient.builder()
                .baseUrl(properties.getUrl())
                .defaultStatusHandler(
                        httpStatusCode -> HttpStatus.NOT_FOUND == httpStatusCode,
                        response -> Mono.empty())
                .defaultStatusHandler(
                        HttpStatusCode::is5xxServerError,
                        response -> Mono.error(new RuntimeException("WildfireClient request failed. Code: " + response.statusCode().value())))
                .build();

        return HttpServiceProxyFactory
                .builder(WebClientAdapter.forClient(webClient))
                .build()
                .createClient(MyClient.class);
    }

And then i am trying to use the client to upload a file from Google Cloud Storage:

...
        try (ReadChannel reader = storage.reader(blobId)) {
            var inputStream = Channels.newInputStream(reader);

            MultipartFile file = new MultipartFile() {
                @Override
                public String getName() {
                    return webhookRequest.name();
                }

                @Override
                public String getOriginalFilename() {
                    return webhookRequest.name();
                }

                @Override
                public String getContentType() {
                    return null;
                }

                @Override
                public boolean isEmpty() {
                    return false;
                }

                @Override
                public long getSize() {
                    return webhookRequest.size();
                }

                @Override
                public byte[] getBytes() throws IOException {
                    return FileCopyUtils.copyToByteArray(inputStream);
                }

                @Override
                public InputStream getInputStream() throws IOException {
                    return inputStream;
                }

                @Override
                public void transferTo(File dest) throws IOException, IllegalStateException {
                    FileCopyUtils.copy(inputStream, Files.newOutputStream(dest.toPath()));
                }
            };

            myClient.submitFile(wildfireApiKey, file);

But something strange happens. I get an error that Jackson cannot encode the value:

org.springframework.core.codec.CodecException: Type definition error: [simple type, class sun.nio.ch.ChannelInputStream]
	at org.springframework.http.codec.json.AbstractJackson2Encoder.encodeValue(AbstractJackson2Encoder.java:256) ~[spring-web-6.0.10.jar:6.0.10]
	at org.springframework.http.codec.json.AbstractJackson2Encoder.lambda$encode$0(AbstractJackson2Encoder.java:158) ~[spring-web-6.0.10.jar:6.0.10]
...

Why is Jackson involved here? The body of the request should be multipart form data. So no JSON conversion should be done here...

I halso have tried to implement it via manual WebClient instantiation and that worked without problems. But i really want to use the new declarative client.

Multipart support isn't possible yet, or at least MultipartFile support hasn't been added. See this enhancement request which will add.

Support has been added with this commit, so it appears as it will be part of Spring Framework 6.1 and therefor probably Spring Boot 3.2.

@M.Deinum is right. Multipart support isn't possible in Spring Boot versions below 3.2

I resolved this by following the commit that is supposed to solve this in Spring Boot 3.2, then I replicated it in my project which is using Spring Boot 3.0.1

So what they did was to introduce a

> MultipartFileArgumentResolver

Below is my HttpClient configuration and how I adapted it to the solution in Spring Boot 3.2

PS: I am using Spring Security hence the OAuth2AuthorizedClientManager on my Webclient

Before:

@Configuration
@RequiredArgsConstructor
public class OAuth2ClientConfig { 

    private final OAuth2AuthorizedClientService clientService;
    private final ApplicationConfigurations applicationConfigurations;
    private final ClientRegistrationRepository clientRegistrationRepository;

    @Bean
    public OAuth2AuthorizedClientManager authorizedClientManager() {
    OAuth2AuthorizedClientProvider authorizedClientProvider =
            OAuth2AuthorizedClientProviderBuilder
                    .builder()
                    .refreshToken()
                    .clientCredentials()
                    .build();

    AuthorizedClientServiceOAuth2AuthorizedClientManager authorizedClientManager =
            new AuthorizedClientServiceOAuth2AuthorizedClientManager(clientRegistrationRepository, clientService);

    authorizedClientManager.setAuthorizedClientProvider(authorizedClientProvider);
    return authorizedClientManager;
    }

    @Bean
    WebClient webClient(OAuth2AuthorizedClientManager authorizedClientManager) {
        ServletOAuth2AuthorizedClientExchangeFilterFunction oauth2Client =
            new ServletOAuth2AuthorizedClientExchangeFilterFunction(authorizedClientManager);
    oauth2Client.setDefaultClientRegistrationId("keycloak");
    return WebClient.builder()
            .baseUrl(applicationConfigurations.getServiceDiscovery().getGatewayService())
            .clientConnector(new ReactorClientHttpConnector())
            .apply(oauth2Client.oauth2Configuration())
            .build();
    }

    @Bean
    GatewayServiceConnectorClient gatewayServiceConnectorClient() {
        HttpServiceProxyFactory httpServiceProxyFactory = HttpServiceProxyFactory
            .builder(WebClientAdapter.forClient(webClient(authorizedClientManager())))
            .build();
    return httpServiceProxyFactory.createClient(GatewayServiceConnectorClient.class);
    }

}

After:

Simply add the MultipartFileArgumentResolver class to your project and import the necessary packages.

public class MultipartFileArgumentResolver extends AbstractNamedValueArgumentResolver {

    private static final String MULTIPART_FILE_LABEL = "multipart file";

    @Override
    protected NamedValueInfo createNamedValueInfo(MethodParameter parameter) {
        if (!parameter.nestedIfOptional().getNestedParameterType().equals(MultipartFile.class)) {
            return null;
        }
        return new NamedValueInfo("", true, null, MULTIPART_FILE_LABEL, true);

    }

    @Override
    protected void addRequestValue(@NotNull String name, @NotNull Object value, @NotNull MethodParameter parameter,
                                   HttpRequestValues.Builder requestValues) {
        Assert.state(value instanceof MultipartFile,
                     "The value has to be of type 'MultipartFile'");

        MultipartFile file = (MultipartFile) value;
        requestValues.addRequestPart(name, toHttpEntity(name, file));
    }

    private HttpEntity<Resource> toHttpEntity(String name, MultipartFile file) {
        HttpHeaders headers = new HttpHeaders();
        if (file.getOriginalFilename() != null) {
            headers.setContentDispositionFormData(name, file.getOriginalFilename());
        }
        if (file.getContentType() != null) {
            headers.add(HttpHeaders.CONTENT_TYPE, file.getContentType());
        }
        return new HttpEntity<>(file.getResource(), headers);
    }
}

then add it to your HttpClient interface proxy using the already available customArgumentResolver() method.

@Bean
GatewayServiceConnectorClient gatewayServiceConnectorClient() {
     HttpServiceProxyFactory httpServiceProxyFactory = HttpServiceProxyFactory
                .builder(WebClientAdapter.forClient(webClient(authorizedClientManager())))
                .customArgumentResolver(new MultipartFileArgumentResolver())
                .build();
     return httpServiceProxyFactory.createClient(GatewayServiceConnectorClient.class);
 }

then finally in your HttpClient definition.

@HttpExchange
public interface GatewayServiceConnectorClient {
     @PostExchange(value = "/upload", contentType = MediaType.MULTIPART_FORM_DATA_VALUE)
    ResponseEntity<String> uploadFacilities(@RequestPart(value = "file") MultipartFile file);
}

And Voila!