Spring Integration 轻松实现服务间消息传递，真香！

码猿技术专栏2025-04-09 8:55

在当今分布式系统的背景下，如何优雅地实现系统之间的消息传递是每个开发者都关心的话题。而Spring Integration，作为Spring家族的一员，正是为了解决这个难题而生。

在这篇文章中，我们将踏上穿越消息之路，深入探讨Spring Integration的魅力。

Spring Integration基础概念

1. 起源：

  • Spring Integration是Spring框架的一个扩展，旨在简化企业集成模式的开发。它提供了一种基于消息的编程模型，使得在分布式系统中进行系统集成变得更加容易。

2. 基本概念：

  • 消息： Spring Integration使用消息来在系统中传递信息。消息是信息的载体，它可以包含业务数据、头部信息、消息标签等。消息在系统中沿着通道（Channel）传递。
  • 通道（Channel）： 通道是消息在系统中传递的管道。Spring Integration提供了不同类型的通道，如直接通道（Direct Channel）、发布-订阅通道（Publish-Subscribe Channel）、队列通道（Queue Channel）等。
  • 端点（Endpoint）： 端点是消息的生产者或者消费者。消息从一个端点流向另一个端点，形成一个消息的处理流程。
  • 适配器（Adapter）： 适配器用于将外部系统或者服务与Spring Integration整合。它可以将外部系统的消息转换为Spring Integration的消息，也可以将Spring Integration的消息传递给外部系统。
  • 过滤器（Filter）： 过滤器用于过滤消息，只有满足特定条件的消息才能通过。它可以用于消息的路由、转换等。
  • 转换器（Transformer）： 转换器用于将消息从一种形式转换为另一种形式，以满足系统的需求。它可以用于数据格式的转换、消息体的修改等。

Spring Integration与传统消息中间件的区别与联系：

1. 区别：

  • Spring Integration是框架： Spring Integration是一个基于Spring的框架，它提供了一整套用于构建企业集成模式的工具和组件。
  • 传统消息中间件是产品： 传统消息中间件通常是独立的产品，如RabbitMQ、Apache Kafka、ActiveMQ等，它们专注于提供消息传递服务。

2. 联系：

  • 整合性： Spring Integration可以与传统消息中间件集成使用，通过适配器与外部消息中间件进行通信。这样，Spring Integration可以作为一个中间层，帮助企业集成系统与不同的消息中间件进行对接。
  • 解耦与异步通信： 类似传统消息中间件，Spring Integration也支持解耦和异步通信的模式，通过消息的发布与订阅，实现系统组件之间的解耦和松耦合。
  • 消息传递： Spring Integration和传统消息中间件一样，都是基于消息传递的模型。消息作为信息的载体，在系统中传递，实现不同组件之间的通信。

总体而言，Spring Integration提供了一种更加轻量级和灵活的方式来实现企业集成，而传统消息中间件更专注于提供可靠的消息传递服务。在实际应用中，可以根据具体的需求选择合适的技术和工具。

关注公众号：码猿技术专栏，回复关键词：1111 获取阿里内部Java性能调优手册！

消息通道与消息端点

消息通道与消息端点：

定义和配置消息通道：

  1. 定义消息通道：
    • 在Spring Integration中，消息通道是消息在系统中传递的管道。可以使用XML配置或Java代码来定义消息通道。
    • XML配置示例：
xml 复制代码 
<int:channel id="myChannel"/>
    • Java配置示例：
java 复制代码 
@Bean
public MessageChannel myChannel() {
    return MessageChannels.direct().get();
}

1.配置消息通道的类型：

    • Spring Integration提供了不同类型的消息通道，如直接通道（Direct Channel）、发布-订阅通道（Publish-Subscribe Channel）、队列通道（Queue Channel）等。可以根据需求选择合适的通道类型。
    • XML配置示例：
xml 复制代码 
<!-- 配置直接通道 -->
<int:channel id="directChannel"/>
<!-- 配置发布-订阅通道 -->
<int:publish-subscribe-channel id="publishSubscribeChannel"/>
<!-- 配置队列通道 -->
<int:queue-channel id="queueChannel"/>
    • Java配置示例：
