Spring-ActiveMQ的点对点和Topic

最新推荐文章于 2022-02-25 18:24:09 发布
最新推荐文章于 2022-02-25 18:24:09 发布
阅读量260 收藏
点赞数
分类专栏： activemq maven 文章标签： java 网络 

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.example.activemq</groupId>
  <artifactId>activemq-test</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>activemq-test</name>
  <url>http://maven.apache.org</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <org.springframework.version>3.1.1.RELEASE</org.springframework.version>
  </properties>

<repositories>
  <repository>
	<id>kxcomm-maven</id>
	<name>Maven kxcomm Repository</name>
	<url>http://122.13.0.56:8088/nexus/content/groups/public/</url>
	<releases>
		<enabled>true</enabled>
	</releases>
	<snapshots>
		<enabled>true</enabled>
	</snapshots>
</repository>   
</repositories>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
    <dependency>
			<groupId>commons-collections</groupId>
			<artifactId>commons-collections</artifactId>
			<version>3.2</version>
		</dependency>
		<dependency>
			<groupId>commons-configuration</groupId>
			<artifactId>commons-configuration</artifactId>
			<version>1.6</version>
		</dependency>
		<dependency>
			<groupId>commons-io</groupId>
			<artifactId>commons-io</artifactId>
			<version>1.3.2</version>
		</dependency>
		<dependency>
			<groupId>commons-logging</groupId>
			<artifactId>commons-logging</artifactId>
			<version>1.1.1</version>
		</dependency>
		<dependency>
			<groupId>log4j</groupId>
			<artifactId>log4j</artifactId>
			<version>1.2.17</version>
		</dependency>
		<dependency>
			<groupId>commons-beanutils</groupId>
			<artifactId>commons-beanutils</artifactId>
			<version>1.8.3</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-asm</artifactId>
			<version>${org.springframework.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jms</artifactId>
			<version>${org.springframework.version}</version>
		</dependency>
		<dependency>
			<groupId>com.davidkarlsen.commonstransaction.spring</groupId>
			<artifactId>commons-transaction-spring</artifactId>
			<version>0.9</version>
		</dependency>
		<dependency>
			<groupId>org.apache.httpcomponents</groupId>
			<artifactId>httpclient</artifactId>
			<version>4.2-beta1</version>
		</dependency>
		<dependency>
			<groupId>fastutil</groupId>
			<artifactId>fastutil</artifactId>
			<version>5.0.9</version>
		</dependency>

		<dependency>
			<groupId>ch.qos.logback</groupId>
			<artifactId>logback-classic</artifactId>
			<version>0.9.27</version>
			<scope>compile</scope>
		</dependency>
		<dependency>
			<groupId>ch.qos.logback</groupId>
			<artifactId>logback-core</artifactId>
			<version>0.9.27</version>
			<scope>compile</scope>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-api</artifactId>
			<version>1.6.1</version>
			<scope>compile</scope>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>jcl-over-slf4j</artifactId>
			<version>1.6.1</version>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-log4j12</artifactId>
			<version>1.7.5</version>
		</dependency>
		<dependency>
			<groupId>org.apache.activemq</groupId>
			<artifactId>activemq-all</artifactId>
			<version>5.8.0</version>
		</dependency>
  </dependencies>
</project>



<?xml version="1.0" encoding="UTF-8"?>
<beans
    xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop" 
    xmlns:tx="http://www.springframework.org/schema/tx" 
    xmlns:context="http://www.springframework.org/schema/context" 
    xsi:schemaLocation=" 
                http://www.springframework.org/schema/beans
                http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
                http://www.springframework.org/schema/aop
                http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
                http://www.springframework.org/schema/tx
                http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
                http://www.springframework.org/schema/context
                http://www.springframework.org/schema/context/spring-context-2.5.xsd"
                 default-autowire="byName" default-lazy-init="true">

<import resource="activemq-test.xml"/>

</beans>



<?xml version="1.0" encoding="UTF-8"?>

<beans
  xmlns="http://www.springframework.org/schema/beans"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
  http://activemq.apache.org/schema/core http://activemq.apache.org/schema/core/activemq-core.xsd
  http://camel.apache.org/schema/spring http://camel.apache.org/schema/spring/camel-spring.xsd">

	<!-- 创建工厂连接 -->
	<bean id="connectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
		<property name="brokerURL" value="tcp://localhost:61616" />
	</bean>

	<bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
		<property name="connectionFactory" ref="connectionFactory" />
		 <property name="defaultDestination" ref="rantzDestination" />  
	</bean>

	<!-- Point-to-Point -->
	<!-- activeMQ消息目标 队列 -->
	<bean id="rantzDestination" class="org.apache.activemq.command.ActiveMQQueue">
		<constructor-arg index="0" value="rantz.marketing.queue"></constructor-arg>
	</bean>

	<!-- activeMQ消息目标 主题-->
        <!--	<bean id="rantzDestination" class="org.apache.activemq.command.ActiveMQTopic">-->
        <!--		<constructor-arg index="0" value="rantz.marketing.queue"></constructor-arg>-->
        <!--	</bean>-->

	<bean id="producer" class="activemq.test.p2p.producer.RantzMarketingGatewayImpl">
		<property name="jmsTemplate" ref="jmsTemplate" />
		<property name="destination" ref="rantzDestination" />
	</bean>
	<bean id="consumer" class="activemq.test.p2p.consumer.MarketingReceiverGatewayImpl">  
	    <property name="jmsTemplate" ref="jmsTemplate" />  
	</bean>  
	<!-- Point-to-Point End-->


	<!-- Topic -->
	<bean id="topic" class="org.apache.activemq.command.ActiveMQTopic" autowire="constructor">
        <constructor-arg index="0" value="kxcomm.mms.topic" />
    </bean>
    <bean id="control" class="org.apache.activemq.command.ActiveMQTopic" autowire="constructor">
        <constructor-arg index="0" value="kxcomm.mms.control" />
    </bean>

	<bean id="myListener" class="activemq.test.topic.MyListener">
    <property name="connectionFactory" ref="connectionFactory" />
    <property name="topic" ref="topic" />
    <property name="control" ref="control" />
    </bean>

   <bean id="myPublisher" class="activemq.test.topic.MyPublisher">
    <property name="connectionFactory" ref="connectionFactory" />
    <property name="topic" ref="topic" />
    <property name="control" ref="control" />
    </bean>
	<!-- Topic End-->

</beans>



package activemq.test.model;

import java.io.Serializable;

public class User implements Serializable{
	private static final long serialVersionUID = -3098636047897519268L;
	private String name;
	private String sex;
	private int age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "User [name=" + name + ", sex=" + sex + ", age=" + age + "]";
	}

}


