Spring应用实现HTTPS POST对接第三方系统的技术方案问询

Hey there! Let's tackle your POC problem step by step. I've worked through similar scenarios before, so here's what you need to know:

1. Does Spring Integration (SI) support HTTPS? #

Yes, Spring Integration does support HTTPS via its HTTP outbound gateway components. However, for your use case—since you're just sending a simple form-data POST request and already have a working curl example—using WebClient (or RestTemplate, though it's in maintenance mode) is far simpler and more straightforward than configuring Spring Integration for this single HTTP call. SI is great for complex integration flows, but overkill here unless you're already deeply invested in an SI-based architecture.

2. Why don't you need a class/method name for the HTTPS connection? #

Looking at your request/response example, the third-party system accepts form-urlencoded POST parameters (like ord=000000&term=022...) directly to the endpoint URL https://xx-cert.keb.com:20143/RMFSWeb/LineAuthListener (note the path from your response's trailing POST /RMFSWeb/LineAuthListener? HTTP/1.1 line). This is a traditional HTTP form submission, not a REST API with method/class conventions. You just need to send the key-value pairs as form data to that exact URL—no additional method/class names required.

3. Recommended Implementation: WebClient (Spring 5+ Preferred) #

WebClient is Spring's modern, non-blocking HTTP client and the replacement for RestTemplate. Here's how to replicate your curl logic:

Step 1: Configure WebClient #

First, set up a WebClient bean (handle SSL if using self-signed/internal certificates—more on that later):

@Configuration
public class WebClientConfig {
    @Bean
    public WebClient webClient() {
        // Uses your JVM's default trust store; works if curl can connect (server cert is trusted)
        return WebClient.builder()
                .baseUrl("https://xx-cert.keb.com:20143")
                .build();
    }
}

Step 2: Send the POST Request #

Create a service to handle the request, populate the form parameters, and process the response (note: the response has a trailing POST ... line we need to strip):

@Service
public class ThirdPartyIntegrationService {
    private final WebClient webClient;

    // Constructor injection (preferred over @Autowired)
    public ThirdPartyIntegrationService(WebClient webClient) {
        this.webClient = webClient;
    }

    public String sendOrderRequest() {
        // Populate your form parameters
        MultiValueMap<String, String> formParams = new LinkedMultiValueMap<>();
        formParams.add("ord", "000000");
        formParams.add("term", "022");
        formParams.add("storenum", "00623");
        formParams.add("fgen", "667");
        formParams.add("action", "1024");
        formParams.add("ctime", "072119:22:23:32");
        formParams.add("tmout", "08");
        formParams.add("PLU", "00007565604633");
        formParams.add("BC", "10364678071919225000623");
        formParams.add("QTY", "1.000");

        return webClient.post()
                .uri("/RMFSWeb/LineAuthListener")
                .contentType(MediaType.APPLICATION_FORM_URLENCODED)
                .body(BodyInserters.fromFormData(formParams))
                .retrieve()
                .bodyToMono(String.class)
                // Strip the trailing "POST /RMFSWeb/LineAuthListener? HTTP/1.1" line from response
                .map(response -> {
                    String[] responseLines = response.split("\n");
                    return String.join("\n", Arrays.copyOf(responseLines, responseLines.length - 1));
                })
                .block(); // Use subscribe() for async calls
    }
}

4. Alternative: RestTemplate (Legacy but Still Functional) #

If you prefer RestTemplate (it's still supported, just not actively developed):

Step 1: Configure RestTemplate #

@Configuration
public class RestTemplateConfig {
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

Step 2: Send the Request #

@Service
public class ThirdPartyIntegrationService {
    private final RestTemplate restTemplate;
    private static final String ENDPOINT_URL = "https://xx-cert.keb.com:20143/RMFSWeb/LineAuthListener";

    public ThirdPartyIntegrationService(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    public String sendOrderRequest() {
        MultiValueMap<String, String> formParams = new LinkedMultiValueMap<>();
        // Same parameter population as above...

        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);
        HttpEntity<MultiValueMap<String, String>> requestEntity = new HttpEntity<>(formParams, headers);

        String rawResponse = restTemplate.postForObject(ENDPOINT_URL, requestEntity, String.class);
        
        // Clean up the response
        if (rawResponse != null) {
            String[] responseLines = rawResponse.split("\n");
            return String.join("\n", Arrays.copyOf(responseLines, responseLines.length - 1));
        }
        return null;
    }
}

5. HTTPS Certificate Trust Issues #

Since your Linux server can connect via curl, the server's SSL certificate is likely trusted by the system. For your Spring app:

• If running on the same Linux server, ensure your JVM uses the system's trust store (most default setups do).
• If using a self-signed/internal CA certificate, import it into your JVM's cacerts store (located in $JAVA_HOME/jre/lib/security/) using the keytool command, or configure a custom SslContext in WebClient/RestTemplate.

6. Spring Integration Approach (If You Must Use SI) #

If you're already using Spring Integration heavily and want to stick with it, configure an HTTP outbound gateway:

@Configuration
@EnableIntegration
public class SiHttpConfig {
    @Bean
    public MessageChannel requestChannel() {
        return new DirectChannel();
    }

    @Bean
    public MessageChannel responseChannel() {
        return new DirectChannel();
    }

    @Bean
    public HttpRequestExecutingMessageHandler httpOutboundGateway() {
        HttpRequestExecutingMessageHandler gateway = 
            new HttpRequestExecutingMessageHandler("https://xx-cert.keb.com:20143/RMFSWeb/LineAuthListener");
        gateway.setHttpMethod(HttpMethod.POST);
        gateway.setRequestChannel(requestChannel());
        gateway.setReplyChannel(responseChannel());
        gateway.setRequestPayloadType(MultiValueMap.class);
        gateway.setContentType(MediaType.APPLICATION_FORM_URLENCODED_VALUE);
        gateway.setMessageConverters(Collections.singletonList(new StringHttpMessageConverter()));
        return gateway;
    }

    // To send a request:
    // messagingTemplate.send(requestChannel(), MessageBuilder.withPayload(formParams).build());
    // Then listen on responseChannel() for the reply
}

Go with WebClient—it's cleaner, supports async operations, and aligns with Spring's current best practices. The SI approach is unnecessary unless you're building a complex integration flow that requires SI's routing/transforming capabilities.

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