ActiveMQ Pub/Sub版的HelloWorld

1. pom.xml

这个和上一篇是一样的：

1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
2. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
3. <modelVersion>4.0.0</modelVersion>
4. <groupId>org.ygy</groupId>
5. <artifactId>activemq</artifactId>
6. <version>0.0.1-SNAPSHOT</version>
7. <packaging>jar</packaging>
8. <name>activemq</name>
9. <url>http://maven.apache.org</url>
10. <properties>
11. <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
12. </properties>
13. <dependencies>
14. <dependency>
15. <groupId>junit</groupId>
16. <artifactId>junit</artifactId>
17. <version>4.10</version>
18. <scope>test</scope>
19. </dependency>
20. <!-- activemq,学习中 -->
21. <dependency>
22. <groupId>org.apache.activemq</groupId>
23. <artifactId>activemq-core</artifactId>
24. <version>5.7.0</version>
25. </dependency>
26. <dependency>
27. <groupId>org.slf4j</groupId>
28. <artifactId>slf4j-api</artifactId>
29. <version>1.5.6</version>
30. </dependency>
31. <dependency>
32. <groupId>org.slf4j</groupId>
33. <artifactId>slf4j-log4j12</artifactId>
34. <version>1.5.6</version>
35. </dependency>
36. </dependencies>
37. </project>

2. Pub/Sub版的HelloWorld

生产者：

1. package org.ygy.mq.lesson01;
2. import javax.jms.Connection;
3. import javax.jms.ConnectionFactory;
4. import javax.jms.DeliveryMode;
5. import javax.jms.Destination;
6. import javax.jms.JMSException;
7. import javax.jms.MessageProducer;
8. import javax.jms.Session;
9. import javax.jms.TextMessage;
10. import org.apache.activemq.ActiveMQConnectionFactory;
11. import org.ygy.mq.constants.MQConstants;
12. public class HelloTopicProducer {
13. public void send(String msg) {
14. // 生产者的主要流程
15. Connection connection = null;
16. try {
17. // 1.初始化connection工厂,使用默认的URL
18. // failover://tcp://localhost:61616
19. ConnectionFactory connectionFactory = new ActiveMQConnectionFactory();
20. // 2.创建Connection
21. connection = connectionFactory.createConnection();
22. // 3.打开连接
23. connection.start();
24. // 4.创建Session，(是否支持事务)
25. Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
26. // 5.创建消息目标
27. Destination destination_send = session.createTopic(MQConstants.DESTINATION_SEND);
28. // 6.创建生产者
29. MessageProducer producer = session.createProducer(destination_send);
30. // 7.配置消息是否持久化
31. /*
32. * DeliverMode有2种方式：
33. *
34. * public interface DeliveryMode { static final int NON_PERSISTENT =
35. * 1;//不持久化：服务器重启之后，消息销毁
36. *
37. * static final int PERSISTENT = 2;//持久化：服务器重启之后，该消息仍存在 }
38. */
39. producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);
40. // 8.初始化要发送的消息
41. TextMessage message = session.createTextMessage(msg);
42. // 9.发送消息
43. producer.send(message);
44. connection.close();
45. } catch (JMSException e) {
46. e.printStackTrace();
47. }
48. }
49. public static void main(String[] args) {
50. new HelloTopicProducer().send("我来试一试发布/订阅...");
51. }
52. }

消费者：

1. package org.ygy.mq.lesson01;
2. import javax.jms.Connection;
3. import javax.jms.ConnectionFactory;
4. import javax.jms.Destination;
5. import javax.jms.JMSException;
6. import javax.jms.Message;
7. import javax.jms.MessageConsumer;
8. import javax.jms.MessageListener;
9. import javax.jms.Session;
10. import javax.jms.TextMessage;
11. import org.apache.activemq.ActiveMQConnectionFactory;
12. import org.ygy.mq.constants.MQConstants;
13. public class HelloTopicConsumer implements MessageListener {
14. @Override
15. public void onMessage(Message message) {
16. if (message instanceof TextMessage) {
17. TextMessage txtMsg = (TextMessage) message;
18. try {
19. System.out.println("哈，我接收到了消息：" + txtMsg.getText());
20. } catch (JMSException e) {
21. e.printStackTrace();
22. }
23. }
24. }
25. public void receive() {
26. // 消费者的主要流程
27. Connection connection = null;
28. try {
29. // 1.初始化connection工厂
30. ConnectionFactory connectionFactory = new ActiveMQConnectionFactory();
31. // 2.创建Connection
32. connection = connectionFactory.createConnection();
33. // 3.打开连接
34. connection.start();
35. // 4.创建session
36. Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
37. // 5.创建消息目标
38. Destination destination = session.createTopic(MQConstants.DESTINATION_SEND);
39. // 6.创建消费者
40. MessageConsumer consumer = session.createConsumer(destination);
41. // 7.配置监听
42. consumer.setMessageListener(new HelloTopicConsumer());
43. } catch (JMSException e) {
44. e.printStackTrace();
45. }
46. }
47. public static void main(String[] args) {
48. new HelloTopicConsumer().receive();
49. }
50. }

3.测试

访问网页：http://localhost:8161/admin/topics.jsp

单击那个Topics连接。

这里显示的是服务器上的主题，这些显示的都没有用，可以都删掉。

Name：主题的名称

Number Of Consumers：正在运行的消费者

Message Enqueued：进入消息队列的

Message Dequeued：出消息队列的

Operations：操作

下面就可以开始运行程序了，

注意顺序：先运行消费者：

这里会产生好几个主题，我们只看我们自己用的那个，（其实，其他几个是干嘛的，暂时还不清楚，以后再研究吧.....）

我们的消费者一直在运行

接下来，运行生产者：

控制台会输出：

再一次，刷新界面：

消费者还在运行，只生产了一条消息，而且已经被消费了。