java 复制代码 
@Bean
public MessageChannel directChannel() {
    return MessageChannels.direct().get();
}
@Bean
public MessageChannel publishSubscribeChannel() {
    return MessageChannels.publishSubscribe().get();
}
@Bean
public MessageChannel queueChannel() {
    return MessageChannels.queue().get();

2.消息通道的属性配置：

    • 可以通过配置消息通道的一些属性，如容量、过期时间等，以满足具体的需求。
    • XML配置示例：
xml 复制代码 
<int:channel id="myChannel" capacity="10" />
    • Java配置示例：
java 复制代码 
@Bean
public MessageChannel myChannel() {
    return MessageChannels.direct().capacity(10).get();
}

消息端点的作用和类型：

  1. 作用：
    • 消息端点是消息的生产者或者消费者，它定义了消息的处理逻辑。消息从一个端点流向另一个端点，形成一个消息的处理流程。

2.消息端点的类型：

    • 消息生产者端点：
      • 消息源（Message Source）： 用于产生消息的端点，如文件输入、JDBC查询等。
      • 通道适配器（Channel Adapter）： 用于将外部系统的消息转换为Spring Integration的消息格式。
    • 消息消费者端点：
      • 服务激活器（Service Activator）： 用于将消息传递给特定的服务进行处理。
      • 消息处理器（Message Handler）： 用于处理消息，可以是一个Java方法、表达式、脚本等。
    • 消息路由器端点：
      • 分发器（Dispatcher）： 用于将消息分发给不同的子通道，根据条件进行消息路由。
    • 其他类型：
      • 过滤器（Filter）： 用于过滤消息，只有满足特定条件的消息才能通过。
      • 转换器（Transformer）： 用于将消息从一种形式转换为另一种形式。

3.配置消息端点：

    • 消息端点可以通过XML配置或Java代码进行定义。
    • XML配置示例：
xml 复制代码 
<int:service-activator input-channel="myChannel" ref="myService" method="processMessage"/>
    • Java配置示例：
java 复制代码 
@ServiceActivator(inputChannel = "myChannel")
public void processMessage(Message<String> message) {
    // 处理消息的逻辑
}

通过合理定义和配置消息通道以及消息端点，可以构建出灵活、可扩展的消息传递系统，实现消息在系统中的流动和处理。

消息处理器与适配器

消息处理器与适配器在Spring Integration中的使用：

1. 消息处理器的使用方法：

消息处理器是Spring Integration中用于处理消息的组件，它可以是一个Java方法、表达式、脚本等。以下是消息处理器的使用方法：

  • Java方法处理器：
java 复制代码 
@ServiceActivator(inputChannel = "inputChannel")
public void handleMessage(String message) {
    // 处理消息的逻辑
    System.out.println("Received Message: " + message);
}
  • 上述代码中，handleMessage方法是一个消息处理器，通过@ServiceActivator注解将其与名为inputChannel的输入通道关联起来。当消息被发送到该通道时，该方法会被调用来处理消息。
  • 表达式处理器：
xml 复制代码 
<int:service-activator input-channel="inputChannel" expression="@myService.process(#payload)">
    <int:poller fixed-rate="1000"/>
</int:service-activator>
  • 上述配置中，expression属性定义了一个表达式，指定了消息处理的逻辑。这个表达式将调用名为process的方法，#payload表示消息的载荷。

2. 适配器与外部系统集成：

适配器用于将外部系统的消息与Spring Integration进行集成，使得外部系统的消息能够在Spring Integration中流通。以下是适配器的使用方法：

  • 文件适配器：
xml 复制代码 
<int-file:inbound-channel-adapter id="filesIn"
                                 channel="inputChannel"
                                 directory="file:${java.io.tmpdir}/input">
    <int:poller fixed-rate="5000"/>
</int-file:inbound-channel-adapter>
  • 上述配置使用文件适配器（<int-file:inbound-channel-adapter>）来监听指定目录中的文件，并将文件内容发送到名为inputChannel的通道。
  • JDBC适配器：
xml 复制代码 
<int-jdbc:inbound-channel-adapter id="jdbcInboundAdapter"
                                  query="SELECT * FROM my_table"
                                  channel="inputChannel">
    <int:poller fixed-rate="10000"/>
</int-jdbc:inbound-channel-adapter>
  • 上述配置中，JDBC适配器（<int-jdbc:inbound-channel-adapter>）从数据库执行查询，并将结果发送到inputChannel通道。
  • HTTP适配器：
xml 复制代码 
<int-http:inbound-channel-adapter id="httpInboundAdapter"
                                  channel="inputChannel"
                                  path="/receiveMessage"
                                  request-mapper="requestMapping">
    <int:poller fixed-rate="10000"/>
</int-http:inbound-channel-adapter>
  • 上述配置使用HTTP适配器（<int-http:inbound-channel-adapter>）监听指定路径的HTTP请求，并将请求的消息发送到inputChannel通道。

以上示例展示了如何使用不同类型的适配器来与外部系统进行集成。适配器将外部系统的消息转换为Spring Integration的消息，并通过通道在整个系统中传递。适配器的配置取决于具体的集成需求和外部系统的特性。

消息转换与路由在Spring Integration中的应用

1. 消息的格式转换与处理：

消息转换是Spring Integration中常见的操作，用于将消息从一种格式或结构转换为另一种格式或结构，以满足系统的需求。以下是消息转换的实际应用场景和示例：

  • JSON到对象的转换：
java 复制代码 
@Transformer(inputChannel = "jsonInputChannel", outputChannel = "objectOutputChannel")
public MyObject convertJsonToObject(String jsonString) {
    // 使用Jackson库将JSON字符串转换为Java对象
    return objectMapper.readValue(jsonString, MyObject.class);
}
  • 上述代码中，@Transformer注解表示这是一个消息转换器，将jsonInputChannel通道的JSON消息转换为Java对象，并将结果发送到objectOutputChannel通道。
  • 对象到JSON的转换：
java 复制代码 
@Transformer(inputChannel = "objectInputChannel", outputChannel = "jsonOutputChannel")
public String convertObjectToJson(MyObject myObject) {
    // 使用Jackson库将Java对象转换为JSON字符串
    return objectMapper.writeValueAsString(myObject);
}
  • 在这个例子中，消息转换器将objectInputChannel通道的Java对象转换为JSON字符串，并将结果发送到jsonOutputChannel通道。

2. 路由器的作用和实际应用场景：

路由器用于根据消息的内容或特征将消息路由到不同的通道，实现消息在系统中的分发。以下是路由器的实际应用场景和示例：

  • 内容路由器：
xml 复制代码 
<int:router input-channel="inputChannel" expression="payload.type">
    <int:mapping value="A" channel="channelA"/>
    <int:mapping value="B" channel="channelB"/>
    <int:mapping value="C" channel="channelC"/>
</int:router>
  • 上述配置中，内容路由器（<int:router>）根据消息的type属性的值将消息路由到不同的通道。如果消息的type是"A"，则路由到channelA；如果是"B"，则路由到channelB，以此类推。
  • 筛选器路由器：
xml 复制代码 
<int:router input-channel="inputChannel">
    <int:mapping value="payload.type == 'A'" channel="channelA"/>
    <int:mapping value="payload.type == 'B'" channel="channelB"/>
    <int:mapping value="payload.type == 'C'" channel="channelC"/>
</int:router>
  • 在这个例子中，路由器根据筛选条件将消息路由到不同的通道。只有满足条件的消息才会被路由到相应的通道。

路由器的灵活性使得可以根据消息的内容、属性或条件进行动态的路由，从而实现系统中不同组件的消息处理逻辑的分离。路由器的配置可以根据具体的需求进行调整，以适应不同的应用场景。

集成模式与设计模式

Spring Integration中常见的集成模式：

Spring Integration提供了许多常见的集成模式，这些模式帮助开发人员构建可靠、可扩展的消息驱动系统。以下是一些常见的集成模式：

  1. 消息通道（Message Channel）：
    • 定义了消息在系统中传递的路径，是消息传递的媒介。

2.消息端点（Message Endpoint）：

    • 定义了消息的生产者或者消费者，可以是服务激活器、消息处理器等。

3.消息适配器（Message Adapter）：

    • 用于将外部系统的消息转换为Spring Integration的消息格式，实现系统与外部系统的集成。

4.消息网关（Message Gateway）：

    • 提供了对系统的入口，允许外部系统通过网关发送消息到系统中，或者从系统中获取消息。

5.消息转换器（Message Transformer）：

    • 用于对消息的格式进行转换，将消息从一种表示形式转换为另一种，以满足系统的需求。

6.消息过滤器（Message Filter）：

    • 用于过滤消息，只有满足特定条件的消息才能通过，实现对消息的筛选。

7.消息路由器（Message Router）：

    • 根据消息的内容、属性或条件将消息路由到不同的通道，实现消息的分发。

8.聚合器（Aggregator）：

    • 将多个相关的消息合并为一个消息，通常用于处理分散的消息片段。

9.分裂器（Splitter）：

    • 将一个消息拆分为多个消息，通常用于处理大块的消息内容。

10.定时器（Timer）：

    • 定期发送消息，用于实现定时任务或者轮询外部系统。

如何根据设计模式构建消息驱动的系统：

构建消息驱动的系统时，可以借鉴一些设计模式来提高系统的可维护性、可扩展性和可测试性。以下是一些常用的设计模式，特别是在消息驱动系统中的应用：

  1. 发布-订阅模式（Publish-Subscribe Pattern）：
    • 在消息驱动系统中，通过使用发布-订阅模式可以实现消息的广播，允许多个组件订阅并接收相同的消息。

2.观察者模式（Observer Pattern）：

    • 观察者模式可以用于实现消息的订阅和通知机制，在消息产生时通知所有的观察者。

3.策略模式（Strategy Pattern）：

    • 策略模式可用于实现灵活的消息处理策略，根据不同的需求选择不同的消息处理算法。

4.装饰者模式（Decorator Pattern）：

    • 装饰者模式可用于动态地添加消息处理逻辑，如消息转换器、消息过滤器等。

5.责任链模式（Chain of Responsibility Pattern）：

    • 责任链模式可用于实现消息处理管道，每个处理器负责处理特定类型的消息，形成一个处理链。

6.命令模式（Command Pattern）：

    • 命令模式可以将消息封装为命令对象，以支持撤销、重做等操作。

7.工厂模式（Factory Pattern）：

    • 工厂模式可用于创建消息适配器、消息处理器等组件，提供一种灵活的对象创建方式。

通过结合这些设计模式，可以更好地组织和管理消息驱动系统的代码，使系统更易于扩展和维护。选择适当的设计模式取决于系统的特定需求和架构。

Spring Integration中流程和通道拦截的实现方法

在Spring Integration中，可以通过拦截器（Interceptor）来对消息通道和流程进行拦截和处理。拦截器允许在消息在通道中传递和处理的过程中执行自定义逻辑。

1. 通道拦截：

在通道级别，可以使用通道拦截器来对消息通道的发送和接收进行拦截。

xml 复制代码 
<int:channel id="myChannel">
    <int:interceptors>
        <int:wire-tap channel="logChannel"/>
    </int:interceptors>
</int:channel>

上述配置中，<int:wire-tap>是一个通道拦截器，将通道上的所有消息发送到logChannel通道，以便记录日志或进行其他操作。

2. 流程拦截：

在流程级别，可以使用<int:advice>和<int:expression-advice>等元素来添加拦截器。

xml 复制代码 
<int:service-activator input-channel="inputChannel" output-channel="outputChannel">
    <int:advice-chain>
        <int:expression-advice expression="payload.toUpperCase()"/>
    </int:advice-chain>
</int:service-activator>

在上述配置中，<int:expression-advice>是一个流程拦截器，它使用SpEL表达式将消息内容转换为大写。

拦截器的应用和自定义：

1. 内置拦截器的应用：

Spring Integration提供了一些内置的拦截器，如WireTap、LoggingHandler等，用于实现常见的拦截需求。例如：

xml 复制代码 
<int:channel id="inputChannel">
    <int:interceptors>
        <int:wire-tap channel="logChannel"/>
    </int:interceptors>
</int:channel>

上述配置中，使用了内置的WireTap拦截器，将通道上的所有消息发送到logChannel通道。

2. 自定义拦截器：

可以通过实现ChannelInterceptor接口或扩展ChannelInterceptorAdapter类来创建自定义的通道拦截器。同样，通过实现Advice接口或扩展AbstractRequestHandlerAdvice类可以创建自定义的流程拦截器。

java 复制代码 
public class CustomChannelInterceptor implements ChannelInterceptor {
    @Override
    public Message<?> preSend(Message<?> message, MessageChannel channel) {
        // 在消息发送之前执行的逻辑
        return message;
    }
    
    @Override
    public void afterSendCompletion(Message<?> message, MessageChannel channel, boolean sent, Exception ex) {
        // 在消息发送完成后执行的逻辑
    }
    
    // 其他方法省略
}
xml 复制代码 
<int:service-activator input-channel="inputChannel" output-channel="outputChannel">
    <int:advice-chain>
        <bean class="com.example.CustomExpressionAdvice"/>
    </int:advice-chain>
</int:service-activator>

上述配置中，使用了自定义的流程拦截器CustomExpressionAdvice，该类需实现Advice接口。

通过应用内置或自定义的拦截器，可以在消息处理的不同阶段执行自定义的逻辑，如日志记录、性能监控、消息转换等。

实战

传统订单处理流程往往涉及多个手动步骤，容易导致延迟和错误。为了提高电商平台的运作效率，客户那边要求我们开发一个自动化订单处理系统，从订单创建到支付、库存检查和发货全流程自动化处理，通过消息触发相关的业务逻辑，减少人为失误。

1.添加依赖：

xml 复制代码 
<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>

2.启动类Application：

java 复制代码 
@SpringBootApplication
@IntegrationComponentScan
public class OrderProcessingApplication {

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

3.配置消息通道

java 复制代码 
/**
 * 配置消息通道
 */
@Configuration
public class IntegrationConfig {

    /**
     * 定义订单创建的消息通道
     * @return DirectChannel 实例
     */
    @Bean
    public MessageChannel orderCreatedChannel() {
        return new DirectChannel();
    }

    /**
     * 定义支付处理的消息通道
     * @return DirectChannel 实例
     */
    @Bean
    public MessageChannel paymentProcessedChannel() {
        return new DirectChannel();
    }

    /**
     * 定义库存检查的消息通道
     * @return DirectChannel 实例
     */
    @Bean
    public MessageChannel inventoryCheckedChannel() {
        return new DirectChannel();
    }

    /**
     * 定义发货调度的消息通道
     * @return DirectChannel 实例
     */
    @Bean
    public MessageChannel shipmentScheduledChannel() {
        return new DirectChannel();
    }
}

4.Controller

java 复制代码 
@RestController
@RequestMapping("/orders")
public class OrderController {

    private final OrderService orderService;

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

    /**
     * 创建订单的API端点
     * @param order 订单对象
     * @return 成功消息
     */
    @PostMapping
    public String createOrder(@RequestBody Order order) {
        orderService.createOrder(order);
        return"Order created successfully";
    }
}

5.订单服务

java 复制代码 
/**
 * 订单服务类，负责创建订单并将订单信息发送到相应的消息通道
 */
@Service
public class OrderService {

    private final OrderGateway gateway;

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

    /**
     * 创建订单并触发订单创建流程
     * @param order 订单对象
     */
    public void createOrder(Order order) {
        System.out.println("Creating order: " + order.getOrderId());
        // 将订单发送到orderCreatedChannel消息通道
        gateway.processOrder(order);
    }
}

6.支付处理服务

java 复制代码 
/**
 * 支付处理服务类，监听订单创建消息通道，处理支付逻辑
 */
@Component
public class PaymentService {

    private final OrderGateway gateway;

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

    /**
     * 处理订单创建消息，模拟支付处理
     * @param order 订单对象
     */
    @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());
        // 假设支付成功
        gateway.processPayment(order);
    }
}

