ActiveMQ的使用

最新推荐文章于 2024-08-24 10:52:13 发布

Haolarn

最新推荐文章于 2024-08-24 10:52:13 发布

阅读量215

点赞数

分类专栏：消息队列文章标签： ActiveMQ消息队列

本文链接：https://blog.csdn.net/weixin_42392859/article/details/85322157

版权

消息队列专栏收录该内容

1 篇文章 0 订阅

订阅专栏

ActiveMQ是什么？

ActiveMQ 是Apache出品，最流行的，能力强劲的开源消息总线。其实就是一个消息队列

ActiveMQ的作用是什么？

解决服务之间的耦合
使用消息队列，增加系统的并发处理量
举例
例如用户注册需求，要求用户注册的时候要输入手机号码，通过第三方平台给用户发送验证码，这时候可以编写一个发送短信的utils 来进行发送短信，但如果考虑到调用很多次，并发可能会很大，很容易造成拥堵的问题，这时候，我们可以通过ActiveMQ来解决，当用户注册的时候，向ActiveMQ发送一条“需要发送一条短信”的消息，然后短信服务平台获取到“要发送短信消息”的消息，短信服务平台调用发送短信的utils来发送短信，这样可以解决用户注册服务，与发送短信业务的耦合，减少业务逻辑的复杂性。

ActiveMQ的安装

可以通过ActiveMQ官网进行下载安装，支持window的与linux，官网地址:http://activemq.apache.org/
下载完成之后，运行bin目录下的activemq.bat
可以在 http://localhost:8161 查看
在这里插入图片描述
管理账号密码，默认为admin
ActiveMQ使用的是标准生产者与消费者模型，有两种数据结构Queue和Topic

Queue 队列，生产者生产了一个消息，只能由一个消费者进行消费
Topic 话题，生产者生产了一个消息，可以由多个消费者进行消费
注意
如果出现activemq.bat启动不了，请检查是否端口占用或者计算机名为中文，端口配置文件在conf目录下的activemq.xml
window系统检查端口是否占用为：netstat -aop | findstr “端口号”
linux系统检查端口是否占用为:netstat -anp | grep “端口号”

ActiveMQ的单独使用

单独开始activeMQ只需要导入activemq的maven坐标即可

  	<dependency>
  		<groupId>org.apache.activemq</groupId>
  		<artifactId>activemq-all</artifactId>
  		<version>5.14.0</version>
  	</dependency>

编写ActiveMQ的生产者

//JMS位java消息服务
		//工厂参数 userName, password, brokerURL 如果是默认，只能用new一个空的，如果不是，需要配置
		//链接工厂 使用默认用户名、密码、路径
		//路径tcp://host:61616
		ConnectionFactory connectionFactory = new ActiveMQConnectionFactory();
		//获取一个连接
		Connection connection = connectionFactory.createConnection();
		//开启连接
		connection.start();
		//建立会话
		//第一个参数，是否使用事务，如果设置true,操作消息队列，必须使用session.commit
		//第二个参数，acknowledge（）方法自动通知JMS提供者消息已成功接收消息。
		Session session = connection.createSession(true, Session.AUTO_ACKNOWLEDGE);
		//创建队列或话题对象
		Queue queue = session.createQueue("HelloWorld");
		//创建消息生产者或者消费者
		MessageProducer producer = session.createProducer(queue);
		
		//发送十次消息，即生产十次消息
		for(int i = 0; i < 10; i++){
			producer.send(session.createTextMessage("你好，activeMQ"));

		}
		//提交操作
		session.commit();

测试
在这里插入图片描述
可以在queue中查看到消息已生产成功
编写ActiveMQ的消费者
消费者与生产者的逻辑相似，只不过可以多用个监听器进行监听是否有消息的产生
第一种方式获取消息

//JMS位java消息服务
		//工厂参数 userName, password, brokerURL 如果是默认，只能用new一个空的，如果不是，需要配置
		//链接工厂 使用默认用户名、密码、路径
		//路径tcp://host:61616
		ConnectionFactory connectionFactory = new ActiveMQConnectionFactory();
		//获取一个连接
		Connection connection = connectionFactory.createConnection();
		//开启连接
		connection.start();
		//建立会话		
		Session session = connection.createSession(true, Session.AUTO_ACKNOWLEDGE);
		//创建队列或话题对象,括号中的参数即为queue的对象名
		Queue queue = session.createQueue("HelloWorld");
		//创建消息生产者或者消费者
		MessageConsumer consumer = session.createConsumer(queue);
		while (true) {
			//分别相隔10秒取一次消息
			TextMessage message = (TextMessage)consumer.receive(10000);
			if (message != null) {
				//如果取出消息，打印
				System.out.println(message.getText());
			}else {
				break;
			}
		}
		//提交操作
		session.commit();

测试结果
在这里插入图片描述

第二种方式获取消息通过监听器进行监听消息

