activeMQ 特点、实战

最新推荐文章于 2024-08-01 11:25:20 发布
最新推荐文章于 2024-08-01 11:25:20 发布
阅读量955 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/slipknotM_/article/details/41013859
版权

ActiveMQ 是Apache出品，最流行的，能力强劲的开源消息总线。ActiveMQ 是一个完全支持JMS1.1和J2EE 1.4规范的 JMS Provider实现,尽管JMS规范出台已经是很久的事情了,但是JMS在当今的J2EE应用中间仍然扮演着特殊的地位。

主要特点：

1. 多种语言和协议编写客户端。语言: Java, C, C++, C#, Ruby, Perl, Python, PHP。应用协议: OpenWire,Stomp REST,WS Notification,XMPP,AMQP

2. 完全支持JMS1.1和J2EE 1.4规范 (持久化,XA消息,事务)

3. 对Spring的支持,ActiveMQ可以很容易内嵌到使用Spring的系统里面去,而且也支持Spring2.0的特性

4. 通过了常见J2EE服务器(如 Geronimo,JBoss 4, GlassFish,WebLogic)的测试,其中通过JCA 1.5 resource adaptors的配置,可以让ActiveMQ可以自动的部署到任何兼容J2EE 1.4 商业服务器上

5. 支持多种传送协议:in-VM,TCP,SSL,NIO,UDP,JGroups,JXTA

6. 支持通过JDBC和journal提供高速的消息持久化

7. 从设计上保证了高性能的集群,客户端-服务器,点对点

8. 支持Ajax

9. 支持与Axis的整合

10. 可以很容易得调用内嵌JMS provider,进行测试


task_dest为发送端的消息队列，接收端监听执行后将执行结果反回给defaultResponseQueue，发送端接收后根据参数保存数据库。两个项目的交互

applicationContext-jms.xml

<?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:context="http://www.springframework.org/schema/context"
	xmlns:jdbc="http://www.springframework.org/schema/jdbc" xmlns:jee="http://www.springframework.org/schema/jee"
	xmlns:tx="http://www.springframework.org/schema/tx" xmlns:jpa="http://www.springframework.org/schema/data/jpa"
	xsi:schemaLocation="
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
		http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-4.0.xsd
		http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-4.0.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
		http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd"
	default-lazy-init="true">


	<bean id="jmsConnectionFactory" class="org.apache.activemq.pool.PooledConnectionFactory">
		<property name="connectionFactory">
			<bean class="org.apache.activemq.ActiveMQConnectionFactory">
				<property name="brokerURL" value="tcp://192.168.1.100:61616" />
				<property name="closeTimeout" value="60000" />
				<!--<property name="userName" value="admin" /> -->
				<!--<property name="password" value="admin" /> -->
				<!--<property name="optimizeAcknowledge" value="true" /> -->
			</bean>
		</property>
	</bean>

	<!-- Spring JMS Template -->
	<bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
		<property name="connectionFactory">
			<ref bean="jmsConnectionFactory" />
		</property>
	</bean>


	<!--视频通道：发送消息目的地 -->
	<bean id="task_dest" name="task_dest" class="org.apache.activemq.command.ActiveMQTopic">
		<constructor-arg index="0">
			<value>task_dest</value>
		</constructor-arg>
	</bean>
	
<!-- 	<bean id="messageConverter" class="com.eciyuanjie.task.jms.converter.ObjectMessageConverter"/> -->
	
	<!--queue通道：消息回复目的地 -->
	<bean id="defaultResponseQueue" name="defaultResponseQueue" class="org.apache.activemq.command.ActiveMQQueue">
		<constructor-arg index="0">
			<value>defaultResponseQueue</value>
		</constructor-arg>
	</bean>
	
	<!-- 消息回复监听器 -->  
	<bean id="defaultResponseListener" class="com.eciyuanjie.task.jms.listener.ResponseListener"/> 
	
	<!-- 消息回复监听容器 -->
	<bean id="responseListenerContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
		<property name="connectionFactory" ref="jmsConnectionFactory" />
		<property name="destination" ref="defaultResponseQueue" />
		<property name="messageListener" ref="defaultResponseListener" />
	</bean>
	
	<bean id="jmsServiceImpl" class="com.eciyuanjie.task.jms.service.impl.JmsServiceImpl"></bean>
