ActiveMq-学习

柔情只为你懂 2024-02-19 13:06 8阅读 0赞

**1.JMS介绍**

JMS即Java消息服务应用接口，是一个Java平台中关于面向消息中间件的API，用于两个应用程序之间，或分布式系统中发送消息，进行
    异步通信。
        Java消息服务是一个与具体平台无关的API，绝大多数MOM提供商都对JMS提供支持。
        JMS是一种与厂商无关的 API，用来访问消息收发系统消息，它类似于JDBC(Java Database Connectivity)。这里，JDBC 是可以
    用来访问许多不同关系数据库的 API，而 JMS 则提供同样与厂商无关的访问方法，以访问消息收发服务。许多厂商都支持 JMS，包括 IBM 
    的 MQSeries、BEA的Weblogic JMS service和 Progress 的 SonicMQ。
        JMS 使您能够通过消息收发服务（有时称为消息中介程序或路由器）从一个 JMS 客户机向另一个 JMS客户机发送消息。
        消息是 JMS 中的一种类型对象，由两部分组成：报头和消息主体。报头由路由信息以及有关该消息的元数据组成。消息主体则携带着
    应用程序的数据或有效负载。根据有效负载的类型来划分，可以将消息分为几种类型，它们分别携带：简单文本(TextMessage)、可序列化
    的对象 (ObjectMessage)、属性集合 (MapMessage)、字节流 (BytesMessage)、原始值流 (StreamMessage)，还有无有效负载的
    消息 (Message)。

**2.组成**

报头
        报头由路由信息以及有关该消息的元数据组成
    消息主体。
        息主体则携带着应用程序的数据或有效负载。

**3.体系架构**

JMS提供者
        连接面向消息中间件的，JMS接口的一个实现。提供者可以是Java平台的JMS实现，也可以是非Java平台的面向消息中间件的适配器。
    JMS客户
        生产或消费基于消息的Java的应用程序或对象。
    JMS生产者
        创建并发送消息的JMS客户。
    JMS消费者
        接收消息的JMS客户。
    JMS消息
        包括可以在JMS客户之间传递的数据的对象
    JMS队列
        一个容纳那些被发送的等待阅读的消息的区域。与队列名字所暗示的意思不同，消息的接受顺序并不
        一定要与消息的发送顺序相同。一旦一个消息被阅读，该消息将被从队列中移走。
    JMS主题
        一种支持发送消息给多个订阅者的机制。

**4.对象模型**

1）连接工厂。连接工厂（ConnectionFactory）是由管理员创建，并绑定到JNDI树中。客户端使用JNDI查找连接工厂，然后利用连接
    工厂创建一个JMS连接。
    2）JMS连接。JMS连接（Connection）表示JMS客户端和服务器端之间的一个活动的连接，是由客户端通过调用连接工厂的方法建立的。
    3）JMS会话。JMS会话（Session）表示JMS客户与JMS服务器之间的会话状态。JMS会话建立在JMS连接上，表示客户与服务器之间的一个
    会话线程。
    4）JMS目的。JMS目的（Destination），又称为消息队列，是实际的消息源。
    5）JMS生产者和消费者。生产者（Message Producer）和消费者（Message Consumer）对象由Session对象创建，用于发送和
    接收消息。
    6）JMS消息通常有两种类型：
    ① 点对点（Point-to-Point）。在点对点的消息系统中，消息分发给一个单独的使用者。点对点消息往往与队列（javax.jms.Queue）
    相关联。
    ② 发布/订阅（Publish/Subscribe）。发布/订阅消息系统支持一个事件驱动模型，消息生产者和消费者都参与消息的传递。生产者发布
    事件，而使用者订阅感兴趣的事件，并使用事件。该类型消息一般与特定的主题（javax.jms.Topic）关联。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU0OTU3OA_size_16_color_FFFFFF_t_70][]

**5.模型**

1.点对点或队列模型
    2.发布者/订阅者模型
    
        在点对点或队列模型下，一个生产者向一个特定的队列发布消息，一个消费者从该队列中读取消息。这里，生产者知道消费者的队列，
    并直接将消息发送到消费者的队列。这种模式被概括为：
        只有一个消费者将获得消息
        生产者不需要在接收者消费该消息期间处于运行状态，接收者也同样不需要在消息发送时处于运行状态。
        每一个成功处理的消息都由接收者签收
    
        发布者/订阅者模型支持向一个特定的消息主题发布消息。0或多个订阅者可能对接收来自特定消息主题的消息感兴趣。在这种模型下，
    发布者和订阅者彼此不知道对方。这种模式好比是匿名公告板。这种模式被概括为：
    多个消费者可以获得消息在发布者和订阅者之间存在时间依赖性。
        发布者需要建立一个订阅（subscription），以便客户能够订阅。订阅者必须保持持续的活动状态以接收消息，除非订阅者建立了持久的订阅。在那种情况下，在订阅者未连接时发布的消息将在订阅者重新连接时重新发布。

