生产者和消费者

导入依赖

  <dependency>
            <groupId>org.apache.activemq</groupId>
            <artifactId>activemq-all</artifactId>
            <version>5.9.0</version>
        </dependency>

 

第一种：队列（queue）

1.生产者生产消息

private static final String ACTIVEMQ_URL = "tcp://ip地址:61616";
private static final String QUEUE_NAME = "queue01";

@Test
public void test1() throws JMSException, JMSException {
    //1.创建连接工厂
    ActiveMQConnectionFactory activeMQConnectionFactory = new ActiveMQConnectionFactory(ACTIVEMQ_URL);

    //2.通过连接工厂，获取连接connection
    Connection connection = activeMQConnectionFactory.createConnection();
    connection.start();

    //3.创建session
    //两个参数，第一个叫事务/第二个叫 签收
    Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);

    //4.创建目的地(具体是队列还是主题)
    Queue queue = session.createQueue(QUEUE_NAME);

    //5.创建消息的生产者
    MessageProducer messageProducer = session.createProducer(queue);

    //6.通过使用messageProducer生产3条消息发送到MQ的队列里面

    for (int i = 0; i < 3; i++) {
        //7.创建消息
        TextMessage textMessage = session.createTextMessage("msg-------" + i);//理解为一个字符串

        //8.通过messageProducer发送给MQ
        messageProducer.send(textMessage);
    }

    //9.关闭资源
    messageProducer.close();
    session.close();
    connection.close();

    System.out.println("消息发布成功");


}

 

2.消费者消费消息

方式一：同步阻塞方式。

订阅者或接收者调用MessageConsumer的receive（）方法来接收消息。receive方法在能够接收到消息之前（超时之前）将一直阻塞。

 public void test2() throws JMSException {
        //1.创建连接工厂
        ActiveMQConnectionFactory activeMQConnectionFactory = new ActiveMQConnectionFactory(ACTIVEMQ_URL);
        //2.通过连接工厂，获取连接connection
        Connection connection = activeMQConnectionFactory.createConnection();
        connection.start();
        //3.创建session
        //两个参数，第一个叫事务/第二个叫 签收
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        //4.创建目的地(具体是队列还是主题topic)
        Queue queue = session.createQueue(QUEUE_NAME);
        //5.创建消息的消费者
        MessageConsumer messageConsumer = session.createConsumer(queue);
        //6.同步阻塞的方法
        while (true) {
            TextMessage textMessage = (TextMessage) messageConsumer.receive(4000L);  //参数是时间
            if (null != textMessage) {
                System.out.println("消费者消费消息：" + textMessage.getText());
            } else {
                break;
            }
        }
        messageConsumer.close();
        session.close();
        connection.close();

    }

 

方式二：用监听的方式来消费消息

              异步非阻塞方式（监听器onMessage()）

              订阅者或接收者通过MessageListener()

 public void test3() throws JMSException, IOException {
        //1.创建连接工厂
        ActiveMQConnectionFactory activeMQConnectionFactory = new ActiveMQConnectionFactory(ACTIVEMQ_URL);
        //2.通过连接工厂，获取连接connection
        Connection connection = activeMQConnectionFactory.createConnection();
        connection.start();
        //3.创建session
        //两个参数，第一个叫事务/第二个叫 签收
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        //4.创建目的地(具体是队列还是主题topic)
        Queue queue = session.createQueue(QUEUE_NAME);
        //5.创建消息的消费者
        MessageConsumer messageConsumer = session.createConsumer(queue);

        //6.通过监听的方式来消费消息
        messageConsumer.setMessageListener(new MessageListener() {
            @Override
            public void onMessage(Message message) {
                if (null != message && message instanceof TextMessage) {
                    TextMessage textMessage = (TextMessage) message;
                    try {
                        System.out.println("消费者消费消息：" + textMessage.getText());
                    } catch (JMSException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        System.in.read(); //等待消费者消费

        messageConsumer.close();
        session.close();
        connection.close();

    }

 

总结：1.如果消费者先存在，然后生产者在生产消息，消费者是可以消费的。

            2.生产者生产消息，然后消费1先消费，然后消费2再消费。结果为所有消息都被消费者1消费，消费者2消费不到任何消息。

            3.消费者1，消费者2在生产者生产消息之前存在，则后续生产者生产的消息会被消费者1和消费者2平均消费。

 

 

第二种：主题（topic） 先生产在消费

创建生产者生产消息

    private static final String ACTIVEMQ_URL = "tcp://106.14.163.117:61616";
    private static final String TOPIC_NAME = "topic_athj";

    @Test
    public void test1() throws  JMSException {
        //1.创建连接工厂
        ActiveMQConnectionFactory activeMQConnectionFactory = new ActiveMQConnectionFactory(ACTIVEMQ_URL);

        //2.通过连接工厂，获取连接connection
        Connection connection = activeMQConnectionFactory.createConnection();
        connection.start();

        //3.创建session
        //两个参数，第一个叫事务/第二个叫 签收
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);

        //4.创建目的地(具体是队列还是主题topic)
        Topic topic = session.createTopic(TOPIC_NAME);

        //5.创建消息的生产者
        MessageProducer messageProducer = session.createProducer(topic);

        //6.通过使用messageProducer生产3条消息发送到MQ的队列里面
        for (int i = 0; i < 6; i++) {
            //7.创建消息
            TextMessage textMessage = session.createTextMessage("msg-------" + i);//理解为一个字符串

            //8.通过messageProducer发送给MQ
            messageProducer.send(textMessage);
        }

        //9.关闭资源
        messageProducer.close();
        session.close();
        connection.close();

        System.out.println("消息发布成功");
    }

 

创建消费者消费

  @Test
    public void test3() throws JMSException, IOException {

        System.out.println("我是二号消费者");
        //1.创建连接工厂
        ActiveMQConnectionFactory activeMQConnectionFactory = new ActiveMQConnectionFactory(ACTIVEMQ_URL);
        //2.通过连接工厂，获取连接connection
        Connection connection = activeMQConnectionFactory.createConnection();
        connection.start();
        //3.创建session
        //两个参数，第一个叫事务/第二个叫 签收
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);

        //4.创建目的地(具体是队列还是主题topic)
        Topic topic = session.createTopic(TOPIC_NAME);
        //5.创建消息的消费者
        MessageConsumer messageConsumer = session.createConsumer(topic);

        //6.通过监听的方式来消费消息
//        messageConsumer.setMessageListener(new MessageListener() {
//            @Override
//            public void onMessage(Message message) {
//                if (null != message && message instanceof TextMessage) {
//                    TextMessage textMessage = (TextMessage) message;
//                    try {
//                        System.out.println("消费者消费消息：" + textMessage.getText());
//                    } catch (JMSException e) {
//                        e.printStackTrace();
//                    }
//                }
//            }
//        });
         //Lambda表达式

        messageConsumer.setMessageListener((message -> {
            if (null != message && message instanceof TextMessage) {
                    TextMessage textMessage = (TextMessage) message;
                    try {
                        System.out.println("消费者消费消息：" + textMessage.getText());
                    } catch (JMSException e) {
                        e.printStackTrace();
                    }
                }
        }));

        System.in.read(); //等待消费者消费

        messageConsumer.close();
        session.close();
        connection.close();

    }