PTP模型
PTP(Point-to-Point)模型是基于队列的，生产者发消息到队列，消费者从队列接收消息，队列的存在使得消息的异步传输成为可能。和邮件系统中的邮箱一样，队列可以包含各种消息，JMS Provider 提供工具管理队列的创建、删除。JMS PTP 模型定义了客户端如何向队列发送消息，从队列接收消息，浏览队列中的消息。 

package activemq.test.p2p.consumer;

import org.springframework.jms.core.JmsTemplate;

import activemq.test.model.User;
public class MarketingReceiverGatewayImpl {

	private JmsTemplate jmsTemplate;

	public JmsTemplate getJmsTemplate() {
		return jmsTemplate;
	}
	public void setJmsTemplate(JmsTemplate jmsTemplate) {
		this.jmsTemplate = jmsTemplate;
	}

	public MarketingReceiverGatewayImpl() {
	}

	public void receiveMotorist() throws Exception{
		User message  = (User)jmsTemplate.receiveAndConvert();
		System.out.println("reviced msg is:" + message.toString());
	}

}


package activemq.test.p2p.consumer;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class StartConsumer {
	public static void main(String[] args) {
		/*开始加载spring配置文件*/
			ApplicationContext context = new ClassPathXmlApplicationContext("classpath:modules/applicationContext.xml");
			MarketingReceiverGatewayImpl rantzMarketingGateway= (MarketingReceiverGatewayImpl) context.getBean("consumer");
			System.out.println("Receive Start ...");
			try {
				while(true){
					rantzMarketingGateway.receiveMotorist();
				}

			} catch (Exception e) {
				e.printStackTrace();
			}
	    }
}


