ActiveMQ 详解 （精）

ActiveMQ

JMS（Java Message Service）
它是一种与厂商无关的API，用来访问消息和收发系统消息。它类似于JDBC，JDBC是可以用来访问不同的关系型数 据库的API，而JMS则提供同样与厂商无关的访问消息收发服务的方法,这样就可以通过消息收发服务实现从一个JMS 客户端向另一个JMS客户端发送消息，所需要的是厂商支持JMS。换句话说，JMS是Java平台上有关面向消息中间件 的技术规范。

JMS提供的对象

连接工厂，是客户用来创建连接的对象，ActiveMQ提供的是ActiveMQConnectionFactory; 连接connection； 会话session，是发送和接收消息的上下文，用于创建消息生产者，消息消费者 目的地destination，指定生产消息的目的地和消费消息的来源对象；
生产者、消费者，由会话创建的对象，顾名思义。

消息通信机制 点对点模式(p2p) 队列 ----

注意:P2P 目的地 queue
应用场景:订单-商品(扣库存)

发布订阅

注意:pub/sub 目的地 topic
应用场景: 消息推送

使用场景

https://blog.csdn.net/wqc19920906/article/details/82193593
1.应用解耦
2.异步消息
3.流量削锋
4.消息通讯

安装MQ

确保有JDK

1. 上传ActiveMQ的压缩包

2. 解压

3. 启动 bin目录中执行命令
   ./activeMq start
   ./activeMq stop

4. 开启日志
   tail -f activeMq.log 开启实时的日志

5. 通过客户端工具连接
   自带有客户端 可视化操作页面 http://虚拟机的ip:8161/admin8161 ，ActiveMQ客户端端口号 61616 ActiveMQ 服务端的端口号。

ip:8161/admin

用户名:admin

密码:admin

用户名,密码在哪看

vi /conf/users.properties

admin=admin

Java代码集成ActiveMQ

导入依赖

org.apache.activemq activemq-core 5.7.0

生成者代码 - Queue

1. 工厂

2. 连接

3. 会话session 收发信息

4. 目的地 指明信息收发的地址的地址
   /** * 生产者 */
   @Test
   public void test1() throws JMSException {
   // 1.创建工厂 参数MQ服务端的地址
   String brokerUrl = “tcp://192.168.195.139:61616”;
   ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory(brokerUrl);

   // 2.创建连接
   Connection connection = factory.createConnection();

   // 3.获取会话session 参数1 事务 false不能使用commit 参数2 签收机制 acknowledgeMode AUTO_ACKNOWLEDGE 自动会自动提交 Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);

   // 4.创建目的地Destination 参数 队列名
   Queue queue = session.createQueue(“03-queue”);

   // 5.创建一个生成者
   MessageProducer producer = session.createProducer(queue);
   TextMessage textMessage = session.createTextMessage(“第一条数据”);

   // 6.生成者发送数据
   producer.send(textMessage);

   // 7.释放资源
   producer.close();
   session.close();
   connection.close();
   }

消费者代码

/** * 消费者代码 */
@Test
public void test2() throws JMSException {
// 1.创建工厂
String brokerUrl = “tcp://192.168.195.139:61616”;
ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory(brokerUrl);

//        2.创建连接        
Connection connection = factory.createConnection();       
 /**         * 注意 消费者需要写connection.start();

   */        
   connection.start(); 
   //        3.创建session        
   Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
 
//        4.创建目的地        
Queue queue = session.createQueue("03-queue");
 
//        5.创建消费者        
MessageConsumer consumer = session.createConsumer(queue);
 
//        6.消费信息  发送数据使用的是哪个Message 接受的时候也要使用哪一个        
TextMessage receive = (TextMessage) consumer.receive();        
String text = receive.getText();        
System.out.println("接受到的数据为："+text);
 
//        7.释放资源        
consumer.close();        
session.close();       
 connection.close();    

}

Spring集成ActiveMQ

导入依赖

org.springframework spring-jms 4.3.18.RELEASE org.apache.activemq activemq-pool 5.15.9

配置Spring

<?xml version="1.0" encoding="UTF-8"?>

<context:component-scan base-package=“com.baizhi.service”/>

<!--创建目的地 queue-->    
<bean class="org.apache.activemq.command.ActiveMQQueue" id="queue">        
    <!--队列的名字-->        
    <property name="physicalName" value="03-queue-spring"></property>    
