or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

configuration.mdinbound-endpoints.mdindex.mdjava-dsl.mdmanagement.mdmessage-conversion.mdmultipart-handling.mdoutbound-handlers.md
tile.json

tessl/maven-spring-integration-http

Spring Integration HTTP support module that provides HTTP inbound and outbound channel adapters and gateways for enterprise integration patterns

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
mavenpkg:maven/org.springframework.integration/spring-integration-http@7.0.x

To install, run

npx @tessl/cli install tessl/maven-spring-integration-http@7.0.0

index.mddocs/

Spring Integration HTTP

A comprehensive Java library for HTTP integration in Spring applications, enabling seamless bidirectional HTTP communication within enterprise integration flows. The module provides HTTP inbound channel adapters and gateways for receiving HTTP requests, as well as outbound handlers for executing HTTP requests using RestTemplate, all integrated with Spring Integration's messaging paradigm.

Package Information

  • Package Name: spring-integration-http
  • Package Type: maven
  • Full Identifier: org.springframework.integration:spring-integration-http
  • Language: Java
  • Version: 7.0.0
  • License: Apache-2.0
  • Installation: Add to Maven pom.xml:
<dependency>
    <groupId>org.springframework.integration</groupId>
    <artifactId>spring-integration-http</artifactId>
    <version>7.0.0</version>
</dependency>

Or Gradle build.gradle:

implementation 'org.springframework.integration:spring-integration-http:7.0.0'

Core Imports

// Inbound endpoints
import org.springframework.integration.http.inbound.HttpRequestHandlingMessagingGateway;
import org.springframework.integration.http.inbound.HttpRequestHandlingController;
import org.springframework.integration.http.inbound.RequestMapping;

// Outbound handlers
import org.springframework.integration.http.outbound.HttpRequestExecutingMessageHandler;

// Java DSL
import org.springframework.integration.http.dsl.Http;

// Configuration
import org.springframework.integration.http.config.EnableIntegrationGraphController;
import org.springframework.integration.http.config.EnableControlBusController;

// Header mapping
import org.springframework.integration.http.support.DefaultHttpHeaderMapper;

Basic Usage

Simple Inbound Gateway (Receiving HTTP Requests)

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.integration.http.inbound.HttpRequestHandlingMessagingGateway;
import org.springframework.integration.http.inbound.RequestMapping;
import org.springframework.integration.channel.DirectChannel;
import org.springframework.http.HttpMethod;

@Configuration
public class InboundConfig {

    @Bean
    public DirectChannel httpRequestChannel() {
        return new DirectChannel();
    }

    @Bean
    public HttpRequestHandlingMessagingGateway inboundGateway() {
        HttpRequestHandlingMessagingGateway gateway =
            new HttpRequestHandlingMessagingGateway();
        gateway.setRequestChannel(httpRequestChannel());
        gateway.setRequestMapping(createRequestMapping());
        return gateway;
    }

    private RequestMapping createRequestMapping() {
        RequestMapping mapping = new RequestMapping();
        mapping.setPathPatterns("/api/orders");
        mapping.setMethods(HttpMethod.POST);
        return mapping;
    }
}

Simple Outbound Gateway (Making HTTP Requests)

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.integration.http.outbound.HttpRequestExecutingMessageHandler;
import org.springframework.http.HttpMethod;

@Configuration
public class OutboundConfig {

    @Bean
    public HttpRequestExecutingMessageHandler outboundHandler() {
        HttpRequestExecutingMessageHandler handler =
            new HttpRequestExecutingMessageHandler("https://api.example.com/data");
        handler.setHttpMethod(HttpMethod.GET);
        handler.setExpectedResponseType(String.class);
        return handler;
    }
}

Java DSL Usage

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.integration.dsl.IntegrationFlow;
import org.springframework.integration.http.dsl.Http;
import org.springframework.http.HttpMethod;

@Configuration
public class DslConfig {

    @Bean
    public IntegrationFlow inboundFlow() {
        return IntegrationFlow
            .from(Http.inboundGateway("/api/process")
                .requestMapping(m -> m.methods(HttpMethod.POST))
                .requestPayloadType(String.class))
            .handle((p, h) -> "Processed: " + p)
            .get();
    }

