SpringBoot消息源码解析：JMS基础自动配置

SpringBoot消息源码解析

Spring框架对消息系统的整合提供了广泛的支持:从简单使用 Jms Template 的 JMS API,到可接收异步消息的完整基础结构。Spring AMQP 为“高级消息队列协议”提供了类似的功能集。

同时，Spring Boot 也为 RabbitTemplate 和 Rabbit MQ 提供了自动配置选项。Spring Boot通过自动配置对 ActiveMQ、RabbitMQ 和 Apache Kafka 提供了支持。本章重点讲解 SpringBoot 对 JMS 和 ActiveMQ 的自动配置操作。

JMS 基础自动配置

JMS 的全称是 Java Message Service,即 Java 消息服务。它主要用于在生产者和消费者之间进行消息传递。JMS 只是一个标准， 在使用的时候需要有具体实现，比如后面要讲到的ActiveMQ。

在 Spring Boot 中，通过 JmsAutoConfiguration 自动配置来完成 JMS 的基础组件的初始化。

像其他自动配置-样，在 ME TA-INF/spring.factories 中可以找到注册的 JMS 自动配置类。

# Auto Configure
org. springframework . boot . autoconfigure . jms . JmsAutoConfiguration

JmsAutoConfiguration 的注解

我们先从 JmsAutoConfiguration 的注解部分看起。

@Configuration(proxyBeanMethods = false)
@Conditional0nClass({ Message . class, JmsTemplate.class })
@ConditionalOnBean(ConnectionFactory . class)
@EnableConfigurationProperties (JmsProperties .class)
@Import (JmsAnnotat ionDrivenConfiguration. class)
public class JmsAutoConfiguration {
}

@ConditionalOnClass 注解指定需要满足在 classpath 下存在javax.jms.Message 类和
org.springframework.jms.core.Jms Template 类的条件才会进行初始化。

@ConditionalOnBean 注解指定需要在容器中存在
javax.jms.ConnectionFactory 的 Bean 对象时才会被实例化。

ConnectionFactory 接口提供了用于创建与 JMS 代理进行交互的 javax.jms.Connection 的标准方法。Spring 需要 ConnectionFactory 来 与 JMS 一起使用，但是通常不需要编程人员直接使用它。

那么，ConnectionFactory 的 Bean 是在什么时候被初始化的呢?以 ActiveMQ 为例，Active-MQ 的自动配置会在 JmsAutoConfiguration 配置之前执行，并在其内部创建Connection-Factory 实现类的 Bean 对象。 其他消息框架也与此类似，至于是如何初始化的，后面关于 ActiveMQ 的自动配置的部分我们会进行详解。

@
EnableConfigurationProperties引入了JMS的配置属性类 ，对应的就 是 在application.properties 文件中配置的以“spring.jms”为前缀的属性。

@Import 引入了
JmsAnnotationDrivenConfiguration 配置，该配置类主要用于 Spring4.1 注解驱动的 JMS 的自动配置。

下面我们先看
JmsAnnotationDrivenConfiguration 的注解部分和构造方法的源代码。

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass (EnableJms .class)class JmsAnnotationDrivenConfiguration {
private final objectProvider<DestinationResolver> destinat ionResolver;
private final objectProvider<JtaTransactionManager> transactionManager J
private final objectProvider<MessageConverter> messageConverter;
private final JmsProperties properties;
JmsAnnotationDrivenConfiguration(ObjectProvider<DestinationResolver> dest
ination-
Resolver,
ObjectProvider<JtaTransactionManager> tr
ansactionManager, 0bject-
Provider<MessageConverter> messageConver
ter,
JmsProperties properties) {
this . destinationResolver = destinationResolver;
this. transactionManager = transactionManager;
this . messageConverter = messageConverter;
this. properties = properties;
}
}

@Configuration 声 明 该 类 也 是 配 置 类 ， @ConditionalOnClass 表 示 类 路 径 下 需 存 在EnableJms 类。其中 EnableJms 为一个注解类，@EnableJms 用于开启 JMS 注解，使@JmsListener 注解生效。

在之前章节已经讲过
JmsAnnotationDrivenConfiguration 的构造方法中 ObjectProvider 的作用，这里看其泛型部分类。其中 JmsProperties 参数为 JMS 的配置，前面已经提到过，下 面我们重点看其他 3 个参数。

DestinationResolver 用于解决 JMS 目标的策略接口，被 Jms Template 用于将目标名称从简单的字符串解析为实际的 Destination 实现实例。JmsTemplate 实例使用的默认Destina-tionResolver 实现
DynamicDestinationResolver 类。

该接口只有一个方法， 通过源代码可以更清晰地看出它的功能。