</bean>

<!--创建jmsTemplate-->    
<bean class="org.springframework.jms.core.JmsTemplate" id="jmsTemplate">        
    <property name="connectionFactory" ref="activeMQConnectionFactory"></property>        
    <property name="defaultDestination" ref="queue"></property>        
    <!--pubSub发布订阅 false关闭 Queue 选择false-->        
    <property name="pubSubDomain" value="false"></property>    
</bean>

生成者

消费者

监听模式

1. 创建一个监听器类

public class MqListener implements MessageListener {
public void onMessage(Message message) {
TextMessage textMessage = (TextMessage) message;
try {
System.out.println(“监听器消费数据：”+textMessage.getText());
} catch (JMSException e) {
e.printStackTrace(); }
} }

2. 配置

<?xml version="1.0" encoding="UTF-8"?>

    <!--包扫描-->    
    <context:component-scan base-package="com.baizhi.service"/>
 
    <!--创建工厂-->    
    <bean class="org.apache.activemq.ActiveMQConnectionFactory" id="activeMQConnectionFactory">        
	    <property name="brokerURL" value="tcp://192.168.195.139:61616"></property>        
	    <property name="password" value="admin"></property>        
	    <property name="userName" value="admin"></property>    
    </bean>
 
    <!--创建目的地 queue-->    
    <bean class="org.apache.activemq.command.ActiveMQQueue" id="queue">        
	    <!--队列的名字-->        
	    <property name="physicalName" value="03-queue-spring"></property>    
    </bean>
 
    <!--创建jmsTemplate-->    
    <bean class="org.springframework.jms.core.JmsTemplate" id="jmsTemplate">        
	    <property name="connectionFactory" ref="activeMQConnectionFactory"></property>        
	    <property name="defaultDestination" ref="queue"></property>        
	    <!--pubSub发布订阅 false关闭 Queue 选择false-->        
	    <property name="pubSubDomain" value="false"></property>    
    </bean>
 
    <!--创建监听器对象-->    
    <bean class="com.baizhi.service.MqListener" id="listener"></bean>
 
    <!--创建一个监听器容器-->    
    <bean id="container" class="org.springframework.jms.listener.SimpleMessageListenerContainer">        
	    <property name="pubSubDomain" value="false"></property>        
	    <!--工厂-->        
	    <property name="connectionFactory" ref="activeMQConnectionFactory"></property>        
	    <!--目的地-->        
	    <property name="destination" ref="queue"></property>        
	    <!--使用哪个监听器-->        
	    <property name="messageListener" ref="listener"></property>    
    </bean> 
</beans>

注意：监听器对象 不需要主动调用 项目启动之后 会自动调用

SpringBoot 集成 ActiveMQ

导入依赖

org.springframework.boot spring-boot-starter-activemq

配置

生产者 消费者

package com.baizhi.service;

import org.apache.activemq.command.ActiveMQQueue;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;
import org.springframework.stereotype.Service;

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.Queue;
import javax.jms.Session;

@Service
public class MqService {
@Autowired
private JmsTemplate jmsTemplate;
@Autowired
private Queue queue;

    public void mqProduct(){        
    /**         
    * 参数1 目的地         
    * 参数2 message         
    */        
    jmsTemplate.send(queue, new MessageCreator() {            
	     @Override            
	     public Message createMessage(Session session) throws JMSException {                
		     return session.createTextMessage("boot");            
	     }        
     });
 
        /**        
         * convertAndSend 自动根据参数2的类型封装到对应类型的message中并发送         
         */        
         jmsTemplate.convertAndSend(queue,"boot-convert");    
         }
 
    public void mqConsumer(){        
	    String o = (String) jmsTemplate.receiveAndConvert(queue);        
	    System.out.println(o);    
    } 
}

监听模式

package com.baizhi.listener;

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

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.TextMessage;

@Component
public class ConsumerListener {

    /**     
    * 1. @JmsListener(destination = "boot-queue")  destination值为目的地的名字     
    * 2. 方法的形参为Message message     
    * @param message     */    
    @JmsListener(destination = "03-queue-spring")    
    
    public void comsumerListener(Message message){        
	    TextMessage textMessage = (TextMessage)message;        
	    try {            
		    System.out.println("SpringBoot项目监听数据："+textMessage.getText());        
	    } catch (JMSException e) {            
		    e.printStackTrace();        
	    }    
    } 
}