//JMS位java消息服务
		//工厂参数 userName, password, brokerURL 如果是默认，只能用new一个空的，如果不是，需要配置
		//链接工厂 使用默认用户名、密码、路径
		//路径tcp://host:61616
		ConnectionFactory connectionFactory = new ActiveMQConnectionFactory();
		//获取一个连接
		Connection connection = connectionFactory.createConnection();
		//开启连接
		connection.start();
		//建立会话
		//第一个参数，是否使用事务，如果设置true,操作消息队列，必须使用session.commit
		
		Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
		//创建队列或话题对象
		Queue queue = session.createQueue("HelloWorld");
		//创建消息生产者或者消费者
		MessageConsumer consumer = session.createConsumer(queue);
		//设置监听器
		consumer.setMessageListener(new MessageListener() {
			//每次接受到消息，自动调用OnMessage方法
			@Override
			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();		 
				}			
			}
		});
		//提交操作

		while (true) {
			//不能让Junit死掉
			
		}

测试结果
在这里插入图片描述
与上面相同都能获取消息，但使用监听器的方式更为便捷,无需判断是否为空

ActiveMQ与Spring整合

导入ActiveMQ的依赖与Spring的依赖

<!--Spring依赖 -->
<dependency>
  		<groupId>org.springframework</groupId>
  		<artifactId>spring-context</artifactId>
  		<version>4.1.7.RELEASE</version>
  	</dependency>
  	<dependency>
  		<groupId>org.springframework</groupId>
  		<artifactId>spring-test</artifactId>
  		<version>4.1.7.RELEASE</version>
  	</dependency>
  	<dependency>
  		<groupId>junit</groupId>
  		<artifactId>junit</artifactId>
  		<version>4.12</version>
  	</dependency>
  	<!-- Activemq依赖-->
  	<dependency>
  		<groupId>org.apache.activemq</groupId>
  		<artifactId>activemq-all</artifactId>
  		<version>5.14.0</version>
  	</dependency>
  	<！--spring与jms的整合依赖包 -->
  	<dependency>
  		<groupId>org.springframework</groupId>
  		<artifactId>spring-jms</artifactId>
  		<version>4.1.7.RELEASE</version>
  	</dependency>
  </dependencies>

编写生产者

配置生产者的applicationContext.xml文件

<!-- 扫描包 -->
	<context:component-scan base-package="包名" />
	<!-- ActiveMQ 连接工厂 -->
    <!-- 真正可以产生Connection的ConnectionFactory，由对应的 JMS服务厂商提供-->
    <!-- 如果连接网络：tcp://ip:61616；未连接网络：tcp://localhost:61616 以及用户名，密码-->
    <amq:connectionFactory id="amqConnectionFactory"
        brokerURL="tcp://localhost:61616" userName="admin" password="admin"  />

    <!-- Spring Caching连接工厂 -->
    <!-- Spring用于管理真正的ConnectionFactory的ConnectionFactory -->  
    <bean id="connectionFactory" class="org.springframework.jms.connection.CachingConnectionFactory">
        <!-- 目标ConnectionFactory对应真实的可以产生JMS Connection的ConnectionFactory -->  
        <property name="targetConnectionFactory" ref="amqConnectionFactory"></property>
        <!-- 同上，同理 -->
        <!-- <constructor-arg ref="amqConnectionFactory" /> -->
        <!-- Session缓存数量 -->
        <property name="sessionCacheSize" value="100" />
    </bean>
    
     <!-- 需要配置Spring JmsTemplate 的消息生产者模板-->

    <!-- 定义JmsTemplate的Queue类型 -->
    <bean id="jmsQueueTemplate" class="org.springframework.jms.core.JmsTemplate">
        <!-- 这个connectionFactory对应的是我们定义的Spring提供的那个ConnectionFactory对象 -->  
        <constructor-arg ref="connectionFactory" />
        <!-- 非pub/sub模型（发布/订阅），即队列模式 -->
        <property name="pubSubDomain" value="false" />
    </bean>

    <!-- 定义JmsTemplate的Topic类型 -->
    <bean id="jmsTopicTemplate" class="org.springframework.jms.core.JmsTemplate">
         <!-- 这个connectionFactory对应的是我们定义的Spring提供的那个ConnectionFactory对象 -->  
        <constructor-arg ref="connectionFactory" />
        <!-- pub/sub模型（发布/订阅） -->
        <property name="pubSubDomain" value="true" />
    </bean>

编写生产者测试代码
queue模板生产者编写

//注入jmsTopicTemlate
	@Autowired
	@Qualifier("jmsQueueTemplate")
	private JmsTemplate jmsTemplate;

	public void send(String queueName,final String message){
		jmsTemplate.send(queueName,new MessageCreator() {
			
			@Override
			public Message createMessage(Session session) throws JMSException {
				
				// TODO Auto-generated method stub
				return session.createTextMessage(message);
			}
		});
	}

topic模板生产者编写