    @Bean
    public IntegrationFlow outboundFlow() {
        return IntegrationFlow
            .from("outboundChannel")
            .handle(Http.outboundGateway("https://api.example.com/submit")
                .httpMethod(HttpMethod.POST)
                .expectedResponseType(String.class))
            .get();
    }
}

Architecture

The Spring Integration HTTP module is built on several key architectural layers:

Core Components

  • Inbound Endpoints: Components that receive HTTP requests and convert them to Spring Integration messages

    • HttpRequestHandlingMessagingGateway - Primary gateway for HTTP requests
    • HttpRequestHandlingController - Spring MVC Controller for view rendering
    • BaseHttpInboundEndpoint - Base class providing common inbound functionality

  • Outbound Handlers: Components that execute HTTP requests from Spring Integration messages

    • HttpRequestExecutingMessageHandler - Primary handler using RestTemplate
    • AbstractHttpRequestExecutingMessageHandler - Base class for outbound communication

  • Message Conversion: Bidirectional conversion between HTTP and Spring Integration messages

    • HttpMessageConverter implementations for various content types
    • DefaultHttpHeaderMapper for header translation

  • Request Mapping: Flexible RESTful URL mapping configuration

    • RequestMapping - URL patterns, HTTP methods, headers, parameters
    • IntegrationRequestMappingHandlerMapping - Spring MVC HandlerMapping integration

Integration Patterns

The module supports standard enterprise integration patterns:

  • Request-Reply: Inbound gateways and outbound gateways with synchronous request/response
  • Fire-and-Forget: Inbound channel adapters and outbound channel adapters for one-way communication
  • Content-Based Routing: Based on HTTP headers, methods, or URL patterns
  • Message Transformation: Automatic conversion between HTTP payloads and Java objects

Spring Framework Integration

  • Spring MVC: Full integration with DispatcherServlet and HandlerMapping
  • RestTemplate: Leverages Spring's HTTP client for outbound requests
  • Message Converters: Uses Spring's HttpMessageConverter infrastructure
  • Validation: Supports Spring Validator for payload validation
  • CORS: Built-in Cross-Origin Resource Sharing configuration

Capabilities

HTTP Inbound Endpoints

Components for receiving HTTP requests and converting them to Spring Integration messages, including gateways, controllers, and channel adapters with support for request mapping, CORS, message conversion, and payload validation.

// Primary inbound gateway
public class HttpRequestHandlingMessagingGateway
    extends HttpRequestHandlingEndpointSupport
    implements HttpRequestHandler {

    public HttpRequestHandlingMessagingGateway();
    public HttpRequestHandlingMessagingGateway(boolean expectReply);
    public void setConvertExceptions(boolean convertExceptions);
    public void handleRequest(
        HttpServletRequest servletRequest,
        HttpServletResponse servletResponse) throws ServletException, IOException;
}

// MVC Controller-based endpoint
public class HttpRequestHandlingController
    extends HttpRequestHandlingEndpointSupport
    implements Controller {

    public HttpRequestHandlingController();
    public HttpRequestHandlingController(boolean expectReply);
    public void setViewName(String viewName);
    public void setViewExpression(Expression viewExpression);
    public void setReplyKey(String replyKey);
    public void setErrorsKey(String errorsKey);
    public void setErrorCode(String errorCode);
    public ModelAndView handleRequest(
        HttpServletRequest servletRequest,
        HttpServletResponse servletResponse) throws Exception;
}

// Base configuration class
public class BaseHttpInboundEndpoint extends MessagingGatewaySupport {
    public void setRequestMapping(RequestMapping requestMapping);
    public RequestMapping getRequestMapping();
    public void setCrossOrigin(CrossOrigin crossOrigin);
    public void setHeaderMapper(HeaderMapper<HttpHeaders> headerMapper);
    public void setPayloadExpression(Expression payloadExpression);
    public void setHeaderExpressions(Map<String, Expression> headerExpressions);
    public void setRequestPayloadTypeClass(Class<?> requestPayloadType);
    public void setExtractReplyPayload(boolean extractReplyPayload);
    public void setStatusCodeExpression(Expression statusCodeExpression);
    public void setValidator(Validator validator);
}

