activemq-spring整合

activemq-spring整合

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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.cjw</groupId>
	<artifactId>spring-activemq</artifactId>
	<version>0.0.1-SNAPSHOT</version>

	<dependencies>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>5.1.7.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.12</version>
		</dependency>
		<dependency>
			<groupId>org.apache.activemq</groupId>
			<artifactId>activemq-all</artifactId>
			<version>5.12.1</version>
		</dependency>
		
		<dependency>
			<groupId>org.apache.xbean</groupId>
			<artifactId>xbean-spring</artifactId>
			<version>4.5</version>
			<type>bundle</type>
		</dependency>
		
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jms</artifactId>
			<version>4.3.10.RELEASE</version>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<!--bundle类型的引用,需要添加这个插件  -->
			<plugin>
				<groupId>org.apache.felix</groupId>
				<artifactId>maven-bundle-plugin</artifactId>
				<extensions>true</extensions>
			</plugin>
		</plugins>
	</build>

</project>

产品

package com.cjw.bean;

import java.io.Serializable;
import java.util.Date;

/**
 * Order Bean
 * 定义消息载体类型. 即要在ActiveMQ中传递的数据实体类型.
 * 消息载体对象必须实现接口java.io.Serializable, 因为消息需要在网络中传递,要求必须可序列化
 *
 */
public class Order implements Serializable{

	private static final long serialVersionUID = 1L;
	
	private String id;
	private String nick;
	private Long price;
	private Date createTime;
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getNick() {
		return nick;
	}
	public void setNick(String nick) {
		this.nick = nick;
	}
	public Long getPrice() {
		return price;
	}
	public void setPrice(Long price) {
		this.price = price;
	}
	public Date getCreateTime() {
		return createTime;
	}
	public void setCreateTime(Date createTime) {
		this.createTime = createTime;
	}
	public static long getSerialversionuid() {
		return serialVersionUID;
	}
	@Override
	public String toString() {
		return "Order [id=" + id + ", nick=" + nick + ", price=" + price + ", createTime=" + createTime + "]";
	}
	public Order(String id, String nick, Long price, Date createTime) {
		super();
		this.id = id;
		this.nick = nick;
		this.price = price;
		this.createTime = createTime;
	}
	public Order() {
		super();
		// TODO Auto-generated constructor stub
	}
	
}

生产者

package com.cjw.producer;


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

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

import com.cjw.bean.Order;


/**
 * ActiveMQ producer 生产者
 *
 */
public class OrderProducer {
	
//	jms模板对象
	private JmsTemplate template;
	
	public JmsTemplate getTemplate() {
		return template;
	}

	public void setTemplate(JmsTemplate template) {
		this.template = template;
	}

	/**
	 * 生产者发送消息
	 * @param destinationName  目的地名称
	 * @param order  需要发送的订单数据
	 */
	public void sendOrder(String destinationName, Order order){
		try{
			template.send(destinationName, new MessageCreator() {
				
				/**
				 * 通过模板模式暴露的方法设置发送的信息
				 */
				@Override
				public Message createMessage(Session session) throws JMSException {
					ObjectMessage objectMessage = session.createObjectMessage(order);
					return objectMessage;
				}
			});
		}catch(Exception e){
			e.printStackTrace();
			throw new RuntimeException("send order to MQ server error!!");
		}
	}
}

消费者

package com.cjw.consumer;


import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.ObjectMessage;

import com.cjw.bean.Order;

/**
 * ActiveMQ Consumer消费者
 *
 */
public class OrderConsumer implements MessageListener{

