spring整合ActiveMQ订阅模式(对象消息发送)

一、前言
在我开始做spring+ActiveMQ的整合时，也是看了不少网上的文章，发现雷同的文章有很多，然后有些操作看的不是很清楚，可能我代码水平有限，在我自己的研究过后，打算整理一下：
1、ActiveMQ的点对点模式以及订阅模式
2、ActiveMQ整合spring 的点对点模式以及订阅模式


二、消息队列，点对点，发布订阅含义解读
1、什么是JMS
JMS即Java消息服务（Java Message Service）应用程序接口，是一个Java平台中关于面向消息中间件（MOM）的API，用于在两个应用程序之间，或分布式系统中发送消息，进行异步通信。Java消息服务是一个与具体平台无关的API，绝大多数MOM提供商都对JMS提供支持（百度百科给出的概述）。
  我们可以简单的理解：两个应用程序之间需要进行通信，我们使用一个JMS服务，进行中间的转发，通过JMS 的使用，我们可以解除两个程序之间的耦合。

2、JMS的优势
Asynchronous（异步），Reliable（可靠）

3、JMS2种通信模式之点对点模式
(3.1)在点对点通信模式中，应用程序由消息队列，发送方，接收方组成。每个消息都被发送到一个特定的队列，接收者从队列中获取消息。队列保留着消息，直到他们被消费或超时。
(3.2)每个消息只要一个消费者
(3.3)发送者和接收者在时间上是没有时间的约束，也就是说发送者在发送完消息之后，不管接收者有没有接受消息，都不会影响发送方发送消息到消息队列中。
(3.4)发送方不管是否在发送消息，接收方都可以从消息队列中去到消息
(3.5)接收方在接收完消息之后，需要向消息队列应答成功

4、JMS2种通信模式之发布订阅模式
(4.1)在发布/订阅消息模型中，发布者发布一个消息，该消息通过topic传递给所有的客户端。该模式下，发布者与订阅者都是匿名的，即发布者与订阅者都不知道对方是谁。并且可以动态的发布与订阅Topic。Topic主要用于保存和传递消息，且会一直保存消息直到消息被传递给客户端。
(4.2)一个消息可以传递个多个订阅者（即：一个消息可以有多个接受方）
(4.3)发布者与订阅者具有时间约束，针对某个主题（Topic）的订阅者，它必须创建一个订阅者之后，才能消费发布者的消息，而且为了消费消息，订阅者必须保持运行的状态。
(4.4)为了缓和这样严格的时间相关性，JMS允许订阅者创建一个可持久化的订阅。这样，即使订阅者没有被激活（运行），它也能接收到发布者的消息。

5、JMS 2种消费消息的方式
(5.1)同步（Synchronous）
　　在同步消费信息模式模式中，订阅者/接收方通过调用 receive（）方法来接收消息。在receive（）方法中，线程会阻塞直到消息到达或者到指定时间后消息仍未到达。


　　(5.2)异步（Asynchronous）
　　使用异步方式接收消息的话，消息订阅者需注册一个消息监听者，类似于事件监听器，只要消息到达，JMS服务提供者会通过调用监听器的onMessage()递送消息。


