Spring Jms 笔记

最新推荐文章于 2022-02-21 22:59:59 发布

胖鸡。

最新推荐文章于 2022-02-21 22:59:59 发布

阅读量147

点赞数

本文链接：https://blog.csdn.net/qq_43299794/article/details/83990115

版权

什么是Jms?
Jms 即 (Java Message Service) 应用程序接口, 是Java平台中对于面向消息中间件的规范, 它便于消息系统中的 Java 应用程序进行消息交换,并且通过提供标准的产生、发送、接收消息的接口简化企业应用的开发。

Jms本身只定义了一系列的接口规范，是一种与厂商无关的 API，用来访问消息收发系统;

Jms使您能够通过消息收发服务从一个 JMS 客户机向另一个 JML 客户机发送消息。消息是 JMS 中的一种类型对象，由两部分组成：报头和消息主体。报头由路由信息以及有关该消息的元数据组成。消息主体则携带着应用程序的数据或有效负载。
JMS 定义了五种不同的消息正文格式，以及调用的消息类型，允许你发送并接收以一
些不同形式的数据，提供现有消息格式的一些级别的兼容性。
· TextMessage–一个字符串对象
· MapMessage–一套名称-值对
· ObjectMessage–一个序列化的 Java 对象
· BytesMessage–一个字节的数据流
· StreamMessage – Java 原始值的数据流
Jms 消息传递模式
(1) 点对点模式 : 由一个生产者对应一个消费者 , 消费者可随时接收,但是当一个消费者接受后 , 其他对应的消费者就不能够接收了;
(2)发布/订阅模式 : 一个生产者对应多个消费者 , 生产者发送消息可供多个消费者接收 ,
前提是消费者要先开启 ( 类似于微博的关注,粉丝要提前关注博主,才能即时收到该博主发的微博,否则接收不到 ) ;

使用ActiveMQ发收消息 :

ActiveMQ是什么 , ActiveMQ实现了Jms规范, 实现了其接口;
1. 点对点模式 :
点对点模式主要建立在队列上 , 发送端不知道接收端是否在接收, 可以直接向 ActiveMQ 发送消息，发送的消息，将会先进入队列中，如果有接收端在监听，则会发向接收端，如果没有接收端接收，则会保存在 activemq 服务器，直到接收端接收消息，点对点的消息模式可以有多个发送端，多个接收端，但是一条消息，只会被一个接收端给接收到，哪个接收端先连上 ActiveMQ，则会先接收到，而后来的接收端则接收不到那条消息。

(1.1) 创建工程JmsDemo,引入ActiveMQ依赖

    <dependency> 
 	 	<groupId>org.apache.activemq</groupId> 
 	 	<artifactId>activemq-client</artifactId> 
 	 	<version>5.13.4</version> 
 	 </dependency>

消息生产者 : 创建类 QueueProducer main 方法代码如下：

//1.创建连接工厂 
 	ConnectionFactory connectionFactory=new 
ActiveMQConnectionFactory("tcp://192.168.25.135:61616"); 
 	//2.获取连接 
 	Connection connection = connectionFactory.createConnection(); 
 	//3.启动连接 
 	connection.start(); 
 	//4.获取session  (参数1：是否启动事务,参数2：消息确认模式) 
 	Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); 
 	 
 	//5.创建队列对象 
 	Queue queue = session.createQueue("test-queue"); 
 	//6.创建消息生产者 
 	MessageProducer producer = session.createProducer(queue); 
 	//7.创建消息 
 	TextMessage textMessage = session.createTextMessage("欢迎来到神奇的品优购世界"); 
 	//8.发送消息 
 	producer.send(textMessage); 
 	//9.关闭资源 
 	producer.close(); 
 	session.close(); 
 	connection.close();

运行后通过 ActiveMQ 管理界面查询
在这里插入图片描述

消息消费者 : 创建类 QueueConsumer ，main 方法代码如下：

