ActiveMQ消息过滤

一、消息的过期

允许消息过期 。默认情况下，消息永不会过期。如果消息在特定周期内失去意义，那么可以设置过期时间。 
有两种方法设置消息的过期时间，时间单位为毫秒： 
1．使用消息生产者的setTimeToLive 方法为所有的消息设置过期时间。
2．使用消息生产者的send 方法为每一条消息设置过期时间。
 消息过期时间，send 方法中的 timeToLive 值加上发送时刻的 GMT 时间值。如果 timeToLive 值等于零，则 JMSExpiration 被设为零， 表示该消息永不过期。

3、消息服务器接收到消息后，在指定的时间后，会从队列中移除指定的消息，超时被移除的消息不会发送给消费者。

4、使用消息生产者的setTimeToLive(long time ) 方法来给所有的消息设置过期时间：

[java] view plain copy

1. // 消息生产者  
2. MessageProducer producer = null;  
3. producer = session.createProducer(queue);  
4. // 消息是否为持久性的，如果不设置默认是持久化的。  
5. producer.setDeliveryMode(DeliveryMode.PERSISTENT);  
6.  //消息过期设置  
7. producer.setTimeToLive(1000);  

5、使用消息生产者的send()方法来设置消息的过期时间

[java] view plain copy

1. //message发送的消息，deliveryMode是否持久化，priority优先级，timeToLive 消息过期时间  
2. //producer.send(message, deliveryMode, priority, timeToLive);  
3. producer.send(message, DeliveryMode.PERSISTENT, 4, 1000);  

这里在插一段吧，上面设置消息过期的都是消息生产者这方的来设置的，也就是如果不满足条件则消息服务器会把消息从消息队列中删除，但是我们也可以在消息消费端来设置接受时间（仅限于同步接受）

[java] view plain copy

1. Message message = consumer.receive(2);  

就是在接受的时候添加等待时间（单位是毫秒）如果在指定的时间内获取不到消息则不会再等了。如果不设置等待时间则一直等待直到接收到消息或超时为止。

二、消息的选择器

不管是在消息发送端设置消息过期时间还是在接收端设置等待时间，都是对不满足的消息有过滤的作用，那消息选择器就是为过滤消息而生的下面来看看消息选择器：

ActiveMQ提供了一种机制，使用它，消息服务可根据消息选择器中的标准来执行消息过滤。生产者可在消息中放入应用程序特有的属性，而消费者可使用基于这些属性的选择标准来表明对消息是否感兴趣。这就简化了客户端的工作，并避免了向不需要这些消息的消费者传送消息的开销。然而，它也使得处理选择标准的消息服务增加了一些额外开销。 消息选择器是用于MessageConsumer的过滤器，可以用来过滤传入消息的属性和消息头部分（但不过滤消息体），并确定是否将实际消费该消息。消息选择器是一些字符串，它们基于某种语法，而这种语法是SQL-92的子集。可以将消息选择器作为MessageConsumer 创建的一部分。

1、消息生产者：

[java] view plain copy

1. package mqtest3;  
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.JMSException;  
8. import javax.jms.MapMessage;  
9. import javax.jms.MessageProducer;  
10. import javax.jms.Session;  
11. import javax.jms.TextMessage;  
12.   
13. import org.apache.activemq.ActiveMQConnectionFactory;  
14.   
15. public class Producer {  
16.     // 单例模式  
17.     // 1、连接工厂  
18.     private ConnectionFactory connectionFactory;  
19.     // 2、连接对象  
20.     private Connection connection;  
21.     // 3、Session对象  
22.     private Session session;  
23.     // 4、生产者  
24.     private MessageProducer messageProducer;  
25.   
26.     public Producer() {  
27.         try {  
28.             this.connectionFactory = new ActiveMQConnectionFactory("admin",  
29.                     "admin", "tcp://127.0.0.1:61616");  
30.             this.connection = connectionFactory.createConnection();  
31.             this.connection.start();  
32.             // 设置自动签收模式  
33.             this.session = this.connection.createSession(false,  
34.                     Session.AUTO_ACKNOWLEDGE);  
35.             this.messageProducer = this.session.createProducer(null);  
36.         } catch (JMSException e) {  
37.             throw new RuntimeException(e);  
38.         }  
39.   
40.     }  
41.   
42.     public Session getSession() {  
43.         return this.session;  
44.     }  
45.   
46.     public void send1(/* String QueueName, Message message */) {  
47.         try {  
48.   
49.             Destination destination = this.session.createQueue("first");  
50.             MapMessage msg1 = this.session.createMapMessage();  
51.             msg1.setString("name", "张三");  
52.             msg1.setInt("age", 20);  
53.             // 设置用于消息过滤器的条件  
54.             msg1.setStringProperty("name", "张三");  
55.             msg1.setIntProperty("age", 20);  
56.             msg1.setStringProperty("color", "bule");  
57.   
58.             MapMessage msg2 = this.session.createMapMessage();  
59.             msg2.setString("name", "李四");  
60.             msg2.setInt("age", 25);  
61.             // 设置用于消息过滤器的条件  
62.             msg2.setStringProperty("name", "李四");  
63.             msg2.setIntProperty("age", 25);  
64.             msg2.setStringProperty("color", "white");  
65.   
66.             MapMessage msg3 = this.session.createMapMessage();  
67.             msg3.setString("name", "赵六");  
68.             msg3.setInt("age", 30);  
69.             // 设置用于消息过滤器的条件  
70.             msg3.setStringProperty("name", "赵六");  
71.             msg3.setIntProperty("age", 30);  
72.             msg3.setStringProperty("color", "black");  
73.             // 发送消息  
74.             this.messageProducer.send(destination, msg1,  
75.                     DeliveryMode.NON_PERSISTENT, 4, 1000 * 60 * 10);  
76.             this.messageProducer.send(destination, msg2,  
77.                     DeliveryMode.NON_PERSISTENT, 4, 1000 * 60 * 10);  
78.             this.messageProducer.send(destination, msg3,  
79.                     DeliveryMode.NON_PERSISTENT, 4, 1000 * 60 * 10);  
80.         } catch (JMSException e) {  
81.             throw new RuntimeException(e);  
82.         }  
83.     }  
84.   
85.     public void send2() {  
86.         try {  
87.             Destination destination = this.session.createQueue("first");  
88.             TextMessage message = this.session.createTextMessage("我是一个字符串");  
89.             message.setIntProperty("age", 25);  
90.             // 发送消息  
91.             this.messageProducer.send(destination, message,  
92.                     DeliveryMode.NON_PERSISTENT, 4, 1000 * 60 * 10);  
93.         } catch (JMSException e) {  
94.             throw new RuntimeException(e);  
95.         }  
96.   
97.     }  
98.   
99.     public static void main(String[] args) {  
100.         Producer producer = new Producer();  
101.         producer.send1();  
102.         // producer.send2();  
103.   
104.     }  
105. }  

