ActiveMQ消息队列之java消息生产与消费

最新推荐文章于 2024-04-22 16:58:24 发布
最新推荐文章于 2024-04-22 16:58:24 发布
阅读量404 收藏
点赞数
分类专栏： activemq 文章标签： java activemq 消息队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29606255/article/details/77754163
版权

话题生产者：

package cn.itcast_03_mq.topic;
import java.util.Random;

import javax.jms.JMSException;      

public class ProducerTest {      

    /**    
     * @param args    
     */     
    public static void main(String[] args) throws JMSException, Exception {      
        ProducerTool producer = new ProducerTool(); 
        Random random = new Random();
        for(int i=0;i<20;i++){

            Thread.sleep(random.nextInt(10)*1000);

            producer.produceMessage("Hello, world!--"+i);      
            producer.close();
        }

    }      
}

话题生产池：

package cn.itcast_03_mq.topic;
import javax.jms.Connection;      
import javax.jms.DeliveryMode;      
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;      

public class ProducerTool {        
    private String user = ActiveMQConnection.DEFAULT_USER;         
    private String password = ActiveMQConnection.DEFAULT_PASSWORD;       
    private String url = ActiveMQConnection.DEFAULT_BROKER_URL;       
    private String subject = "mytopic";      
    private Destination destination = null;      
    private Connection connection = null;      
    private Session session = null;      
    private MessageProducer producer = null;
    // 初始化      
    private void initialize() throws JMSException, Exception {      
        ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory(      
                user, password, url);      
        connection = connectionFactory.createConnection();      
        session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);      
        destination = session.createTopic(subject);      
        producer = session.createProducer(destination);      
        producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);      
    }
    // 发送消息      
    public void produceMessage(String message) throws JMSException, Exception {      
        initialize();      
        TextMessage msg = session.createTextMessage(message);      
        connection.start();      
        System.out.println("Producer:->Sending message: " + message);      
        producer.send(msg);      
        System.out.println("Producer:->Message sent complete!");      
    }
    // 关闭连接      
    public void close() throws JMSException {      
        System.out.println("Producer:->Closing connection");      
        if (producer != null)      
            producer.close();      
        if (session != null)      
            session.close();      
        if (connection != null)      
            connection.close();      
    }      
}

话题消费者：

package cn.itcast_03_mq.topic;

import javax.jms.JMSException;

public class ConsumerTest implements Runnable {
    static Thread t1 = null;

    /**
     * @param args
     * @throws InterruptedException
     * @throws InterruptedException
     * @throws JMSException
     * @throws InterruptedException
     */
    public static void main(String[] args) throws InterruptedException {

        t1 = new Thread(new ConsumerTest());
        t1.setDaemon(false);
        t1.start();
        /**
         * 如果发生异常，则重启consumer
         */
        /*while (true) {
            System.out.println(t1.isAlive());
            if (!t1.isAlive()) {
                t1 = new Thread(new ConsumerTest());
                t1.start();
                System.out.println("重新启动");
            }
            Thread.sleep(5000);
        }*/
        // 延时500毫秒之后停止接受消息
        // Thread.sleep(500);
        // consumer.close();
    }

    public void run() {
        try {
            ConsumerTool consumer = new ConsumerTool();
            consumer.consumeMessage();
            while (ConsumerTool.isconnection) { 
            }
        } catch (Exception e) {
        }

    }
}

话题消费池：

package cn.itcast_03_mq.topic;
import javax.jms.Connection;      
import javax.jms.Destination;      
import javax.jms.ExceptionListener;
import javax.jms.JMSException;      
import javax.jms.MessageConsumer;      
import javax.jms.Session;      
import javax.jms.MessageListener;      
import javax.jms.Message;      
import javax.jms.TextMessage;      

import org.apache.activemq.ActiveMQConnection;      
import org.apache.activemq.ActiveMQConnectionFactory;      

