如何用Hystrix Command封装Spring Integration出站网关调用

Alright, let's figure out how to wrap your Spring Integration HTTP outbound gateway with Hystrix Command—just like you'd do in a regular Spring Boot app—to handle those annoying frequent exceptions from your target service. Here's a step-by-step breakdown:

First, make sure you have the right Hystrix dependencies in your build file. If you're using Maven, add this to your pom.xml:

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
    <!-- Use a version compatible with your Spring Boot/Spring Integration setup -->
    <version>2.2.10.RELEASE</version>
</dependency>

For Gradle, add this to your build.gradle:

implementation 'org.springframework.cloud:spring-cloud-starter-netflix-hystrix:2.2.10.RELEASE'

If you prefer the explicit Hystrix Command class pattern, create a wrapper that encapsulates your outbound gateway call:

import com.netflix.hystrix.HystrixCommand;
import com.netflix.hystrix.HystrixCommandGroupKey;
import org.springframework.messaging.Message;
import org.springframework.messaging.MessageChannel;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.messaging.core.MessagingTemplate;

public class OutboundGatewayHystrixCommand extends HystrixCommand<Message<?>> {
    private final MessageChannel requestChannel;
    private final Message<?> requestMessage;

    public OutboundGatewayHystrixCommand(MessageChannel requestChannel, Message<?> requestMessage) {
        // Define a group key for Hystrix metrics and configuration
        super(HystrixCommandGroupKey.Factory.asKey("OutboundGatewayGroup"));
        this.requestChannel = requestChannel;
        this.requestMessage = requestMessage;
    }

    @Override
    protected Message<?> run() throws Exception {
        // Use MessagingTemplate for synchronous send-receive to the outbound gateway
        MessagingTemplate template = new MessagingTemplate();
        return template.sendAndReceive(requestChannel, requestMessage);
    }

    @Override
    protected Message<?> getFallback() {
        // Return a custom fallback response when the target service fails
        return MessageBuilder.withPayload("Fallback: Target service is currently unavailable, please try again later")
                .build();
    }
}

To use this command, inject your get.request.channel and create/execute the command wherever you need to trigger the outbound call:

@Autowired
@Qualifier("get.request.channel")
private MessageChannel requestChannel;

// When you need to make the call:
Message<?> request = MessageBuilder.withPayload("").build(); // Adjust payload as needed
OutboundGatewayHystrixCommand hystrixCommand = new OutboundGatewayHystrixCommand(requestChannel, request);
Message<?> response = hystrixCommand.execute();
// Send the response to your reply.channel if needed
replyChannel.send(response);

If you prefer annotation-driven configuration (closer to standard Spring Boot practices), follow these steps:

3.1 Enable Hystrix #

Add the @EnableHystrix annotation to your Spring Boot application class or configuration class:

import org.springframework.cloud.netflix.hystrix.EnableHystrix;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@EnableHystrix
public class YourIntegrationApp {
    public static void main(String[] args) {
        SpringApplication.run(YourIntegrationApp.class, args);
    }
}

3.2 Create a Wrapper Service #

Create a service class that wraps the outbound gateway call, annotated with @HystrixCommand:

import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import org.springframework.messaging.Message;
import org.springframework.messaging.MessageChannel;
import org.springframework.messaging.core.MessagingTemplate;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.stereotype.Service;

@Service
public class OutboundGatewayService {
    private final MessagingTemplate messagingTemplate;
    private final MessageChannel requestChannel;

    // Inject the request channel from your XML configuration
    public OutboundGatewayService(MessagingTemplate messagingTemplate, 
                                 @Qualifier("get.request.channel") MessageChannel requestChannel) {
        this.messagingTemplate = messagingTemplate;
        this.requestChannel = requestChannel;
    }

    @HystrixCommand(fallbackMethod = "handleFallback")
    public Message<?> callTargetService(Message<?> requestMessage) {
        // Delegate to the outbound gateway via its request channel
        return messagingTemplate.sendAndReceive(requestChannel, requestMessage);
    }

    // Fallback method - triggers when the target service fails
    private Message<?> handleFallback(Message<?> requestMessage, Throwable throwable) {
        // Log the exception for debugging (optional)
        // log.error("Target service call failed: {}", throwable.getMessage(), throwable);
        return MessageBuilder.withPayload(String.format("Fallback Response: Target service error - %s", throwable.getMessage()))
                .build();
    }
}

3.3 Update Your Integration Flow #

Instead of sending directly to the outbound gateway's request channel, route messages to a service activator that uses your wrapped service. If you're using Java DSL, you can define the flow like this:

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

@Configuration
public class IntegrationFlowConfig {

    @Bean
    public IntegrationFlow gatewayCallFlow(OutboundGatewayService gatewayService) {
        return IntegrationFlows.from("get.request.channel")
                .handle(gatewayService, "callTargetService")
                .channel("reply.channel")
                .get();
    }
}

If you want to keep using XML configuration, replace your existing outbound gateway setup with a service activator:

<int:service-activator input-channel="get.request.channel" 
                       output-channel="reply.channel"
                       ref="outboundGatewayService" 
                       method="callTargetService"/>

<bean id="outboundGatewayService" class="com.yourpackage.OutboundGatewayService"/>

Tweak Hystrix settings in your application.properties to match your needs (like timeout, circuit breaker thresholds):

# Set timeout for outbound calls (5 seconds)
hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds=5000
# Open circuit if 50% of calls fail within 10 seconds
hystrix.command.default.circuitBreaker.errorThresholdPercentage=50
# Keep circuit open for 10 seconds before trying again
hystrix.command.default.circuitBreaker.sleepWindowInMilliseconds=10000

Trigger calls to your integration flow when the target service is down or throwing exceptions—you should see your fallback response returned immediately, and Hystrix will manage the circuit breaker to prevent overwhelming the target service once it recovers.

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