Spring结合嵌入式ActiveMQ使用消息队列

最新推荐文章于 2024-08-14 20:05:38 发布
最新推荐文章于 2024-08-14 20:05:38 发布
阅读量2.7k 收藏 2
点赞数
分类专栏： Spring Boot 工具
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/y_f_raquelle/article/details/78115678
版权

applicationContext.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:tx="http://www.springframework.org/schema/tx"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:jpa="http://www.springframework.org/schema/data/jpa"
	xmlns:amq="http://activemq.apache.org/schema/core"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:util="http://www.springframework.org/schema/util"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
		http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/aop
		http://www.springframework.org/schema/aop/spring-aop.xsd
		http://www.springframework.org/schema/context
		http://www.springframework.org/schema/context/spring-context-3.2.xsd
		http://www.springframework.org/schema/tx
		http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
		http://www.springframework.org/schema/data/jpa
    	http://www.springframework.org/schema/data/jpa/spring-jpa.xsd
		http://www.springframework.org/schema/jms
		http://www.springframework.org/schema/jms/spring-jms-3.0.xsd
		http://activemq.apache.org/schema/core
  		http://activemq.apache.org/schema/core/activemq-core-5.1.0.xsd">
......
	<!-- Embedded ActiveMQ Broker -->
	<amq:broker id="broker" useJmx="false" persistent="false">
		<amq:transportConnectors>
			<amq:transportConnector uri="tcp://localhost:61617" />
		</amq:transportConnectors>
	</amq:broker>
	<import resource="classpath:activemq-properties.xml" />
	<import resource="classpath:activemq-jms.xml" />
</beans>
这里引入了activemq-properties.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                        http://www.springframework.org/schema/beans/spring-beans.xsd">

  <bean id="jmsProperties"
        class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"
        name="jmsProperties">
    <property name="order" value="99999" />
    <property name="systemPropertiesModeName" value="SYSTEM_PROPERTIES_MODE_OVERRIDE" />
    <property name="ignoreUnresolvablePlaceholders" value="true" />
    <property name="properties">
      <value>

        <!-- JMS -->
        JMS.BROKER.URL=tcp://localhost:61617
        JMS.QUEUE.NAME1=IN_QUEUE1
        JMS.QUEUE.NAME2=IN_QUEUE2


      </value>
    </property>
  </bean>