**6.应用程序**

ConnectionFactory 接口（连接工厂）
        用户用来创建到JMS提供者的连接的被管对象。JMS客户通过可移植的接口访问连接，这样当下层的实现改变时，代码不需要进行修改
    。管理员在JNDI名字空间中配置连接工厂，这样，JMS客户才能够查找到它们。根据消息类型的不同，用户将使用队列连接工厂，或者主题
    连接工厂。
    Connection 接口（连接）
        连接代表了应用程序和消息服务器之间的通信链路。在获得了连接工厂后，就可以创建一个与JMS提供者的连接。根据不同的连接
    类型，连接允许用户创建会话，以发送和接收队列和主题到目标。
    Destination 接口（目标）
        目标是一个包装了消息目标标识符的被管对象，消息目标是指消息发布和接收的地点，或者是队列，或者是主题。JMS管理员
    创建这些对象，然后用户通过JNDI发现它们。和连接工厂一样，管理员可以创建两种类型的目标，点对点模型的队列，
    以及发布者/订阅者模型的主题。
    Session 接口（会话）
        表示一个单线程的上下文，用于发送和接收消息。由于会话是单线程的，所以消息是连续的，就是说消息是按照发送的顺序一个一个
    接收的。会话的好处是它支持事务。如果用户选择了事务支持，会话上下文将保存一组消息，直到事务被提交才发送这些消息。在提交事务
    之前，用户可以使用回滚操作取消这些消息。一个会话允许用户创建消息，生产者来发送消息，消费者来接收消息。
    MessageConsumer 接口（消息消费者）
        由会话创建的对象，用于接收发送到目标的消息。消费者可以同步地（阻塞模式），或（非阻塞）接收队列和主题类型的消息。
    MessageProducer 接口（消息生产者）
        由会话创建的对象，用于发送消息到目标。用户可以创建某个目标的发送者，也可以创建一个通用的发送者，在发送消息时指定目标。
    Message 接口（消息）
        是在消费者和生产者之间传送的对象，也就是说从一个应用程序传送到另一个应用程序。一个消息有三个主要部分：
        消息头（必须）：包含用于识别和为消息寻找路由的操作设置。
        一组消息属性（可选）：包含额外的属性，支持其他提供者和用户的兼容。可以创建定制的字段和过滤器（消息选择器）。
        一个消息体（可选）：允许用户创建五种类型的消息（文本消息，映射消息，字节消息，流消息和对象消息）。
        消息接口非常灵活，并提供了许多方式来定制消息的内容。

**7.介绍与下载安装**

![20181108164305227.png][]

**8.模式代理**

**1.点对点**

1.生产者

package com.java1234.activemq;
     
    import javax.jms.Connection;
    import javax.jms.ConnectionFactory;
    import javax.jms.Destination;
    import javax.jms.JMSException;
    import javax.jms.MessageProducer;
    import javax.jms.Session;
    import javax.jms.TextMessage;
     
    import org.apache.activemq.ActiveMQConnection;
    import org.apache.activemq.ActiveMQConnectionFactory;
     
    /**
     * 消息生产者
     * @author Administrator
     *
     */
    public class JMSProducer {
     
      private static final String USERNAME=ActiveMQConnection.DEFAULT_USER; // 默认的连接用户名
      private static final String PASSWORD=ActiveMQConnection.DEFAULT_PASSWORD; // 默认的连接密码
      private static final String BROKEURL=ActiveMQConnection.DEFAULT_BROKER_URL; // 默认的连接地址
      private static final int SENDNUM=10; // 发送的消息数量
      
      public static void main(String[] args) {
         
         ConnectionFactory connectionFactory; // 连接工厂
         Connection connection = null; // 连接
         Session session; // 会话 接受或者发送消息的线程
         Destination destination; // 消息的目的地
         MessageProducer messageProducer; // 消息生产者
         
         // 实例化连接工厂
         connectionFactory=new ActiveMQConnectionFactory(JMSProducer.USERNAME, JMSProducer.PASSWORD, JMSProducer.BROKEURL);
         
         try {
           connection=connectionFactory.createConnection(); // 通过连接工厂获取连接
           connection.start(); // 启动连接
           session=connection.createSession(Boolean.TRUE, Session.AUTO_ACKNOWLEDGE); // 创建Session
           destination=session.createQueue("FirstQueue1"); // 创建消息队列
           messageProducer=session.createProducer(destination); // 创建消息生产者
           sendMessage(session, messageProducer); // 发送消息
           session.commit();
         } catch (Exception e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
         } finally{
           if(connection!=null){
              try {
                connection.close();
              } catch (JMSException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
              }
           }
         }
      }
      
      /**
       * 发送消息
       * @param session
       * @param messageProducer
       * @throws Exception
       */
      public static void sendMessage(Session session,MessageProducer messageProducer)throws Exception{
         for(int i=0;i<JMSProducer.SENDNUM;i++){
           TextMessage message=session.createTextMessage("ActiveMQ 发送的消息"+i);
           System.out.println("发送消息："+"ActiveMQ 发送的消息"+i);
           messageProducer.send(message);
         }
      }
    }