// Request mapping configuration
public class RequestMapping {
    public void setPathPatterns(String... pathPatterns);
    public void setMethods(HttpMethod... supportedMethods);
    public void setParams(String... params);
    public void setHeaders(String... headers);
    public void setConsumes(String... consumes);
    public void setProduces(String... produces);
}

// CORS configuration
public class CrossOrigin {
    public void setOrigin(String... origin);
    public void setAllowedHeaders(String... allowedHeaders);
    public void setExposedHeaders(String... exposedHeaders);
    public void setMethod(RequestMethod... method);
    public void setAllowCredentials(Boolean allowCredentials);
    public void setMaxAge(long maxAge);
}

HTTP Inbound Endpoints

HTTP Outbound Handlers

Components for executing HTTP requests from Spring Integration messages, with support for dynamic URIs, HTTP methods, header mapping, cookie management, and response handling.

// Primary outbound handler
public class HttpRequestExecutingMessageHandler
    extends AbstractHttpRequestExecutingMessageHandler {

    public HttpRequestExecutingMessageHandler(URI uri);
    public HttpRequestExecutingMessageHandler(String uri);
    public HttpRequestExecutingMessageHandler(Expression uriExpression);
    public HttpRequestExecutingMessageHandler(
        String uri, RestTemplate restTemplate);
    public HttpRequestExecutingMessageHandler(
        Expression uriExpression, RestTemplate restTemplate);

    public void setRequestFactory(ClientHttpRequestFactory requestFactory);
    public void setErrorHandler(ResponseErrorHandler errorHandler);
    public void setMessageConverters(
        List<HttpMessageConverter<?>> messageConverters);
}

// Base configuration class
public abstract class AbstractHttpRequestExecutingMessageHandler
    extends AbstractReplyProducingMessageHandler {

    public void setHttpMethod(HttpMethod httpMethod);
    public void setHttpMethodExpression(Expression httpMethodExpression);
    public void setExpectReply(boolean expectReply);
    public void setExpectedResponseType(Class<?> expectedResponseType);
    public void setExpectedResponseTypeExpression(
        Expression expectedResponseTypeExpression);
    public void setHeaderMapper(HeaderMapper<HttpHeaders> headerMapper);
    public void setUriVariableExpressions(
        Map<String, Expression> uriVariableExpressions);
    public void setUriVariablesExpression(Expression uriVariablesExpression);
    public void setExtractPayload(boolean extractPayload);
    public void setTransferCookies(boolean transferCookies);
    public void setExtractResponseBody(boolean extractResponseBody);
    public void setCharset(String charset);
    public void setEncodingMode(
        DefaultUriBuilderFactory.EncodingMode encodingMode);
}

HTTP Outbound Handlers

Java DSL Support

Fluent API for configuring HTTP integration components using Java DSL with builders and specifications, providing a concise and type-safe way to define inbound and outbound HTTP endpoints.

// Main DSL factory class
public final class Http {

    // Outbound gateways (request-reply)
    public static HttpMessageHandlerSpec outboundGateway(String uri);
    public static HttpMessageHandlerSpec outboundGateway(URI uri);
    public static HttpMessageHandlerSpec outboundGateway(Expression uriExpression);
    public static <P> HttpMessageHandlerSpec outboundGateway(
        Function<Message<P>, ?> uriFunction);

    // Outbound channel adapters (one-way)
    public static HttpMessageHandlerSpec outboundChannelAdapter(String uri);
    public static HttpMessageHandlerSpec outboundChannelAdapter(URI uri);

    // Inbound gateways (request-reply)
    public static HttpRequestHandlerEndpointSpec inboundGateway(String... path);

    // Inbound channel adapters (one-way)
    public static HttpRequestHandlerEndpointSpec inboundChannelAdapter(
        String... path);

    // Controller-based endpoints
    public static HttpControllerEndpointSpec inboundControllerGateway(
        String viewName, String... path);
    public static HttpControllerEndpointSpec inboundControllerAdapter(
        String viewName, String... path);
}