@Autowired
	@Qualifier("jmsTopicTemplate")
	private JmsTemplate jmsTemplate;
	
	public void send(String topicName,final String message){
		jmsTemplate.send(topicName,new MessageCreator() {
			
			@Override
			public Message createMessage(Session session) throws JMSException {
				
				return session.createTextMessage(message);
			}
		});
		
	}

两者没有区别，只是通过Spring注入的模板不同
测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations="classpath:applicationContext-mq.xml")
public class ProducerTest {

	@Autowired
	private QueueSender queueSender;
	@Autowired
	private TopicSender topicSender;
	
	@Test
	public void testSendMessage(){
		queueSender.send("spring_queue", "你好世界");
		topicSender.send("spring_topic", "你好我的家");
	}
}

queuq
在这里插入图片描述
topic

编写消费者

配置消费者的applicationContext.xml文件

<!-- 扫描包 -->
   <context:component-scan base-package="包名" />

 	<!-- ActiveMQ 连接工厂 -->
   <!-- 真正可以产生Connection的ConnectionFactory，由对应的 JMS服务厂商提供-->
   <!-- 如果连接网络：tcp://ip:61616；未连接网络：tcp://localhost:61616 以及用户名，密码-->
   <amq:connectionFactory id="amqConnectionFactory"
       brokerURL="tcp://localhost:61616" userName="admin" password="admin"  />

   <!-- Spring Caching连接工厂 -->
   <!-- Spring用于管理真正的ConnectionFactory的ConnectionFactory -->  
   <bean id="connectionFactory" class="org.springframework.jms.connection.CachingConnectionFactory">
       <!-- 目标ConnectionFactory对应真实的可以产生JMS Connection的ConnectionFactory -->  
       <property name="targetConnectionFactory" ref="amqConnectionFactory"></property>
       <!-- 同上，同理 -->
       <!-- <constructor-arg ref="amqConnectionFactory" /> -->
       <!-- Session缓存数量 -->
       <property name="sessionCacheSize" value="100" />
   </bean>

   <!-- 消息消费者 start-->

   <!-- 定义Queue监听器 -->
 <jms:listener-container destination-type="queue" container-type="default" connection-factory="connectionFactory" acknowledge="auto">
       <!-- 默认注册bean的名称，应该是类名的首字母小写 -->
       <!-- spring_queue为ActiveMQ中queue的名称-->
       <jms:listener destination="spring_queue" ref="queueConsumer1"/>
       <jms:listener destination="spring_queue" ref="queueConsumer2"/>
   </jms:listener-container>
   

   <!-- 定义Topic监听器--> 
   <jms:listener-container destination-type="topic" container-type="default" connection-factory="connectionFactory" acknowledge="auto">
       <!-- 默认注册bean的名称，应该是类名的首字母小写 -->
        <!-- spring_queue为ActiveMQ中topic的名称-->
       <jms:listener destination="spring_topic" ref="topicConsumer1"/>
       <jms:listener destination="spring_topic" ref="topicConsumer2"/>
   </jms:listener-container>

编写消费者
queue的消费者

@Service
//实现监听器接口
public class QueueConsumer1 implements MessageListener{

	@Override
	public void onMessage(Message message) {
		TextMessage textMessage = (TextMessage) message;
		try {
			System.out.println("消费者Consumer1:获取消息:"+textMessage.getText());
		} catch (JMSException e) {
			
			 // TODO Auto-generated catch block
			 e.printStackTrace();		 
		} 
	}
}

Topic的消费者

@Service
public class TopicConsumer1 implements MessageListener{

	@Override
	public void onMessage(Message message) {
		TextMessage textMessage = (TextMessage) message;
		 
		 try {
			System.out.println("消费者Topic1获取消息:"+textMessage.getText());
		} catch (JMSException e) {
			
			 // TODO Auto-generated catch block
			 e.printStackTrace();
			 
		}
	}

}

测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations="classpath:applicationContext-mq-consumer.xml")
public class CustomerTest {


	@Test
	public void testSendMessage(){
		while (true) {
		//Junite退出，防止进程死掉
			
		}
	}
}

因为在监听器配置了要监听的消息名称，因此无需写代码，在spring容器加载的时候就会监听，只要防止单元测试的进程不死
在这里插入图片描述
结果只获取到一条queue的消息，为什么？
答案:Queue 队列，生产者生产了一个消息，只能由一个消费者进行消费
那为什么获取不到Topic的消息，为什么？
答案：因为Topic 有有效期，过了有效期后，监听器无法再获取到 topic 信息
那如何能获取？
答案:只能实时获取，先开监听，在用生产者生产消息
在这里插入图片描述

总结

AcriveMQ的使用要先创建ActiveMQ的连接工厂，在从工厂中创建连接，连接创建与ActiveMQ的会话对象，由会话对象指定要创建Queue还是Topic对象，在决定是创建生产者生产此对象还是创建消费者消费此对象，最后会话进行提交
注意
1、 Queue 队列，生产者生产了一个消息，只能由一个消费者进行消费
2、 Topic 话题，生产者生产了一个消息，可以由多个消费者进行消费