public class ConsumerTool implements MessageListener,ExceptionListener {      
    private String user = ActiveMQConnection.DEFAULT_USER;      
    private String password = ActiveMQConnection.DEFAULT_PASSWORD;      
    private String url =ActiveMQConnection.DEFAULT_BROKER_URL;      
    private String subject = "mytopic";      
    private Destination destination = null;      
    private Connection connection = null;      
    private Session session = null;      
    private MessageConsumer consumer = null;  
    public static Boolean isconnection=false;
    // 初始化      
    private void initialize() throws JMSException, Exception {      
        ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory(      
                user, password, url);      
        connection = connectionFactory.createConnection();      
        session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);      
        destination = session.createTopic(subject);      
        consumer = session.createConsumer(destination);     
    }      

    // 消费消息      
    public void consumeMessage() throws JMSException, Exception {      
        initialize();      
        connection.start();
        consumer.setMessageListener(this);    
        connection.setExceptionListener(this);
        isconnection=true;
        System.out.println("Consumer:->Begin listening...");      
        // 开始监听  
        // Message message = consumer.receive();      
    }
    // 关闭连接      
    public void close() throws JMSException {      
        System.out.println("Consumer:->Closing connection");      
        if (consumer != null)      
            consumer.close();      
        if (session != null)      
            session.close();      
        if (connection != null)      
            connection.close();      
    }
    // 消息处理函数      
    public void onMessage(Message message) {      
        try {      
            if (message instanceof TextMessage) {      
                TextMessage txtMsg = (TextMessage) message;      
                String msg = txtMsg.getText();      
                System.out.println("Consumer:->Received: " + msg);      
            } else {      
                System.out.println("Consumer:->Received: " + message);      
            }      
        } catch (JMSException e) {      
            // TODO Auto-generated catch block      
            e.printStackTrace();      
        }      
    }

    public void onException(JMSException arg0) {
        isconnection=false;
    }      
}

队列生产者：

package cn.itcast_03_mq.queue;
import javax.jms.JMSException;      

public class ProducerTest {      

    /**    
     * @param args    
     * @throws Exception 
     * @throws JMSException 
     */     
    public static void main(String[] args) throws JMSException, Exception{      
        ProducerTool producer = new ProducerTool();     
        producer.produceMessage("Hello, world!");      
        producer.close();
    }      
}

队列生产池：

package cn.itcast_03_mq.queue;
import javax.jms.Connection;      
import javax.jms.DeliveryMode;      
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;      

public class ProducerTool {        
    private String user = ActiveMQConnection.DEFAULT_USER;         
    private String password = ActiveMQConnection.DEFAULT_PASSWORD;       
    private String url = ActiveMQConnection.DEFAULT_BROKER_URL;       
    private String subject = "myqueue";      
    private Destination destination = null;      
    private Connection connection = null;      
    private Session session = null;      
    private MessageProducer producer = null;
    // 初始化   
    private void initialize() throws JMSException, Exception {      
        ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory(      
                user, password, url);      
        connection = connectionFactory.createConnection();      
        session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);      
        destination = session.createQueue(subject);      
        producer = session.createProducer(destination);      
        producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);      
    }
 // 发送消息          
    public void produceMessage(String message) throws JMSException, Exception {      
        initialize();      
        TextMessage msg = session.createTextMessage(message);      
        connection.start();      
        System.out.println("Producer:->Sending message: " + message);      
        producer.send(msg);      
        System.out.println("Producer:->Message sent complete!");      
    }
    // 关闭连接      
    public void close() throws JMSException {      
        System.out.println("Producer:->Closing connection");      
        if (producer != null)      
            producer.close();      
        if (session != null)      
            session.close();      
        if (connection != null)      
            connection.close();      
    }      
}

队列消费者：

package cn.itcast_03_mq.queue;


public class ConsumerTest implements Runnable {
    static Thread t1 = null;
    public static void main(String[] args) throws InterruptedException {

        t1 = new Thread(new ConsumerTest());
        t1.start();
        while (true) {
            System.out.println(t1.isAlive());
            if (!t1.isAlive()) {
                t1 = new Thread(new ConsumerTest());
                t1.start();
                System.out.println("重新启动");
            }
            Thread.sleep(5000);
        }
        // 延时500毫秒之后停止接受消息
        // Thread.sleep(500);
        // consumer.close();
    }

    public void run() {
        try {
            ConsumerTool consumer = new ConsumerTool();
            consumer.consumeMessage();
            while (ConsumerTool.isconnection) { 
                //System.out.println(123);
            }
        } catch (Exception e) {
        }

    }
}

队列消费池：

package cn.itcast_03_mq.queue;

import javax.jms.Connection;
import javax.jms.Destination;
import javax.jms.ExceptionListener;
import javax.jms.JMSException;
import javax.jms.MessageConsumer;
import javax.jms.Session;
import javax.jms.MessageListener;
import javax.jms.Message;
import javax.jms.TextMessage;

import org.apache.activemq.ActiveMQConnection;
import org.apache.activemq.ActiveMQConnectionFactory;