7.库存检查服务

java 复制代码 
/**
 * 库存检查服务类，监听支付处理消息通道，检查库存并决定是否发货
 */
@Component
public class InventoryService {

    private final OrderGateway gateway;

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

    /**
     * 处理支付处理消息，检查库存
     * @param order 订单对象
     */
    @ServiceActivator(inputChannel = "paymentProcessedChannel")
    public void checkInventory(@Payload Order order) {
        System.out.println("Checking inventory for product: " + order.getProductId());
        // 模拟库存检查
        boolean isInStock = true; // 假设库存充足
        if (isInStock) {
            System.out.println("Product is in stock.");
            gateway.scheduleShipment(order);
        } else {
            System.out.println("Product is out of stock.");
            // 通知用户的逻辑,自己写吧
        }
    }
}

8.发货调度服务

java 复制代码 
/**
 * 发货调度服务类，监听发货调度消息通道，安排发货
 */
@Component
public class ShipmentService {

    /**
     * 处理发货调度消息，模拟发货
     * @param order 订单对象
     */
    @ServiceActivator(inputChannel = "shipmentScheduledChannel")
    public void scheduleShipment(@Payload Order order) {
        System.out.println("Scheduling shipment for order: " + order.getOrderId());
        // 模拟发货调度
        System.out.println("Shipment scheduled for order: " + order.getOrderId());
    }
}

