JMS使用ActiveMQ实现Queue和Topic两种模式

最新推荐文章于 2024-04-21 21:55:20 发布
最新推荐文章于 2024-04-21 21:55:20 发布
阅读量1.1w 收藏 7
点赞数 2
分类专栏： JMS-ActiveMQ 文章标签： activemq java jms
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zmx729618/article/details/51082844
版权

       jms就是java message service，是J2EE规范的一部分，跟jdbc差不多，sun只提供了接口，由各个厂商（provider）来进行具体的实现，然后使用者使用他们的jar包进行开发使用即可。
        另外在jms的API中，jms传递消息有两种方式，一种是点对点的Queue，还有一个是发布订阅的Topic方式。区别在于：
        对于Queue模式，一个发布者发布消息，下面的接收者按队列顺序接收，比如发布了10个消息，两个接收者A,B那就是A,B总共会收到10条消息，不重复。
        对于Topic模式，一个发布者发布消息，有两个接收者A,B来订阅，那么发布了10条消息，A,B各收到10条消息。

       使用activeMQ来完成jms的发送，必须要下载activeMQ，然后再本机安装，并且启动activeMQ的服务才行。在官网下载完成之后，运行bin目录下面的activemq.bat，将activeMQ成功启动。启动成功之后可以运行：http://localhost:8161/admin/index.jsp 查看一下。

1、Queue模式实现：

 1.1、发送端Sender

package jms.test;

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
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 Sender {
	
	public static void main(String[] args) throws JMSException, InterruptedException {
		// ConnectionFactory ：连接工厂，JMS 用它创建连接
		ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(
				                                  ActiveMQConnection.DEFAULT_USER,
				                                  ActiveMQConnection.DEFAULT_PASSWORD,
				                                  "tcp://localhost:61616");
		
		// Connection ：JMS 客户端到JMS Provider 的连接
		Connection connection =  connectionFactory.createConnection();
		
		connection.start();
		// Session： 一个发送或接收消息的线程
		Session session = connection.createSession(true, Session.AUTO_ACKNOWLEDGE);
		
		// Destination ：消息的目的地;消息发送给谁.
		Destination destination =  session.createQueue("my-queue");
		
		// MessageProducer：消息发送者
		MessageProducer producer =  session.createProducer(destination);
		
		// 设置不持久化，可以更改
        producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);
        
		for(int i=0;i<10;i++){
			//创建文本消息
			TextMessage message = session.createTextMessage("hello everyone, this is a test message"+i);
			
			Thread.sleep(1000);
			//发送消息
			producer.send(message);
		}
		
		session.commit();
		session.close();
		connection.close();
	}

}

运行之后控制台输出：

hello everyone, this is a test message0
hello everyone, this is a test message1
hello everyone, this is a test message2
hello everyone, this is a test message3
hello everyone, this is a test message4
hello everyone, this is a test message5
hello everyone, this is a test message6
hello everyone, this is a test message7
hello everyone, this is a test message8
hello everyone, this is a test message9


 1.2、接收端，Receiver代码：

 

package jms.test;

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

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


public class Receiver {
	// ConnectionFactory ：连接工厂，JMS 用它创建连接
   private static ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(ActiveMQConnection.DEFAULT_USER,
           ActiveMQConnection.DEFAULT_PASSWORD, "tcp://localhost:61616");
	
