# 消息传递

Spring 框架为与消息传递系统集成提供了广泛的支持,从使用JmsTemplate的 JMS API 的简化使用到异步接收消息的完整基础设施。 Spring AMQP 为高级消息队列协议提供了类似的功能集。 Spring Boot 还提供了RabbitTemplate和 RabbitMQ 的自动配置选项。 Spring WebSocket 原生地包括对 Stomp 消息传递的支持,并且 Spring 引导通过启动器和少量自动配置对此提供支持。 Spring Boot 还支持 Apache Kafka。

# 1. JMS

javax.jms.ConnectionFactory接口提供了一种标准方法来创建用于与 JMS 代理交互的javax.jms.Connection。尽管 Spring 需要ConnectionFactory来处理 JMS,但你通常不需要自己直接使用它,而是可以依赖于更高级别的消息传递抽象。(有关详细信息,请参见 Spring Framework 参考文档的相关部分 (opens new window)。) Spring Boot 还自动配置发送和接收消息所需的基础设施。

# 1.1.ActiveMQ 支持

ActiveMQ (opens new window)在 Classpath 上可用时, Spring 引导也可以配置ConnectionFactory。如果存在代理,则会自动启动并配置嵌入式代理(前提是通过配置未指定代理 URL,并且在配置中未禁用嵌入式代理)。

如果使用spring-boot-starter-activemq,则提供了连接或嵌入 ActiveMQ 实例所需的依赖关系, Spring 与 JMS 集成的基础设施也是如此。

ActiveMQ 配置由spring.activemq.*中的外部配置属性控制。

默认情况下,ActiveMQ 被自动配置为使用VM 传输 (opens new window),它启动嵌入在同一 JVM 实例中的代理。

可以通过配置spring.activemq.in-memory属性禁用嵌入式代理,如以下示例所示:

属性

spring.activemq.in-memory=false

Yaml

spring:
  activemq:
    in-memory: false

如果你配置代理 URL,那么嵌入式代理也将被禁用,如以下示例所示:

属性

spring.activemq.broker-url=tcp://192.168.1.210:9876
spring.activemq.user=admin
spring.activemq.password=secret

Yaml

spring:
  activemq:
    broker-url: "tcp://192.168.1.210:9876"
    user: "admin"
    password: "secret"

如果你想完全控制嵌入式代理,请参阅ActiveMQ 文档 (opens new window)以获取更多信息。

默认情况下,CachingConnectionFactory将本机ConnectionFactory包装成合理的设置,你可以通过spring.jms.*中的外部配置属性来控制这些设置:

属性

spring.jms.cache.session-cache-size=5

Yaml

spring:
  jms:
    cache:
      session-cache-size: 5

如果你更愿意使用本机池,那么可以通过向org.messaginghub:pooled-jms添加一个依赖项并相应地配置JmsPoolConnectionFactory来实现,如下面的示例所示:

属性

spring.activemq.pool.enabled=true
spring.activemq.pool.max-connections=50

Yaml

spring:
  activemq:
    pool:
      enabled: true
      max-connections: 50