</beans>
一端只需配置一个发送目的地标签，回复是接收别的项目的回复信息

ResponseListener

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;

import org.springframework.beans.factory.annotation.Autowired;

import com.eciyuanjie.task.service.TaskLogService;

public class ResponseListener implements MessageListener {
	
	@Autowired
	private TaskLogService taskLogService;
	
	@Override
	public void onMessage(Message message) {
		
		if(message instanceof TextMessage){
			TextMessage msg = (TextMessage)message;
			try {
				
				System.out.println("返回内容：-----------"+msg.getText());
				String []args = msg.getText().split("_");
				taskLogService.update(Integer.parseInt(args[2]));
			} catch (JMSException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

}

发送代码 

((JmsService) ApplicationContextHolder.getBean("jmsServiceImpl")).sendTextMessage(MessageType.task_info, ""+className+"_"+methodName+"_"+taskId);

MessageType是自己定义的枚举

public enum MessageType {
task_info
}

发送方法接口 

import java.io.Serializable;
import java.util.Map;

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

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;

import com.eciyuanjie.task.constants.MessageType;
import com.eciyuanjie.task.jms.service.JmsService;

/**
 * @ClassName: JmsServiceImpl
 * @Description: TODO(消息队列服务)
 * @author Wei Xing
 * @date 2014年10月31日 下午2:44:22
 * 
 */
@Component
public class JmsServiceImpl implements JmsService {
	
	private static Log logger = LogFactory.getLog(JmsServiceImpl.class);

	@Autowired
	private JmsTemplate jmsTemplate;
	
	@Autowired
	@Qualifier("task_dest")
	private Destination destinationVideoTask;

	/**
	 * @Title: sendTextMessage
	 * @Description: TODO(发送Text消息)
	 * @author Wei Xing
	 * @param messageType
	 * @param message
	 * @throws
	 * @date 2014年10月31日 下午5:36:48
	 */
	@Override
	public void sendTextMessage(MessageType messageType, final String message) {
		Destination destination = null;
		logger.debug("messageType: " + messageType);
		logger.debug("message: " + message);
//		switch (messageType) {
//		case video_submit_topic:
			destination = this.destinationVideoTask;
//			break;
//		case seo_update_topic:
//			destination = this.destinationSeoTopic;
//			break;
//		}
		logger.debug("destination: " + destination);
		jmsTemplate.send(destination, new MessageCreator() {
			public Message createMessage(Session session) throws JMSException {
				return session.createTextMessage(message);
			}
		});
	}

	/**
	 * @Title: sendMapMessage
	 * @Description: TODO(发送Map消息)
	 * @author Wei Xing
	 * @param messageType
	 * @param message
	 * @throws
	 * @date 2014年10月31日 下午5:36:48
	 */
	@Override
	public void sendMapMessage(MessageType messageType, final Map<String, Object> message) {
		Destination destination = null;
//		switch (messageType) {
//		case video_submit_topic:
			destination = this.destinationVideoTask;
//			break;
//		case seo_update_topic:
//			destination = this.destinationSeoTopic;
//			break;
//		}
		jmsTemplate.send(destination, new MessageCreator() {
			public Message createMessage(Session session) throws JMSException {
				MapMessage MapMessage = session.createMapMessage();
				for (Map.Entry<String, Object> entry : message.entrySet()) {
					MapMessage.setObject((String) entry.getKey(), entry.getValue());
				}
				return MapMessage;
			}
		});
	}

	/**
	 * @Title: sendBytesMessage
	 * @Description: TODO(发送Bytes消息)
	 * @author Wei Xing
	 * @param messageType
	 * @param message
	 * @throws
	 * @date 2014年10月31日 下午5:36:48
	 */
	@Override
	public void sendBytesMessage(MessageType messageType, final byte[] message) {
		Destination destination = null;
//		switch (messageType) {
//		case video_submit_topic:
			destination = this.destinationVideoTask;
//			break;
//		case seo_update_topic:
//			destination = this.destinationSeoTopic;
//			break;
//		}
		jmsTemplate.send(destination, new MessageCreator() {
			public Message createMessage(Session session) throws JMSException {
				BytesMessage bytesMessage = session.createBytesMessage();
				bytesMessage.writeBytes(message);
				return bytesMessage;
			}
		});
	}

	/**
	 * @Title: sendObjectMessage
	 * @Description: TODO(发送Object消息)
	 * @author Wei Xing
	 * @param messageType
	 * @param message
	 * @throws
	 * @date 2014年10月31日 下午5:36:48
	 */
	@Override
	public void sendObjectMessage(MessageType messageType, final Serializable message) {
		Destination destination = null;
//		switch (messageType) {
//		case video_submit_topic:
			destination = this.destinationVideoTask;
//			break;
//		case seo_update_topic:
//			destination = this.destinationSeoTopic;
//			break;
//		}
		jmsTemplate.send(destination, new MessageCreator() {
			public Message createMessage(Session session) throws JMSException {
				return session.createObjectMessage(message);
			}
		});
	}

接收端application-jms.xml 

<?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:context="http://www.springframework.org/schema/context"
	xmlns:jdbc="http://www.springframework.org/schema/jdbc" xmlns:jee="http://www.springframework.org/schema/jee"
	xmlns:tx="http://www.springframework.org/schema/tx" xmlns:jpa="http://www.springframework.org/schema/data/jpa"
	xsi:schemaLocation="
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
		http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-4.0.xsd
		http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-4.0.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
		http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd"
	default-lazy-init="true">


	<bean id="jmsConnectionFactory" class="org.apache.activemq.pool.PooledConnectionFactory">
		<property name="connectionFactory">
			<bean class="org.apache.activemq.ActiveMQConnectionFactory">
				<property name="brokerURL" value="tcp://192.168.1.100:61616" />
				<property name="closeTimeout" value="60000" />
				<!--<property name="userName" value="admin" /> -->
				<!--<property name="password" value="admin" /> -->
				<!--<property name="optimizeAcknowledge" value="true" /> -->
			</bean>
		</property>
	</bean>

	<!-- Spring JMS Template -->
	<bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
		<property name="connectionFactory">
			<ref bean="jmsConnectionFactory" />
		</property>
	</bean>
	
	
	<!--视频通道：发送消息目的地 -->
	<bean id="task_dest" name="task_dest" class="org.apache.activemq.command.ActiveMQTopic">
		<constructor-arg index="0">
			<value>task_dest</value>
		</constructor-arg>
	</bean>
	
	<!--queue通道：消息回复目的地 -->
	<bean id="defaultResponseQueue" name="defaultResponseQueue" class="org.apache.activemq.command.ActiveMQQueue">
		<constructor-arg index="0">
			<value>defaultResponseQueue</value>
		</constructor-arg>
	</bean>
	
	<!--计划任务消息接收监听器 --> 
	<bean id="taskMessageListener" class="org.springframework.jms.listener.adapter.MessageListenerAdapter">
		<constructor-arg>
			<bean class="com.eciyuanjie.jms.listener.TaskMessageListener" />
		</constructor-arg>
		<property name="defaultListenerMethod" value="receiveMessage"/>
		<property name="defaultResponseDestination" ref="defaultResponseQueue"/>
	</bean>
	
	<!--视频消息接收监听容器，多线程异步接受消息 -->
	<bean id="taskJmsContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
		<property name="connectionFactory" ref="jmsConnectionFactory" />
		<property name="destination" ref="task_dest"/>
		<property name="messageListener" ref="taskMessageListener" />
		<property name="sessionTransacted" value="false" />
	</bean>
</beans>

task_dest为发送端的消息队列，接收端执行后将执行结果反回给defaultResponseQueue，发送端接收后根据参数保存数据库


import java.lang.reflect.Method;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.Autowired;

import com.eciyuanjie.data.video.service.VideoService;
import com.eciyuanjie.jms.service.JmsService;
import com.eciyuanjie.utils.ApplicationContextHolder;

/**
 * @ClassName: VideoMessageListener
 * @Description: TODO(视频消息监听器)
 * @author Wei Xing
 * @date 2014年11月3日 下午3:04:57
 * 
 */
public class TaskMessageListener {
	
	@Autowired
	private VideoService videoService;
	
	@Autowired
	private JmsService jmsService;
	
	/**
	 * @Title: handleMessage
	 * @Description: TODO(String)
	 * @author Wei Xing
	 * @param message
	 * @throws
	 * @date 2014年11月3日 下午3:04:57
	 */
	public String receiveMessage(String message) {
			
			String []args = message.split("_");
			
			
			try {
				Class targetClass = Class.forName(args[0]);
				Object object =  ApplicationContextHolder.getApplicationContext().getBean(targetClass);
				
				Method method = targetClass.getMethod(args[1]);
				method.invoke(object, new Object[]{});
			} catch (BeansException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (Exception e) {
				e.printStackTrace();
			}			
			
	<span style="white-space:pre">		System.out.println("--------------------视频任务已执行-------------------"+message);
<span style="white-space:pre">			</span>return args[0]+"_"+ args[1]+"_"+args[2];</span>}}




slipknotM_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Apache ActiveMQ实战(1)-基本安装配置与消息类型
lifetragedy的专栏
07-06 3万+
ActiveMQ是一种开源的，实现了JMS1.1规范的，面向消息(MOM)的中间件，为应用程序提供高效的、可扩展的、稳定的和安全的企业级消息通信。ActiveMQ使用Apache提供的授权，任何人都可以对其实现代码进行修改。 ActiveMQ的设计目标是提供标准的，面向消息的，能够跨越多语言和多系统的应用集成消息通信中间件。ActiveMQ实现了JMS标准并提供了很多附加的特性。这些附加的特性包括，JMX管理（java Management Extensions，即java管理扩展），主从管理（master
ActiveMQ in Active
06-10
总结来说，《ActiveMQ in Action》是一本实操性的书籍，它不仅详细介绍了ActiveMQ的基本概念和特点，还通过实例演示了如何配置和使用ActiveMQ，是希望深入学习和使用ActiveMQ的开发者的宝贵资源。文档通过大量的实战...
ActiveMQ 高级特性
summer85的博客
03-21 161
  异步发送消息生产者使用持久（persistent）传递模式发送消息的时候，Producer.send() 方法会被阻塞，直到 broker 发送一个确认消息给生产者，这个确认消息暗示生产者 broker 已经成功地将它发送的消息路由到目标目的并把消息保存到二级存储中。这个过程通常称为同步发送。但有一个例外，当发送方法在一个事物上下文中时，被阻塞的是 commit 方法而不是 send 方法。...
Activemq优点和缺点
热门推荐
霍少爷的专栏
09-16 1万+
activemq有自己的特点和优势： （1）activemq可以很好的运行在任何JVM上，而不只是集成到JBoss的应用服务器中； （2）activemq支持大量的跨语言客户端； （3）activemq支持许多不同的协议，如Ajax，REST，Stomp，OpenWire，XMPP （4）activemq支持许多高级功能，例如MessageGroups，ExclusiveConsumer，
消息队列中间件 - ActiveMQ关键特性与工作原理
最新发布
逍遥Sean的博客
08-01 686
Apache ActiveMQ 是一个完全支持 JMS（Java Message Service）规范的消息代理软件。它采用了基于消息队列的异步通信模型，能够在分布式系统中可靠地传递消息。ActiveMQ 提供了多种通信协议，包括 OpenWire、STOMP、AMQP 和 MQTT，使得它可以与不同类型的客户端和应用程序集成。广泛的协议支持：ActiveMQ 支持多种通信协议，包括 OpenWire、STOMP、AMQP 和 MQTT，使得它可以与不同类型的客户端和应用程序集成。高可靠性。
ActiveMQ4.1 +Spring2.0的POJO JMS方案
花钱的年华
12-04 167
 作者：cctvx1，calvin 1.概述 1.1 JMS与ActiveMQ特性      JMS始终在JavaEE五花八门的协议里，WebService满天飞的时候占一位置，是因为： 它可以把不影响用户执行结果又比较耗时的任务（比如发邮件通知管理员）异步的扔给JMS 服务端去做，而尽快的把屏幕返还给用户。 服务端能够多线程排队响应高并发的请求。 可以在Java世界...
ActiveMQ特性_01
村里的原振侠的博客
08-10 348
ActiveMQ 特性 本文为本人开ActiveMQ官方文档所做笔记，翻译可能受限于水平，比较粗糙。本翻译文档的集合我已经上传到github上 Active Groups Active Groups 是一个动态协作框架，因此简化了组员之间消息传递和共享状态 Active Groups 包含以下： 动态成员信息 广播信息 点对点 盒内（in boxes） 分布状态（distributed state “Map”） Map改变监听器 写锁 锁过期 可选状态和锁去除，当一个成员离开 自动状态和锁复制以及防失败（
activeMQ特性与代码使用讲解
嘎嘎的博客
07-30 8500
首先看一下在java程序里面是如何利用jmsAPI使用activeMQ的
activeMq 实战
10-30
### ActiveMQ 实战 #### JMS 基本构件概览 **ActiveMQ** 是一个高性能、功能丰富的开源消息中间件，它实现了 **Java Message Service (JMS)** 规范。JMS 规范定义了一组接口，这些接口提供了一个标准的方式来进行...
2019实战ActiveMQ集群与应用实战视频教程
04-03
本视频教程通过实战的方式介绍了 ActiveMQ 的集群搭建与应用，涵盖了从基础概念到实际部署的全过程。通过学习这些知识点，不仅可以帮助开发者深入了解 ActiveMQ 的工作原理，还能够掌握如何在实际项目中有效地利用 ...
Activemq的常用特性
czr19900428的博客
12-27 486
个人整理了些在日常开发中遇到的一些mq的使用特性，做一个小整理（只整理了日常中自己遇到的）客户端特色消息传送模式（deliveryMode）ActiveMQ支持两种消息传送模式：PERSISTENT和NON_PERSISTENT两种。 传送模式分别为： 1． DeliveryMode.PERSISTENT 2． DeliveryMode.NON_PERSISTENT消息优先级（priori
高可用、可扩展、稳定和安全的消息队列ActiveMQ特点分析
weixin_34032792的博客
05-20 181
ActiveMQ是Apache软件基金下的一个开源软件。是目前能力强劲、应用广泛的开源消息总线之一。它为企业消息传递提供高可用、出色性能、可扩展、稳定和安全保障。ActiveMQ的目标是在尽可能多的平台和语言上提供一个标准的、消息驱动的应用集成。 ActiveMQ特点 ActiveMQ具备如下特点： 多种语言的支持：Java、C、C++、Python、PHP、Perl、.NET等。 多种协议的...
浅谈对ActiveMQ的理解
Smile_Miracle的博客
05-19 4163
现如今项目开发过程中由于功能多，流程长，机制繁多且复杂，让一个线程去跑完一个业务的整个流程的话会显得非常繁琐且耦合性太强，代码量很大，这个时候我们就可以用到一款技术叫做消息队列，我们可以通过定义好发送消息的模式以及一些其他数据，就可以在一个业务有很多流程的时候通过发送消息的形式让队列通知消息消费者去完成一些操作，比如说数据的存储与修改等，这样无形之中就把一个大业务拆分成了很多小的业务的组合体，实现了
5.1源码解析Handler
万子的博客
07-21 234
为什么要使用Handler 将工作线程需操作UI的消息 传递 到主线程，使得主线程可根据工作线程的需求 更新UI，从而避免线程操作不安全的问题 首先正常Handler写法 1，创建Handler对象 private Handler mHandler = new Handler() { @Override public void handleMessage(Message msg) { switch (msg.what) { case: ..
ActiveMQ学习笔记-消息特性
05-20 2070
ActiveMQ消息属性 消息属性 属性名 类型 默认值 描述 JMSDestination javax.jms.Destination 生产者set进去 发送消息目的地 JMSReplyTo javax.jms.Destination null 用户定义 JMSType String “” 用户定义
ActiveMQ简介
BryantLmm的博客
10-26 501
title:ActiveMQ简介date：2017年10月19日18:51:18ActiveMQ是最大的开源组织Apache推出的开源的，完全支持JMS1.1和J2EE1.4规范的JMS Provider实现的消息中间件（MOM,message oriented middleware）。ActiveMQ能做什么：实现JMS Provider,用来帮助实现高可用，高性能，可伸缩，易用和安全的企业级面向
常见消息队列：ActiveMQ、RabbitMQ、RocketMQ、Kafka的区别总结
qq_30713721的博客
02-02 2355
常见消息队列：ActiveMQ、RabbitMQ、RocketMQ、Kafka的区别。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值