ActiveMQ处理Message（String -javabean）

一、ActiveMq想要实现必备的六要素（基于jms）

  //链接工厂。用于创建链接
     private ConnectionFactory factory;
     
     //用于访问Mq的链接，由链接工厂创建
     private Connection connection;
     
     //消息队列的一次持久的有状态的会话，由链接创建
     private Session session;
     
     //本次访问activeMq队列的目的地(我觉得是别名，你放数据的队列的名字)，由会话创建
     private Destination  destination;
     
     //消息的生成者，会话中消息就是由他生成的。由session创建
     private MessageProducer producer;       或者// 消息接收方 private MessageConsumer consumer;
     
     //消息，消息在传递中的载体可以由session创建，也可以通过session从ActiveMq中获取
     private Message message;

  

 

 

二 、 生成者源码

public void  sendMsgToMq(String msg) {    传个要发送到队列的信息进来
           
           
           try{
                /**
                 * 1、实例化链接工厂
                 *
                  *    ActiveMQConnectionFactory - 由ActiveMQ实现的ConnectionFactory接口实现类.
             *   构造方法: public ActiveMQConnectionFactory(String userName, String password, String brokerURL)
                 * userName:用户名   默认admin
                 * password:密码       默认admin
                 * brokerURL:activemq服务的地址       消息服务的端口：61616     管理控制台的端口：8161
                 *      tcp协议    tcp://localhost:61616
                 */
                factory = new org.apache.activemq.ActiveMQConnectionFactory("admin", "admin"，"tcp://localhost:61616");
                //2.创建连接 
                connection = factory.createConnection();
                connection.start();
                /**
                 * 3、创建会话
                 * 方法 - connection.createSession(boolean transacted, int acknowledgeMode);
                 * 
                 *         transacted  可选值  true  |   false
                 *         当值为true，第二个参数失效  ；读取消息之后，事物需求手动提交   session.commit();
                 *         当值为false，表示启用消息确认机制，即第二个参数起作用
                 *   
                 *          acknowledgeMode  消息确认机制   可选值：
                 *          Session.AUTO_ACKNOWLEDGE - 自动确认消息机制  一般选这个
                 *          Session.CLIENT_ACKNOWLEDGE - 客户端确认消息机制
                 *          Session.DUPS_OK_ACKNOWLEDGE - 有副本的客户端确认消息机制
                 */
                session = connection.createSession(false, session.AUTO_ACKNOWLEDGE);
                //4. 创建目的地, 目的地命名即队列命名, 消息消费者需要通过此命名访问对应的队列
                destination  =  session.createQueue("text-msg");
                // 5. 创建消息生成者, 创建的消息生成者与某目的地对应, 即方法参数目的地.
                producer = session.createProducer(destination);
                //6 .创建消息对象 创建一个文本消息, 此消息对象中保存要传递的文本数据.
                message = session.createTextMessage(msg);        //createTextMessage  因为是文本信息
                //7.将消息对象发送到队列
                producer.send(message);
                
           } catch (JMSException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
           }finally {
                if(null!=producer) {
                      try {
                           producer.close();
                      } catch (JMSException e) {
                           // TODO Auto-generated catch block                        关闭资源
                           e.printStackTrace();
                      }
                }
                if(session!=null) {
                      
                      try {
                           session.close();
                      } catch (JMSException e) {
                           // TODO Auto-generated catch block
                           e.printStackTrace();
                      }
                
                }
                if (connection!=null) {
                      try {
                           connection.close();
                      } catch (JMSException e) {
                           // TODO Auto-generated catch block
                           e.printStackTrace();
                      }
                }
           }
     }

 

 

 

三  、 消息的消费者（传进来的是目的地）

 

