如何为Spring Integration的http:outbound-gateway封装Hystrix Command？

Absolutely! You can absolutely wrap your Spring Integration http:outbound-gateway REST calls with a Hystrix Command using a custom request handler advice. Let me walk you through the exact implementation steps, including code examples for both Java Config and XML setups to make it clear.

1. Add Required Dependencies #

First, make sure your project includes the necessary Spring Integration and Hystrix dependencies. For Maven, add these to your pom.xml:

<dependency>
    <groupId>org.springframework.integration</groupId>
    <artifactId>spring-integration-http</artifactId>
</dependency>
<dependency>
    <groupId>com.netflix.hystrix</groupId>
    <artifactId>hystrix-core</artifactId>
    <version>1.5.18</version> <!-- Use a version compatible with your Spring stack -->
</dependency>

2. Create a Custom Hystrix Request Handler Advice #

Extend Spring Integration's AbstractRequestHandlerAdvice to wrap the HTTP call logic inside a Hystrix Command. This class will handle executing the original gateway call and defining fallback behavior:

import com.netflix.hystrix.HystrixCommand;
import com.netflix.hystrix.HystrixCommandGroupKey;
import org.springframework.integration.handler.AbstractRequestHandlerAdvice;
import org.springframework.messaging.Message;

public class HystrixRequestHandlerAdvice extends AbstractRequestHandlerAdvice {

    private final String commandGroupKey;

    public HystrixRequestHandlerAdvice(String commandGroupKey) {
        this.commandGroupKey = commandGroupKey;
    }

    @Override
    protected Object doInvoke(ExecutionCallback callback, Object target, Message<?> message) {
        // Wrap the HTTP call in a Hystrix Command
        HystrixCommand<Object> hystrixCommand = new HystrixCommand<Object>(
                HystrixCommandGroupKey.Factory.asKey(commandGroupKey)) {

            @Override
            protected Object run() throws Exception {
                // Execute the original HTTP outbound gateway logic
                return callback.execute();
            }

            @Override
            protected Object getFallback() {
                // Define your fallback logic here
                // You can return a default response, call an alternative API, or throw an exception
                return "Fallback response: HTTP service is unavailable or timed out";
            }
        };

        return hystrixCommand.execute();
    }
}

3. Configure the HTTP Outbound Gateway with the Custom Advice #

Now bind your custom advice to the http:outbound-gateway—here's how to do it in both Java Config and XML:

Java Configuration #

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

@Configuration
public class HttpIntegrationConfig {

    @Bean
    public HystrixRequestHandlerAdvice hystrixHttpAdvice() {
        return new HystrixRequestHandlerAdvice("HttpGatewayCommandGroup");
    }

    @Bean
    public IntegrationFlow httpOutboundFlow() {
        return IntegrationFlows.from("httpRequestChannel")
                .handle(
                        Http.outboundGateway("https://api.your-service.com/resource")
                                .httpMethod(org.springframework.http.HttpMethod.GET)
                                .expectedResponseType(String.class),
                        handlerSpec -> handlerSpec.advice(hystrixHttpAdvice()) // Attach the Hystrix advice
                )
                .channel("httpResponseChannel")
                .get();
    }
}

XML Configuration #

If you prefer XML-based configuration:

<int:channel id="httpRequestChannel"/>
<int:channel id="httpResponseChannel"/>

<!-- Define the custom Hystrix advice bean -->
<bean id="hystrixHttpAdvice" class="com.your.package.HystrixRequestHandlerAdvice">
    <constructor-arg value="HttpGatewayCommandGroup"/>
</bean>

<!-- Configure the HTTP outbound gateway with the advice chain -->
<int-http:outbound-gateway id="httpOutboundGateway"
                           request-channel="httpRequestChannel"
                           url="https://api.your-service.com/resource"
                           http-method="GET"
                           expected-response-type="java.lang.String"
                           reply-channel="httpResponseChannel">
    <int:request-handler-advice-chain>
        <ref bean="hystrixHttpAdvice"/>
    </int:request-handler-advice-chain>
</int-http:outbound-gateway>

4. Optional: Fine-Tune Hystrix Configuration #

You can customize Hystrix behavior (like timeouts, circuit breaker thresholds, thread pools) by adding command properties to your Hystrix Command:

@Override
protected Object doInvoke(ExecutionCallback callback, Object target, Message<?> message) {
    HystrixCommand<Object> hystrixCommand = new HystrixCommand<Object>(
            HystrixCommand.Setter.withGroupKey(HystrixCommandGroupKey.Factory.asKey(commandGroupKey))
                    .andCommandPropertiesDefaults(
                            HystrixCommandProperties.Setter()
                                    .withExecutionTimeoutInMilliseconds(5000) // 5-second timeout
                                    .withCircuitBreakerEnabled(true)
                                    .withCircuitBreakerRequestVolumeThreshold(10) // Trigger circuit after 10 failed requests
                                    .withCircuitBreakerSleepWindowInMilliseconds(30000) // Wait 30s before testing circuit again
                    )) {

        @Override
        protected Object run() throws Exception {
            return callback.execute();
        }

        @Override
        protected Object getFallback() {
            // You can also use the incoming message to customize the fallback response
            return String.format("Fallback for request payload: %s", message.getPayload());
        }
    };

    return hystrixCommand.execute();
}

Key Notes #

• The callback.execute() method triggers the original HTTP outbound gateway call—this is how we wrap the core logic inside Hystrix.
• The getFallback() method is invoked when Hystrix detects a failure, timeout, or circuit breaker activation. Customize this to fit your business needs.
• You can inject additional dependencies into the HystrixRequestHandlerAdvice if you need more complex fallback logic (like calling a backup service).

内容的提问来源于stack exchange，提问作者Murali J