2.消息消费者（两种消费方式）

2.1：直接 Receive 方式

Session.AUTO_ACKNOWLEDGE。当客户成功的从receive方法返回的时候，或者MessageListener.onMessage
    方法成功返回的时候，会话自动确认客户收到的消息。
    Session.CLIENT_ACKNOWLEDGE。 客户通过消息的 acknowledge 方法确认消息。需要注意的是，在这种模
    式中，确认是在会话层上进行：确认一个被消费的消息将自动确认所有已被会话消 费的消息。例如，如果一
    个消息消费者消费了 10 个消息，然后确认第 5 个消息，那么所有 10 个消息都被确认。
    Session.DUPS_ACKNOWLEDGE。 该选择只是会话迟钝第确认消息的提交。如果 JMS provider 失败，那么可
    能会导致一些重复的消息。如果是重复的消息，那么 JMS provider 必须把消息头的 JMSRedelivered 字段设置
    为 true
     
    例子：
    
    import javax.jms.Connection;
    import javax.jms.ConnectionFactory;
    import javax.jms.Destination;
    import javax.jms.JMSException;
    import javax.jms.MessageConsumer;
    import javax.jms.Session;
    import javax.jms.TextMessage;
     
    import org.apache.activemq.ActiveMQConnection;
    import org.apache.activemq.ActiveMQConnectionFactory;
     
    /**
     * 消息消费者
     * @author Administrator
     *
     */
    public class JMSConsumer {
     
      private static final String USERNAME=ActiveMQConnection.DEFAULT_USER; // 默认的连接用户名
      private static final String PASSWORD=ActiveMQConnection.DEFAULT_PASSWORD; // 默认的连接密码
      private static final String BROKEURL=ActiveMQConnection.DEFAULT_BROKER_URL; // 默认的连接地址
      
      public static void main(String[] args) {
         ConnectionFactory connectionFactory; // 连接工厂
         Connection connection = null; // 连接
         Session session; // 会话 接受或者发送消息的线程
         Destination destination; // 消息的目的地
         MessageConsumer messageConsumer; // 消息的消费者
         
         // 实例化连接工厂
         connectionFactory=new ActiveMQConnectionFactory(JMSConsumer.USERNAME, JMSConsumer.PASSWORD, JMSConsumer.BROKEURL);
              
         try {
           connection=connectionFactory.createConnection();  // 通过连接工厂获取连接
           connection.start(); // 启动连接
           session=connection.createSession(Boolean.FALSE, Session.AUTO_ACKNOWLEDGE); // 创建Session
           destination=session.createQueue("FirstQueue1");  // 创建连接的消息队列
           messageConsumer=session.createConsumer(destination); // 创建消息消费者
           while(true){
              TextMessage textMessage=(TextMessage)messageConsumer.receive(100000);
              if(textMessage!=null){
                System.out.println("收到的消息："+textMessage.getText());
              }else{
                break;
              }
           }
         } catch (JMSException e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
         } 
      }
    }

2.2： Listener 监听方式

