(二)--JAVA编码实现ActiveMQ通讯

生产者

1. 新建MAVEN工程

2. 修改POM.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.xianyiquan</groupId>
    <artifactId>activemq</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

    <dependencies>
        <!--activemq所需要的jar包配置-->
        <dependency>
            <groupId>org.apache.activemq</groupId>
            <artifactId>activemq-all</artifactId>
            <version>5.15.9</version>
        </dependency>

        <dependency>
            <groupId>org.apache.xbean</groupId>
            <artifactId>xbean-spring</artifactId>
            <version>3.16</version>
        </dependency>

        <!--下面是junit/log4j等基础通用配置-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.25</version>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.18</version>
            <scope>provided</scope>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

</project>

3. 编写主启动类

import org.apache.activemq.ActiveMQConnectionFactory;

import javax.jms.*;

/**
 * @author xianyiquan
 * @className
 * @create 2019-12-28 13:45
 */
public class JmsProduce {

    public static final String ACYIVEMQ_URL = "tcp://192.168.249.88:61616";
    public static final String QUEUE_NAME = "queue01";
    
    public static void main(String[] args) throws JMSException {
        //1.创建连接工厂,按照给定的url地址,采用默认用户名和密码
        ActiveMQConnectionFactory activeMQConnectionFactory = new ActiveMQConnectionFactory(ACYIVEMQ_URL);

        //2.通过连接工厂,获得connection并启动访问
        Connection connection = activeMQConnectionFactory.createConnection();
        connection.start();

        //3.创建会话session
        //两个参数,第一个叫事务/第二个叫签收
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);

        //4.创建目的地(具体是队列还是主题topic)
//        Destination destination = session.createQueue(QUEUE_NAME);
        Queue queue = session.createQueue(QUEUE_NAME);

        //5.创建消息的生产者
        MessageProducer producer = session.createProducer(queue);

        //6. 通过使用producer生产3条消息发送到MQ队列里面
        for (int i = 1; i <= 3; i++) {
            //7. 创建消息,好比创建好的订单消息
            TextMessage textMessage = session.createTextMessage("msg----" + i);//理解为一个字符串
            //8. 通过producer 发送给MQ
            producer.send(textMessage);
        }

        //关闭资源
        producer.close();
        session.close();
        connection.close();
        System.out.println("*************消息发布到MQ完成");
    }

}

总共分为9步:
1.创建连接工厂,按照给定的url地址,采用默认用户名和密码
2.通过连接工厂,获得connection并启动访问
3.创建会话session
4.创建目的地(具体是队列还是主题topic)
5.创建消息的生产者
6. 通过使用producer生产3条消息发送到MQ队列里面
7. 创建消息,好比创建好的订单消息
8. 通过producer 发送给MQ
9. 关闭资源

Number Of Pending Messages	等待消费的消息	这个是当前未出队列的数量.公式= 总接收数 - 总出队列数
Number Of Consumers	消费者数量	消费者端的消费者数量
Messages Enqueued	进队消息数	进入队列的总数量,包括出队列的,这个数量只增不减
Messages Dequeued	出队消息数	可以理解为是消费者消费掉的数量

总结: 当有一个消息进入这个队列时,等待消费的消息是1,进入队列的消息是1.
当消息消费后,等待消费的消息是0,进入队列的消息是1,出队列的消息是1.
再来一条消息时,等待消费的消息是1,进入队列的消息就是2.

消费者

main

这里消费者的前4步与生产者的相同

注意生产者生产的是TextMessage,消费者也应该消费TextMessage,
receive的三种方式

执行结果

1. 上面所说的是同步阻塞方式(receive())
订阅者或接受者调用MessageConsumer的receive()方法来接收消息,receive方法在能够接收到消息之前(或超时之前)将一直阻塞,
2. 下面是异步非阻塞方式(监听器onMessage)
//订阅者或接收者通过MessageConsumer==的 setMessageListener(MessageListener listener) 注册一个消息监听器,
//当消息到达之后,系统自动调用监听器 MessageListener的onMessage(Message message) 方法
这里注意要添加System.in.read()等待

输出结果

有多个消费者的情况

* 1. 先生产       只启动1号消费者  ,问题: 1号消费者能消费消息吗?  Y

* 2. 先生产       启动1号消费者, 再启动2号消费者  ,问题: 2号消费者还能消费消息吗?
*          2.1 1号消费者可以消费  Y
*          2.2 2号消费者不能消费   N

* 3.先启动两个消费者,  再生产6条消息, 请问:消费情况如何?
*          3.1 2个消费者都有6条
*          3.2 先到先得,6条全部给一个
*          3.3 一人一半  Y

先启动两个消费者,再生产6条消息,最终会一人一半
结果如下

队列案例小总结

JMS开发的基本步骤

1. 创建一个connection factory
2. 通过connection factory来创建Jms connection

3. 启动JMS connection

4. 通过connection创建 JMS session

5. 创建JMS destination

6. 创建JMS producer 或者创建JMS message 并设置destination

7. 创建JMS consumer或者是注册一个JMS message listener

8. 发送或者接收JMS message(s)

9. 关闭所有的JMS资源
(connection .session, producer, consumer等)

2. Topic

produce

consumer

消费情况

两大模式比较

比较项目	TOPIC模式队列	Queue模式队列
工作模式	订阅-发布模式,如果当前没有订阅者,消息会被丢弃,如果有多个订阅者,那么这些订阅者都会收到消息	"负载均衡"模式, 如果当前没有消费者,消息也不会丢弃; 如果有多个消费者, 那么一条消息也只会发送给其中一个消费者,并且要求消费者ack信息
有无状态	无状态	Queue数据默认会在MQ服务器上以文件形式报错,比如Active MQ一般保存在$AMQ_HOME\data\kr-store\data下面,也可以配置成DB存储
传递完整性	如果没有订阅者, 消息会被丢弃	消息不会丢弃
处理效率	由于消息要按照订阅者的数量进行复制, 所以处理性能会随着订阅者的增加而明显降低,并且还要结合不同消息协议自身的性能差异	由于一条消息只发送一个消费者,所以就算消费者数量再多, 性能也不会有明显降低,当然不同消息协议的具体性能也是有差异的