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
相关推荐
考虑考虑37 分钟前
JDK9中的dropWhile
java·后端·java ee
想躺平的咸鱼干1 小时前
Volatile解决指令重排和单例模式
java·开发语言·单例模式·线程·并发编程
hqxstudying1 小时前
java依赖注入方法
java·spring·log4j·ioc·依赖
·云扬·1 小时前
【Java源码阅读系列37】深度解读Java BufferedReader 源码
java·开发语言
Bug退退退1232 小时前
RabbitMQ 高级特性之重试机制
java·分布式·spring·rabbitmq
小皮侠2 小时前
nginx的使用
java·运维·服务器·前端·git·nginx·github
Zz_waiting.3 小时前
Javaweb - 10.4 ServletConfig 和 ServletContext
java·开发语言·前端·servlet·servletconfig·servletcontext·域对象
全栈凯哥3 小时前
02.SpringBoot常用Utils工具类详解
java·spring boot·后端
兮动人3 小时前
获取终端外网IP地址
java·网络·网络协议·tcp/ip·获取终端外网ip地址
呆呆的小鳄鱼3 小时前
cin,cin.get()等异同点[面试题系列]
java·算法·面试
热门推荐
01集群聊天服务器---MySQL数据库的建立02GPU 进阶笔记（二）：华为昇腾 910B GPU03Coze扣子平台完整体验和实践（附国内和国际版对比）04使用Ruby接入实时行情API教程05Word粘贴时出现“运行时错误53,文件未找到：MathPage.WLL“的解决方案06扣子（coze）实战|我用扣子搭建了一个自动分析小红薯笔记内容的AI应用|详细步骤拆解07Java学习第十五部分——MyBatis08扣子空间的使用教程与大模型技术思考09DeepSeek各版本说明与优缺点分析10基于odoo17的设计模式详解---装饰模式