import javax.jms.JMSException;
    import javax.jms.Message;
    import javax.jms.MessageListener;
    import javax.jms.TextMessage;
     
    /**
     * 消息监听
     * @author Administrator
     *
     */
    public class Listener implements MessageListener{
     
      @Override
      public void onMessage(Message message) {
         // TODO Auto-generated method stub
         try {
           System.out.println("收到的消息："+((TextMessage)message).getText());
         } catch (JMSException e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
         }
      }
     
    }
    消费者代码：
    
    import javax.jms.Connection;
    import javax.jms.ConnectionFactory;
    import javax.jms.Destination;
    import javax.jms.JMSException;
    import javax.jms.MessageConsumer;
    import javax.jms.Session;
    import javax.jms.TextMessage;
     
    import org.apache.activemq.ActiveMQConnection;
    import org.apache.activemq.ActiveMQConnectionFactory;
     
    /**
     * 消息消费者
     * @author Administrator
     *
     */
    public class JMSConsumer2 {
     
      private static final String USERNAME=ActiveMQConnection.DEFAULT_USER; // 默认的连接用户名
      private static final String PASSWORD=ActiveMQConnection.DEFAULT_PASSWORD; // 默认的连接密码
      private static final String BROKEURL=ActiveMQConnection.DEFAULT_BROKER_URL; // 默认的连接地址
      
      public static void main(String[] args) {
         ConnectionFactory connectionFactory; // 连接工厂
         Connection connection = null; // 连接
         Session session; // 会话 接受或者发送消息的线程
         Destination destination; // 消息的目的地
         MessageConsumer messageConsumer; // 消息的消费者
         
         // 实例化连接工厂
         connectionFactory=new ActiveMQConnectionFactory(JMSConsumer2.USERNAME, JMSConsumer2.PASSWORD, JMSConsumer2.BROKEURL);
              
         try {
           connection=connectionFactory.createConnection();  // 通过连接工厂获取连接
           connection.start(); // 启动连接
           session=connection.createSession(Boolean.FALSE, Session.AUTO_ACKNOWLEDGE); // 创建Session
           destination=session.createQueue("FirstQueue1");  // 创建连接的消息队列
           messageConsumer=session.createConsumer(destination); // 创建消息消费者
           messageConsumer.setMessageListener(new Listener()); // 注册消息监听
         } catch (JMSException e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
         } 
      }
    }

2.发布-订阅消息模式实现

注意：先订阅才能接受消息

《1》：发布消息

import javax.jms.Connection;
    import javax.jms.ConnectionFactory;
    import javax.jms.Destination;
    import javax.jms.JMSException;
    import javax.jms.MessageProducer;
    import javax.jms.Session;
    import javax.jms.TextMessage;
     
    import org.apache.activemq.ActiveMQConnection;
    import org.apache.activemq.ActiveMQConnectionFactory;
     
    /**
     * 消息生产者-消息发布者
     * @author Administrator
     *
     */
    public class JMSProducer {
     
      private static final String USERNAME=ActiveMQConnection.DEFAULT_USER; // 默认的连接用户名
      private static final String PASSWORD=ActiveMQConnection.DEFAULT_PASSWORD; // 默认的连接密码
      private static final String BROKEURL=ActiveMQConnection.DEFAULT_BROKER_URL; // 默认的连接地址
      private static final int SENDNUM=10; // 发送的消息数量
      
      public static void main(String[] args) {
         
         ConnectionFactory connectionFactory; // 连接工厂
         Connection connection = null; // 连接
         Session session; // 会话 接受或者发送消息的线程
         Destination destination; // 消息的目的地
         MessageProducer messageProducer; // 消息生产者
         
         // 实例化连接工厂
         connectionFactory=new ActiveMQConnectionFactory(JMSProducer.USERNAME, JMSProducer.PASSWORD, JMSProducer.BROKEURL);
         
         try {
           connection=connectionFactory.createConnection(); // 通过连接工厂获取连接
           connection.start(); // 启动连接
           session=connection.createSession(Boolean.TRUE, Session.AUTO_ACKNOWLEDGE); // 创建Session  
           destination=session.createTopic("FirstTopic1");
           messageProducer=session.createProducer(destination); // 创建消息生产者
           sendMessage(session, messageProducer); // 发送消息
           session.commit();
         } catch (Exception e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
         } finally{
           if(connection!=null){
              try {
                connection.close();
              } catch (JMSException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
              }
           }
         }
      }
      
      /**
       * 发送消息
       * @param session
       * @param messageProducer
       * @throws Exception
       */
      public static void sendMessage(Session session,MessageProducer messageProducer)throws Exception{
         for(int i=0;i<JMSProducer.SENDNUM;i++){
           TextMessage message=session.createTextMessage("ActiveMQ 发送的消息"+i);
           System.out.println("发送消息："+"ActiveMQ 发布的消息"+i);
           messageProducer.send(message);
         }
      }
    }