//1.创建连接工厂 
 	ConnectionFactory connectionFactory=new ActiveMQConnectionFactory("tcp://192.168.25.135:61616"); 
 	//2.获取连接 
 	Connection connection = connectionFactory.createConnection(); 
 	//3.启动连接 
 	connection.start(); 
 	//4.获取session  (参数1：是否启动事务,参数2：消息确认模式) 
 	Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); 
 	//5.创建队列对象 
 	Queue queue = session.createQueue("test-queue"); 
 	//6.创建消息消费 
 	MessageConsumer consumer = session.createConsumer(queue); 
 	 
 	//7.监听消息 
 	consumer.setMessageListener(new MessageListener() { 
 	 	public void onMessage(Message message) {  	 	 	TextMessage textMessage=(TextMessage)message; 
 	 	 	try { 
 	 	 	 	System.out.println("接收到消息："+textMessage.getText()); 
 	 	 	} catch (JMSException e) {  	 	 	 	// TODO Auto-generated catch block 
 	 	 	 	e.printStackTrace(); 
 	 	 	} 
 	 	} 
 	});  
 	//8.等待键盘输入 
 	System.in.read(); 	 
 	//9.关闭资源 
 	consumer.close(); 
 	session.close(); 
 	connection.close();

执行后看到控制台输出 :
在这里插入图片描述

2. 发布/订阅模式 :

消息生产者 :
创建类 TopicProducer ，main 方法代码如下：

//1.创建连接工厂 
 	ConnectionFactory connectionFactory=new 
ActiveMQConnectionFactory("tcp://192.168.25.135:61616"); 
 	//2.获取连接 
 	Connection connection = connectionFactory.createConnection(); 
 	//3.启动连接 
 	connection.start(); 
 	//4.获取session  (参数1：是否启动事务,参数2：消息确认模式) 
 	Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); 
 	//5.创建主题对象 
 	Topic topic = session.createTopic("test-topic"); 
 	//6.创建消息生产者 
 	MessageProducer producer = session.createProducer(topic); 
 	//7.创建消息 
 	TextMessage textMessage = session.createTextMessage("欢迎来到神奇的品优购世界"); 
 	//8.发送消息 
 	producer.send(textMessage); 
 	//9.关闭资源 
 	producer.close(); 
 	session.close(); 
 	connection.close();

消息消费者 :
创建类 TopicConsumer ,main 方法代码如下：

//1.创建连接工厂 
 	ConnectionFactory connectionFactory=new 
ActiveMQConnectionFactory("tcp://192.168.25.135:61616"); 
 	//2.获取连接 
 	Connection connection = connectionFactory.createConnection(); 
 	//3.启动连接 
 	connection.start(); 
 	//4.获取session  (参数1：是否启动事务,参数2：消息确认模式) 
 	Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); 
 	//5.创建主题对象 
 	//Queue queue = session.createQueue("test-queue"); 
 	Topic topic = session.createTopic("test-topic"); 
 	//6.创建消息消费 
 	MessageConsumer consumer = session.createConsumer(topic); 
 	 
 	//7.监听消息 
 	consumer.setMessageListener(new MessageListener() { 
 	 	public void onMessage(Message message) {  	 	 	TextMessage textMessage=(TextMessage)message; 
 	 	 	try { 
 	 	 	 	System.out.println("接收到消息："+textMessage.getText()); 
 	 	 	} catch (JMSException e) {  	 	 	 	// TODO Auto-generated catch block 
 	 	 	 	e.printStackTrace(); 
 	 	 	} 
 	 	} 
 	}); 
 	//8.等待键盘输入 
 	System.in.read(); 
 	//9.关闭资源 
 	consumer.close(); 
 	session.close(); 
 	connection.close();

同时开启 2 个以上的消费者，再次运行生产者，观察每个消费者控制台的输出，会发现
每个消费者会接收到消息。

Spring 对Jms 的整合 :

（1）引入SpringJms 、activeMQ 相关依赖 :

			<dependency>
				<groupId>org.springframework</groupId>
				<artifactId>spring-jms</artifactId>
				<version>4.2.4.RELEASE</version>
			</dependency>
			 <dependency> 
		 	 	<groupId>org.apache.activemq</groupId> 
		 	 	<artifactId>activemq-client</artifactId> 
		 	 	<version>5.13.4</version> 
 	 		</dependency>

（2）在 src/main/resources 下创建 spring 配置文件 applicationContext-jms-producer.xml