</beans>
和activemq-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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                        http://www.springframework.org/schema/beans/spring-beans.xsd">

  <!-- ActiveMQ connection factory -->
  <bean id="amqConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
    <constructor-arg index="0" value="${JMS.BROKER.URL}" />
  </bean>

  <!-- ConnectionFactory Definition -->
  <bean id="connectionFactory1"
        class="org.springframework.jms.connection.CachingConnectionFactory">
    <constructor-arg ref="amqConnectionFactory" />
    <property name="sessionCacheSize" value="10"></property>
  </bean>
  <bean id="connectionFactory2"
        class="org.springframework.jms.connection.CachingConnectionFactory">
    <constructor-arg ref="amqConnectionFactory" />
    <property name="sessionCacheSize" value="10"></property>
  </bean>

  <!-- Destination Queue -->
  <bean id="destinationQueue1" class="org.apache.activemq.command.ActiveMQQueue">
    <constructor-arg index="0" value="${JMS.QUEUE.NAME1}" />
  </bean>
  <bean id="destinationQueue2" class="org.apache.activemq.command.ActiveMQQueue">
    <constructor-arg index="0" value="${JMS.QUEUE.NAME2}" />
  </bean>

  <!-- Message converter -->
  <bean id="messageConv" class="com.sap.c4c.wechat.jms.MessageConverter"><!--自定义的消息转换器-->

  </bean>

  <!-- JmsTemplate Definition -->
  <!--<bean id="jmsTemplate1" class="com.sap.c4c.wechat.jms.MessageJmsTemplate">--><!--自定义的消息JMS模板，但其实没有必要，可以像下面两个那样-->
    <!--<property name="connectionFactory" ref="connectionFactory1" />-->
    <!--<property name="defaultDestination" ref="destinationQueue1" />-->
    <!--<property name="messageConverter" ref="messageConv"></property>-->
  <!--</bean>-->
  <bean id="jmsTemplate1" class="org.springframework.jms.core.JmsTemplate">
    <property name="connectionFactory" ref="connectionFactory1" />
    <property name="defaultDestination" ref="destinationQueue1" />
    <property name="messageConverter" ref="messageConv"></property>
  </bean>
  <bean id="jmsTemplate1_b" class="org.springframework.jms.core.JmsTemplate">
    <property name="connectionFactory" ref="connectionFactory1" />
    <property name="defaultDestination" ref="destinationQueue1" />
    <property name="messageConverter" ref="messageConv"></property>
  </bean>
  <bean id="jmsTemplate2" class="com.sap.c4c.wechat.jms.MessageJmsTemplate">
    <property name="connectionFactory" ref="connectionFactory2" />
    <property name="defaultDestination" ref="destinationQueue2" />
    <property name="messageConverter" ref="messageConv"></property>
  </bean>

  <!-- Message Producer -->
  <bean id="messageProducer1" class="com.sap.c4c.wechat.jms.MessageProducer1" ><!--第一种消息生产者-->
    <!--<property name="jmsTemplate">--><!--这里不定义，在类中定义-->
      <!--<list>-->
        <!--<ref bean="jmsTemplate_1" />-->
        <!--<ref bean="jmsTemplate_2" />-->
      <!--</list>-->
    <!--</property>-->
  </bean>
  <bean id="messageProducer2" class="com.sap.c4c.wechat.jms.MessageProducer2" /><!--第二种消息生产者-->

  <!-- Message Consumer -->
  <bean id="messageConsumer1" class="com.sap.c4c.wechat.jms.MessageConsumer1" /><!--第一种消息消费者-->
  <bean id="messageConsumer2" class="com.sap.c4c.wechat.jms.MessageConsumer2" /><!--第二种消息消费者-->

  <!-- Message Consumer Container -->
  <bean id="container1"
          class="org.springframework.jms.listener.DefaultMessageListenerContainer"><!--第一套消息传送-->
    <property name="connectionFactory" ref="connectionFactory1" />
    <property name="destinationName" value="${JMS.QUEUE.NAME1}" />
    <property name="messageListener" ref="messageConsumer1" />
  </bean>
  <bean id="container2"
        class="org.springframework.jms.listener.DefaultMessageListenerContainer"><!--第二套消息传送，这里允许多个第二种消费者-->
    <property name="connectionFactory" ref="connectionFactory2" />
    <property name="destinationName" value="${JMS.QUEUE.NAME2}" />
    <property name="messageListener" ref="messageConsumer2" />
    <!-- 配置多个消费者，可以是具体数值，也可以是数值区间，根据消息的规模来确定消费者的多少 -->
    <property name="concurrency" value="4-8"></property>
  </bean>

</beans>
它们都放在src/main/resources下

pom.xml相关部分

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jms</artifactId>
			<version>${org.springframework.version}</version>
		</dependency>
		<dependency>
			<groupId>org.apache.activemq</groupId>
			<artifactId>activemq-all</artifactId>
			<version>5.9.0</version>
			<!--<scope>test</scope>-->
		</dependency>
		<dependency>
			<groupId>org.apache.xbean</groupId>
			<artifactId>xbean-spring</artifactId>
			<version>3.7</version>
		</dependency>

MessageJmsTemplate

public class MessageJmsTemplate extends org.springframework.jms.core.JmsTemplate{

}

MessageConverter 

import org.springframework.jms.support.converter.MessageConversionException;

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.ObjectMessage;
import javax.jms.Session;
import java.io.Serializable;

public class MessageConverter implements org.springframework.jms.support.converter.MessageConverter{

    @Override
    public Message toMessage(Object o, Session session) throws JMSException, MessageConversionException {
        Message message=session.createObjectMessage((Serializable) o);
        int group=Integer.parseInt(((com.sap.c4c.wechat.model.Message)o).getContent());
        message.setStringProperty("JMSXGroupID","group"+group);
//        message.setIntProperty("JMSXGroupSeq", -1);
        return message;
    }

    @Override
    public Object fromMessage(Message message) throws JMSException, MessageConversionException {
        ObjectMessage objMessage = (ObjectMessage) message;
        return objMessage.getObject();
    }
}

MessageProducer1 

import com.sap.c4c.wechat.model.Message;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jms.core.JmsTemplate;

import java.util.logging.Logger;