《2》 ：订阅消息

两种实现：

import javax.jms.Connection;
    import javax.jms.ConnectionFactory;
    import javax.jms.Destination;
    import javax.jms.JMSException;
    import javax.jms.MessageConsumer;
    import javax.jms.Session;
    import javax.jms.TextMessage;
     
    import org.apache.activemq.ActiveMQConnection;
    import org.apache.activemq.ActiveMQConnectionFactory;
     
    /**
     * 消息消费者
     * @author Administrator
     *
     */
    public class JMSConsumer {
     
      private static final String USERNAME=ActiveMQConnection.DEFAULT_USER; // 默认的连接用户名
      private static final String PASSWORD=ActiveMQConnection.DEFAULT_PASSWORD; // 默认的连接密码
      private static final String BROKEURL=ActiveMQConnection.DEFAULT_BROKER_URL; // 默认的连接地址
      
      public static void main(String[] args) {
         ConnectionFactory connectionFactory; // 连接工厂
         Connection connection = null; // 连接
         Session session; // 会话 接受或者发送消息的线程
         Destination destination; // 消息的目的地
         MessageConsumer messageConsumer; // 消息的消费者
         
         // 实例化连接工厂
         connectionFactory=new ActiveMQConnectionFactory(JMSConsumer.USERNAME, JMSConsumer.PASSWORD, JMSConsumer.BROKEURL);
              
         try {
           connection=connectionFactory.createConnection();  // 通过连接工厂获取连接
           connection.start(); // 启动连接
           session=connection.createSession(Boolean.FALSE, Session.AUTO_ACKNOWLEDGE); // 创建Session
           destination=session.createQueue("FirstQueue1");  // 创建连接的消息队列
           messageConsumer=session.createConsumer(destination); // 创建消息消费者
           while(true){
              TextMessage textMessage=(TextMessage)messageConsumer.receive(100000);
              if(textMessage!=null){
                System.out.println("收到的消息："+textMessage.getText());
              }else{
                break;
              }
           }
         } catch (JMSException e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
         } 
      }
    }

import javax.jms.Connection;
    import javax.jms.ConnectionFactory;
    import javax.jms.Destination;
    import javax.jms.JMSException;
    import javax.jms.MessageConsumer;
    import javax.jms.Session;
    import javax.jms.TextMessage;
     
    import org.apache.activemq.ActiveMQConnection;
    import org.apache.activemq.ActiveMQConnectionFactory;
     
    /**
     * 消息消费者
     * @author Administrator
     *
     */
    public class JMSConsumer2 {
     
      private static final String USERNAME=ActiveMQConnection.DEFAULT_USER; // 默认的连接用户名
      private static final String PASSWORD=ActiveMQConnection.DEFAULT_PASSWORD; // 默认的连接密码
      private static final String BROKEURL=ActiveMQConnection.DEFAULT_BROKER_URL; // 默认的连接地址
      
      public static void main(String[] args) {
         ConnectionFactory connectionFactory; // 连接工厂
         Connection connection = null; // 连接
         Session session; // 会话 接受或者发送消息的线程
         Destination destination; // 消息的目的地
         MessageConsumer messageConsumer; // 消息的消费者
         
         // 实例化连接工厂
         connectionFactory=new ActiveMQConnectionFactory(JMSConsumer2.USERNAME, JMSConsumer2.PASSWORD, JMSConsumer2.BROKEURL);
              
         try {
           connection=connectionFactory.createConnection();  // 通过连接工厂获取连接
           connection.start(); // 启动连接
           session=connection.createSession(Boolean.FALSE, Session.AUTO_ACKNOWLEDGE); // 创建Session
           destination=session.createQueue("FirstQueue1");  // 创建连接的消息队列
           messageConsumer=session.createConsumer(destination); // 创建消息消费者
           messageConsumer.setMessageListener(new Listener()); // 注册消息监听
         } catch (JMSException e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
         } 
      }
    }

**监听listener：**

参考：[ActiveMQ][]，[JMS][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU0OTU3OA_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/29/d4e4b1e6923e4a1da613f30d13d58db8.png
[20181108164305227.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/29/cd9d58fc59394e02aa77ae281095c066.png
[ActiveMQ]: https://baike.baidu.com/item/ActiveMQ/7889688?fr=aladdin
[JMS]: https://baike.baidu.com/item/JMS/2836691?fr=aladdin