<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.5</version>
        <relativePath/>
    </parent>
    <groupId>com.example</groupId>
    <artifactId>order-processing</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>order-processing</name>
    <description>Demo project for Spring Boot and Spring Integration</description>
    <properties>
        <java.version>11</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-integration</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

package com.example.orderprocessing;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.integration.annotation.IntegrationComponentScan;

@SpringBootApplication
@IntegrationComponentScan
public class OrderProcessingApplication {

    public static void main(String[] args) {
        SpringApplication.run(OrderProcessingApplication.class, args);
    }
}

package com.example.orderprocessing.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.integration.channel.DirectChannel;
import org.springframework.messaging.MessageChannel;

/**
 * 配置消息通道
 */
@Configuration
public class IntegrationConfig {

    /**
     * 定義訂單創(chuàng)建的消息通道
     * @return DirectChannel 實(shí)例
     */
    @Bean
    public MessageChannel orderCreatedChannel() {
        return new DirectChannel();
    }

    /**
     * 定義支付處理的消息通道
     * @return DirectChannel 實(shí)例
     */
    @Bean
    public MessageChannel paymentProcessedChannel() {
        return new DirectChannel();
    }

    /**
     * 定義庫(kù)存檢查的消息通道
     * @return DirectChannel 實(shí)例
     */
    @Bean
    public MessageChannel inventoryCheckedChannel() {
        return new DirectChannel();
    }

    /**
     * 定義發(fā)貨調(diào)度的消息通道
     * @return DirectChannel 實(shí)例
     */
    @Bean
    public MessageChannel shipmentScheduledChannel() {
        return new DirectChannel();
    }
}

package com.example.orderprocessing.controller;

import com.example.orderprocessing.model.Order;
import com.example.orderprocessing.service.OrderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/orders")
public class OrderController {

    private final OrderService orderService;

    @Autowired
    public OrderController(OrderService orderService) {
        this.orderService = orderService;
    }

    /**
     * 創(chuàng)建訂單的API端點(diǎn)
     * @param order 訂單對(duì)象
     * @return 成功消息
     */
    @PostMapping
    public String createOrder(@RequestBody Order order) {
        orderService.createOrder(order);
        return"Order created successfully";
    }
}

package com.example.orderprocessing.model;

/**
 * 訂單模型類(lèi)
 */
public class Order {
    private String orderId;
    private String productId;
    private int quantity;

    // Getters and Setters
    public String getOrderId() {
        return orderId;
    }

    public void setOrderId(String orderId) {
        this.orderId = orderId;
    }

    public String getProductId() {
        return productId;
    }

    public void setProductId(String productId) {
        this.productId = productId;
    }

    public int getQuantity() {
        return quantity;
    }

    public void setQuantity(int quantity) {
        this.quantity = quantity;
    }

    @Override
    public String toString() {
        return"Order{" +
                "orderId='" + orderId + '\'' +
                ", productId='" + productId + '\'' +
                ", quantity=" + quantity +
                '}';
    }
}

package com.example.orderprocessing.service;

import com.example.orderprocessing.gateway.OrderGateway;
import com.example.orderprocessing.model.Order;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * 訂單服務(wù)類(lèi)，負(fù)責(zé)創(chuàng)建訂單并將訂單信息發(fā)送到相應(yīng)的消息通道
 */
@Service
public class OrderService {

    private final OrderGateway gateway;

    @Autowired
    public OrderService(OrderGateway gateway) {
        this.gateway = gateway;
    }

    /**
     * 創(chuàng)建訂單并觸發(fā)訂單創(chuàng)建流程
     * @param order 訂單對(duì)象
     */
    public void createOrder(Order order) {
        System.out.println("Creating order: " + order.getOrderId());
        // 將訂單發(fā)送到orderCreatedChannel消息通道
        gateway.processOrder(order);
    }
}

package com.example.orderprocessing.service;

import com.example.orderprocessing.gateway.OrderGateway;
import com.example.orderprocessing.model.Order;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.integration.annotation.ServiceActivator;
import org.springframework.messaging.handler.annotation.Payload;
import org.springframework.stereotype.Component;

/**
 * 支付處理服務(wù)類(lèi)，監(jiān)聽(tīng)訂單創(chuàng)建消息通道，處理支付邏輯
 */
@Component
public class PaymentService {

    private final OrderGateway gateway;

    @Autowired
    public PaymentService(OrderGateway gateway) {
        this.gateway = gateway;
    }