   public static void main(String[] args) throws JMSException {
	    // Connection ：JMS 客户端到JMS Provider 的连接
		final Connection connection =  connectionFactory.createConnection();
		
		connection.start();
		// Session： 一个发送或接收消息的线程
		final Session session = connection.createSession(true, Session.AUTO_ACKNOWLEDGE);
		// Destination ：消息的目的地;消息送谁那获取.
		Destination destination =  session.createQueue("my-queue");
		// 消费者，消息接收者
		MessageConsumer consumer1 =  session.createConsumer(destination);
		
		consumer1.setMessageListener(new MessageListener() {
				@Override
				public void onMessage(Message msg) {

					try {
						
						TextMessage message = (TextMessage)msg ;
						System.out.println("consumer1收到消息： "+message.getText());
						session.commit();
					} catch (JMSException e) {				
						e.printStackTrace();
					}
					
				}
			});
	
		// 再来一个消费者，消息接收者
		MessageConsumer consumer2 =  session.createConsumer(destination);
		
		consumer2.setMessageListener(new MessageListener() {
				@Override
				public void onMessage(Message msg) {

					try {
						
						TextMessage message = (TextMessage)msg ;
						System.out.println("consumer2收到消息： "+message.getText());
						session.commit();
					} catch (JMSException e) {				
						e.printStackTrace();
					}
					
				}
			});

		
		
	
}
	
	

}


运行之后控制台不会退出一直监听消息库，对于消息发送者的十条信息，控制输出：

consumer1收到消息： hello everyone, this is a test message0
consumer2收到消息： hello everyone, this is a test message1
consumer1收到消息： hello everyone, this is a test message2
consumer2收到消息： hello everyone, this is a test message3
consumer1收到消息： hello everyone, this is a test message4
consumer2收到消息： hello everyone, this is a test message5
consumer1收到消息： hello everyone, this is a test message6
consumer2收到消息： hello everyone, this is a test message7
consumer1收到消息： hello everyone, this is a test message8
consumer2收到消息： hello everyone, this is a test message9

2、Topic模式实现

2.1 、 消息发布者，Publisher代码：

package jms.test;

import java.util.Hashtable;  
import java.util.Map;  
  
import javax.jms.Connection;  
import javax.jms.ConnectionFactory;  
import javax.jms.Destination;  
import javax.jms.JMSException;  
import javax.jms.MapMessage;  
import javax.jms.Message;  
import javax.jms.MessageProducer;  
import javax.jms.Session;  
  
import org.apache.activemq.ActiveMQConnectionFactory;  
import org.apache.activemq.command.ActiveMQMapMessage;

public class Publisher {
	
    protected int MAX_DELTA_PERCENT = 1;  
    protected Map<String, Double> LAST_PRICES = new Hashtable<String, Double>();  
    protected static int count = 1;  
    protected static int total;  
      
    protected static String brokerURL = "tcp://localhost:61616";  
    protected static transient ConnectionFactory factory;  
    protected transient Connection connection;  
    protected transient Session session; 
    protected transient Destination destination;
    protected transient MessageProducer producer;  
      
    public Publisher() throws JMSException {  
        factory = new ActiveMQConnectionFactory(brokerURL);  //创建连接工场
        connection = factory.createConnection();   //创建连接
        try {  
            connection.start();   //打开连接
        } catch (JMSException jmse) {  
            connection.close();  
            throw jmse;  
        }  
        session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);  //创建session 不带事务
        destination = session.createTopic("STOCKS.topic"); //创建topic
        producer = session.createProducer(destination);    //创建publisher
    }  
      
    public void close() throws JMSException {  
        if (connection != null) {  
            connection.close();  
        }  
    }  
      
    public static void main(String[] args) throws JMSException {  
        Publisher publisher = new Publisher();  
        while (total < 50) {  
            for (int i = 0; i < count; i++) {  
                publisher.sendMessage();  
            }  
            total += count;  
            System.out.println("Published '" + count + "' of '" + total + "' price messages");  
            try {  
              Thread.sleep(1000);  
            } catch (InterruptedException x) {  
            }  
        }  
        publisher.close();  
    }  
  
    protected void sendMessage() throws JMSException {                  
        Message message = createStockMessage(session);  
        System.out.println("Sending: " + ((ActiveMQMapMessage)message).getContentMap() + " on destination: " + destination);  
        producer.send(destination, message);  
    }  
  
    protected Message createStockMessage(Session session) throws JMSException {  
        Double value = LAST_PRICES.get("topic");  
        if (value == null) {  
            value = new Double(Math.random() * 100);  
        }  
 
        double oldPrice = value.doubleValue();  
        value = new Double(mutatePrice(oldPrice));  
        LAST_PRICES.put("topic", value);  
        double price = value.doubleValue();  
        double offer = price * 1.001;  
        boolean up = (price > oldPrice);  
  
        MapMessage message = session.createMapMessage();  
        message.setString("topic", "topic");  
        message.setDouble("price", price);  
        message.setDouble("offer", offer);  
        message.setBoolean("up", up);  
        return message;  
    }

