Activemq:消息队列

有关于activemq的学习

ActiveMQ 是Apache出品，最流行的，能力强劲的开源消息总线。ActiveMQ 是一个完全支持JMS1.1和J2EE 1.4规范的 JMS Provider实现。

消息队列的主要作用是为了解决高并发访问高峰，加快响应速度。一般情况下，不用消息队列，客户端来的请求会直接写入数据库，在访问高峰期，高并发的情况下，会对数据库访问造成压力，响应发生延迟，造成数据库访问的瓶颈。使用队列后，用户的请求发给队列后会立刻返回，之后再由消息队列的消费者进程监听对应的队列，从消息队列中获取数据，异步写入数据库。消息队列的服务处理速度远快于数据库，因此用户的响应延迟可得到有效改善。

消费者程序：

1. package com.ll.activemq;
2. 
   
3. import java.util.Collection;
4. import java.util.Iterator;
5. 
   
6. import javax.jms.Connection;
7. import javax.jms.ConnectionFactory;
8. import javax.jms.Destination;
9. import javax.jms.MapMessage;
10. import javax.jms.MessageConsumer;
11. import javax.jms.Session;
12. import javax.jms.TextMessage;
13. import org.apache.activemq.ActiveMQConnection;
14. import org.apache.activemq.ActiveMQConnectionFactory;
15. 
    
16. public class Receiver {
17. public static void main(String[] args) {
18. // ConnectionFactory ：连接工厂，JMS 用它创建连接
19. ConnectionFactory connectionFactory;
20. // Connection ：JMS 客户端到JMS Provider 的连接
21. Connection connection = null;
22. // Session： 一个发送或接收消息的线程
23. Session session;
24. // Destination ：消息的目的地;消息发送给谁.
25. Destination destination;
26. // 消费者，消息接收者
27. MessageConsumer consumer;
28. connectionFactory = new ActiveMQConnectionFactory(
29. ActiveMQConnection.DEFAULT_USER,
30. ActiveMQConnection.DEFAULT_PASSWORD, "tcp://localhost:61616");
31. try {
32. // 构造从工厂得到连接对象
33. connection = connectionFactory.createConnection();
34. // 启动
35. connection.start();
36. // 获取操作连接
37. session = connection.createSession(Boolean.FALSE,
38. Session.AUTO_ACKNOWLEDGE);
39. // 获取session注意参数值xingbo.xu-queue是一个服务器的queue，须在在ActiveMq的console配置
40. destination = session.createQueue("FirstQueue");
41. consumer = session.createConsumer(destination);
42. // consumer2 = session.createConsumer(destination);
43. System.out.println("消费者1：消费者程序开始运行...");
44. while (true) {
45. // 设置接收者接收消息的时间，为了便于测试，这里谁定为100s
46. TextMessage message = (TextMessage) consumer.receive(18000);
47. // Object message = (Object) consumer.receive(28000);
48. if (null != message) {
49. System.out.println("消费者1：收到消息-->" + message.getText());
50. } else {
51. System.out.println("消费者1：运行结束...\n");
52. break;
53. }
54. }
55. } catch (Exception e) {
56. e.printStackTrace();
57. } finally {
58. try {
59. if (null != connection)
60. connection.close();
61. } catch (Throwable ignore) {
62. }
63. }
64. }
65. }

生产者程序：

1. package com.ll.activemq;
2. 
   
3. import javax.jms.Connection;
4. import javax.jms.ConnectionFactory;
5. import javax.jms.DeliveryMode;
6. import javax.jms.Destination;
7. import javax.jms.MessageProducer;
8. import javax.jms.Session;
9. import javax.jms.TextMessage;
10. import org.apache.activemq.ActiveMQConnection;
11. import org.apache.activemq.ActiveMQConnectionFactory;
12. 
    