三、准备
1、首先去下载一个ActiveMQ(http://activemq.apache.org/activemq-5145-release.html),以下测试是基于windows版本
2、进入到activemq的bin的文件夹找到与当前系统版本对应的文件夹运行'activemq.bat'文件;


四、单个java项目做为 发布方 和 消费方


1,发布方代码(点对点模式)：
public class Server {

private static final Logger log = LoggerFactory.getLogger(Server.class);

//连接账号

    private final static String userName = "system";

    //连接密码
    private final static String password = "manager";
    //连接地址
    private final static String brokerURL = "tcp://localhost:61616";
    //connection的工厂
    private ConnectionFactory factory;
    //连接对象
    private Connection connection;
    //一个操作会话
    private Session session;
    //目的地，其实就是连接到哪个队列，如果是点对点，那么它的实现是Queue，如果是订阅模式，那它的实现是Topic
    private Destination destination;
    //生产者，就是产生数据的对象
    private MessageProducer producer;
    
    public static void main(String[] args) {
    Server ser = new Server();
    ser.send();
    }
    
    private void send(){
        try {
            //根据用户名，密码，url创建一个连接工厂
            factory = new ActiveMQConnectionFactory(userName, password, brokerURL);
            //从工厂中获取一个连接
            connection = factory.createConnection();
            connection.start();
            //创建一个session
            //第一个参数:是否支持事务，如果为true，则会忽略第二个参数，被jms服务器设置为SESSION_TRANSACTED
            //第二个参数为false时，paramB的值可为Session.AUTO_ACKNOWLEDGE，Session.CLIENT_ACKNOWLEDGE，DUPS_OK_ACKNOWLEDGE其中一个。
            //Session.AUTO_ACKNOWLEDGE为自动确认，客户端发送和接收消息不需要做额外的工作。哪怕是接收端发生异常，也会被当作正常发送成功。
            //Session.CLIENT_ACKNOWLEDGE为客户端确认。客户端接收到消息后，必须调用javax.jms.Message的acknowledge方法。jms服务器才会当作发送成功，并删除消息。
            //DUPS_OK_ACKNOWLEDGE允许副本的确认模式。一旦接收方应用程序的方法调用从处理消息处返回，会话对象就会确认消息的接收；而且允许重复确认。
            session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
            //创建一个到达的目的地
            destination = session.createQueue("text-msg");
            //从session中，获取一个消息生产者
            producer = session.createProducer(destination);
            //设置生产者的模式，有两种可选
            //DeliveryMode.PERSISTENT 当activemq关闭的时候，队列数据将会被保存
            //DeliveryMode.NON_PERSISTENT 当activemq关闭的时候，队列里面的数据将会被清空
            producer.setDeliveryMode(DeliveryMode.PERSISTENT);
            
            //创建一条消息，当然，消息的类型有很多，如文字，字节，对象等,可以通过session.create..方法来创建出来
            TextMessage textMsg = session.createTextMessage("hello ActiveMQ");
            for(int i = 0 ; i < 100 ; i ++){
                //发送一条消息
                producer.send(textMsg);
log.info("发送消息成功:{}，序号:{}",textMsg.getText(),i);
            }
            
            producer.close();
            session.close();
            connection.close();
        } catch (JMSException e) {
            log.error("method send,error msg:{}",e.getMessage());
        }
    }
}


2、消费方代码：
public class Client {

private static final Logger log = LoggerFactory.getLogger(Client.class);

//连接账号
    private static final  String userName = "system";
    //连接密码
    private static final String password = "manager";
    //连接地址
    private String brokerURL = "tcp://localhost:61616";
    //connection的工厂
    private ConnectionFactory factory;
    //连接对象
    private Connection connection;
    //一个操作会话
    private Session session;
    //目的地，其实就是连接到哪个队列，如果是点对点，那么它的实现是Queue，如果是订阅模式，那它的实现是Topic
    private Destination destination;
    //消费者，就是接收数据的对象
    private MessageConsumer consumer;
    public static void main(String[] args) {
    Client cl = new Client();
        cl.getMsg();
    }
    
    public void getMsg(){
        try {
            //根据用户名，密码，url创建一个连接工厂
            factory = new ActiveMQConnectionFactory(userName, password, brokerURL);
            //从工厂中获取一个连接
            connection = factory.createConnection();
            connection.start();
            //创建一个session
            //第一个参数:是否支持事务，如果为true，则会忽略第二个参数，被jms服务器设置为SESSION_TRANSACTED
            //第二个参数为false时，paramB的值可为Session.AUTO_ACKNOWLEDGE，Session.CLIENT_ACKNOWLEDGE，DUPS_OK_ACKNOWLEDGE其中一个。
            //Session.AUTO_ACKNOWLEDGE为自动确认，客户端发送和接收消息不需要做额外的工作。哪怕是接收端发生异常，也会被当作正常发送成功。
            //Session.CLIENT_ACKNOWLEDGE为客户端确认。客户端接收到消息后，必须调用javax.jms.Message的acknowledge方法。jms服务器才会当作发送成功，并删除消息。
            //DUPS_OK_ACKNOWLEDGE允许副本的确认模式。一旦接收方应用程序的方法调用从处理消息处返回，会话对象就会确认消息的接收；而且允许重复确认。
            session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
            //创建一个到达的目的地
            destination = session.createQueue("text-msg");
            //根据session，创建一个接收者对象
            consumer = session.createConsumer(destination);
            
            
            //实现一个消息的监听器
            //实现这个监听器后，以后只要有消息，就会通过这个监听器接收到
            consumer.setMessageListener(new MessageListener() {
                @Override
                public void onMessage(Message message) {
                    try {
                        //获取到接收的数据
                        String text = ((TextMessage)message).getText();
                        log.info("消息接收成功:{}",text);
                    } catch (JMSException e) {
                    log.error("消息接收失败:{}",e.getMessage());
                    }
                }
            });
        //消费方不要关闭，让它一直开着。
        } catch (JMSException e) {
        log.error("method getMsg,error msg:{}",e.getMessage());
        }
    }
}
3,发布方代码(发布订阅模式)：
public class Server {

private static final Logger log = LoggerFactory.getLogger(Server.class);

//连接账号
    private final static String userName = "system";
    //连接密码
    private final static String password = "manager";
    //连接地址
    private final static String brokerURL = "tcp://localhost:61616";
    //connection的工厂
    private ConnectionFactory factory;
    //连接对象
    private Connection connection;
    //一个操作会话
    private Session session;
    //目的地，其实就是连接到哪个队列，如果是点对点，那么它的实现是Queue，如果是订阅模式，那它的实现是Topic
    private Destination destination;
    //生产者，就是产生数据的对象
    private MessageProducer producer;
    
    public static void main(String[] args) {
    Server ser = new Server();
    ser.send();
    }
    
    private void send(){
        try {
            //根据用户名，密码，url创建一个连接工厂
            factory = new ActiveMQConnectionFactory(userName, password, brokerURL);
            //从工厂中获取一个连接
            connection = factory.createConnection();
            connection.start();
            //创建一个session
            //第一个参数:是否支持事务，如果为true，则会忽略第二个参数，被jms服务器设置为SESSION_TRANSACTED
            //第二个参数为false时，paramB的值可为Session.AUTO_ACKNOWLEDGE，Session.CLIENT_ACKNOWLEDGE，DUPS_OK_ACKNOWLEDGE其中一个。
            //Session.AUTO_ACKNOWLEDGE为自动确认，客户端发送和接收消息不需要做额外的工作。哪怕是接收端发生异常，也会被当作正常发送成功。
            //Session.CLIENT_ACKNOWLEDGE为客户端确认。客户端接收到消息后，必须调用javax.jms.Message的acknowledge方法。jms服务器才会当作发送成功，并删除消息。
            //DUPS_OK_ACKNOWLEDGE允许副本的确认模式。一旦接收方应用程序的方法调用从处理消息处返回，会话对象就会确认消息的接收；而且允许重复确认。
            session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
            //创建一个到达的目的地
            destination = session.createTopic("topic"); ---------与点对点不同之处
            //从session中，获取一个消息生产者
            producer = session.createProducer(destination);
            //设置生产者的模式，有两种可选
            //DeliveryMode.PERSISTENT 当activemq关闭的时候，队列数据将会被保存
            //DeliveryMode.NON_PERSISTENT 当activemq关闭的时候，队列里面的数据将会被清空
            producer.setDeliveryMode(DeliveryMode.PERSISTENT);
            
            //创建一条消息，当然，消息的类型有很多，如文字，字节，对象等,可以通过session.create..方法来创建出来
            TextMessage textMsg = session.createTextMessage("hello ActiveMQ");
            for(int i = 0 ; i < 100 ; i ++){
                //发送一条消息
                producer.send(textMsg);
log.info("发送消息成功:{}，序号:{}",textMsg.getText(),i);
            }
            
            producer.close();
            session.close();
            connection.close();
        } catch (JMSException e) {
            log.error("method send,error msg:{}",e.getMessage());
        }
    }
}


4、消费方代码：
public class Client {

private static final Logger log = LoggerFactory.getLogger(Client.class);

//连接账号
    private static final  String userName = "system";
    //连接密码
    private static final String password = "manager";
    //连接地址
    private String brokerURL = "tcp://localhost:61616";
    //connection的工厂
    private ConnectionFactory factory;
    //连接对象
    private Connection connection;
    //一个操作会话
    private Session session;
    //目的地，其实就是连接到哪个队列，如果是点对点，那么它的实现是Queue，如果是订阅模式，那它的实现是Topic
    private Destination destination;
    //消费者，就是接收数据的对象
    private MessageConsumer consumer;
    public static void main(String[] args) {
    Client cl = new Client();
        cl.getMsg();
    }
    
    public void getMsg(){
        try {
            //根据用户名，密码，url创建一个连接工厂
            factory = new ActiveMQConnectionFactory(userName, password, brokerURL);
            //从工厂中获取一个连接
            connection = factory.createConnection();
            connection.start();
            //创建一个session
            //第一个参数:是否支持事务，如果为true，则会忽略第二个参数，被jms服务器设置为SESSION_TRANSACTED
            //第二个参数为false时，paramB的值可为Session.AUTO_ACKNOWLEDGE，Session.CLIENT_ACKNOWLEDGE，DUPS_OK_ACKNOWLEDGE其中一个。
            //Session.AUTO_ACKNOWLEDGE为自动确认，客户端发送和接收消息不需要做额外的工作。哪怕是接收端发生异常，也会被当作正常发送成功。
            //Session.CLIENT_ACKNOWLEDGE为客户端确认。客户端接收到消息后，必须调用javax.jms.Message的acknowledge方法。jms服务器才会当作发送成功，并删除消息。
            //DUPS_OK_ACKNOWLEDGE允许副本的确认模式。一旦接收方应用程序的方法调用从处理消息处返回，会话对象就会确认消息的接收；而且允许重复确认。
            session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
            //创建一个到达的目的地
            destination = session.createTopic("topic"); ---------与点对点不同之处
            //根据session，创建一个接收者对象
            consumer = session.createConsumer(destination);
            
            
            //实现一个消息的监听器
            //实现这个监听器后，以后只要有消息，就会通过这个监听器接收到
            consumer.setMessageListener(new MessageListener() {
                @Override
                public void onMessage(Message message) {
                    try {
                        //获取到接收的数据
                        String text = ((TextMessage)message).getText();
                        log.info("消息接收成功:{}",text);
                    } catch (JMSException e) {
                    log.error("消息接收失败:{}",e.getMessage());
                    }
                }
            });
        //消费方不要关闭，让它一直开着。
        } catch (JMSException e) {
        log.error("method getMsg,error msg:{}",e.getMessage());
        }
    }
}
五、一个发布方项目，2个消费方项目(整合spring)
1、ActiveMQ发布方整合spring 文件：

      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:amq="http://activemq.apache.org/schema/core"
    xmlns:jms="http://www.springframework.org/schema/jms"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans     
        http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-4.1.xsd
        http://www.springframework.org/schema/jms
        http://www.springframework.org/schema/jms/spring-jms-4.1.xsd"
    >
   
   
            class="org.springframework.jms.connection.CachingConnectionFactory">
         
         
             
                 
                 
               
               
                   
                 
             
         
   
    
   
   
       
       
   
    
    
   
   
       
       
       
       
       
   
 
2、简单的发布方代码
直接运行main 方法就好了.
public class Producer {

public static void main(String[] args) {

ApplicationContext ctx = new ClassPathXmlApplicationContext("ActiveMQ.xml");

JmsTemplate jt = (JmsTemplate)ctx.getBean("jmsTemplate");
//创建一个对象，作为消费消息发送出去
Person p = new Person();
p.setAge("27");
p.setName("南柯一梦");
final String string = JSON.toJSONString(p);
for(int i = 0; i < 5 ; i++){
jt.send(new MessageCreator() {

@Override
public Message createMessage(Session session) throws JMSException {
ObjectMessage message = session.createObjectMessage();
message.setObject((Serializable)string);
return message;
}
});
}

}
}
3、第一台消费方
1、ActiveMQ整合spring 配置文件

      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:amq="http://activemq.apache.org/schema/core"
    xmlns:jms="http://www.springframework.org/schema/jms"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans     
        http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-4.1.xsd
        http://www.springframework.org/schema/jms
        http://www.springframework.org/schema/jms/spring-jms-4.1.xsd"
    >
   
        
    
   
            class="org.springframework.jms.connection.CachingConnectionFactory">
         
         
         
             
                 
                 
               
               
                   
                 
             
         
   
    
   
   
       
       
   
    
    
     
    
       
            class="org.springframework.jms.listener.adapter.MessageListenerAdapter">  
         
         
         
         
         
     
    
   
   
       
       
       
       
       
       
       
       
       
       
   
 
2、消费方代码
大家请注意 这里的类名和方法名 在上面的配置文件中指定了。
public class Consumer {

private static final Logger log = LoggerFactory.getLogger(Consumer.class);

    public void receive(ObjectMessage message) throws JmsException, JMSException {  
    log.info("我是第一台消费方");
   
    String object = (String)message.getObject();
   
    log.info(object);
   
    }  
      
}

3、结果：

4、第二台消费方
1、ActiveMQ整合spring 配置文件

      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:amq="http://activemq.apache.org/schema/core"
    xmlns:jms="http://www.springframework.org/schema/jms"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans     
        http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-4.1.xsd
        http://www.springframework.org/schema/jms
        http://www.springframework.org/schema/jms/spring-jms-4.1.xsd"
    >
   
        
    
   
            class="org.springframework.jms.connection.CachingConnectionFactory">
         
         
         
             
                 
                 
               
               
                   
                 
             
         
   
    
   
   
       
       
   
    
    
     
    
       
            class="org.springframework.jms.listener.adapter.MessageListenerAdapter">  
         
         
         
         
         
     
    
   
   
       
       
       
       
       
       
       
       
       
       
   
 
2、消费方代码
大家请注意 这里的类名和方法名 在上面的配置文件中指定了。
public class Consumer {

private static final Logger log = LoggerFactory.getLogger(Consumer.class);

    public void receive(ObjectMessage message) throws JmsException, JMSException {  
    log.info("我是第二台消费方");
   
    String object = (String)message.getObject();
   
    log.info(object);
   
    }  
      
}