package activemq.test.p2p.producer;

public interface IRantzMarketingGateway {
	/**
	 * 
	 * 发送文本对象
	 * 
	 * @author zhangjh 新增日期：2013-9-20
	 * @since smsc-gateway
	 */
	public void sendMotoristInfo();

	/**
	 * 
	 * 发送对象
	 * 
	 * @author zhangjh 新增日期：2013-9-20
	 * @since smsc-gateway
	 */
	public void sendObjectInfo();
}


package activemq.test.p2p.producer;

import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.Session;

import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;

import activemq.test.model.User;

public class RantzMarketingGatewayImpl implements IRantzMarketingGateway {

	private JmsTemplate jmsTemplate;
	private Destination destination;

	public JmsTemplate getJmsTemplate() {
		return jmsTemplate;
	}

	public void setJmsTemplate(JmsTemplate jmsTemplate) {
		this.jmsTemplate = jmsTemplate;
	}

	public Destination getDestination() {
		return destination;
	}

	public void setDestination(Destination destination) {
		this.destination = destination;
	}

	public void sendMotoristInfo() {
		MessageCreator msg = new MessageCreator(){
			public Message createMessage(Session session) throws JMSException {
				return session.createTextMessage("这是一个测试,"+System.currentTimeMillis());
			}
		};
		jmsTemplate.send(destination, msg);
	}


	public void sendObjectInfo() {
		User u = new User();
		u.setAge(17);
		u.setName("yuky"+System.currentTimeMillis());
		u.setSex("女");
		jmsTemplate.convertAndSend(u);

	}
}


package activemq.test.p2p.producer;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class StartProducer {
	public static void main(String[] args) {
		/*开始加载spring配置文件*/
			ApplicationContext context = new ClassPathXmlApplicationContext("classpath:modules/applicationContext.xml");
			IRantzMarketingGateway rantzMarketingGateway= (RantzMarketingGatewayImpl) context.getBean("producer");
			for(int i=0;i<10;i++){
				rantzMarketingGateway.sendObjectInfo();
				System.out.println("Start ...");
			}

		}
}


PUB/SUB模型
消息订阅分为非持久订阅(non-durable subscription)和持久订阅(durable subscrip-tion)，非持久订阅只有当客户端处于激活状态，也就是和JMS Provider 保持连接状态才能收到发送到某个主题的消息，而当客户端处于离线状态，这个时间段发到主题的消息将会丢失，永远不会收到。持久订阅时，客户端向JMS 注册一个识别自己身份的ID，当这个客户端处于离线时，JMS Provider 会为这个ID 保存所有发送到主题的消息，当客户再次连接到JMS Provider时，会根据自己的ID 得到所有当自己处于离线时发送到主题的消息。 


package activemq.test.topic;

import javax.jms.Connection;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageListener;
import javax.jms.MessageProducer;
import javax.jms.ObjectMessage;
import javax.jms.Session;
import javax.jms.TextMessage;
import javax.jms.Topic;

import org.apache.activemq.ActiveMQConnectionFactory;

import activemq.test.model.User;

public class MyListener implements MessageListener {
	private ActiveMQConnectionFactory connectionFactory;
	private Connection connection;
	private Session session;
	private MessageProducer producer;
	private Topic topic;
    private Topic control;

	public Topic getTopic() {
		return topic;
	}

	public void setTopic(Topic topic) {
		this.topic = topic;
	}

	public Topic getControl() {
		return control;
	}

	public void setControl(Topic control) {
		this.control = control;
	}