13. public class Sender {
14. private static final int SEND_NUMBER = 5;
15. 
    
16. public static void main(String[] args) {
17. // ConnectionFactory ：连接工厂，JMS 用它创建连接
18. ConnectionFactory connectionFactory;
19. // Connection ：JMS 客户端到JMS Provider 的连接
20. Connection connection = null;
21. // Session： 一个发送或接收消息的线程
22. Session session;
23. // Destination ：消息的目的地;消息发送给谁.
24. Destination destination;
25. // MessageProducer：消息发送者
26. MessageProducer producer;
27. // TextMessage message;
28. // 构造ConnectionFactory实例对象，此处采用ActiveMq的实现jar
29. connectionFactory = new ActiveMQConnectionFactory(
30. ActiveMQConnection.DEFAULT_USER,
31. ActiveMQConnection.DEFAULT_PASSWORD,
32. "tcp://localhost:61616");
33. try {
34. // 构造从工厂得到连接对象
35. connection = connectionFactory.createConnection();
36. // 启动
37. connection.start();
38. // 获取操作连接
39. session = connection.createSession(Boolean.TRUE,
40. Session.AUTO_ACKNOWLEDGE);
41. // 获取session注意参数值xingbo.xu-queue是一个服务器的queue，须在在ActiveMq的console配置
42. destination = session.createQueue("FirstQueue");
43. // 得到消息生成者【发送者】
44. producer = session.createProducer(destination);
45. // 设置不持久化，此处学习，实际根据项目决定
46. producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);
47. // 构造消息，此处写死，项目就是参数，或者方法获取
48. sendMessage(session, producer);
49. session.commit();
50. } catch (Exception e) {
51. e.printStackTrace();
52. } finally {
53. try {
54. if (null != connection)
55. connection.close();
56. } catch (Throwable ignore) {
57. }
58. }
59. }
60. 
    

1. public static void sendMessage(Session session, MessageProducer producer)
2. throws Exception {
3. for (int i = 1; i <= SEND_NUMBER; i++) {
4. TextMessage message = session
5. .createTextMessage("ActiveMq 发送的消息" + i);
6. // 发送消息到目的地方
7. System.out.println("发送消息：" + "ActiveMq 发送的消息" + i);
8. producer.send(message);
9. }
10. System.out.println("生产者程序退出...");
11. }
12. }

总结：

1. 使用Queue时，生产者只要将Message发送到MQ服务器端，消费者就可以进行消费，而无需生产者程序一直运行；

2. 消息是按照先入先出的顺序，一旦有消费者将Message消费，该Message就会从MQ服务器队列中删去；

3. 有文章说，“生产者”<-->"消费者"是一对一的关系，其实并不准确，从上面可以看出，一个生产者产生的消息，可以被

多个消费者进行消费，只不过多个消费者在消费消息时是竞争的关系，先得到的先消费，一旦消费完成，该消息就会出队列，

就不能被其他消费者再消费了，即“一次性消费”。

特点：

1.“离线一次性消费”；

离线：指生产者在发送消息时，不需要消费者在线，生产者只需要将消息发送到MQ队列中，消费者可以稍后上线取消息；

一次性消费：指消费者之间存在竞争关系，任何一个消费者将消息消费掉之后，其他消费者都不能再进行消费；

若是只有1个生产者和1个消费者，就是我们熟悉的“点对点”通信了；

类似场景对比：

类似送快递，快递员（producer）将快递（Message）放到指定地点（destination）后，就可以离开了，

拿快递的人（customer）在接收到通知后，到指定地点（destination）去取快递（Message）就可以了。

当然，取快递时可能要进行身份验证，这就涉及到创建连接（connection）时，需要指定用户名和密码了。

还有就是，实际生活中，当快递员把快递放好之后，照理说应该通知客户去哪里取快递，而ActiveMq帮我们

做好了一切，通知的工作Activemq会帮我们实现，而无需我们亲自编码通知消费者，生产者只需要将Message

放到Mq中即可，通知消费者的工作，mq会帮我们处理。