public class ConsumerTool implements MessageListener,ExceptionListener {
    private String user = ActiveMQConnection.DEFAULT_USER;
    private String password = ActiveMQConnection.DEFAULT_PASSWORD;
    private String url = ActiveMQConnection.DEFAULT_BROKER_URL;
    private String subject = "myqueue";
    private Destination destination = null;
    private Connection connection = null;
    private Session session = null;
    private MessageConsumer consumer = null;
    private ActiveMQConnectionFactory connectionFactory=null;
    public static Boolean isconnection=false;
    // 初始化
    private void initialize() throws JMSException {
            connectionFactory= new ActiveMQConnectionFactory(
                user, password, url);
            connection = connectionFactory.createConnection();
            session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
            destination = session.createQueue(subject);
            consumer = session.createConsumer(destination);
    }

    // 消费消息
    public void consumeMessage() throws JMSException {
            initialize();
            connection.start();

            consumer.setMessageListener(this);
            connection.setExceptionListener(this);
            System.out.println("Consumer:->Begin listening...");
            isconnection=true;
            // 开始监听
            Message message = consumer.receive();
            System.out.println(message.getJMSMessageID());
    }

    // 关闭连接
    public void close() throws JMSException {
            System.out.println("Consumer:->Closing connection");
            if (consumer != null)
                consumer.close();
            if (session != null)
                session.close();
            if (connection != null)
                connection.close();
    }

    // 消息处理函数
    public void onMessage(Message message) {
        try {
            if (message instanceof TextMessage) {
                TextMessage txtMsg = (TextMessage) message;
                String msg = txtMsg.getText();
                System.out.println("Consumer:->Received: " + msg);
            } else {
                System.out.println("Consumer:->Received: " + message);
            }
        } catch (JMSException e) {
            e.printStackTrace();
        }
    }