	public ActiveMQConnectionFactory getConnectionFactory() {
		return connectionFactory;
	}

	public void setConnectionFactory(ActiveMQConnectionFactory connectionFactory) {
		this.connectionFactory = connectionFactory;
	}

	public void onMessage(Message message) {
		try{
			if (checkText(message, "SHUTDOWN")) {
	            try {
	                connection.close();
	                System.out.println("退出监听消息");
	            } catch (Exception e) {
	                e.printStackTrace(System.out);
	            }

	        } else if (checkText(message, "REPORT")) {
	            // send a report:
	            try {
	            	 System.out.println("MyListener->收到 a report");
	                long time = System.currentTimeMillis();
	                String msg = "MyListener->返回 a report :" + time + "ms";
	                System.out.println(msg);
	                producer.send(session.createTextMessage(msg));
	            } catch (Exception e) {
	                e.printStackTrace(System.out);
	            }
	        } else {
	        	ObjectMessage obj = (ObjectMessage)message;
	        	User u = (User) obj.getObject();
	        	System.out.println("Received  messages."+ u.toString());
	        }
		}catch(Exception e){

		}
	}

	public void run() throws JMSException {
		if(connectionFactory!=null){
			System.out.println("connectionFactory is ok");
			connection = connectionFactory.createConnection();
	        session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
	        MessageConsumer consumer = session.createConsumer(topic);
	        consumer.setMessageListener(this);
	        connection.start();

	        producer = session.createProducer(control);
	        System.out.println("Waiting for messages...");
		}
	}

	private static boolean checkText(Message m, String s) {
        try {
            return m instanceof TextMessage && ((TextMessage)m).getText().equals(s);
        } catch (JMSException e) {
            e.printStackTrace(System.out);
            return false;
        }
    }

}


package activemq.test.topic;


import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class StartListener {

	public static void main(String[] args) {
		/*开始加载spring配置文件*/
			ApplicationContext context = new ClassPathXmlApplicationContext("classpath:modules/applicationContext.xml");
			MyListener myListener= (MyListener) context.getBean("myListener");

			try {
				if(myListener!=null){
					System.out.println("success...");
				}
				myListener.run();

			} catch (Exception e) {
				e.printStackTrace();
			}
	    }

}


package activemq.test.topic;

import javax.jms.Connection;
import javax.jms.DeliveryMode;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.MessageProducer;
import javax.jms.ObjectMessage;
import javax.jms.Session;
import javax.jms.TextMessage;
import javax.jms.Topic;

import org.apache.activemq.ActiveMQConnectionFactory;

import activemq.test.model.User;

public class MyPublisher implements MessageListener {
	private ActiveMQConnectionFactory connectionFactory;
	private Connection connection;
	private Session session;
	private MessageProducer publisher;
	private Topic topic;
	private Topic control;
	private final Object mutex = new Object();

	public ActiveMQConnectionFactory getConnectionFactory() {
		return connectionFactory;
	}

	public void setConnectionFactory(ActiveMQConnectionFactory connectionFactory) {
		this.connectionFactory = connectionFactory;
	}

	public Topic getTopic() {
		return topic;
	}

	public void setTopic(Topic topic) {
		this.topic = topic;
	}

	public Topic getControl() {
		return control;
	}

	public void setControl(Topic control) {
		this.control = control;
	}


	public void onMessage(Message message) {
        synchronized (mutex) {
            System.out.println("Received report " + getReport(message) );

        }
    }

	Object getReport(Message m) {
        try {
            return ((TextMessage)m).getText();
        } catch (JMSException e) {
            e.printStackTrace(System.out);
            return e.toString();
        }
    }

	public void publish() throws Exception {
		 	User u = new User();
			u.setAge(17);
			u.setName("yuky"+System.currentTimeMillis());
			u.setSex("女");
	        // send events
			ObjectMessage obj = session.createObjectMessage();
			obj.setObject(u);
	        for (int i = 0; i < 10; i++) {
	            publisher.send(obj);
	            publisher.send(session.createTextMessage("REPORT"));
	        }
	    }

