Java中使用AMQ的简单实例

最新推荐文章于 2023-10-09 23:09:04 发布
最新推荐文章于 2023-10-09 23:09:04 发布
阅读量1.6k 收藏 1
点赞数
文章标签： 源码 开发 并发 技术 视频
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dp83166019po/article/details/80132876
版权
本文介绍了如何在Java中使用AMQ，包括设置AMQ 5.14.5服务，添加Maven依赖，以及点对点模型和发布订阅模型的消息发送与接收实现。
摘要由CSDN通过智能技术生成

好了，接上一篇，在对JMS的概念以及AMQ的下载安装有了一定认识之后，本篇就来学习一下AMQ在Java中的Hello World级使用（下文我将着重把重点写在注释里面，请注意代码注释部分！！！）。

  1. 开发环境

AMQ 5.14.5 服务启动运行
准备Java Maven项目

依赖jar包在apache-activemq-5.14.5根目录下即可找到，或者直接Maven依赖：

org.apache.activemq
activemq-all
5.14.5

1
2
3
4
5
2. 点对点模型

2.1 队列消息发送者

编写 QueueProducer.java 如下：

package com.jastar.activemq.queue;

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.DeliveryMode;
import javax.jms.Destination;
import javax.jms.MessageProducer;
import javax.jms.Session;
import javax.jms.TextMessage;

import org.apache.activemq.ActiveMQConnection;
import org.apache.activemq.ActiveMQConnectionFactory;

/**
* 队列消息-发送（生产）者
*


* ClassName: QueueProducer
*



* Copyright: (c)2017 JASTAR·WANG,All rights reserved.
* 






/** 默认用户名 */
public static final String USERNAME = ActiveMQConnection.DEFAULT_USER;
/** 默认密码 */
public static final String PASSWORD = ActiveMQConnection.DEFAULT_PASSWORD;
/** 默认连接地址（格式如：tcp://IP:61616） */
public static final String BROKER_URL = ActiveMQConnection.DEFAULT_BROKER_URL;
/** 队列名称 */
public static final String QUEUE_NAME = "hello amq";

// 连接工厂（在AMQ中由ActiveMQConnectionFactory实现）
private ConnectionFactory connectionFactory;

// 连接对象
private Connection connection;

// 会话对象
private Session session;

// 消息目的地（对于点对点模型，是Queue对象；对于发布订阅模型，是Topic对象；它们都继承或实现了该接口）
private Destination destination;

// 消息发送（生产）者
private MessageProducer messageProducer;

public static void main(String[] args) {
    QueueProducer producer = new QueueProducer();
    producer.doSend();
}