2、消息消费者：

[java] view plain copy

1. package mqtest3;  
2.   
3. import javax.jms.Connection;  
4. import javax.jms.ConnectionFactory;  
5. import javax.jms.Destination;  
6. import javax.jms.JMSException;  
7. import javax.jms.MapMessage;  
8. import javax.jms.Message;  
9. import javax.jms.MessageConsumer;  
10. import javax.jms.MessageListener;  
11. import javax.jms.Session;  
12. import javax.jms.TextMessage;  
13. import org.apache.activemq.ActiveMQConnectionFactory;  
14.   
15. public class Conmuser {  
16.     // 单例模式  
17.     // 1、连接工厂  
18.     private ConnectionFactory connectionFactory;  
19.     // 2、连接对象  
20.     private Connection connection;  
21.     // 3、Session对象  
22.     private Session session;  
23.     // 4、生产者  
24.     private MessageConsumer messageConsumer;  
25.     // 5、目的地址  
26.     private Destination destination;  
27.     // 消息选择器  
28.     public final String SELECTOR_1 = "age > 25";  
29.     public final String SELECTOR_2 = " age > 20 and color='black'";  
30.   
31.     public Conmuser() {  
32.         try {  
33.             this.connectionFactory = new ActiveMQConnectionFactory("admin",  
34.                     "admin", "tcp://127.0.0.1:61616");  
35.             this.connection = connectionFactory.createConnection();  
36.             this.connection.start();  
37.             // 设置自动签收模式  
38.             this.session = this.connection.createSession(false,  
39.                     Session.AUTO_ACKNOWLEDGE);  
40.             this.destination = this.session.createQueue("first");  
41.             // 在构造消费者的时候，指定了 消息选择器  
42.             // 有选择性的消费消息  
43.             this.messageConsumer = this.session.createConsumer(destination,  
44.                     SELECTOR_1);  
45.         } catch (JMSException e) {  
46.             throw new RuntimeException(e);  
47.         }  
48.     }  
49.   
50.     public Session getSession() {  
51.         return this.session;  
52.     }  
53.   
54.     // 用于监听消息队列的消息  
55.     class MyLister implements MessageListener {  
56.   
57.         @Override  
58.         public void onMessage(Message message) {  
59.             try {  
60.                 if (message instanceof TextMessage) {  
61.                     TextMessage ret = (TextMessage) message;  
62.                     System.out.println("results;" + ret.getText());  
63.                 }  
64.                 if (message instanceof MapMessage) {  
65.                     MapMessage ret = (MapMessage) message;  
66.                     System.out.println(ret.toString());  
67.                     System.out.println(ret.getString("name"));  
68.                     System.out.println(ret.getInt("age"));  
69.                 }  
70.             } catch (JMSException e) {  
71.                 throw new RuntimeException(e);  
72.             }  
73.         }  
74.   
75.     }  
76.   
77.     // 用于异步监听消息  
78.     public void receiver() {  
79.         try {  
80.             this.messageConsumer.setMessageListener(new MyLister());  
81.         } catch (JMSException e) {  
82.             throw new RuntimeException(e);  
83.         }  
84.     }  
85.   
86.     public static void main(String[] args) {  
87.         Conmuser conmuser = new Conmuser();  
88.         conmuser.receiver();  
89.   
90.     }  
91. }  

上面的demo是对MapMessage和TextMessage两种消息的过滤条件的设置和消费，过滤条件的设置使在消息的属性中设置，而消费消息的时候直接是在session创建MessageConsumer时传入的参数即过滤条件（过滤条件的写法和SQL的写法是很像的）

在写过滤条件的时候要注意设置的是什么类型的条件即： int 、string 如果是int 则加引号而如果是String则要加哦！！！

三、消息的优先级

通常，可以确保将单个会话向目标发送的所有消息按其发送顺序传送至消费者。然而，如果为这些消息分配了不同的优先级，消息传送系统将首先尝试传送优先级较高的消息。 
有两种方法设置消息的优先级： 
1．使用 setPriority 方法，这样所有的消息都采用此传送模式； 
2．使用 send 方法为每一条消息设置传送模式； 
消息优先级从 0-9 十个级别，0-4 是普通消息，5-9 是加急消息。如果不指定优先级，则默认为 4。JMS 不要求严格按照这十个优先级发送消息，但必须保证加急消息要先于普通消息到达。