    public void onException(JMSException arg0){
        isconnection=false;
    }
}
奕起学习
关注
专栏目录
ActiveMQ 消息队列
01-12
1. **点对点 (Point-to-Point, P2P)**：在此模型中，消息发送者（生产者）向队列发送消息，而消息接收者（消费者）从队列中读取消息。每条消息只能被一个消费者消费。 2. **发布/订阅 (Publish/Subscribe, Pub/Sub...
activemq消息的产生与消费 Java
不言不语，不骄不躁
04-04 1747
activemq:进入bin目录启动,localhost:8161访问activemq客户端 1.发送消息给activemq客户端： String url = "tcp://ip地址:61616"; String user = ActiveMQConnection.DEFAULT_USER; //默认用户名admin String password = Activ...
ActiveMQ学习笔记（二）java编码实现消息生产者/消费者
cj1140874158的博客
11-19 308
1.idea新建maven工程 2.需要的导入的依赖： activemq所需要的jar包 <dependency> <groupId>org.apache.activemq</groupId> <artifactId>activemq-all</artifactId> <version>5.15.10...
java队列 生产消费_java Queue队列实现生产消费模式
weixin_36463131的博客
02-15 1479
一、什么是Queue什么是Java编程中的Queue(队列)详细介绍请参考上一篇：Java Queue队列使用入门详解该文章详细讲解了Java编程中的queue是什么，基本的操作等。二、Java中Queue如何实现生产消费模式以下为队列服务代码：$title(QueneService.java)package com.example.demospringbootblockingqueue.tes...
Java实现ActiveMQ之主题的生产者和消费者（二）
DT辰白
06-12 641
前言 假如：三个消费者同时关注并且订阅了一个公众号，公众号同时推送N份消息的时候，他们三个各收到的是N份，还是先到先得到全部，还是均分消息呢？ 1、创建maven项目，导入pom.xml依赖包 <!--activemq所需依赖jar配置--> <dependency> <groupId>org.apache.activemq</groupId> <artifactId>activemq-all</artifactId>
Java语言实现生产者与消费者的消息队列模型（附源码）
千与编程
02-19 1464
package com.company; import java.util.LinkedList; /** * 生产者消费者问题 */ public class Main{ //最大容量 public static final int MAX_SIZE = 2; //存储媒介 public static LinkedList<Integer> list = new LinkedList<>(); static class Produc
ActiveMQ消息队列技术融合Spring过程解析
08-25
在使用广播机制时，我们需要确保消息生产者和消费者同时在线，才能接收我的消息。否则，消息将被丢弃，导致系统的不一致性。 三、使用消息中间件 使用消息中间件是实现 ActiveMQ 消息队列技术融合 Spring 过程解析...
activeMq消息队列demo
04-28
这个"activeMQ消息队列demo"将展示如何创建生产者和消费者，设置消息的发送和接收，以及如何利用ActiveMQ的基本功能。对于初学者来说，这是一个很好的起点，可以深入理解消息队列的工作原理以及如何在实际项目中应用...
PHP使用ActiveMQ实现消息队列的方法详解
10-16
总结来说，PHP与ActiveMQ结合实现消息队列可以提高系统的稳定性和可扩展性。通过使用STOMP协议和PHP中的`stomp-php`扩展，我们可以实现跨语言的消息通信。在实现过程中，注意消息的发送确认和持久化设置，以保证消息...
activemq生产消费的Demo
04-02
java整合activemq的demo，生产者和消费者两个方法。结合自带的工具http://192.168.1.106:8161。来查看消息传递情况
Java并发编程（1）—— 实现一个生产者消费者队列（三种方式）
Aviato
03-01 3064
生产者消费者队列，顾名思义，就是一个队列，不停地有生产者在里面生产对象并通知阻塞的消费者可以消费了，如果队列满了，生产者就阻塞不能再生产；消费者来消费（也就是读取并拿走队列里的对象）并通知阻塞的生产者，直到把队列消费空，就阻塞不能再消费。 wait/notify机制 wait/notify机制原理 wait/notify机制是与Monitor监视器锁关联在一起的。一个线程在持有某个对象的监视器...
ActiveMQ——消息的生产和消费
如不來的博客
07-16 3736
是一对一，还是一对多 消费者
【JAVA】多线程案例之阻塞队列---》生产者消费者模型
qq_61862008的博客
10-11 683
加上阻塞队列的场景就比如包饺子：你爸爸负责擀饺子皮，你和你妈妈负责包饺子（爸爸是生产者，你跟妈妈是消费者），如果你爸爸的速度很快，你跟妈妈才包好10个饺子，爸爸就已经擀好了100张饺子皮，此时你爸爸可以停下来玩会手机休息~反过来，你跟你妈妈包饺子的速度大于爸爸擀饺子皮的速度的话，你跟你妈妈可以停下来等爸爸擀多些饺子皮，你们娘俩再开始包饺子。，等到这个满的队列中有元素出队列了，这时你上一步插入元素的动作就会接着往下执行~反过来也一样，假如队列的元素空了，你准备从这个空队列里取元素，3.实现队列的阻塞功能。
Java 队列queue的生产和消费
最新发布
qihangVIP4的博客
04-22 306
Java 队列queue的生产和消费
java 队列 消费者模式_9.队列：生产者消费者模式
weixin_42365688的博客
03-05 247
队列：生产消费模式及线程池的运用> 关注公众号 MageByte，设置星标获取最新干货。 “加群” 进入技术交流群获更多技术成长。向固定大小的线程池投放请求任务时，若果线程池中没有空闲资源了，这时候还有新的请求进来，线程池如何处理这个请求？拒绝请求还是排队？使用怎样的处理机制一般两种策略：直接拒绝任务请求；将请求排队，等有空闲线程的时候取出排队的请求继续处理。那如何存储排队的请求呢？这就是今...
java使用阻塞队列实现生产者消费者模式
Nickjun123的专栏
08-09 4233
Java 5之前实现同步存取时，可以使用普通的一个集合，然后在使用线程的协作和线程同步可以实现生产者，消费者模式，主要的技术就是用好，wait ,notify,notifyAll,sychronized这些关键字。而在java 5之后，可以使用组阻塞队列来实现，此方式大大简少了代码量，使得多线程编程更加容易，安全方面也有保障。  BlockingQueue接口是Queue的子接口，它的主
11-JUC中的Condition对象
永无止境
04-28 613
文章目录ConditionCondition常用方法总结参考 Condition 任何一个java对象都天然继承于Object类，在线程间实现通信的往往会应用到Object的几个方法，比如wait()、wait(long timeout)、wait(long timeout, int nanos)与notify()、notifyAll()几个方法实现等待/通知机制，同样的， 在java Lock体...
Java队列实现生产者消费者进行任务排队执行
qq_16334741的博客
10-14 1920
场景：在开发固件测试项目的时候，遇到一个问题。由于底层跑固件的是分析程序是单线程的，b端上层这边是多线程的，这就产生了一个需求，上层需要把测试任务进行排队，然后让底层分析程序一个一个的执行固件的测试。 说明解释：CloudTask是我自定义的实体类。这些代码是从业务中剥离出来的，所以有些没用的我注释掉了。项目中用到了logger工厂，为了方便demo运行我注释掉了，改成了println()输出到控制台。 队列服务类： import org.springframework.stereotype.Ser
Java ActiveMQ 消息队列实战教程
中间消息件如ActiveMQ充当一个缓冲区，存储来自生产者的消息，并在消费者准备好处理时将其传递给消费者，确保消息的可靠传输，同时避免了系统间的直接耦合。 ActiveMQ支持两种主要的消息传递模式： 1. 点对点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值