public void doSend() {
    try {
        /**
         * 1.创建连接工厂<br>
         * 构造函数有多个重载，默认连接本地MQ服务器，也可以手动设置用户名、密码、连接地址信息<br>
         * new ActiveMQConnectionFactory(userName, password, brokerURL)
         */
        connectionFactory = new ActiveMQConnectionFactory();

        /**
         * 2.创建连接
         */
        connection = connectionFactory.createConnection();

        /**
         * 3.启动连接
         */
        connection.start();

        /**
         * 4.创建会话<br>
         * param1:是否支持事务，若为true，则会忽略第二个参数，默认为SESSION_TRANSACTED<br>
         * param2:确认消息模式，若第一个参数为false时，该参数有以下几种状态<br>
         * -Session.AUTO_ACKNOWLEDGE：自动确认。客户端发送和接收消息不需要做额外的工作，即使接收端发生异常，
         * 也会被当作正常发送成功 <br>
         * -Session.CLIENT_ACKNOWLEDGE：客户端确认。客户端接收到消息后，必须调用message.
         * acknowledge() 方法给予收到反馈，JMS服务器才会把该消息当做发送成功，并删除<br>
         * -Session.DUPS_OK_ACKNOWLEDGE：副本确认。一旦接收端应用程序的方法调用从处理消息处返回，
         * 会话对象就会确认消息的接收，而且允许重复确认。
         */
        session = connection.createSession(true, Session.AUTO_ACKNOWLEDGE);

        /**
         * 5.创建（发送）消息目的地，即队列，参数为队列名称
         */
        destination = session.createQueue(QUEUE_NAME);

        /**
         * 6.创建一个消息生产者，并指定目的地
         */
        messageProducer = session.createProducer(destination);
        /**
         * 其他操作： 设置生产者的生产模式，默认为持久化<br>
         * 参数有以下两种状态：<br>
         * -DeliveryMode.NON_PERSISTENT：消息不持久化，消息被消费之后或者超时之后将从队列中删除
         * -DeliveryMode.PERSISTENT：消息会持久化，即使接收端消费消息之后仍然会保存
         */
        messageProducer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);

        /**
         * 其他操作：设置消息的存活时间（单位：毫秒）
         */
        messageProducer.setTimeToLive(60000);

        for (int i = 0; i < 5; i++) {
            /**
             * 7.创建文本消息<br>
             * 此外，还有多种类型的消息如对象，字节……都可以通过session.createXXXMessage()方法创建
             */
            TextMessage message = session.createTextMessage("send content:"
                    + i);

            /**
             * 8. 发送
             */
            messageProducer.send(message);

        }
        System.out.println("消息发送完成！");
        /**
         * 如果有事务操作也可以提交事务
         */
        session.commit();

        /**
         * 9.关闭生产者对象（即使关闭了程序也在运行）
         */
        messageProducer.close();
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        if (connection != null) {
            try {
                /**
                 * 10.关闭连接（将会关闭程序）
                 */
                connection.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
2.2 队列消息接收者

编写 QueueConsumer.java 其他同上，注意注释部分：

package com.jastar.activemq.queue;

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageListener;
import javax.jms.Session;
import javax.jms.TextMessage;

import org.apache.activemq.ActiveMQConnectionFactory;

/**
* 队列消息-接收（消费）者
*


* ClassName: QueueConsumer
*



* Copyright: (c)2017 JASTAR·WANG,All rights reserved.
* 






private ConnectionFactory connectionFactory;
private Connection connection;
private Session session;
private Destination destination;
// 注意这里是消息接收（消费）者
private MessageConsumer messageConsumer;

public static void main(String[] args) {
    QueueConsumer consumer = new QueueConsumer();
    consumer.doReceive();
}

public void doReceive() {
    try {
        connectionFactory = new ActiveMQConnectionFactory();
        connection = connectionFactory.createConnection();
        connection.start();
        session = connection.createSession(true, Session.AUTO_ACKNOWLEDGE);
        destination = session.createQueue(QueueProducer.QUEUE_NAME);

        /**
         * 注意：这里要创建一个消息消费，并指定目的地（即消息源队列）
         */
        messageConsumer = session.createConsumer(destination);

        // 方式一：监听接收
        receiveByListener();

        // 方式二：阻塞接收
        // receiveByManual();

        /**
         * 注意：这里不能再关闭对象了
         */
        // messageConsumer.close();
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        /**
         * 注意：这里不能再关闭Connection了
         */
        // connection.close();
    }

}

/**
 * 通过注册监听器的方式接收消息，属于被动监听
 */
private void receiveByListener() {
    try {
        messageConsumer.setMessageListener(new MessageListener() {

            @Override
            public void onMessage(Message message) {
                if (message instanceof TextMessage) {
                    try {
                        TextMessage msg = (TextMessage) message;
                        System.out.println("Received:“" + msg.getText()
                                + "”");
                        // 可以通过此方法反馈消息已收到
                        msg.acknowledge();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }

            }
        });
    } catch (Exception e) {
        e.printStackTrace();
    }
}

/**
 * 通过手动去接收消息的方式，属于主动获取
 */
private void receiveByManual() {
    while (true) {
        try {
            /**
             * 通过receive()方法阻塞接收消息，参数为超时时间（单位：毫秒）
             */
            TextMessage message = (TextMessage) messageConsumer
                    .receive(60000);
            if (message != null) {
                System.out.println("Received:“" + message.getText() + "”");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
3. 发布订阅模型

3.1 主题消息发送者

和点对点模型的发送者唯一不同的是——创建目的地Destination的时候是通过 session.createTopic(); 来创建，其他的使用套路如同 QueueProducer.java ，在此不再贴代码，最后我会留下示例代码地址，需要的可以去down下看看。

3.2 主题消息接收者

编写 TopicConsumer.java ，如下：

package com.jastar.activemq.topic;

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageListener;
import javax.jms.Session;
import javax.jms.TextMessage;

import org.apache.activemq.ActiveMQConnectionFactory;

/**
* 主题消息-接收（消费）者
*


* ClassName: TopicConsumer
*



* Copyright: (c)2017 JASTAR·WANG,All rights reserved.
* 











public static void main(String[] args) {
    /**
     * Pub/Sub模型中，消息可被多个对象接收，不同于P2P模型
     */
    TopicConsumer consumer1 = new TopicConsumer();
    consumer1.doReceive();
    TopicConsumer consumer2 = new TopicConsumer();
    consumer2.doReceive();
}

public void doReceive() {
    try {
        connectionFactory = new ActiveMQConnectionFactory();
        connection = connectionFactory.createConnection();
        connection.start();
        session = connection.createSession(true, Session.AUTO_ACKNOWLEDGE);
        destination = session.createTopic(TopicProducer.TOPIC_NAME);
        messageConsumer = session.createConsumer(destination);

        // 方式一：监听接收
        receiveByListener();

        // 方式二：阻塞接收
        // receiveByManual();

    } catch (Exception e) {
        e.printStackTrace();
    }

}

/**
 * 通过注册监听器的方式接收消息，属于被动监听
 */
private void receiveByListener() {
    try {
        messageConsumer.setMessageListener(new MessageListener() {

            @Override
            public void onMessage(Message message) {
                if (message instanceof TextMessage) {
                    try {
                        TextMessage msg = (TextMessage) message;
                        System.out.println("Received:“" + msg.getText()
                                + "”");
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }

            }
        });
    } catch (Exception e) {
        e.printStackTrace();
    }
}

/**
 * 通过手动去接收消息的方式，属于主动获取
 */
private void receiveByManual() {
    while (true) {
        try {
            /**
             * 通过receive()方法阻塞接收消息，参数为超时时间（单位：毫秒）
             */
            TextMessage message = (TextMessage) messageConsumer
                    .receive(60000);
            if (message != null) {
                System.out.println("Received:“" + message.getText() + "”");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
4.最后说几句

以上代码全部经过我的测试，绝对保证可靠运行
浏览器访问ActiveMQ的Web控制台（http://localhost:8161/admin），即可看到消息、队列、主题等等信息，在此不再上图了，懒死了真是……
示例代码项目地址：https://gitee.com/jastar-wang/demo-amq

单弓丨
关注
java通过AMQ通讯
04-19
在Eclipse中，你需要导入相关的AMQ库，如activemq-client.jar，以便在Java程序中使用AMQ功能。创建AMQ连接通常包括以下步骤： 1. 导入必要的AMQ类库。 2. 创建ConnectionFactory实例，指定服务器URL（如tcp://...
RabbitMQ初步到精通-第八章-Java-AMQP-Client源码分析
勤能补拙是良训,一分辛苦一分才
11-20 1362
总的来说，amqp的代码相对简单的，最绕的就是消费者那块了。首先是靠 MainLoop驱动，其次，将消息内容的处理方法投递到了本地 BlockingQueue中，最后，靠启动线程取出Queue中的处理方法，进行本地消费。
【Java】微服务——RabbitMQ消息队列（SpringAMQP实现五种消息模型）
qq_59708493的博客
10-09 2220
基本消息队列的消息发送流程：建立connection创建channel利用channel声明队列利用channel向队列发送消息基本消息队列的消息接收流程：建立connection创建channel利用channel声明队列定义consumer的消费行为handleDelivery()利用channel将消费者与队列绑定多个消费者绑定到一个队列，同一条消息只会被一个消费者处理通过设置prefetch来控制消费者预取的消息数量交换机的作用是什么？接收publisher发送的消息。
AMQ-Topic-主题-发布订阅模式持久化订阅与非持久化订阅
u012966087的博客
07-12 1562
    目前在开发的项目使用了AMQ（ActiveMQ）中间件的Topic模式（主题模式、发布订阅模式）实现消息收发的功能。    为什么使用发布订阅模式呢，因为项目是C/S架构（民航业，没办法）。服务端对应多个客户端，客户端自己就可以实现订阅消息，接收消息，发送消息，甚至根据不同业务模块分发消息。因此，在MQ的使用上也不同于一般的B/S项目（B/S项目一般是使用队列模式-queue，在避免消息漏...
java amqp_AMQP-基本概念篇
weixin_34987818的博客
02-15 910
尝试试用了下rabbitmq ，比activemq 简单很多，客户端API很简洁。先普及几个概念AMQP1.基本概念：AMQP(消息队列协议，Advanced Message Queuing Protocol)是一种消息协议 ，等同于JMS，但是JMS只是java平台的方案，且只是API级别的一个协议，AMQP是一个跨语言的协议。AMQP允许来自不同供应商的消息生产者和消费者实现真正的互操作扩展，...
rabbitmq java 订阅_（翻译）RabbitMQ Java Client教程（三）发布/订阅
weixin_42361666的博客
03-02 233
在前一篇教程中我们创建了一个工作队列。工作队列假设每个消息只会分发给一个消费者。在本篇教程中我们将会做一些完全不同的事情——发送同一条消息给多个消费者。这种模式被称为“发布/订阅”。为了描述这种模式，我们将会构建一个简单的日志系统。它包含两个程序——一个发送日志消息，另一个接收并打印这些消息。在我们的日志系统中每一个接收程序都会获取到这些消息。通过这种方式我们可以启动一个消费者将日志记录到磁盘，然...
rabbitmq+java简单例子
10-24
### rabbitmq+java简单例子知识点解析 #### 一、RabbitMQ简介 RabbitMQ 是一个开源的消息代理软件，它支持多种消息协议，包括 AMQP（Advanced Message Queuing Protocol）。RabbitMQ 可以帮助开发者在分布式系统...
springboot-amq-s2i
03-26
Red Hat JBoss A-MQ xPaaS产品应该已经安装并在OpenShift安装上运行，一种运行A-MQ服务的简单方法是遵循与amq63-basic模板相关的OpenShift的A-MQ xPaaS映像的文档。 。 然后，以下命令将打包您的应用并在OpenShift...
animalorder-jpa-amq:演示服务，用于轮询数据库并使用JPA进行更新
03-22
这个例子演示了如何在Spring Boot中使用Apache Camel。 快速入门使用Spring Boot配置一个小的应用程序，该应用程序包含一个骆驼路由，该路由每5秒触发一次消息，并将消息路由到日志。 建筑 这个例子可以用 mvn clean...
spring-boot-camel-amq:快速入门，展示如何将Spring Boot，Apache Camel和Apache ActiveMQ与Kubernetes或OpenShift一起使用
05-14
在此示例中，我们将使用两个容器，一个容器作为EnMasse实例运行，另一个容器作为运行Camel路由的代理的客户端。 此快速入门要求首先部署和运行EnMasse。 要将EnMasse安装到OpenShift或Kubernetes中，请遵循。 该...
java ActiveMQ的例子
07-22
java ActiveMQ的例子，里面有apache-activemq-5.9.0的压缩包，有使用说明，适合c初步了解activeMQ的朋友
AMQ接收与发送
09-10
activeMQ的接收端与发送端分离出来的，接收与发送分离，运行之后在MQ控制台查看。
深入浅出JMS ActiveMQ
lky5387的专栏
03-23 694
深入浅出JMS(一)--JMS基本概念 摘要：The Java Message Service (JMS) API is a messaging standard that allows application components based on the Java Platform Enterprise Edition (Java EE) to create, send,
SpringBoot中使用AMQ的两种方式（Java配置、注解方式）
hu0141的博客
09-29 2355
                                       Java配置方式使用AMQ 1. 引入依赖（pom.xml） &lt;project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocatio...
AMQ的一些简单实战
qq_37988146的博客
11-04 1409
目录 一、创建客户端  二、创建接收端 三、发布 四、用户订阅 五、配置安全认证       一、创建客户端 public class Sender { public static void main(String[] args) throws Exception{ //第一步:建立connectionFactory工厂对象【需填入用户名、密码、要连接的地址】 ...
Amq 使用+springboot
cmx1060220219的博客
07-08 662
Amq 使用+springboot AMQ是JMS 是java的标准 spring 提供了 JmsTemplate @JmsListerner @EnableJms 使用： 配置 @Configuration public class AmqConfig { //配置Amq的连接池 @Bean(name = "primaryMqConnectionFactory") @Primary public ActiveMQConnectionFactory primaryMqCo
ibm websphere mq 监控自研（待补充）
runningya的专栏
09-19 772
参考IBM MQ官网：https://www.ibm.com/support/knowledgecenter/SSFKSJ_8.0.0/com.ibm.mq.pro.doc/q001010_.htm 配置统计打开开关 to enable statistics information collection for the queue,Q1, use the following MQSC ...
amq简单使用
sunnyivan的专栏
03-05 2588
queue senderpackage org.arrow.amq.test; import javax.jms.*;import org.apache.activemq.ActiveMQConnection; import org.apache.activemq.ActiveMQConnectionFactory; import org.apache.activemq.jms.pool.Poole
ActiveMQ入门-amq入门
blackknightt的博客
11-04 9383
ActiveMQ是什么 ActiveMQ是Apache出品，最流行的，能力强劲的开源消息总线。 ActiveMQ是一个完全支持JMS1.1和J2EE1.4规范的JMS Provider实现，尽管JMS规范出台已经是很久的事情了，但是JMS在当今的J2EE应用中任然扮演着特殊的地位。 JMS规范 Java消息服务（Java Message Service，即JMS）应用程序接口是一个Java平台中关...
Java实现一下amq获取消息
最新发布
09-20
在Java中，使用AMQ (Advanced Message Queuing Protocol) 进行消息队列操作通常涉及到Apache ActiveMQ这样的开源消息中间件。这里提供一个简单的示例，展示如何使用ActiveMQ的客户端API从一个队列中接收消息： 首先...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值