<context:component-scan base-package="cn.itcast.demo"></context:component-scan>  
    <!-- 真正可以产生Connection的ConnectionFactory，由对应的 JMS服务厂商提供-->   
 	<bean id="targetConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">   
 	    <property name="brokerURL" value="tcp://192.168.25.135:61616"/>   
 	</bean>           
    <!-- Spring用于管理真正的ConnectionFactory的ConnectionFactory -->   
 	<bean id="connectionFactory" class="org.springframework.jms.connection.SingleConnectionFactory">   
 	<!-- 目标ConnectionFactory对应真实的可以产生JMS Connection的ConnectionFactory -->  
 	    <property name="targetConnectionFactory" ref="targetConnectionFactory"/>   
 	</bean>       
    <!-- Spring提供的JMS工具类，它可以进行消息发送、接收等 -->   
 	<bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">   
 	    <!-- 这个connectionFactory对应的是我们定义的Spring提供的那个ConnectionFactory 对象 -->   
 	    <property name="connectionFactory" ref="connectionFactory"/>   
 	</bean>       
    <!--这个是队列目的地，点对点的  文本信息-->   
 	<bean id="queueTextDestination" class="org.apache.activemq.command.ActiveMQQueue">   
 	    <constructor-arg value="queue_text"/>   
 	</bean>

（3）在 cn.itcast.demo 包下创建消息生产者类:

@Component 
public class QueueProducer { 
 	 
 	@Autowired 
 	private JmsTemplate jmsTemplate; 
 	 
 	@Autowired 
 	private Destination queueTextDestination; 
 	 
 	/** 
*	发送文本消息 
*	@param text 
 	 */ 
 	public void sendTextMessage(final String text){ 
 	 	jmsTemplate.send(queueTextDestination, new MessageCreator() {  	 	 
 	 	 	public Message createMessage(Session session) throws JMSException { 
 	 	 	 	return session.createTextMessage(text); 
 	 		} 
		});  	 
	} 	
}

（4）单元测试

在 src/test/java 创建测试类 :

@RunWith(SpringJUnit4ClassRunner.class) 
@ContextConfiguration(locations="classpath:applicationContext-jms-producer.xml") 
public class TestQueue { 
 
 	@Autowired 
 	private QueueProducer queueProducer; 
Test
 	  	@	 
 	public void testSend(){ 
 	 	queueProducer.sendTextMessage("SpringJms-点对点"); 
 	}  
}

3.1.2 消息消费者
（1）创建工程 springjms_consumer，在 POM 文件中引入依赖（同上一个工程）
（2）创建配置文件 applicationContext-jms-consumer-queue.xml

<!-- 真正可以产生Connection的ConnectionFactory，由对应的 JMS服务厂商提供-->   
<bean id="targetConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">   
    <property name="brokerURL" value="tcp://192.168.25.135:61616"/>   
</bean>     
<!-- Spring用于管理真正的ConnectionFactory的ConnectionFactory -->   
<bean id="connectionFactory" class="org.springframework.jms.connection.SingleConnectionFactory">   
<!-- 目标ConnectionFactory对应真实的可以产生JMS Connection的ConnectionFactory -->  
    <property name="targetConnectionFactory" ref="targetConnectionFactory"/>   
</bean>    
<!--这个是队列目的地，点对点的  文本信息-->   
<bean id="queueTextDestination" class="org.apache.activemq.command.ActiveMQQueue">   
    <constructor-arg value="queue_text"/>   
</bean>     
<!-- 我的监听类 --> 
<bean id="myMessageListener" class="cn.itcast.demo.MyMessageListener"></bean> 
<!-- 消息监听容器 --> 
<bean class="org.springframework.jms.listener.DefaultMessageListenerContainer"> 
 	<property name="connectionFactory" ref="connectionFactory" /> 
 	<property name="destination" ref="queueTextDestination" /> 
 	<property name="messageListener" ref="myMessageListener" /> 
</bean>

（3）编写监听类

public class MyMessageListener implements MessageListener { 
 	public void onMessage(Message message) { 
		TextMessage textMessage 	=(TextMessage)message;  	 
		try { 
		textMessage
	 	System.out.println("接收到消息："+	.getText()); 
	} catch (JMSException e) { 
	 	e.printStackTrace(); 
	} 
	 
} 	} 
（4）	创建测试类 
@RunWith(SpringJUnit4ClassRunner.class) 
@ContextConfiguration(locations="classpath:applicationContext-jms-consumer-queue.xm l") 
public class TestQueue { 
Test
 	@	 
 	public void testQueue(){ 
 	 	try { 
 	 	 	System.in.read(); 
 	 	} catch (IOException e) { 
 	 	 	e.printStackTrace(); 
 	 	}  	 
 	}  
}