// Outbound handler specification
public class HttpMessageHandlerSpec
    extends BaseHttpMessageHandlerSpec<HttpMessageHandlerSpec> {

    public HttpMessageHandlerSpec requestFactory(
        ClientHttpRequestFactory requestFactory);
    public HttpMessageHandlerSpec errorHandler(ResponseErrorHandler errorHandler);
    public HttpMessageHandlerSpec messageConverters(
        HttpMessageConverter<?>... messageConverters);
}

// Inbound gateway specification
public class HttpRequestHandlerEndpointSpec
    extends BaseHttpInboundEndpointSpec<HttpRequestHandlerEndpointSpec> {

    public HttpRequestHandlerEndpointSpec convertExceptions(
        boolean convertExceptions);
}

// Base outbound specification
public abstract class BaseHttpMessageHandlerSpec<S>
    extends MessageHandlerSpec {

    public S httpMethod(HttpMethod httpMethod);
    public S expectedResponseType(Class<?> expectedResponseType);
    public S headerMapper(HeaderMapper<HttpHeaders> headerMapper);
    public S mappedRequestHeaders(String... patterns);
    public S mappedResponseHeaders(String... patterns);
    public S uriVariable(String variable, String expression);
    public S uriVariable(String variable, Expression expression);
    public S transferCookies(boolean transferCookies);
    public S extractResponseBody(boolean extractResponseBody);
}

// Base inbound specification
public abstract class HttpInboundEndpointSupportSpec<S>
    extends MessagingGatewaySpec<S> {

    public S requestMapping(Consumer<RequestMappingSpec> mapping);
    public S crossOrigin(Consumer<CrossOriginSpec> crossOrigin);
    public S payloadExpression(String payloadExpression);
    public S headerExpression(String header, String expression);
    public S headerMapper(HeaderMapper<HttpHeaders> mapper);
    public S requestPayloadType(Class<?> requestPayloadType);
    public S statusCodeExpression(String statusCodeExpression);
    public S validator(Validator validator);
}

Java DSL

Message Conversion and Header Mapping

HTTP message converters for content type handling and header mappers for bidirectional translation between Spring Integration MessageHeaders and HTTP headers.

// Header mapping
public class DefaultHttpHeaderMapper
    implements HeaderMapper<HttpHeaders> {

    public DefaultHttpHeaderMapper();

    public void setOutboundHeaderNames(String... outboundHeaderNames);
    public void setInboundHeaderNames(String... inboundHeaderNames);
    public void setUserDefinedHeaderPrefix(String userDefinedHeaderPrefix);
    public void setExcludedOutboundStandardRequestHeaderNames(
        String... excludedOutboundStandardRequestHeaderNames);
    public void setExcludedInboundStandardResponseHeaderNames(
        String... excludedInboundStandardResponseHeaderNames);

    public void fromHeaders(MessageHeaders headers, HttpHeaders target);
    public Map<String, Object> toHeaders(HttpHeaders source);

    public static DefaultHttpHeaderMapper outboundMapper();
    public static DefaultHttpHeaderMapper inboundMapper();
}

// Multipart form data converter
public class MultipartAwareFormHttpMessageConverter
    implements HttpMessageConverter<MultiValueMap<String, ?>> {

    public MultipartAwareFormHttpMessageConverter();

    public void setCharset(Charset charset);
    public void setMultipartFileReader(
        MultipartFileReader<?> multipartFileReader);
    public List<MediaType> getSupportedMediaTypes();
    public boolean canRead(Class<?> clazz, MediaType mediaType);
    public boolean canWrite(Class<?> clazz, MediaType mediaType);
    public MultiValueMap<String, ?> read(
        Class<? extends MultiValueMap<String, ?>> clazz,
        HttpInputMessage inputMessage) throws IOException;
    public void write(
        MultiValueMap<String, ?> map,
        MediaType contentType,
        HttpOutputMessage outputMessage) throws IOException;
}