    /**
     * 處理訂單創(chuàng)建消息，模擬支付處理
     * @param order 訂單對(duì)象
     */
    @ServiceActivator(inputChannel = "orderCreatedChannel")
    public void handleOrderCreation(@Payload Order order) {
        System.out.println("Handling order creation for: " + order.getOrderId());
        // 模擬支付處理
        System.out.println("Processing payment for order: " + order.getOrderId());
        // 假設(shè)支付成功
        gateway.processPayment(order);
    }
}

package com.example.orderprocessing.service;

import com.example.orderprocessing.gateway.OrderGateway;
import com.example.orderprocessing.model.Order;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.integration.annotation.ServiceActivator;
import org.springframework.messaging.handler.annotation.Payload;
import org.springframework.stereotype.Component;

/**
 * 庫(kù)存檢查服務(wù)類(lèi)，監(jiān)聽(tīng)支付處理消息通道，檢查庫(kù)存并決定是否發(fā)貨
 */
@Component
public class InventoryService {

    private final OrderGateway gateway;

    @Autowired
    public InventoryService(OrderGateway gateway) {
        this.gateway = gateway;
    }

    /**
     * 處理支付處理消息，檢查庫(kù)存
     * @param order 訂單對(duì)象
     */
    @ServiceActivator(inputChannel = "paymentProcessedChannel")
    public void checkInventory(@Payload Order order) {
        System.out.println("Checking inventory for product: " + order.getProductId());
        // 模擬庫(kù)存檢查
        boolean isInStock = true; // 假設(shè)庫(kù)存充足
        if (isInStock) {
            System.out.println("Product is in stock.");
            gateway.scheduleShipment(order);
        } else {
            System.out.println("Product is out of stock.");
            // 通知用戶的邏輯,自己寫(xiě)吧，我懶得寫(xiě)了。不是重點(diǎn)
        }
    }
}

package com.example.orderprocessing.service;

import com.example.orderprocessing.model.Order;
import org.springframework.integration.annotation.ServiceActivator;
import org.springframework.messaging.handler.annotation.Payload;
import org.springframework.stereotype.Component;

/**
 * 發(fā)貨調(diào)度服務(wù)類(lèi)，監(jiān)聽(tīng)發(fā)貨調(diào)度消息通道，安排發(fā)貨
 */
@Component
public class ShipmentService {

    /**
     * 處理發(fā)貨調(diào)度消息，模擬發(fā)貨
     * @param order 訂單對(duì)象
     */
    @ServiceActivator(inputChannel = "shipmentScheduledChannel")
    public void scheduleShipment(@Payload Order order) {
        System.out.println("Scheduling shipment for order: " + order.getOrderId());
        // 模擬發(fā)貨調(diào)度
        System.out.println("Shipment scheduled for order: " + order.getOrderId());
    }
}

package com.example.orderprocessing.gateway;

import com.example.orderprocessing.model.Order;
import org.springframework.integration.annotation.Gateway;
import org.springframework.messaging.MessageChannel;

/**
 * 定義訂單處理相關(guān)的消息網(wǎng)關(guān)接口
 */
public interface OrderGateway {

    /**
     * 將訂單發(fā)送到orderCreatedChannel消息通道
     * @param order 訂單對(duì)象
     */
    @Gateway(requestChannel = "orderCreatedChannel")
    void processOrder(Order order);

    /**
     * 將訂單發(fā)送到paymentProcessedChannel消息通道
     * @param order 訂單對(duì)象
     */
    @Gateway(requestChannel = "paymentProcessedChannel")
    void processPayment(Order order);

    /**
     * 將訂單發(fā)送到inventoryCheckedChannel消息通道
     * @param order 訂單對(duì)象
     */
    @Gateway(requestChannel = "inventoryCheckedChannel")
    void checkInventory(Order order);

    /**
     * 將訂單發(fā)送到shipmentScheduledChannel消息通道
     * @param order 訂單對(duì)象
     */
    @Gateway(requestChannel = "shipmentScheduledChannel")
    void scheduleShipment(Order order);
}

curl -X POST http://localhost:8080/orders \
     -H "Content-Type: application/json" \
     -d '{"orderId": "123", "productId": "P001", "quantity": 2}'

Order created successfully

Creating order: 123
Handling order creation for: 123
Processing payment for order: 123
Checking inventory for product: P001
Product is in stock.
Scheduling shipment for order: 123
Shipment scheduled for order: 123