public class MessageProducer1 {
    private static final Logger logger = Logger.getLogger(MessageProducer1.class.getName());
    @Autowired
    private JmsTemplate jmsTemplate1;
    @Autowired
    private JmsTemplate jmsTemplate1_b;

    public void sendMessageToDefaultDestination(Message message) {
        logger.info("producer1: "+message.getContent());
        if(Integer.parseInt(message.getContent())%3==0) {
            message.setContent(message.getContent() + "_b");
            jmsTemplate1_b.convertAndSend(message);
        }else
        {
            jmsTemplate1.convertAndSend(message);
        }
    }

}

MessageProducer2

import com.sap.c4c.wechat.model.Message;
import org.springframework.beans.factory.annotation.Autowired;

import java.util.logging.Logger;

public class MessageProducer2 {
    private static final Logger logger = Logger.getLogger(MessageProducer2.class.getName());
    @Autowired
    private MessageJmsTemplate jmsTemplate2;

    public void sendMessageToDefaultDestination(Message message) {
        logger.info("producer2: "+message.getContent());
        jmsTemplate2.convertAndSend(message);
    }

}

MessageConsumer1

import com.sap.c4c.wechat.model.Message;
import com.sap.c4c.wechat.service.MessageService;
import org.springframework.beans.factory.annotation.Autowired;

import javax.jms.JMSException;
import javax.jms.MessageListener;
import javax.jms.ObjectMessage;
import java.util.logging.Logger;

public class MessageConsumer1 implements MessageListener {
    private static final Logger logger = Logger.getLogger(MessageConsumer1.class.getName());
    @Autowired
    MessageService messageService;

    @Override
    public void onMessage(javax.jms.Message message) {
            try {
                ObjectMessage objMessage=(ObjectMessage) message;
                Object obj = objMessage.getObject();
                Message wechatMessage = (Message) obj;
                //TODO
                logger.info("consumer1: "+wechatMessage.getContent()+" thread-"+Thread.currentThread().getName());

            } catch (JMSException ex) {
                throw new RuntimeException(ex);
            }
    }

}

MessageConsumer2

import com.sap.c4c.wechat.model.Message;
import com.sap.c4c.wechat.service.MessageService;
import org.springframework.beans.factory.annotation.Autowired;

import javax.jms.JMSException;
import javax.jms.MessageListener;
import javax.jms.ObjectMessage;
import java.util.logging.Logger;

public class MessageConsumer2 implements MessageListener {
    private static final Logger logger = Logger.getLogger(MessageConsumer2.class.getName());
    @Autowired
    MessageService messageService;

    @Override
    public void onMessage(javax.jms.Message message) {
            try {
                ObjectMessage objMessage=(ObjectMessage) message;
                Object obj = objMessage.getObject();
                Message wechatMessage = (Message) obj;
                //TODO
                logger.info("consumer2: "+wechatMessage.getContent()+" thread-"+Thread.currentThread().getName());

            } catch (JMSException ex) {
                throw new RuntimeException(ex);
            }
    }

}

MessageController

import com.google.gson.JsonElement;
import com.google.gson.JsonParser;

import io.swagger.annotations.Api;

import org.apache.commons.io.IOUtils;
import org.apdplat.word.WordSegmenter;
import org.apdplat.word.segmentation.Word;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.List;

@RestController("ControllerV1")
@RequestMapping("/v1/message")
@Api(value="Message")
public class MessageController extends GenericController<MessageDTO, Message> {//这里的Message是一个Model，有String类型的content成员
	private static final Logger logger = LoggerFactory.getLogger(MessageController.class.getName());

	@Autowired
	private MessageProducer1 messageProducer1;
	@Autowired
	private MessageProducer2 messageProducer2;

	@RequestMapping(value = "/{id}",method = RequestMethod.GET)
	public void test(@PathVariable int id) throws Exception
	{
		Message message=new Message();
		message.setContent(id+"");
		if(id%2!=0)//odd
			messageProducer1.sendMessageToDefaultDestination(message);
		else//even
			messageProducer2.sendMessageToDefaultDestination(message);
	}
}
这样模拟实现了多个queue，多个consumer的ActiveMQ
MessageConverter使用了消息的分组，运行发现JMSGroupID相同的总是在同一个线程（同一个Consumer2）中处理。


参考链接：

http://www.jeejava.com/embedded-activemq-and-spring-jms-integration/

http://activemq.apache.org/features.html