// Java serialization converter
public class SerializingHttpMessageConverter
    extends AbstractHttpMessageConverter<Serializable> {

    public SerializingHttpMessageConverter();

    public boolean supports(Class<?> clazz);
    public boolean canWrite(Class<?> clazz, MediaType mediaType);
}

// HTTP header constants
public abstract class HttpHeaders {
    public static final String PREFIX = "http_";
    public static final String REQUEST_URL = "http_requestUrl";
    public static final String REQUEST_METHOD = "http_requestMethod";
    public static final String USER_PRINCIPAL = "http_userPrincipal";
    public static final String STATUS_CODE = "http_statusCode";
}

Message Conversion and Header Mapping

Multipart File Handling

Support for multipart file uploads with various strategies for reading and storing file content, including in-memory, temporary file, and simplified content reading.

// Strategy interface
public interface MultipartFileReader<T> {
    T readMultipartFile(MultipartFile multipartFile) throws IOException;
}

// Default in-memory reader
public class DefaultMultipartFileReader
    implements MultipartFileReader<MultipartFile> {

    public DefaultMultipartFileReader();

    public MultipartFile readMultipartFile(MultipartFile multipartFile)
        throws IOException;
}

// File-copying reader
public class FileCopyingMultipartFileReader
    implements MultipartFileReader<File> {

    public FileCopyingMultipartFileReader();
    public FileCopyingMultipartFileReader(File directory);

    public void setPrefix(String prefix);
    public void setSuffix(String suffix);
    public File readMultipartFile(MultipartFile multipartFile)
        throws IOException;
}

// Simple content reader
public class SimpleMultipartFileReader
    implements MultipartFileReader<Object> {

    public SimpleMultipartFileReader();

    public void setDefaultMultipartCharset(String defaultCharset);
    public Object readMultipartFile(MultipartFile multipartFile)
        throws IOException;
}

// MultipartFile implementation
public class UploadedMultipartFile implements MultipartFile {

    public UploadedMultipartFile(
        byte[] bytes,
        String contentType,
        String formParameterName,
        String originalFilename);

    public UploadedMultipartFile(
        File file,
        long size,
        String contentType,
        String formParameterName,
        String originalFilename);

    public String getName();
    public String getOriginalFilename();
    public String getContentType();
    public boolean isEmpty();
    public long getSize();
    public byte[] getBytes() throws IOException;
    public InputStream getInputStream() throws IOException;
    public void transferTo(File dest) throws IOException;
}

Multipart File Handling

Management and Monitoring

REST controllers for integration graph visualization and control bus management operations, providing HTTP endpoints for runtime monitoring and control of Spring Integration flows.

// Integration graph controller
@RestController
@RequestMapping("${spring.integration.graph.controller.request.mapping.path:/integration}")
public class IntegrationGraphController {

    public IntegrationGraphController(
        IntegrationGraphServer integrationGraphServer);

    @GetMapping
    public Graph getGraph();

    @GetMapping("/refresh")
    public Graph refreshGraph();
}

// Control bus controller
@RestController
@RequestMapping("/control-bus")
public class ControlBusController {

    public ControlBusController(
        ControlBusCommandRegistry controlBusCommandRegistry,
        FormattingConversionService conversionService);

    @GetMapping
    public List<ControlBusBean> getCommands();

    @PostMapping
    public Object invokeCommand(
        @RequestParam String command,
        @RequestBody(required = false) List<CommandArgument> arguments);
}