参见[ActiveMQ属性](https://github.com/ Spring-projects/ Spring-boot/tree/v2.6.4/ Spring-boot-project/ Spring-boot-autofigure/SRC/main/java/org/springframework/boot/autofigure/jms/activemq/activemqproperties.java)以获得更多支持的选项。
还可以注册任意数量的 bean 来实现ActiveMQConnectionFactoryCustomizer以进行更高级的定制。

默认情况下,ActiveMQ 会创建一个尚不存在的目标,以便根据其提供的名称对目标进行解析。

# 1.2.ActiveMQ Artemis 支持

Spring 当在 Classpath 上检测到ActiveMQ Artemis (opens new window)可用时,启动可以自动配置ConnectionFactory。如果存在代理,则会自动启动和配置嵌入式代理(除非已显式设置了 Mode 属性)。支持的模式是embedded(明确表示需要嵌入式代理,并且如果代理在 Classpath 上不可用,则应该发生错误)和native(使用netty传输协议连接到代理)。当对后者进行配置时, Spring 引导将配置一个ConnectionFactory,该代理连接到使用默认设置在本地计算机上运行的代理。

如果使用spring-boot-starter-artemis,则提供了连接到现有 ActiveMQ Artemis 实例的必要依赖项,以及 Spring 与 JMS 集成的基础设施。
org.apache.activemq:artemis-jms-server添加到应用程序中,可以使用嵌入式模式。

ActiveMQ Artemis 配置由spring.artemis.*中的外部配置属性控制。例如,你可以在application.properties中声明以下部分:

属性

spring.artemis.mode=native
spring.artemis.broker-url=tcp://192.168.1.210:9876
spring.artemis.user=admin
spring.artemis.password=secret

Yaml

spring:
  artemis:
    mode: native
    broker-url: "tcp://192.168.1.210:9876"
    user: "admin"
    password: "secret"

嵌入代理时,你可以选择是否要启用持久性,并列出应该使其可用的目标。它们可以指定为逗号分隔的列表,以使用默认选项创建它们,或者你可以分别为高级队列和主题配置定义类型org.apache.activemq.artemis.jms.server.config.JMSQueueConfigurationorg.apache.activemq.artemis.jms.server.config.TopicConfiguration的 Bean(s)。

默认情况下,CachingConnectionFactory将本机ConnectionFactory包装成合理的设置,你可以通过spring.jms.*中的外部配置属性来控制这些设置:

属性

spring.jms.cache.session-cache-size=5

Yaml

spring:
  jms:
    cache:
      session-cache-size: 5

如果你更愿意使用本机池,那么可以通过向org.messaginghub:pooled-jms添加一个依赖项并相应地配置JmsPoolConnectionFactory来实现,如下面的示例所示:

属性

spring.artemis.pool.enabled=true
spring.artemis.pool.max-connections=50

Yaml

spring:
  artemis:
    pool:
      enabled: true
      max-connections: 50

参见[Artemis属性](https://github.com/ Spring-projects/ Spring-boot/tree/v2.6.4/ Spring-boot-project/ Spring-boot-autofigure/SRC/main/java/org/springframework/boot/autofigure/jms/artemis/artemproperties.java)以获得更多支持的选项。

不涉及 JNDI 查找,并且使用 Artemis 配置中的name属性或通过配置提供的名称,根据它们的名称解析目标。

# 1.3.使用 JNDI ConnectionFactory

如果你在应用程序服务器中运行你的应用程序, Spring 引导将尝试通过使用 JNDI 来定位 JMSConnectionFactory。默认情况下,将检查java:/JmsXAjava:/XAConnectionFactory位置。如果需要指定替代位置,可以使用spring.jms.jndi-name属性,如下例所示:

属性

spring.jms.jndi-name=java:/MyConnectionFactory

Yaml

spring:
  jms:
    jndi-name: "java:/MyConnectionFactory"

# 1.4.发送消息

Spring 的JmsTemplate是自动配置的,你可以直接将其自动连接到自己的 bean 中,如以下示例所示:

import org.springframework.jms.core.JmsTemplate;
import org.springframework.stereotype.Component;

@Component
public class MyBean {

    private final JmsTemplate jmsTemplate;

    public MyBean(JmsTemplate jmsTemplate) {
        this.jmsTemplate = jmsTemplate;
    }

    // ...

    public void someMethod() {
        this.jmsTemplate.convertAndSend("hello");
    }

}

[JmsMessagingTemplate](https://DOCS. Spring.io/ Spring-framework/DOCS/5.3.16/javadoc-api/org/springframework/jms/core/jmssagingtemplate.html)可以以类似的方式注入。
如果定义了DestinationResolverMessageConverter Bean,则自动关联到自动配置的JmsTemplate

# 1.5.接收消息

当存在 JMS 基础设施时,任何 Bean 都可以用@JmsListener进行注释,以创建侦听器端点。如果没有JmsListenerContainerFactory被定义,一个默认的是自动配置的。如果定义了DestinationResolverMessageConverterjavax.jms.ExceptionListenerbean,则它们将自动与默认工厂关联。

默认情况下,默认工厂是事务性的。如果在存在JtaTransactionManager的基础设施中运行,则默认情况下它与侦听器容器关联。如果没有,则启用sessionTransacted标志。在后一种场景中,可以通过在侦听器方法(或其委托)上添加@Transactional,将本地数据存储事务与传入消息的处理相关联。这可以确保在本地事务完成后确认传入消息。这还包括发送在同一 JMS 会话上执行的响应消息。

以下组件在someQueue目标上创建一个侦听器端点:

import org.springframework.jms.annotation.JmsListener;
import org.springframework.stereotype.Component;

@Component
public class MyBean {

    @JmsListener(destination = "someQueue")
    public void processMessage(String content) {
        // ...
    }

}

有关更多详细信息,请参见[@EnableJms的 Javadoc](https://DOCS. Spring.io/ Spring-framework/DOCS/5.3.16/javadoc-api/org/springframework/jms/annotation/enablejms.html)。

如果你需要创建更多的JmsListenerContainerFactory实例,或者如果你想重写默认值, Spring Boot 提供了一个DefaultJmsListenerContainerFactoryConfigurer,你可以使用它初始化DefaultJmsListenerContainerFactory,并使用与自动配置的设置相同的设置。

例如,下面的示例公开了另一个使用特定MessageConverter的工厂:

import javax.jms.ConnectionFactory;

import org.springframework.boot.autoconfigure.jms.DefaultJmsListenerContainerFactoryConfigurer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jms.config.DefaultJmsListenerContainerFactory;

@Configuration(proxyBeanMethods = false)
public class MyJmsConfiguration {

    @Bean
    public DefaultJmsListenerContainerFactory myFactory(DefaultJmsListenerContainerFactoryConfigurer configurer) {
        DefaultJmsListenerContainerFactory factory = new DefaultJmsListenerContainerFactory();
        ConnectionFactory connectionFactory = getCustomConnectionFactory();
        configurer.configure(factory, connectionFactory);
        factory.setMessageConverter(new MyMessageConverter());
        return factory;
    }

    private ConnectionFactory getCustomConnectionFactory() {
        return ...
    }

}

然后,你可以在任何@JmsListener注释的方法中使用工厂,如下所示:

import org.springframework.jms.annotation.JmsListener;
import org.springframework.stereotype.Component;

@Component
public class MyBean {

    @JmsListener(destination = "someQueue", containerFactory = "myFactory")
    public void processMessage(String content) {
        // ...
    }

}

# 2. AMQP

高级消息队列协议是一种面向消息中间件的平台中立、线路级协议。 Spring AMQP 项目将核心 Spring 概念应用于基于 AMQP 的消息传递解决方案的开发。 Spring Boot 为通过 RabbitMQ 使用 AMQP 提供了几种便利,包括spring-boot-starter-amqp“starter”。

# 2.1.RabbitMQ 支持

RabbitMQ (opens new window)是一种基于 AMQP 协议的轻量级、可靠、可扩展和可移植的消息代理。 Spring 使用RabbitMQ通过 AMQP 协议进行通信。

RabbitMQ 配置由spring.rabbitmq.*中的外部配置属性控制。例如,你可以在application.properties中声明以下部分:

属性

spring.rabbitmq.host=localhost
spring.rabbitmq.port=5672
spring.rabbitmq.username=admin
spring.rabbitmq.password=secret

Yaml

spring:
  rabbitmq:
    host: "localhost"
    port: 5672
    username: "admin"
    password: "secret"

或者,你可以使用addresses属性配置相同的连接:

属性

spring.rabbitmq.addresses=amqp://admin:[email protected]

Yaml

spring:
  rabbitmq:
    addresses: "amqp://admin:[email protected]"
当以这种方式指定地址时,hostport属性将被忽略。
如果地址使用amqps协议,则将自动启用 SSL 支持。

参见[Rabbit属性](https://github.com/ Spring-projects/ Spring-boot/tree/v2.6.4/ Spring-boot-project/ Spring-boot-autofigure/SRC/main/java/org/springframework/boot/autofigure/amqp/rabbitproperties.java)以获得更多支持的基于属性的配置选项。要配置 Spring AMQP 使用的 RabbitMQConnectionFactory的较低级别的详细信息,请定义ConnectionFactoryCustomizer Bean。

如果在上下文中存在ConnectionNameStrategy Bean,则将自动使用它来命名由自动配置的CachingConnectionFactory创建的连接。

有关更多详细信息,请参见理解 RabbitMQ 使用的协议 AMQP (opens new window)

# 2.2.发送消息

Spring 的AmqpTemplateAmqpAdmin是自动配置的,你可以将它们直接自动连接到自己的 bean 中,如以下示例所示:

import org.springframework.amqp.core.AmqpAdmin;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.stereotype.Component;

@Component
public class MyBean {

    private final AmqpAdmin amqpAdmin;

    private final AmqpTemplate amqpTemplate;

    public MyBean(AmqpAdmin amqpAdmin, AmqpTemplate amqpTemplate) {
        this.amqpAdmin = amqpAdmin;
        this.amqpTemplate = amqpTemplate;
    }

    // ...

    public void someMethod() {
        this.amqpAdmin.getQueueInfo("someQueue");
    }

    public void someOtherMethod() {
        this.amqpTemplate.convertAndSend("hello");
    }

}

[RabbitMessagingTemplate](https://DOCS. Spring.io/ Spring-amqp/DOCS/2.4.2/api/org/springframework/amqp/rabbit/core/rabbitmessagingtemplate.html)可以以类似的方式注入。
如果定义了MessageConverter Bean,则自动关联到自动配置的AmqpTemplate

如果有必要,任何被定义为 Bean 的org.springframework.amqp.core.Queue都会自动用于在 RabbitMQ 实例上声明相应的队列。

要重试操作,你可以在AmqpTemplate上启用重试(例如,在代理连接丢失的情况下):

属性

spring.rabbitmq.template.retry.enabled=true
spring.rabbitmq.template.retry.initial-interval=2s

Yaml

spring:
  rabbitmq:
    template:
      retry:
        enabled: true
        initial-interval: "2s"

默认情况下,重试是禁用的。你还可以通过声明一个RabbitRetryTemplateCustomizer Bean 以编程方式定制RetryTemplate

如果你需要创建更多的RabbitTemplate实例,或者如果你想要重写默认值, Spring boot 提供了一个RabbitTemplateConfigurer Bean,你可以使用它初始化RabbitTemplate,并使用与自动配置所使用的工厂相同的设置。

# 2.3.接收消息

当 Rabbit 基础结构存在时,任何 Bean 都可以用@RabbitListener进行注释,以创建侦听器端点。如果没有RabbitListenerContainerFactory已被定义,一个默认的SimpleRabbitListenerContainerFactory将被自动配置,并且你可以使用spring.rabbitmq.listener.type属性切换到一个直接容器。如果定义了MessageConverterMessageRecoverer Bean,则会自动与默认工厂关联。

以下示例组件在someQueue队列上创建一个侦听器端点:

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class MyBean {

    @RabbitListener(queues = "someQueue")
    public void processMessage(String content) {
        // ...
    }

}

有关更多详细信息,请参见[@EnableRabbit的 javadoc](https://DOCS. Spring.io/ Spring-amqp/DOCS/2.4.2/api/org/springframework/amqp/rabbit/annotation/enablerabbit.html)。

如果你需要创建更多的RabbitListenerContainerFactory实例,或者你想要重写默认值, Spring Boot 提供了一个SimpleRabbitListenerContainerFactoryConfigurer和一个DirectRabbitListenerContainerFactoryConfigurer,你可以使用它们初始化一个SimpleRabbitListenerContainerFactory和一个DirectRabbitListenerContainerFactory,其设置与自动配置所使用的工厂相同。

选择哪种容器类型并不重要。
这两个 bean 是通过自动配置公开的。

例如,下面的配置类公开了另一个使用特定MessageConverter的工厂:

import org.springframework.amqp.rabbit.config.SimpleRabbitListenerContainerFactory;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.boot.autoconfigure.amqp.SimpleRabbitListenerContainerFactoryConfigurer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration(proxyBeanMethods = false)
public class MyRabbitConfiguration {

    @Bean
    public SimpleRabbitListenerContainerFactory myFactory(SimpleRabbitListenerContainerFactoryConfigurer configurer) {
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        ConnectionFactory connectionFactory = getCustomConnectionFactory();
        configurer.configure(factory, connectionFactory);
        factory.setMessageConverter(new MyMessageConverter());
        return factory;
    }

    private ConnectionFactory getCustomConnectionFactory() {
        return ...
    }

}

然后,你可以在任何@RabbitListener-注释的方法中使用工厂,如下所示:

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class MyBean {

    @RabbitListener(queues = "someQueue", containerFactory = "myFactory")
    public void processMessage(String content) {
        // ...
    }

}

你可以启用重试来处理侦听器抛出异常的情况。默认情况下,使用RejectAndDontRequeueRecoverer,但你可以定义自己的MessageRecoverer。当重复尝试用完时,消息将被拒绝,如果代理配置为这样做,消息将被丢弃或路由到死信交换。默认情况下,重试是禁用的。你还可以通过声明一个RabbitRetryTemplateCustomizer Bean 以编程方式定制RetryTemplate

默认情况下,如果禁用了重试,并且侦听器抛出了异常,交付将无限期地重试。
你可以通过两种方式修改此行为:将defaultRequeueRejected属性设置为false所以尝试进行零次重新交付或抛出AmqpRejectAndDontRequeueException以表示消息应被拒绝。
后者是在启用重试并达到最大交付尝试次数时使用的机制。

# 3. Apache Kafka 支持

Apache Kafka (opens new window)通过提供spring-kafka项目的自动配置而得到支持。

Kafka 配置由spring.kafka.*中的外部配置属性控制。例如,你可以在application.properties中声明以下部分:

属性

spring.kafka.bootstrap-servers=localhost:9092
spring.kafka.consumer.group-id=myGroup

Yaml

spring:
  kafka:
    bootstrap-servers: "localhost:9092"
    consumer:
      group-id: "myGroup"
要在启动时创建主题,请添加类型NewTopic的 Bean。如果主题已经存在,则忽略 Bean。

参见[Kafka属性](https://github.com/ Spring-projects/ Spring-boot/tree/v2.6.4/ Spring-boot-project/ Spring-boot-autofigure/SRC/main/java/org/springframework/boot/autofigure/kafka/kaproperties.java)以获得更多支持的选项。

# 3.1.发送消息

Spring 的KafkaTemplate是自动配置的,你可以直接在自己的 bean 中自动连接它,如以下示例所示:

import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Component;

@Component
public class MyBean {

    private final KafkaTemplate<String, String> kafkaTemplate;

    public MyBean(KafkaTemplate<String, String> kafkaTemplate) {
        this.kafkaTemplate = kafkaTemplate;
    }

    // ...

    public void someMethod() {
        this.kafkaTemplate.send("someTopic", "Hello");
    }

}

如果定义了属性spring.kafka.producer.transaction-id-prefix,则自动配置一个KafkaTransactionManager
同样,如果定义了一个RecordMessageConverter Bean,则自动将其关联到自动配置的KafkaTemplate

# 3.2.接收消息

当存在 Apache Kafka 基础设施时,任何 Bean 都可以用@KafkaListener进行注释,以创建侦听器端点。如果没有KafkaListenerContainerFactory被定义,默认的一个是自动配置与spring.kafka.listener.*中定义的键。

以下组件在someTopic主题上创建一个侦听器端点:

import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Component;

@Component
public class MyBean {

    @KafkaListener(topics = "someTopic")
    public void processMessage(String content) {
        // ...
    }

}

如果定义了KafkaTransactionManager Bean,则它将自动与容器工厂关联。类似地,如果定义了一个RecordFilterStrategyCommonErrorHandlerAfterRollbackProcessorConsumerAwareRebalanceListener Bean,则它将自动关联到默认工厂。

根据侦听器类型,与默认工厂关联的是RecordMessageConverterBatchMessageConverter Bean。如果批处理侦听器仅存在一个RecordMessageConverter Bean,则将其包装在BatchMessageConverter中。

自定义ChainedKafkaTransactionManager必须标记@Primary,因为它通常引用自动配置的KafkaTransactionManager Bean。

# 3.3.卡夫卡溪流

Spring 对于 Apache,Kafka 提供了一种工厂 Bean 来创建StreamsBuilder对象并管理其流的生命周期。 Spring 引导自动配置所需的KafkaStreamsConfiguration Bean,只要kafka-streams在 Classpath 上并且 Kafka 流是由@EnableKafkaStreams注释启用的。

启用 Kafka 流意味着必须设置应用程序 ID 和引导程序服务器。前者可以使用spring.kafka.streams.application-id进行配置,如果没有设置,则默认为spring.application.name。后者可以全局设置,也可以只针对流专门重写。

使用专用属性可以获得几个附加属性;可以使用spring.kafka.streams.properties名称空间设置其他任意 Kafka 属性。有关更多信息,请参见features.html

要使用工厂 Bean,将StreamsBuilder连接到你的@Bean中,如以下示例所示:

import org.apache.kafka.common.serialization.Serdes;
import org.apache.kafka.streams.KeyValue;
import org.apache.kafka.streams.StreamsBuilder;
import org.apache.kafka.streams.kstream.KStream;
import org.apache.kafka.streams.kstream.Produced;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.annotation.EnableKafkaStreams;
import org.springframework.kafka.support.serializer.JsonSerde;

@Configuration(proxyBeanMethods = false)
@EnableKafkaStreams
public class MyKafkaStreamsConfiguration {

    @Bean
    public KStream<Integer, String> kStream(StreamsBuilder streamsBuilder) {
        KStream<Integer, String> stream = streamsBuilder.stream("ks1In");
        stream.map(this::uppercaseValue).to("ks1Out", Produced.with(Serdes.Integer(), new JsonSerde<>()));
        return stream;
    }

    private KeyValue<Integer, String> uppercaseValue(Integer key, String value) {
        return new KeyValue<>(key, value.toUpperCase());
    }

}

默认情况下,由它创建的StreamBuilder对象管理的流是自动启动的。你可以使用spring.kafka.streams.auto-startup属性自定义此行为。

# 3.4.其他卡夫卡物业

Auto Configuration 支持的属性显示在附录的“集成属性”部分中。请注意,在大多数情况下,这些属性(连字符或 CamelCase)直接映射到 Apache Kafka 点线属性。有关详细信息,请参见 Apache Kafka 文档。

这些属性中的前几个应用于所有组件(生产者、消费者、管理员和流),但如果你希望使用不同的值,则可以在组件级别指定这些属性。Apache Kafka 将属性的重要性指定为高、中或低。 Spring 引导自动配置支持所有高重要性属性、一些选定的中低属性以及不具有默认值的任何属性。

只有 Kafka 支持的属性的一个子集可以直接通过Kafka属性类获得。如果你希望为生产者或消费者配置不受直接支持的附加属性,请使用以下属性:

属性

spring.kafka.properties[prop.one]=first
spring.kafka.admin.properties[prop.two]=second
spring.kafka.consumer.properties[prop.three]=third
spring.kafka.producer.properties[prop.four]=fourth
spring.kafka.streams.properties[prop.five]=fifth

Yaml

spring:
  kafka:
    properties:
      "[prop.one]": "first"
    admin:
      properties:
        "[prop.two]": "second"
    consumer:
      properties:
        "[prop.three]": "third"
    producer:
      properties:
        "[prop.four]": "fourth"
    streams:
      properties:
        "[prop.five]": "fifth"

这会将常见的prop.oneKafka 属性设置为first(适用于生产者、消费者和管理员),将prop.two管理属性设置为second,将prop.three消费者属性设置为prop.four生产者属性设置为fourth,将prop.five流属性设置为fifth

还可以将 Spring kafkaJsonDeserializer配置如下:

属性

spring.kafka.consumer.value-deserializer=org.springframework.kafka.support.serializer.JsonDeserializer
spring.kafka.consumer.properties[spring.json.value.default.type]=com.example.Invoice
spring.kafka.consumer.properties[spring.json.trusted.packages]=com.example.main,com.example.another

Yaml

spring:
  kafka:
    consumer:
      value-deserializer: "org.springframework.kafka.support.serializer.JsonDeserializer"
      properties:
        "[spring.json.value.default.type]": "com.example.Invoice"
        "[spring.json.trusted.packages]": "com.example.main,com.example.another"

类似地,你可以禁用JsonSerializer在标题中发送类型信息的默认行为:

属性

spring.kafka.producer.value-serializer=org.springframework.kafka.support.serializer.JsonSerializer
spring.kafka.producer.properties[spring.json.add.type.headers]=false

Yaml

spring:
  kafka:
    producer:
      value-serializer: "org.springframework.kafka.support.serializer.JsonSerializer"
      properties:
        "[spring.json.add.type.headers]": false
以这种方式设置的属性覆盖 Spring 引导明确支持的任何配置项。

# 3.5.嵌入式 Kafka 测试

Spring 对于 Apache Kafka 提供了一种方便的方式来测试带有嵌入式 Apache Kafka 代理的项目。要使用此功能,请在spring-kafka-test模块中用@EmbeddedKafka注释一个测试类。有关更多信息,请参见 Apache Kafka参考手册 (opens new window)的 Spring。

要使 Spring 引导自动配置与前面提到的嵌入式 Apache Kafka 代理一起工作,你需要将嵌入式代理地址(由EmbeddedKafkaBroker填充)的系统属性重新映射到 Apache Kafka 的 Spring 引导配置属性中。有几种方法可以做到这一点:

  • 提供一个系统属性,将嵌入式代理地址映射到测试类中的spring.kafka.bootstrap-servers:
static {
    System.setProperty(EmbeddedKafkaBroker.BROKER_LIST_PROPERTY, "spring.kafka.bootstrap-servers");
}

  • @EmbeddedKafka注释上配置属性名:
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.kafka.test.context.EmbeddedKafka;

@SpringBootTest
@EmbeddedKafka(topics = "someTopic", bootstrapServersProperty = "spring.kafka.bootstrap-servers")
class MyTest {

    // ...

}

  • 在配置属性中使用占位符:

属性

spring.kafka.bootstrap-servers=${spring.embedded.kafka.brokers}

Yaml

spring:
  kafka:
    bootstrap-servers: "${spring.embedded.kafka.brokers}"

# 4. RSocket

RSocket (opens new window)是一种用于字节流传输的二进制协议。它支持通过在单个连接上传递异步消息的对称交互模型。

Spring 框架的spring-messaging模块在客户端和服务器端为 RSocket 请求者和响应者提供支持。有关更多详细信息,请参见 Spring 框架引用的RSocket 部分 (opens new window),包括 RSocket 协议的概述。

# 4.1.RSocket 策略自动配置

Spring 引导自动配置RSocketStrategies Bean,该配置提供了编码和解码 RSocket 有效负载所需的所有基础设施。默认情况下,自动配置将尝试配置以下内容(按顺序):

  1. CBOR (opens new window)带 Jackson 的编解码器

  2. 具有 Jackson 的 JSON 编解码器

spring-boot-starter-rsocketstarter 提供了这两个依赖项。请参阅Jackson 支助科以了解更多有关定制可能性的信息。

开发人员可以通过创建实现RSocketStrategiesCustomizer接口的 bean 来定制RSocketStrategies组件。请注意,它们的@Order很重要,因为它决定了编解码器的顺序。

# 4.2.RSocket 服务器自动配置

Spring 启动提供了 RSocket 服务器的自动配置。所需的依赖关系由spring-boot-starter-rsocket提供。

Spring 启动允许在 WebSocket 上从 WebFlux 服务器公开 RSocket,或者支持独立的 RSocket 服务器。这取决于应用程序的类型及其配置。

对于 WebFlux 应用程序(类型为WebApplicationType.REACTIVE),只有在以下属性匹配的情况下,才会将 RSocket 服务器插入到 Web 服务器中:

Properties

spring.rsocket.server.mapping-path=/rsocket
spring.rsocket.server.transport=websocket

Yaml

spring:
  rsocket:
    server:
      mapping-path: "/rsocket"
      transport: "websocket"
将 RSocket 插入到 Web 服务器中只受 Reactor Netty 的支持,因为 RSocket 本身是用该库构建的。

或者,RSocket TCP 或 WebSocket 服务器作为独立的嵌入式服务器启动。除了依赖关系需求外,唯一需要的配置是为该服务器定义一个端口:

Properties

spring.rsocket.server.port=9898

Yaml

spring:
  rsocket:
    server:
      port: 9898

# 4.3. Spring 消息 RSocket 支持

Spring 启动将自动为 RSocket 配置 Spring 消息传递基础结构。

这意味着 Spring 引导将创建一个RSocketMessageHandler Bean,它将处理对应用程序的 RSocket 请求。

# 4.4.使用 RSocketRequester 调用 RSocket 服务

一旦在服务器和客户端之间建立了RSocket通道,任何一方都可以向另一方发送或接收请求。

作为服务器,你可以在 RSocket@Controller的任何处理程序方法上插入RSocketRequester实例。作为客户机,你需要首先配置和建立一个 RSocket 连接。 Spring 对于这种情况,引导自动配置带有预期编解码器的RSocketRequester.Builder,并应用任何RSocketConnectorConfigurer Bean。

RSocketRequester.Builder实例是一个原型 Bean,这意味着每个注入点都将为你提供一个新实例。这是有目的的,因为这个构建器是有状态的,你不应该使用相同的实例创建具有不同设置的请求者。

下面的代码展示了一个典型的示例:

import reactor.core.publisher.Mono;

import org.springframework.messaging.rsocket.RSocketRequester;
import org.springframework.stereotype.Service;

@Service
public class MyService {

    private final RSocketRequester rsocketRequester;

    public MyService(RSocketRequester.Builder rsocketRequesterBuilder) {
        this.rsocketRequester = rsocketRequesterBuilder.tcp("example.org", 9898);
    }

    public Mono<User> someRSocketCall(String name) {
        return this.rsocketRequester.route("user").data(name).retrieveMono(User.class);
    }

}

# 5. Spring 整合

Spring Boot 为使用Spring Integration (opens new window)提供了几种便利,包括spring-boot-starter-integration“starter”。 Spring 集成在消息传递和其他传输(例如 HTTP、TCP 和其他传输)上提供了抽象。如果 Spring 集成在你的 Classpath 上可用,则通过@EnableIntegration注释对其进行初始化。

Spring 集成轮询逻辑依赖于[自动配置的TaskScheduler](features.html#features.task-execution-and-schedule)。可以使用spring.integration.poller.*配置属性定制默认的PollerMetadata(每秒轮询无界的消息数量)。

Spring 引导还配置了由存在额外的 Spring 集成模块触发的一些特征。如果spring-integration-jmx也在 Classpath 上,则消息处理统计信息将在 JMX 上发布。如果spring-integration-jdbc可用,则可以在启动时创建默认的数据库模式,如下列所示:

Properties

spring.integration.jdbc.initialize-schema=always

Yaml

spring:
  integration:
    jdbc:
      initialize-schema: "always"

如果spring-integration-rsocket可用,开发人员可以使用"spring.rsocket.server.*"属性配置 RSocket 服务器,并让它使用IntegrationRSocketEndpointRSocketOutboundGateway组件来处理传入的 RSocket 消息。这个基础结构可以处理 Spring 集成 RSocket 通道适配器和@MessageMapping处理程序(给定"spring.integration.rsocket.server.message-mapping-enabled"是已配置的)。

Spring 启动还可以使用配置属性自动配置ClientRSocketConnector:

Properties

# Connecting to a RSocket server over TCP
spring.integration.rsocket.client.host=example.org
spring.integration.rsocket.client.port=9898

Yaml

# Connecting to a RSocket server over TCP
spring:
  integration:
    rsocket:
      client:
        host: "example.org"
        port: 9898

Properties

# Connecting to a RSocket Server over WebSocket
spring.integration.rsocket.client.uri=ws://example.org

Yaml

# Connecting to a RSocket Server over WebSocket
spring:
  integration:
    rsocket:
      client:
        uri: "ws://example.org"

参见[IntegrationAutoConfiguration](https://github.com/ Spring-projects/ Spring-boot/tree/v2.6.4/ Spring-boot-project/ Spring-boot-autofconfigure/SRC/main/java/org/org/SpringFramework/Boot/autoframework/autoframework/autoframework/AutoConfigation/AutoConfiguration/justion.java)和[<IntegrationProperties](https:///github.com/[[ Spring-projects/ Spring-

# 6. 接下来要读什么?

下一节介绍如何在应用程序中启用IO 功能。你可以在本节中阅读有关cachingmailvalidationREST 客户等内容。