控制台打印：

Sending: {topic=topic, price=26.707862686880095, offer=26.73457054956697, up=false} on destination: topic://STOCKS.topic
Published '1' of '1' price messages
Sending: {topic=topic, price=26.904104854950052, offer=26.931008959805, up=true} on destination: topic://STOCKS.topic
Published '1' of '2' price messages
Sending: {topic=topic, price=26.84132968750509, offer=26.868171017192594, up=false} on destination: topic://STOCKS.topic
Published '1' of '3' price messages
Sending: {topic=topic, price=26.652301297312082, offer=26.67895359860939, up=false} on destination: topic://STOCKS.topic
Published '1' of '4' price messages
Sending: {topic=topic, price=26.60180161811153, offer=26.62840341972964, up=false} on destination: topic://STOCKS.topic
Published '1' of '5' price messages
Sending: {topic=topic, price=26.527634257875008, offer=26.55416189213288, up=false} on destination: topic://STOCKS.topic
Published '1' of '6' price messages
Sending: {topic=topic, price=26.758846815361945, offer=26.785605662177304, up=true} on destination: topic://STOCKS.topic
Published '1' of '7' price messages
Sending: {topic=topic, price=26.93616880981415, offer=26.96310497862396, up=true} on destination: topic://STOCKS.topic
Published '1' of '8' price messages
Sending: {topic=topic, price=26.80748490634637, offer=26.834292391252713, up=false} on destination: topic://STOCKS.topic
Published '1' of '9' price messages
Sending: {topic=topic, price=26.845968050168864, offer=26.872814018219028, up=true} on destination: topic://STOCKS.topic
Published '1' of '10' price messages

2.2 消息订阅者，Subscriber代码：

package jms.test;

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 java.text.DecimalFormat;  

import javax.jms.MapMessage;  
import javax.jms.Message;  
import javax.jms.MessageListener;

import org.apache.activemq.ActiveMQConnectionFactory;

public class Subscriber {
	
	
	private static String brokerURL = "tcp://localhost:61616";  
    private static transient ConnectionFactory factory;  
    private transient Connection connection;  
    private transient Session session;  
    private transient Destination destination;  
    private transient MessageConsumer messageConsumer;  
      
    public Subscriber() throws JMSException {  
        factory = new ActiveMQConnectionFactory(brokerURL);  
        connection = factory.createConnection();  
        connection.start();  
        session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); 
        destination = session.createTopic("STOCKS.topic" );   
        messageConsumer = session.createConsumer(destination);
        
    } 
    
    public MessageConsumer getMessageConsumer() {  
        return messageConsumer;  
    }
  
      
    public void close() throws JMSException {  
        if (connection != null) {  
            connection.close();  
        }  
    }      
      
    public static void main(String[] args) throws JMSException {  
    	Subscriber consumer1 = new Subscriber();  
    	consumer1.messageConsumer.setMessageListener(new Listener());     
    	
    	Subscriber consumer2 = new Subscriber();  
    	consumer2.messageConsumer.setMessageListener(new Listener());  
    	
    	
    	Subscriber consumer3 = new Subscriber();  
    	consumer3.messageConsumer.setMessageListener(new Listener());  
    } 
    
    
    private static class Listener implements MessageListener {  
    	  
        public void onMessage(Message message) {  
            try {  
                MapMessage map = (MapMessage)message;  
                String topic = map.getString("topic");  
                double price = map.getDouble("price");  
                double offer = map.getDouble("offer");  
                boolean up = map.getBoolean("up");  
                DecimalFormat df = new DecimalFormat( "#,###,###,##0.00" );  
                System.out.println(topic + "\t" + df.format(price) + "\t" + df.format(offer) + "\t" + (up?"up":"down"));  
            } catch (Exception e) {  
                e.printStackTrace();  
            }  
        }  
      
    }
   

	

}