public void  sendMsgToMq(String msg) {    传个要发送到队列的信息进来
           
           
           try{
                /**
                 * 1、实例化链接工厂
                 *
                  *    ActiveMQConnectionFactory - 由ActiveMQ实现的ConnectionFactory接口实现类.
             *   构造方法: public ActiveMQConnectionFactory(String userName, String password, String brokerURL)
                 * userName:用户名   默认admin
                 * password:密码       默认admin
                 * brokerURL:activemq服务的地址       消息服务的端口：61616     管理控制台的端口：8161
                 *      tcp协议    tcp://localhost:61616
                 */
                factory = new org.apache.activemq.ActiveMQConnectionFactory("admin", "admin"，"tcp://localhost:61616");
                //2.创建连接 
                connection = factory.createConnection();
                connection.start();
                /**
                 * 3、创建会话
                 * 方法 - connection.createSession(boolean transacted, int acknowledgeMode);
                 * 
                 *         transacted  可选值  true  |   false
                 *         当值为true，第二个参数失效  ；读取消息之后，事物需求手动提交   session.commit();
                 *         当值为false，表示启用消息确认机制，即第二个参数起作用
                 *   
                 *          acknowledgeMode  消息确认机制   可选值：
                 *          Session.AUTO_ACKNOWLEDGE - 自动确认消息机制  一般选这个
                 *          Session.CLIENT_ACKNOWLEDGE - 客户端确认消息机制
                 *          Session.DUPS_OK_ACKNOWLEDGE - 有副本的客户端确认消息机制
                 */
                session = connection.createSession(false, session.AUTO_ACKNOWLEDGE);
                //4. 创建目的地, 目的地命名即队列命名, 消息消费者需要通过此命名访问对应的队列
                destination  =  session.createQueue("text-msg");
                // 5. 创建消息生成者, 创建的消息生成者与某目的地对应, 即方法参数目的地.
                producer = session.createProducer(destination);
                //6 .创建消息对象 创建一个文本消息, 此消息对象中保存要传递的文本数据.
                message = session.createTextMessage(msg);        //createTextMessage  因为是文本信息
                //7.将消息对象发送到队列
                producer.send(message);
                
           } catch (JMSException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
           }finally {
                if(null!=producer) {
                      try {
                           producer.close();
                      } catch (JMSException e) {
                           // TODO Auto-generated catch block                        关闭资源
                           e.printStackTrace();
                      }
                }
                if(session!=null) {
                      
                      try {
                           session.close();
                      } catch (JMSException e) {
                           // TODO Auto-generated catch block
                           e.printStackTrace();
                      }
                
                }
                if (connection!=null) {
                      try {
                           connection.close();
                      } catch (JMSException e) {
                           // TODO Auto-generated catch block
                           e.printStackTrace();
                      }
                }
           }
     }

 

 

四 、 测试类

 
@Test
     /**
      * 发送文本的测试
      */
     public void sendMsgtoMqTest() {
           TextMessageProducer textProducer = new TextMessageProducer();
           textProducer.sendMsgToMq("eeesssss");   传文本信息进去
           
     }
     
     /**
      * 接受文本的测试
      */
     @Test
     public void reciMsgToMqTest() {
           
           TextMessageConsumer textConsumer = new TextMessageConsumer();
           
           textConsumer.recieverFromMq("text-msg"); 传目的地名称
           
     }
 

 

 

五、对象类型信息在消息队列中的存取

 

 

一 、 生成者（和文本唯一的不同就是消息的载体对象类型是Object的）

 
// 5. 消息的生成者处理者
 message = session.createObjectMessage(order); ------------>  文本的  message = session.createTextMessage(msg);

 

二  、消费者

                           message = consumer.receive();
                      if (null != message) {
                           ObjectMessage obj = (ObjectMessage) message;         -----------》 强转的类型不同TextMessage msg = (TextMessage) message;   
                           Order order = (Order) obj.getObject();              
                      }

 

 

三 、 测试类

/**
      * 发送一个对象到消息队列中
      */
     @Test
     public void sendObjToMq() {
           ObjectMessageProducer objProducer = new ObjectMessageProducer();
           Order order = new Order();
           order.setInfo("33333");
           order.setOrderId(1L);
           order.setPrice(600f);
           
           objProducer.sendObjToMq(order);   ----------》发送一个对象
           
     }
     /**
      * 从消息队列中取一个对象信息
      */
     @Test
     public void receiveObjFromMq() {
           
           ObjectMessageConsumer objConsumer = new ObjectMessageConsumer();
           objConsumer.recieverObjFromMq("aaa"); 
           
     }

 

 

六 、 ActiveMq的监听器

就是把第六步给改了，生成一个受监听的Message对象

consumer.setMessageListener(new MessageListener() {
                      
                      @Override
                      public void onMessage(Message message) {
                           // TODO Auto-generated method stub
                           //将消息载体转成对象消息载体
                           ObjectMessage objMessage = (ObjectMessage) message;
                           try {
                                 
                                 //在对象消息载体中获取对象
                                 Order order = (Order) objMessage.getObject();
                                 System.out.println("id:" + order.getOrderId() + "价格:" + order.getPrice() + "详细信息" + order.getInfo());
                                 
                           } catch (JMSException e) {
                                 // TODO Auto-generated catch block
                                 e.printStackTrace();
                           }
                           
                      }
                });