@FunctionalInterface
public interface Dest inationResolver
//将给定的目标名称解析为定位资源或作为动态的 Destinat ion(返回 topic 或 queue)
// Session: 为当前 JMS 的 Session
// destinat ionName:目标名称
// pubSubDomain: true 表示 pub-sub 模式，false 表示 P2P 模式
Destination resolveDestinationName (@Nullable Session session, String destina-tionName, boolean pubSubDomain) throws
JMSException;
}

Jta TransactionManager 是
PlatformTransactionManager 的实现类，它提供了 Spring 的JTA 事务管理，也可用于分布式事务的管理。关于事务相关的内容，在此不进行展开。

MessageConverter 是一个策略接口， 用于指定 Java 对象和 JMS 消息之间的转换器。

SimpleMessageConverter 作 为 其 简 单 的 默 认 实 现 ， 能 够 处 理 TextMessages 、BytesMessages、 MapMessages 和 ObjectMessages 之 间的消息转换。

public interface MessageConverter {
//转换 Java 对象到 JMS 消息
Message toMessage(object
object,
Session
session)
throws
JMSException,
MessageConversionException;
//转 JMS 消息为 Java 对象
Object fromMessage (Message message) throws JMSException, MessageConversio
nException;
}

通过 MessageConverter 接口方法的定义也能够看出它的核心功能就是进行 Java 对象与JMS 消息之间的转换。

了解完构法我们先看
DefaultJmsListenerContainerFactoryConfigurer 的初始化，代码如下。

@Bean
@ConditionalOnMissingBean
DefaultJmsListenerContainerFactoryConfigurer jmsL istenerContainerFactoryCon
rer() {
DefaultJmsL istenerContainerF actoryConfigurer configurer = new DefaultJmsL
is -
tenerContainerFactoryConfigurer();
configurer . setDestinationResolver(this . destinationResolver . getIfUnique
());
configurer . setTransactionManager(this . transactionManager . getIfUnique());
configurer . setMessageConverter(this . messageConverter . getIfUnique());
configurer . setJmsProperties (this . properties);
return configurer;
}

初始化操作就是创建一个
DefaultJmsListenerContainerFactoryConfigurer 对象，然后将上面构造方法传入的参数设置到 DefaultJmsListenerContainerFactoryConfigurer 对象中。该类的作用是配置DefaultJmsListenerContainerFactory通过DefaultJmsListenerContainerFact-oryConfigurer 中的 configure 方法将构造方法中的参数项赋值给 DefaultJmsListenerContainer-Factory.而 DefaultJmsListenerContainerFactory是个 JmsListenerContainerFactory 实现,

用于构建常规的 DefaultMessageL istenerContainer。对于大多数用户，这是默认设置，对于用于手动构建此类容器定义的用户，这应该是一个很好的过渡路径。

接下来便是
DefaultJmsListenerContainerFactory 的初始化操作，代码如下。

@Bean
@ConditionalOnSingleCandidate(Connect ionFactory. class)
@ConditionalOnMissingBean(name = "jimsListenerContainerFactory")
DefaultJmsListenerContainerFactory jmsListenerContainerFactory(
DefaultJmsListenerContainerF actoryConfigurer configurer, ConnectionFactory
connectionFactory) {
DefaultImsListenerContainerFactory factory = new DefaultJmsL istenerContai
nerFactory();
configurer . configure(factory, connectionFactory);
return factory;
}

当存在唯一候选 ConnectionFactory 的 Bean 并且当 name 为
jmsListenerContainer-Factory的 DefaultJmsListenerContainerFactory Bean 不存在时，会执行创建和初始化操作。其中创建就是直接 new-一个对象，而关于初始化操作，上面已经提到了，通过 DefaultJms-ListenerContainerFactoryConfigurer 的 configure 方法来对 DefaultJmsListenerContainerFacto-ry 对应的各项参数进行赋值。

JmsAnnotationDrivenConfiguration 剩余部分代码定义了两个内部类，代码如下。

@Configuration(proxyBeanMethods = false)
@EnableJms
@ConditionalOnMissingBean(name = JmsL istenerConfigUtils.JMS_ LISTENER NNOTA
TION_
PROCESSOR_ BEAN NAME)
static class EnableJmsConfiguration
@Configuration(proxyBeanMethods = false)
@Conditional0nJndi
static class IndiConfiguration {
@Bean
@Conditiona lOnMissingBean(DestinationResolver. class)
JndiDestinationResolver dest inationResolver() {
JndiDestinationResolver resolver = new JndiDestinationResolver();resolver . setFallbackToDynamicDestination(true);
return resolver;
}
}

其 中 ， 内 部 类 EnableJmsConfiguration 的 实 现 为 空 ， 主 要 作 用 是 根 据 条 件 来 使@EnableJms 注解生效生效条件是类
org.springframework.jms.config.internalJmsListenerAnnotation-Processor 对应的 Bean 不存在。