控制台打印：

topic 26.71 26.73 down
topic 26.71 26.73 down
topic 26.71 26.73 down
topic 26.90 26.93 up
topic 26.90 26.93 up
topic 26.90 26.93 up
topic 26.84 26.87 down
topic 26.84 26.87 down
topic 26.84 26.87 down
topic 26.65 26.68 down

 

 

零度anngle
关注
  • 2
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Spring 实现远程访问详解——jms和activemq
04-21
前几章我们分别利用spring rmi、httpinvoker、httpclient、webservice技术实现不同服务器间的远程访问。本章我将通过spring jms和activemq实现单Web项目服务器间异步访问和多Web项目服务器间异步访问。 一. 简介 1. 什么是Apache ActiveMq Apache ActiveMq是最流行和最强大的开源消息和集成服务器。同时Apache ActiveMq是速度快，支持多种跨语言客户端和协议，同时配有易于使用的企业集成模式和优秀的特性，并且支持JMS1.1和J2EE1.4。具体特性见官网：http://activemq.apache.org/ 2. 什么是JMS JMS的全称是Java Message Service，即Java消息服务。它主要用于在生产者和消费者之间进行消息传递，生产者负责产生消息，而消费者负责接收消息。把它应用到实际的业务需求中的话我们可以在特定的时候利用生产者生成一消息，并进行发送，对应的消费者在接收到对应的消息后去完成对应的业务逻辑。 JMS 支持两种消息传递模型： 点对点（point-to-point，简称 PTP） 发布/订阅（publish/subscribe，简称 pub/sub）。 这两种消息传递模型非常相似，但有以下区别： PTP 消息传递模型规定了一条消息只能传递给一个接收方。 采用javax.jms.Queue 表示。Spring配置类型destination-type="queue"。 Pub/sub 消息传递模型允许一条消息传递给多个接收方。采用javax.jms.Topic表示。Spring配置类型destination-type="topic"。 二. 单服务器异步访问 3. Spring 整合JMS和ActiveMq流程 1) 下载和部署ActiveMq服务器 2) Spring jms和activemq相关依赖引入 3) Spring整合activemq配置 4) 定义消息发布者(生产者) 5) 定义消息订阅者(消费者) 6) Spring mvc配置 7) 实例测试
MS入门（四）--Topic的使用
大树叶 技术专栏
02-03 532
与Queue不同的是，Topic实现的是发布/订阅模型， 在一个基于发布/订阅模型的应用或者产品中，客户端根据主题来订阅消息，有点像公告牌。发布者和订阅者一般都是匿名的，而且可以动态的发布或者订阅内容。消息系统会谨慎处理消息的分发到订阅了某个主题的所有订阅者，消息只会发送给当前订阅者，然后就失效，新的订阅者无法接收到刚刚失效的消息。 发布和订阅的消息机制具有以下特征
RocketMQ中，Topic（主题）和Queue（队列）有什么区别
程序新视界
02-23 1204
总的来说，Topic和Queue的主要区别在于，Topic是消息的分类，用于区分不同类型的消息，而Queue是消息的存储结构，用于提高消息的并发处理能力。如果你的应用场景中，消息的处理时间可能会有较大的差异，或者某些消息的处理时间可能会较长，那么你可能需要创建多个Queue，以便能够并行处理消息，提高系统的吞吐量。例如，你可以为不同类型的消息创建不同的Topic，然后根据消息的处理需求，为每个Topic创建适当数量的Queue。如果某个消息的处理时间较长，那么后续的消息将会被阻塞，直到这个消息被消费完毕。
快速上手ActiveMQ消息队列的JMS方式使用（两种模式：Topic和Queue的消息推送和订阅）...
最好的GIS地图开发教程和GIS地图技术分享(GIS入门、Openlayers教程、Leaflet教程)
04-21 322
一、实现功能 希望使用一套API，实现两种模式下的消息发送和接收功能，方便业务程序调用 1、发送Topic 2、发送Queue 3、接收Topic 4、接收Queue 二、接口设计 根据功能设计公共调用接口 ```java /** * 数据分发接口(用于发送、接收消息队列数据) * * @author eguid * */ public interface MsgDist...
SpringBoot项目如何使用ActiveMQ的订阅/发布（topic）、点对点（queue）两种模式？
谢小鱼的博客
09-05 1408
前言：mq的订阅/发布模式和点对点模式的区别网上很多，博主不再赘述，直接上代码： 一、部署MQ 网上很多教程，操作相对简单，这里我就不详细说了。大概就是： 1、去官网下载active的解压缩版； 2、解压之后以管理员身份运行“...\ActiveMQ\bin\win64”目录下的InstallService.bat批处理文件，然后就可以将mq注册成windows服务了。 二、在pom文件...
ActiveMQ入门教程(二)之队列模式(Queue)和主题模式(Topic)
尼古拉斯大树的博客
06-09 1074
ActiveMQ的架构 ActiveMQ主要涉及到5个方面： 1.传输协议：消息之间的传递，无疑需要协议进行沟通，启动一个ActiveMQ打开了一个监听端口， ActiveMQ提供了广泛的连接模式，其中主要包括SSL、STOMP、XMPP；ActiveMQ默认的使用的协议是openWire，端口号：61616; 2.消息域：ActiveMQ主要包含Point-to-Point (点对点)...
activeMq 学习queue、topic两种模式
qq_31876557的博客
11-15 918
1. activeMq 的queue、topic两种模式 1.1 queue（消息队列模式） 模式点对点 即为： 如果现在消费者人数有两个， 共有十条消息 ，那么 消费者1 和消费者2 收到的消息总共为10条且消费者1和消费者2 接收到的不重复 如图： 1.2 topic 发布订阅消息 即为： 如果现在消费者人数有两个， 共有十条消息 ，那么 消费者...
spring boot-同时使用jms的Queue(队列)和Topic(发布订阅)
牛奋lch
05-25 7496
前言 前面有一篇博客讲到了spring boot整合jms的使用http://blog.csdn.net/liuchuanhong1/article/details/54603546 但是最近遇到一个需求，需要同时使用jms的队列和topic，于是就有了下面的测试代码： 消费者代码 @Component // 必须加此注解，该类才会被作为Message Driven POJO使用 pu
JMS（二）：MessageListener，实战Queue ，实战Topic，消息头
Franco的博客
09-25 4112
MessageListener 消息的消费者接收消息可以采用两种方式：   1、consumer.receive() 或 consumer.receive(int timeout)；   2、注册一个MessageListener。   采用第一种方式，消息的接收者会一直等待下去，直到有消息到达，或者超时。后一种方式会注册一个监听器，当有消息到达的时候，会回调它的onMessage()
ActiveMQ入门-ActiveMQ跟SpringBoot整合发送接收Topic
Leon_Jinhai_Sun的博客
09-29 361
默认情况下@JmsListener不能监听topic，需要添加工厂类 package jms; import org.apache.activemq.command.ActiveMQQueue; import org.apache.activemq.command.ActiveMQTopic; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configu
JMS入门（四）--Topic的使用
wl_ldy的专栏
08-19 3090
与Queue不同的是，Topic实现的是发布/订阅模型， 在一个基于发布/订阅模型的应用或者产品中，客户端根据主题来订阅消息，有点像公告牌。发布者和订阅者一般都是匿名的，而且可以动态的发布或者订阅内容。消息系统会谨慎处理消息的分发到订阅了某个主题的所有订阅者，消息只会发送给当前订阅者，然后就失效，新的订阅者无法接收到刚刚失效的消息。 发布和订阅的消息机制具有以下特征： 1）每个消
activeMQ JMS 3种创建方式
11-04
activeMQ JMS 3种创建方式 公共方式 QUEUE TOPIC
一个jms activemq Topic 消息实例
07-30
一个jms activemq Topic 消息实例 关于jms JMS 是接口，相当于jdbc ，要真正使用它需要某些厂商进行实现 ，即jms provider 常见的jms provider 有 ActiveMQ JBoss 社区所研发的 HornetQ (在jboss6 中默认即可以...
Queue与Topic的比较
03-15
Queue与Topic的比较，学习JMS和activemq必须看的资料之一
jms简单demo,集成spring和不集成
09-16
jms简单demo,activemq集成spring和不集成
ActiveMQ入门案例（queue模式和topic模式）
IT深耕十余载，大道之简
04-18 670
ActiveMQ是一个流行的开源消息中间件，它支持多种消息传递模式，包括点对点（queue）模式和发布/订阅（topic）模式。以下是一个ActiveMQ的入门案例，分别展示了如何使用这两种模式。
深入理解Java消息中间件-ActiveMQ
最新发布
u011532237的博客
04-21 304
在现代企业级应用开发中，消息中间件扮演着连接各个系统与应用、保证数据流畅传输的关键角色。Apache ActiveMQ，作为一款成熟的开源消息队列系统，为Java环境中的异步通信和系统集成提供了强大支持。本文将为您揭晓ActiveMQ的来源，消息传递流程，数据不丢失的保障措施，以及它是如何对Topic和Queue进行区分的。
ActiveMQ 如果数据处理出现异常会怎么样
HONEY MOOSE
04-19 233
因此，在 ActiveMQ 消息处理队列中需要持续关注 DLQ 队列， DLQ 的队列都是无法处理的或者处理的过程中出现了异常。我们有一个 Spring 的客户端，在处理消息的时候因为程序的原因出现消息处理异常。对这种情况，ActiveMQ 会把出现异常的消息放在 DLQ 队列中进行持久化。通常，我们可以通过对 DLQ 队列中的消息进行重发了触发处理程序。如上图中后端程序的日志上显示的消息处理异常。可以通过异常的处理，来让消息队列进入正常化。
使用 JmsTemplate 向 ActiveMQ 发送和获取 Topic 类型消息
05-26
使用 JmsTemplate 向 ActiveMQ 发送和获取 Topic 类型消息的示例代码如下： 发送消息： ```java @Autowired private JmsTemplate jmsTemplate; public void sendMessageToTopic(String message) { jmsTemplate.setPubSubDomain(true); // 设置为 Topic 模式 jmsTemplate.convertAndSend("myTopic", message); } ``` 其中，`jmsTemplate.setPubSubDomain(true)` 表示设置为 Topic 模式，`myTopic` 是 Topic 名称，`message` 是要发送的消息内容。 获取消息： ```java @Autowired private JmsTemplate jmsTemplate; public void receiveMessageFromTopic() { jmsTemplate.setPubSubDomain(true); // 设置为 Topic 模式 String message = (String) jmsTemplate.receiveAndConvert("myTopic"); System.out.println("Received message: " + message); } ``` 其中，`jmsTemplate.setPubSubDomain(true)` 表示设置为 Topic 模式，`myTopic` 是 Topic 名称，`receiveAndConvert` 方法用于接收并转换消息，返回的是 Object 类型，需要强制转换为实际类型。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值