// Enable annotations
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface EnableIntegrationGraphController {
    String[] value() default {};
    String[] path() default {};
    String[] allowedOrigins() default {};
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface EnableControlBusController {
}

Management and Monitoring

Configuration Support

Configuration annotations, utilities, and infrastructure for setting up HTTP integration components, including bean initialization and request mapping registration.

// Configuration utilities
public final class HttpContextUtils {
    public static final boolean WEB_MVC_PRESENT;
    public static final boolean WEB_FLUX_PRESENT;
    public static final String HANDLER_MAPPING_BEAN_NAME;
    public static final String GRAPH_CONTROLLER_PATH_PROPERTY;
    public static final String GRAPH_CONTROLLER_DEFAULT_PATH;
    public static final String GRAPH_CONTROLLER_BEAN_NAME;

    public static org.springframework.web.bind.annotation.RequestMapping
        convertRequestMappingToAnnotation(RequestMapping requestMapping);
}

// Configuration initializer
public class HttpIntegrationConfigurationInitializer
    implements IntegrationConfigurationInitializer {

    public void initialize(ConfigurableListableBeanFactory beanFactory);
}

// Dynamic request mapping registration
public class DynamicRequestMappingBeanPostProcessor
    implements BeanFactoryAware,
               DestructionAwareBeanPostProcessor,
               SmartInitializingSingleton {

    public void setBeanFactory(BeanFactory beanFactory);
    public void afterSingletonsInstantiated();
    public Object postProcessBeforeInitialization(Object bean, String beanName);
    public void postProcessBeforeDestruction(Object bean, String beanName);
    public boolean requiresDestruction(Object bean);
}

// Integration request mapping handler
public final class IntegrationRequestMappingHandlerMapping
    extends RequestMappingHandlerMapping
    implements ApplicationListener<ContextRefreshedEvent> {

    public void onApplicationEvent(ContextRefreshedEvent event);
}

Configuration Support

Exception Handling

The module provides specialized exception types for HTTP-specific error scenarios:

public class IntegrationWebExchangeBindException
    extends WebExchangeBindException {

    public IntegrationWebExchangeBindException(
        String endpointId,
        Object failedPayload,
        BindingResult bindingResult);

    public String getMessage();
}

When validation fails on an HTTP inbound endpoint, an IntegrationWebExchangeBindException is thrown containing the endpoint ID, failed payload, and detailed binding result with validation errors.

Common Use Cases

RESTful API Endpoints

Create RESTful endpoints that process HTTP requests and integrate with Spring Integration flows:

@Bean
public IntegrationFlow restApiFlow() {
    return IntegrationFlow
        .from(Http.inboundGateway("/api/customers/{id}")
            .requestMapping(m -> m.methods(HttpMethod.GET))
            .payloadExpression("#pathVariables.id"))
        .handle("customerService", "findById")
        .get();
}

HTTP Request Aggregation

Make parallel HTTP requests and aggregate responses:

@Bean
public IntegrationFlow aggregationFlow() {
    return IntegrationFlow
        .from("inputChannel")
        .split()
        .channel(c -> c.executor(taskExecutor()))
        .handle(Http.outboundGateway("https://api.example.com/data/{id}")
            .uriVariable("id", "payload")
            .expectedResponseType(String.class))
        .aggregate()
        .get();
}

File Upload Processing

Handle multipart file uploads in integration flows:

@Bean
public HttpRequestHandlingMessagingGateway uploadGateway() {
    HttpRequestHandlingMessagingGateway gateway =
        new HttpRequestHandlingMessagingGateway();

    RequestMapping mapping = new RequestMapping();
    mapping.setPathPatterns("/upload");
    mapping.setMethods(HttpMethod.POST);
    gateway.setRequestMapping(mapping);

    MultipartAwareFormHttpMessageConverter converter =
        new MultipartAwareFormHttpMessageConverter();
    converter.setMultipartFileReader(new FileCopyingMultipartFileReader());
    gateway.setMessageConverters(List.of(converter));

    return gateway;
}

CORS-Enabled Endpoints

Configure Cross-Origin Resource Sharing for browser-based clients:

@Bean
public IntegrationFlow corsFlow() {
    return IntegrationFlow
        .from(Http.inboundGateway("/api/data")
            .requestMapping(m -> m.methods(HttpMethod.GET, HttpMethod.POST))
            .crossOrigin(c -> c
                .origin("https://example.com")
                .allowedHeaders("Authorization", "Content-Type")
                .maxAge(3600)))
        .handle((p, h) -> processData(p))
        .get();
}

Related Spring Integration Modules

  • spring-integration-core: Core messaging infrastructure
  • spring-integration-webflux: Reactive WebFlux-based HTTP integration
  • spring-integration-ws: SOAP Web Services support
  • spring-integration-security: Security features for endpoints

Additional Resources