内部类 JndiConfiguration 主要实例化了 JndiDestinationResolver，JndiDestinationResolver 是我们上面讲到的 DestinationResolver 具体实现，用于将目标名称解释为 JNDI 位置。

至此，关于 JmsAutoConfiguration 注解部分， 及其注解部分的延伸内容已经讲解完毕。下一 节， 我们继续学习 JmsAutoConfiguration 内部的自动配置实现。

JmsAutoC onfiauration 内部实现

JmsAutoConfiguration 的内部代码部分主要包含两个内部静态类:Jms' TemplateConfi-guration 和 Messaging TemplateConfiguration。

Jms' TemplateConfiguration 主要用来初始化 Jms Template 对象。它的构造方法主要设置了JmsProperties、ObjectProvider<DestinationResolver>和ObjectProvider<MessageConver-ter>，参数的具体功能前面已经讲过，不再赘述。

下面看 Jms TemplateConfiguration 中 Jms Template 的初始化。

@Configuration(proxyBeanMethods = false)
protected static class Jms TemplateConfiguration {
.. .
@Bean
@Condit ionalOnMissingBean
@ConditionalOnSingleCandidate(ConnectionFactory. class)
public Jms Template jmsTemplate(ConnectionFactory connectionFactory) {
PropertyMapper map = PropertyMapper .get();
//基于 ConnectionFactory 创建 Jms Template 对象
JmsTemplate template = new Jms Template( connectionFactory);
//没置是否为发布订阅模式
template . setPubSubDomain(this . properties . isPubSubDomain());
map . from(this . dest inat ionResolver: :getIfUnique ) . whenNonNull()
. to(template: :setDestinationResolver);
map . from(this . messageConverter :: getIfUnique) . whenNonNull(). to(template: :setMessageConverter);
mapTemplateProperties(this . properties . getTemplate()，template);
return template;
private void mapT emplateProperties (Template properties, JmsTemplate templ
ate)
//... Template 的其他参数设置
}
}

在初始化 JmsTemplate 的过程中，明确要求必须只有一个候选 ConnectionFactory 对象存在，并且不存在 Jms Template 对象。

Jms Template 是用于简化同步 JMS 访问代码的 Helper 类。以上代码业务比较简单，就是创 建 了 JmsTemplate 对 象 ， 并 判 断 DestinationResolver 、 MessageConverter 和JmsPro-perties 中的值是否为 null,如果不为 null 则对 Jms Template 进行赋值。

其中值得注意的是 Jms Template 的 pubSubDomain 的设置，默认情况下为 false，即 P2P模 式 (Point-to-Point <Queues>) 。 如 果 需 要 设 置 为 发 布 - 订 阅 模 式 (Publish/Subscribe<Topics>)，则需设置为 true。

另外一个内部类 Messaging TemplateConfiguration 用来创建 JmsMessaging Template 对象。

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass (JmsMessagingTemplate. class)
@Import(JmsTemplateConfiguration. class)
protected static class MessagingTemplateConfiguration {
@Bean
@ConditionalOnMiss ingBean( JmsMessageOperations. class)
@ConditionalOnSingleCandidate(Jms Template. class)
public JmsMessagingTemplate jmsMessagingTemplate(JmsProperties propertie
s，JmsTemplate
jmsTemplate) {
JmsMessagingTemplate messagingTemplate = new JmsMessagingTemplate(jms -
Templ
ate);
//没置目标名称
mapTemplateProperties(properties . getTemplate(), messagingTemplate);p
return
messagingTemplate;
private void mapTemplateProperties (Template properties, JmsMessagingTemplatemessagingTemplate) {
PropertyMapper map = PropertyMapper . get(). alwaysApplyingWhenNonNu1l();
/没置目标名称
map. from(properties : :getDefaultDestination) . to(messagingTemplate: : setDe
fault-
DestinationName);
}
}

当类路径下有 JmsMessagingTemplate 时才会触发
MessagingTemplateConfiguration 的自动配置。 通过@lmport 注解引入了上面井到的 Jms TemplateConfiguration 配置类， 为了确保 Jms Template 的实例化，创建、JmsMessagingTemplate 时将 Jms Template 对象作为参数， 然后设置目标名称。

JmsMessagingTemplate 为 JmsMessageOperations 的具体实现，也是提共 Spring 发送消息的工具类。 自 Spring 4.1 起，JmsMessaging Template 构建于 JmsTemplate 之上，提供了消息抽象的集成，例如
rg.springframework.messaging.Message。

至此，JmsAuto( Confiauration 相关的自动配置讲解完毕，也完成了 JMS 基础的自动配置。

本文给大家讲解的内容是SpringBoot消息源码解析：JMS基础自动配置

1. 下篇文章给大家讲解的是以ActiveMQ为例，讲解其自动配置的实现；
2. 觉得文章不错的朋友可以转发此文关注小编；
3. 感谢大家的支持！