http://activemq.apache.org/message-groups.html

http://activemq.apache.org/spring-support.html

http://activemq.apache.org/how-do-i-embed-a-broker-inside-a-connection.html

http://elim.iteye.com/blog/1900937

http://isoftyh.iteye.com/blog/1774015

https://stackoverflow.com/questions/18802982/no-declaration-can-be-found-for-element-contextannotation-config

http://coderbase64.iteye.com/blog/2065528

https://codedependents.com/2009/10/16/efficient-lightweight-jms-with-spring-and-activemq/

http://www.blogjava.net/ldd600/archive/2010/11/02/336755.html

https://stackoverflow.com/questions/30183907/activemq-how-to-programmatically-monitor-embedded-broker

http://blog.csdn.net/u010248330/article/details/62429001

http://www.360doc.com/content/16/0406/18/203871_548376577.shtml

http://www.bubuko.com/infodetail-2065759.html


yfraquelle
关注
专栏目录
SpringBoot-ActiveMQ消息列队
linksalvatore的博客
06-25 460
Spring框架为与消息传递系统的集成提供了广泛的支持，从使用JmsTemplate简化JMS API的使用，到异步接收消息的完整基础架构。Spring AMQP为高级消息队列协议提供了类似的功能集。Spring Boot还为RabbitTemplate和RabbitMQ提供了自动配置选项。SpringWebSocket本机包括对STOMP消息的支持，SpringBoot通过启动器和少量自动配置来支持这一点。Spring Boot还支持Apache Kafka。javax。jms。ConnectionFac
消息队列的简单讲解
08-17
在Java中，我们通常使用Spring AMQP库来集成RabbitMQ，通过创建`ConnectionFactory`，然后创建`Queue`和`Exchange`，最后定义`Binding`将交换机和队列绑定起来，实现消息的发送和接收。 在实际应用中，我们需要考虑...
spring+activeMQ 嵌入式配置 完整demo（包含jar包）
11-06
spring+activeMQ 嵌入式配置 完整demo（包含jar包）
Spring mvc4 + ActiveMQ 整合
weixin_34168880的博客
12-25 120
一、配置部分 二、代码部分 三、页面部分 四、Controller控制器 五、效果展示 六、加入监听器 七、最最重要的，别忘了打赏   一、配置部分 ActiveMQ的安装这就不说了，很简单， 这个例子采用maven构建，首先看一下pom.xml &lt;project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi...
嵌入式-消息队列
最新发布
m0_74969398的博客
08-14 218
1.设计一个消息队列程序,发送时,通过键盘来指定消息标识。接收时,通过键盘来指定要接收的消息。msg_snd.c文件。msg_rcv.c文件。
mq入门
chenhaiyang_ok的专栏
08-18 700
本次我将给出ActiveMQ和Spring结合使用的一个实例，在这个实例中创建了一个队列，服务端向队列中写入一条消息，客户端从队列中读取消息，并输出到控制台。为了简化问题，我们将服务端和客户端放在一个应用程序中，您完全可以将其拆分成两个程序。这种情况，相当于应用程序发送一条消息到ActiveMQ，然后ActiveMQ将消息反馈给应用程序。程序中使用的是内嵌的ActiveMQ，就是说您在使用的时候不
SOA On Tomcat专题7--内嵌activeMQ
zgyzgyzgy3338759的专栏
08-15 1189
Tomcat内嵌activeMQ是参考《ActiveMQ In Action(Manning-2011).pdf》但是失败了。后面发现是书中描述不全。现将最佳实践提炼出来。 内嵌activeMQ5.4.0，只需要： 1. 增加以下jar包 2并在context.xml中配置连接工厂和消息队列的JNDI资源，要注意brokerURL的设置，它只识别"/"。大家最
ActiveMQ 入门（三）——嵌入式 和 消息持久化方案
csdnbeyoung的博客
06-08 1151
ActiveMQ 高级用法一、嵌入式MQ 在实际开发中，如果项目没能给太多资源，而现在业务中又需要用到MQ，可以考虑嵌入式MQ，嵌入式MQ不需要安装ActiveMQ，只需要导入相关依赖就可以 1、pom文件需导入依赖：（在前两篇关于MQ的依赖的基础上导入这个依赖） <dependency> <groupId>org....
spring-boot-jms:演示如何在Spring Boot中使用嵌入式activemq并将json消息添加到队列中
04-29
在Spring Boot中如何使用嵌入式ActiveMQ代理的示例： -The example shows how to add JSON string to the queue as well. 先决条件 -Java 8 -Gradle 2.3+ 安装 运行junit $ gradle test 运行演示 $ gradle bootRun
Apache ActiveMQ Artemis.pdf
04-07
20. Maven插件、单元测试、嵌入式ActiveMQ Artemis：涵盖了如何使用Maven插件，如何进行单元测试，以及如何将ActiveMQ Artemis嵌入到应用程序中。 整体而言，ActiveMQ Artemis用户手册是一份全面的文档，旨在指导...
activeMQ的高级特性：嵌入activemq
weixin_33809981的博客
04-01 568
activemq的高级特性之嵌入式activemq 1：编写activeMQ服务 import org.apache.activemq.broker.BrokerService; import org.apache.activemq.broker.jmx.ManagementContext; /** * 编写activemq的服务 */ public class Em...
ActiveMQ学习笔记之四--启动嵌入式Broker（纯代码方式）
08-02
NULL 博文链接：https://sswh.iteye.com/blog/1974156
spring 整合activemq实现自定义动态消息队列
04-18
百度spring整合activemq 发现几乎都只是在xml文件配置固定的消息队列而且太麻烦。并没有根据需求进行动态生成主题和队列。本文档参考了纯粹的activemq java代码和百度上的demo，很简洁的实现了动态消息队列的生成和获取，但是没有自定义监听（当前项目不需要），本文档只有功能实现类 即业务层。若要调用和推送 则需要自己根据需求编写。此处提供参考价值。 activemq下载文件中有一个demo 包含所有jar包。此处就不上传了。
轻量级嵌入式MQDataCarrier.zip
07-17
DataCarrierDataCarrier 是轻量级，嵌入式，高流通量，发布订阅模式的 MQ.特点订阅式 MQ. 支持多商家与多用户。轻量级与嵌入式，jdk1.6.中的迷你Java库。高流通量， 用于 Sky-Walking APM。产生异步数据。使用简单，简洁 API. 标签：DataCarrier
Active MQ 高级特性和用法（一）：内嵌Active MQ、Active MQ的各种持久化方式、消息（Topic）的持久化订阅
weixin_43519048的博客
02-28 2287
Active MQ 高级特性和用法（一）内嵌Active MQ、Active MQ的各种持久化方式、消息（Topic）的持久化订阅
Spring Integration介绍
Dead_Knight的专栏
05-29 221
关于Spring Integration的介绍，这里提供几个引用片段： 一、infoQ上的Spring Integration入门文章 http://www.infoq.com/cn/articles/Spring-Integration-Joshua-Long Spring Integration是Spring框架创建的又一个API，面向企业应用集成（EAI）。说到集成，并不缺“解决办法”...
Spring整合ActiveMQ 之 ActiveMQ配置
weixin_30840573的博客
07-29 149
1.依赖 <!-- ActiveMQ客户端完整jar包依赖 --> <dependency> <groupId>org.apache.activemq</groupId> <artifactId>activemq-all</artifactId> <version>5...
java 内嵌调用_技术大咖分享：Java消息中间件之ActiveMQ详解
weixin_39907289的博客
11-20 228
ActiveMQ是什么？ActiveMQ 是Apache出品，最流行的、能力强劲的开源消息总线。ActiveMQ 是一个完全支持JMS1.1和J2EE 1.4规范的 JMS Provider实现,尽管JMS规范出台已经是很久的事情了,但是JMS在当今的J2EE应用中间仍然扮演着特殊的地位。主要特点：1、多种语言和协议编写客户端。语言: Java, C, C++, C#, Ruby, Pe...
Spring Boot 2.0.3 集成 ActiveMQ 5.15.4 与 内嵌启动 ActiveMQ 服务
蚩尤后裔-汪茂雄
10-12 3548
目录 ActiveMQ 5.15.4 集成 Spring Boot 2.0.3 pom.xml 依赖 application.yml 配置 @JmsListener 接收消息 JmsTemplate 发送消息 运行测试 内嵌启动 ActiveMQ 服务 ActiveMQ 5.15.4 集成 Spring Boot 2.0.3 1、SpringBoot 提供了对 JMS 的支持，对...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值