如何从Spring-Integration外部调用rest端点

Question

我正在尝试从我的Spring-Integration项目连接外部端点。这是我的结构

IntegrationConfig.java

package com.demo.integration.config;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.demo.integration.bean.Program;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.integration.annotation.IntegrationComponentScan;
import org.springframework.integration.annotation.Transformer;
import org.springframework.integration.channel.DirectChannel;
import org.springframework.integration.config.EnableIntegration;
import org.springframework.integration.json.JsonToObjectTransformer;
import org.springframework.integration.json.ObjectToJsonTransformer;
import org.springframework.integration.support.json.Jackson2JsonObjectMapper;
import org.springframework.messaging.MessageChannel;

@Configuration
@EnableIntegration
@IntegrationComponentScan
public class IntegrationConfig {

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

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

    @Bean
    @Transformer(inputChannel = "integration.program.gateway.channel", outputChannel = "integration.program.objectToJson.channel")
    public ObjectToJsonTransformer objectToJsonTransformer(){
        return new ObjectToJsonTransformer(getMapper());
    }

    @Bean
    public Jackson2JsonObjectMapper getMapper(){
        ObjectMapper mapper = new ObjectMapper();
        return new Jackson2JsonObjectMapper(mapper);
    }

    @Bean
    @Transformer(inputChannel = "integration.program.jsonToObject.channel", outputChannel = "integration.program.jsonToObject.fromTransformer.channel")
    public JsonToObjectTransformer jsonToObjectTransformer(){
        return new JsonToObjectTransformer(Program.class);
    }
}

ProgramService.java

package com.demo.integration.service;

import com.demo.integration.bean.Program;
import org.springframework.integration.annotation.ServiceActivator;
import org.springframework.integration.support.MessageBuilder;
import org.springframework.messaging.Message;
import org.springframework.messaging.MessageChannel;
import org.springframework.stereotype.Component;

@Component
public class ProgramService {
    @ServiceActivator(inputChannel = "integration.program.objectToJson.channel", outputChannel = "integration.program.jsonToObject.channel")
    public Message<?> receiveMessage(Message<?> message){
        System.out.println("###############");
        System.out.println(message);
        System.out.println("###############");
        System.out.println("Object To JSON : "+message.getPayload());
        //Message<String> newMessage = MessageBuilder.withPayload(message.getPayload() + "Modified").build();
        return message;
    }

    @ServiceActivator(inputChannel = "integration.program.jsonToObject.fromTransformer.channel")
    public void processJsonToObject(Message<?> message){
        MessageChannel replyChannel = (MessageChannel) message.getHeaders().getReplyChannel();
        MessageBuilder.fromMessage(message);
        System.out.println("JSON To Object : "+message.getPayload());
        Program program = (Program)message.getPayload();
        Message<String> newMessage = MessageBuilder.withPayload(program.toString() + "Modified").build();
        replyChannel.send(newMessage);
    }
}

Program.java

package com.demo.integration.bean;


import java.io.Serializable;

public class Program implements Serializable {
    private String id;
    private String name;
    private String code;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    @Override
    public String toString() {
        return "Program{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", code='" + code + '\'' +
                '}';
    }
}

IntegrationController.java

package com.demo.integration.controller;

import com.demo.integration.bean.Program;
import com.demo.integration.service.IntegrationGateway;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/v1/integration")
public class IntegrationRestController {

    @Autowired
    private IntegrationGateway gateway;

    @GetMapping(value = "{name}")
    public String test(
            @PathVariable(value = "name") String name) {
        return gateway.sendMessage(name);
    }

    @PostMapping
    public String processProgram(@RequestBody Program program) {
        return gateway.processProgram(program);
    }
}

哪里是编写Rest端点连接调用的更好的地方？在Spring-Integration中使用RestTemplate或任何其他可用的接口类型是可行的吗?因为在这里我只需要启动一个调用，获取响应并将其发送回另一个通道。

Answer 1

RestTemplate有点旧了，我推荐使用feignclient或webclient。

https://cloud.spring.io/spring-cloud-netflix/multi/multi_spring-cloud-feign.html

像这样：

@FeignClient(name = "segmentGroupClient", url = "${cdp.segment-group-base-url}")
public interface SegmentGroupClient {

    @PostMapping(value = "/segment-group",consumes = "application/json")
    ResponseEntity<SegmentGroupResponse> handle(@RequestBody SegmentGroupRequest request);
}

在你的apllication.properties中：

cdp.segment-group-base-url=http://url:port

Answer 2

你展示了太多的自定义代码，但它们都没有指出你想要在哪里进行REST调用。不管怎样，Spring Integration有一个HTTP和WebFlux模块，让你在你的流程中有端点来调用另一端的REST服务，并等待响应，这将是你流程中下一个通道的回复消息有效负载。

在文档中查看更多信息：

https://docs.spring.io/spring-integration/docs/current/reference/html/http.html#http

https://docs.spring.io/spring-integration/docs/current/reference/html/webflux.html#webflux