	public void run() throws Exception {
		connection = connectionFactory.createConnection();
		session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
		publisher = session.createProducer(topic);
		publisher.setDeliveryMode(DeliveryMode.NON_PERSISTENT);

		session.createConsumer(control).setMessageListener(this);
        connection.start();
	}

	public void stop() throws JMSException{
		publisher.send(session.createTextMessage("SHUTDOWN"));
		connection.stop();
        connection.close();
	}
}


package activemq.test.topic;

import javax.jms.JMSException;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class StartPublisher {
	public static void main(String[] args) throws InterruptedException {
		/*开始加载spring配置文件*/
			ApplicationContext context = new ClassPathXmlApplicationContext("classpath:modules/applicationContext.xml");
			MyPublisher publisher= (MyPublisher) context.getBean("myPublisher");
			try {
				publisher.run();
				publisher.publish();
			} catch (Exception e) {
				try {
					publisher.stop();
				} catch (JMSException e1) {
					e1.printStackTrace();
				}
				e.printStackTrace();
			}

    }
}
yuky1327
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring整合ActiveMQ（topic 详细配置步骤）
m0_46405589的博客
03-22 1297
首先和大家一起回顾一下JMS服务： 消息服务：一个中间件，用于解决两个活多个程序之间的耦合，底层由Java 实现。 优势：异步、可靠 消息模型：点对点，发布/订阅 JMS中的对象 事前说明： 这里和大家讲解一下这个配置文件，如果大家能够从上述配置文件中看懂，可以跳过。同学们也可以在ActiveMQ官网中的查看。 ActiveMq 中的DTD，我们在声明相关配置之前，我们需要先导入ActiveMq 中的DTD，不然Spring 并不理解我们的标签是什么意思。 　　　　　　　...
Spring、ActiveMQ整合——Topic模式
SnowMultiflora的博客
10-11 168
消息生产者 配置文件 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:jms="http://www.sp...
Spring整合ActiveMQ
qq_44796093的博客
01-26 365
1、创建maven工程导入响应的依赖 <packaging>jar</packaging> <dependencies> <!-- activemq核心依赖包 --> <dependency> <groupId>org.apache.activemq</groupId> <artifactId>activemq-all&l
ActiveMQ消息队列实现点对点(Queue)和发布/订阅(Topic)
zhx__的博客
08-21 4808
（Message Queue 消息队列）JMS 文章目录（Message Queue 消息队列）JMS前言一、什么是ActiveMQ？二、启动MQ三、点对点(Queue)和发布/订阅(Topic)的区别1、点对点(Queue)2、发布/订阅(Topic)3、点对点 与 发布/订阅的区别四、ActiveMQ 点对点代码实现1.消息发送者(Sender)2.消息接收者(Receiver)五、ActiveMQ 发布/订阅代码实现1.消息发布者2.消息订阅者总结 前言 JMS即Java消息服务（Java Messa
消息队列两种模式：点对点与发布订阅
Coder
02-25 2658
消息队列两种模式：点对点与发布订阅
Spring-ActiveMQ-设计文档+源码
04-11
- `ActiveMQ-service.xml`和`ActiveMQ-client.xml`：这些XML配置文件用于定义ActiveMQ服务器和客户端的相关设置，包括连接工厂、目的地（Queue或Topic）、认证和网络配置等。 - `ActiveMQ.xml`：这是ActiveMQ...
Spring和ActiveMQ的整合实例源码
09-26
6. **消息传输**：Spring支持点对点（Queue）和发布/订阅（Topic）两种模式。Queue中，消息被一个消费者接收后，其他消费者无法再收到；而Topic中，消息可以被多个订阅者接收。 7. **事务管理**：Spring的JMS支持与...
apache-activemq-5.15.0-bin.tar.7z
05-19
MQ是消息中间件，是一种在分布式系统中应用程序借以传递消息的媒介，常用的有ActiveMQ，RabbitMQ，kafka。ActiveMQ是Apache下的开源项目，完全支持JMS1.1和J2EE1.4规范的JMS ...1、点对点（queue） 2、一对多（topic）
apache-activemq-5.12.0.zip
02-24
7. **消息模式**：ActiveMQ支持点对点（Queue）、发布/订阅（Topic）等多种消息模式，满足不同场景的需求。 8. **监控与调试**：通过Web控制台（默认端口8161）可以实时查看和管理消息队列，包括查看队列长度、消息...
word变量替换含段和表格
工欲其善必先利其器
08-14 910
package jeecg.kxcomm.util; import java.io.File; import java.io.FileOutputStream; import java.io.IOException; import java.util.ArrayList; import java.util.HashMap; import java.util.List; imp...
ActiveMQ点对点及topic使用
不变的24号
01-11 989
ActiveMQ点对点及topic使用
ActiveMQ的使用与遇到的相关坑（点对点，发布与订阅,resreq）
纸上得来终觉浅,绝知此事要躬行
06-25 1万+
1、介绍 ActiveMQ是Apache出品，最流行的，能力强劲的开源消息总线。ActiveMQ 是一个完全支持JMS1.1和J2EE 1.4规范的 JMS Provider实现，尽管JMS规范出台已经是很久的事情了，但是JMS在当今的J2EE应用中间仍然扮演着特殊的地位。 MQ可以是不同应用之间进行沟通的桥梁， 支持多种语言和协议编写客户端，如: Java,C,C++,C#,Ruby,
消息队列中点对点与发布订阅区别
热门推荐
李志涛的专栏
08-17 4万+
背景知识JMS一个在 Java标准化组织（JCP）内开发的标准（代号JSR 914）。2001年6月25日，Java消息服务发布JMS 1.0.2b，2002年3月18日Java消息服务发布 1.1. Java消息服务（Java Message Service，JMS）应用程序接口是一个Java平台中关于面向消息中间件（MOM）的API，用于在两个应用程序之间，或分布式系统中发送消息，进行异步通信
ActiveMQ 点对点消息实现
jane_jojo的博客
04-01 304
第一节： 直接Receive 方式 Session.AUTO_ACKNOWLEDGE。当客户成功的从receive 方法返回的时候，或者从MessageListener.onMessage方法成功返回的时候，会话自动确认客户收到的消息。Session.CLIENT_ACKNOWLEDGE。客户通过消息的acknowledge 方法确认消息。需要注意的是，在这种模式中，确认是在会话层上进行：确认一
Activemq点对点模式
gzhorizon0825的博客
04-25 664
首先下载ActiveMQ，下载地址： http://activemq.apache.org/解压后双击对应操作系统文件夹下activemq.bat启动ActiveMQ服务，打开浏览器地址栏输入http://localhost:8161/登录服务主页，默认登录名/密码为admin/admin，可查看服务运行详细情况。 修改管理界面端口号：默认端口号为8161，打开根目录下conf文件夹jetty.
ActiveMQ实战(五)--Spring整合ActiveMQ实现点对点与主题发布订阅通信
fendo
07-23 1716
一、项目结构 二、加入Maven依赖 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 ht
分析ActiveMQ的点对点和发布/订阅二种消息传递形式
水木年华的博客
08-03 3491
ActiveMQ对于消息的传递有两种类型： 一种是点对点的，即一个生产者和一个消费者一一对应； 另一种是发布/订阅模式，即一个生产者产生消息并进行发送后，可以由多个消费者进行接收。 首先是点对点的这种消息传递，提供方演示代码如下 public void Test() throws JMSException { // 第一步：创建ConnectionFactory对象，需...
Spring整合ActiveMQ配置与实战
- Queue适合点对点通信，每个消息仅被一个消费者消费。 - Topic适合发布/订阅模式，消息可以被多个订阅者消费。 通过以上步骤，你可以构建一个基本的Spring与ActiveMQ集成系统，实现消息的发送和接收。这个系统...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值