	@Override
	public void onMessage(Message message) {
		try{
			ObjectMessage objectMassage = (ObjectMessage) message;
			Order order = (Order) objectMassage.getObject();
			System.out.println("the order is : " + order);
		}catch(Exception e){
			e.printStackTrace();
		}
	}
}

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	xmlns:amq="http://activemq.apache.org/schema/core"
	xmlns:jms="http://www.springframework.org/schema/jms"
	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/jms  
        http://www.springframework.org/schema/jms/spring-jms-4.0.xsd  
        http://activemq.apache.org/schema/core  
        http://activemq.apache.org/schema/core/activemq-core-5.9.0.xsd">
    <!-- 添加扫描 -->
	<context:component-scan base-package="com.cjw.*"></context:component-scan>
	
	<!-- ActiveMQ 连接工厂 -->
	<!-- 真正可以产生Connection的ConnectionFactory,由对应的 JMS服务厂商提供 -->
	<!-- 需提供访问路径tcp://ip:61616;以及用户名,密码 -->
	<amq:connectionFactory id="amqConnectionFactory"
		brokerURL="tcp://192.168.197.130:61616" userName="admin" password="admin" />

	<!-- Spring Caching连接工厂 -->
	<!-- Spring用于管理真正的ConnectionFactory的ConnectionFactory -->
	<bean id="connectionFactory"
		class="org.springframework.jms.connection.CachingConnectionFactory">
		<!-- 目标ConnectionFactory对应真实的可以产生JMS Connection的ConnectionFactory -->
		<property name="targetConnectionFactory" ref="amqConnectionFactory"></property>
		<!-- Session缓存数量 -->
		<property name="sessionCacheSize" value="100" />
	</bean>

	<!-- 消息生产者 start -->

	<!-- 定义JmsTemplate对象. 此类型由Spring框架JMS组件提供. 用于访问ActiveMQ使用. -->
	<bean id="jmsQueueTemplate" class="org.springframework.jms.core.JmsTemplate">
		<!-- 这个connectionFactory对应的是我们定义的Spring提供的那个ConnectionFactory对象 -->
		<constructor-arg ref="connectionFactory" />
		<!-- 非pub/sub模型（发布/订阅）,即队列模式, 默认数据可省略配置 -->
		<!-- <property name="pubSubDomain" value="false" /> -->
	</bean>
	
	<!-- 定义生产者对象 -->
	<bean id="orderProducer" class="com.cjw.producer.OrderProducer">
		<!-- 为属性赋值 -->
		<property name="template" ref="jmsQueueTemplate"></property>
	</bean>
	
	<!--消息生产者 end -->

	<!-- 消息消费者 start -->

	<!-- 定义消息监听器, 此组件为spring-jms组件定义. 可以一次注册若干消息监听器.
		属性解释:
			destination-type - 目的地类型, queue代表消息队列
				可选值: queue | topic | durableTopic
				queue - 默认值. 代表消息队列
				topic - 代表消息队列集合
				durableTopic - 持久化的消息队列集合. ActiveMQ会保证消息的消费者一定接收到此消息.
			container-type - 容器类型
				可选值: default | simple
				default - 默认值. 默认容器类型, 对应DefaultMessageListenerContainer
				simple - 简单容器类型, 对应SimpleMessageListenerContainer
			connection-factory - 链接工厂, 注入的是Spring-JMS组件提供的链接工厂对象.
			acknowledge - 确认方式
				可选值: auto | client | dups-ok | transacted
				auto - 默认值, 即自动确认消息
				client - 客户端确认消息
				dups-ok - 可使用副本的客户端确认消息
				transacted - 有事务的持久化消息确认机制. 需开启对ActiveMQ的事务控制才可应用. 
	 -->
	<jms:listener-container destination-type="queue"
		container-type="default" connection-factory="connectionFactory"
		acknowledge="auto">
		<!-- 注册消息监听器. 如果需要注册多个, 重复定义下述标签. -->
		<jms:listener destination="test-spring" ref="orderReciver" />
	</jms:listener-container>
	
	<!-- 容器管理消息监听器实现类对象 -->
	<bean id="orderReciver" class="com.cjw.consumer.OrderConsumer"/>

	<!-- 消息消费者 end -->
</beans>

applicationContext.xml配置分析图

测试

package com.cjw.test;

import static org.junit.Assert.*;

import java.util.Date;

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

import com.cjw.bean.Order;
import com.cjw.producer.OrderProducer;

public class Test01 {

	/**
	 * 测试:发送对象到queue
	 */
	@Test
	public void test() {
		ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
		OrderProducer pro = ac.getBean("orderProducer",OrderProducer.class);
		Order order = new Order();
		order.setId("101");
		order.setNick("cjw");
		order.setPrice(10000L);
		order.setCreateTime(new Date());
		pro.sendOrder("test-spring", order);
	}

}

运行截图

问题

整合的配置文件，及spring与activemq结合的使用不熟悉。

项目打包

项目打包 提取码：hts4 环境：eclipse，jdk1.8，maven