9.订单处理相关的消息网关接口

java 复制代码 
/**
 * 定义订单处理相关的消息网关接口
 */
public interface OrderGateway {

    /**
     * 将订单发送到orderCreatedChannel消息通道
     * @param order 订单对象
     */
    @Gateway(requestChannel = "orderCreatedChannel")
    void processOrder(Order order);

    /**
     * 将订单发送到paymentProcessedChannel消息通道
     * @param order 订单对象
     */
    @Gateway(requestChannel = "paymentProcessedChannel")
    void processPayment(Order order);

    /**
     * 将订单发送到inventoryCheckedChannel消息通道
     * @param order 订单对象
     */
    @Gateway(requestChannel = "inventoryCheckedChannel")
    void checkInventory(Order order);

    /**
     * 将订单发送到shipmentScheduledChannel消息通道
     * @param order 订单对象
     */
    @Gateway(requestChannel = "shipmentScheduledChannel")
    void scheduleShipment(Order order);
}

10.测试

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

11.测试日志

java 复制代码 
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
相关推荐
Touper.4 分钟前
JavaSE -- 泛型详细介绍
java·开发语言·算法
静若繁花_jingjing21 分钟前
Redis线程模型
java·数据库·redis
hello早上好42 分钟前
CGLIB代理核心原理
java·spring
魔镜魔镜_谁是世界上最漂亮的小仙女43 分钟前
java-web开发
java·后端·架构
爱吃小土豆豆豆豆44 分钟前
定时器和守护线程
java
Seven971 小时前
了解GC吗？什么是GC？
java
Edingbrugh.南空1 小时前
Flink ClickHouse 连接器维表源码深度解析
java·clickhouse·flink
掘金-我是哪吒2 小时前
分布式微服务系统架构第157集：JavaPlus技术文档平台日更-Java多线程编程技巧
java·分布式·微服务·云原生·架构
飞翔的佩奇2 小时前
Java项目：基于SSM框架实现的忘忧小区物业管理系统【ssm+B/S架构+源码+数据库+毕业论文+开题报告】
java·数据库·mysql·vue·毕业设计·ssm框架·小区物业管理系统
RainbowSea2 小时前
跨域问题(Allow CORS)解决(3 种方法)
java·spring boot·后端
热门推荐
01集群聊天服务器---MySQL数据库的建立02GPU 进阶笔记（二）：华为昇腾 910B GPU03Coze扣子平台完整体验和实践（附国内和国际版对比）04使用Ruby接入实时行情API教程05Word粘贴时出现“运行时错误53,文件未找到：MathPage.WLL“的解决方案06扣子（coze）实战|我用扣子搭建了一个自动分析小红薯笔记内容的AI应用|详细步骤拆解07Java学习第十五部分——MyBatis08扣子空间的使用教程与大模型技术思考09DeepSeek各版本说明与优缺点分析10基于odoo17的设计模式详解---装饰模式