SpringMVC+JMS(ActiveMQ)的小Demo

最新推荐文章于 2021-02-24 10:04:37 发布

置顶 rainorfire

最新推荐文章于 2021-02-24 10:04:37 发布

阅读量3.4k

点赞数 1

分类专栏： java 文章标签： springmvc activemq jms

本文链接：https://blog.csdn.net/rainorfire/article/details/41725235

版权

java 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

前段时间，听说公司要用JMS，就想着要未雨绸缪，就自己先了解了一番。经过一番努力，总算有点小成绩了，把环境搭了起来，结合ActiveMQ，将SpringMVC+JMS跑了起来，现分享出来，供初学者参考，如有错漏之处，请批评指正。

环境：SpringMVC+JMS+ActiveMQ

所需jar包：SpringMVC所需jar包、ActiveMQ 5.4.3、activemq-all-5.3.0.jar

步骤：1、下载ActiveMQ ，并运行

1、搭建SpringMVC工程

2、整合JMS

废话不多说，先贴代码。

首先贴控制层的：

package com.springmvc.controller;

import javax.annotation.Resource;

import org.apache.activemq.command.ActiveMQQueue;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

import com.springmvc.service.JMSProducer;

@Controller
@RequestMapping("/jms-controller")
public class JMSController {
	
	@Resource
	private JMSProducer jMSProducer;
	
	@Resource
	private ActiveMQQueue queueDestination;
	
	@Resource
	private ActiveMQQueue sessionAwareQueue;
	
	@Resource
	private ActiveMQQueue adapterQueue;
	
	@RequestMapping(value="")
	public String index(){
		return "JMS-producer";
	}
	
	@RequestMapping(value="/send")
	public String producerSendMessage(String message){
		jMSProducer.sendMessage(queueDestination, message);
		return "JMS-producer";
	}
	
	@RequestMapping(value="/sendsessionawaremessagelistenermessage")
	public String sessionAwareMessageListenerMessage(String sessionAwareMessageListenerMessage){
		jMSProducer.sendMessage(sessionAwareQueue, sessionAwareMessageListenerMessage);
		return "JMS-producer";
	}
	
	@RequestMapping(value="/sendmessagelisteneradapter")
	public String sendMessageListeneradApter(String messageListenerAdapter){
		jMSProducer.sendMessage(adapterQueue, messageListenerAdapter);
		return "JMS-producer";
	}
}

再贴服务层JMSProducerImpl ：

package com.springmvc.service.impl;

import javax.annotation.Resource;
import javax.jms.Destination;

import org.apache.activemq.command.ActiveMQQueue;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.stereotype.Service;

import com.springmvc.jms.JMSMessageCreator;
import com.springmvc.service.JMSProducer;

@Service
public class JMSProducerImpl implements JMSProducer {
	
	@Resource
	private JmsTemplate jmsTemplate;
	
	@Resource
	private ActiveMQQueue defaultResponseQueue;
	
	@Override
	public void sendMessage(Destination destination,String message) {
		// TODO Auto-generated method stub
		
		System.out.println("**********producer发送一个消息。。。。***********");
		
		JMSMessageCreator myMessageCreator = new JMSMessageCreator(message,defaultResponseQueue);
		jmsTemplate.send(destination, myMessageCreator);
		
	}

}

再贴JMSMessageCreator :

package com.springmvc.jms;

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

import org.springframework.jms.core.MessageCreator;

public class JMSMessageCreator implements MessageCreator{
	
	private Object messageInformation;
	
	private Destination responseDestination;
	
	public JMSMessageCreator(){
		
	}
	
	public JMSMessageCreator(String textMessage){
		this.messageInformation = textMessage;
	}
	
	public JMSMessageCreator(String textMessage, Destination responseDestination){
		this.messageInformation = textMessage;
		this.responseDestination = responseDestination;
	}
	
	@Override
	public Message createMessage(Session session) throws JMSException {
		// TODO Auto-generated method stub
		Message message = session.createTextMessage((String)messageInformation);
		((TextMessage)message).setJMSReplyTo(responseDestination);   
		return message;
	}

	public Object getMessageInformation() {
		return messageInformation;
	}

	public void setMessageInformation(Object messageInformation) {
		this.messageInformation = messageInformation;
	}

	public Destination getResponseDestination() {
		return responseDestination;
	}

	public void setResponseDestination(Destination responseDestination) {
		this.responseDestination = responseDestination;
	}

	
	
	
	
}

再贴JMS整合Spring的配置文件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:p="http://www.springframework.org/schema/p"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xsi:schemaLocation="
	http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
	http://www.springframework.org/schema/context 
	http://www.springframework.org/schema/context/spring-context-3.1.xsd
	http://www.springframework.org/schema/mvc 
	http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd">
	
	<!-- 真正可以产生Connection的ConnectionFactory，由对应的 JMS服务厂商提供--> 
	<bean id="targetConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">  
	    <property name="brokerURL" value="tcp://localhost:61616"/>  
	</bean> 
	
	<!-- Spring用于管理真正的ConnectionFactory的ConnectionFactory -->  
	<bean id="connectionFactory" class="org.springframework.jms.connection.SingleConnectionFactory">
		<!-- 目标ConnectionFactory对应真实的可以产生JMS Connection的ConnectionFactory -->  
    	<property name="targetConnectionFactory" ref="targetConnectionFactory"/>  
	</bean>
	
	<!-- Spring提供的JMS工具类，它可以进行消息发送、接收等 -->  
	<bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">  
	    <!-- 这个connectionFactory对应的是我们定义的Spring提供的那个ConnectionFactory对象 -->  
	    <property name="connectionFactory" ref="connectionFactory"/>  
	</bean>
	
	
	<!--这个是队列目的地，点对点的，基于-->  
	<bean id="queueDestination" name="queueDestination" class="org.apache.activemq.command.ActiveMQQueue">  
	    <constructor-arg value="queue" />  
	        <!-- <value>queue</value>  
	    </constructor-arg>   -->
	</bean>  
	
	<!--这个是主题目的地，一对多的-->  
	<bean id="topicDestination" class="org.apache.activemq.command.ActiveMQTopic">  
	    <constructor-arg value="topic"/>  
	</bean> 
	
	<!-- 消息监听器 ，类方法继承最原始的MessageListener，只能接收消息-->  
	<bean id="consumerMessageListener" class="com.springmvc.jms.JMSConsumerMessageListener"/>     
	
	<!-- 消息监听容器 -->  
	<bean id="jmsContainer"  class="org.springframework.jms.listener.DefaultMessageListenerContainer">  
	    <property name="connectionFactory" ref="connectionFactory" />  
	    <property name="destination" ref="queueDestination" />  
	    <property name="messageListener" ref="consumerMessageListener" />  
	</bean>  
	
	
	<!--这个是sessionAwareQueue目的地-->  
    <bean id="sessionAwareQueue" class="org.apache.activemq.command.ActiveMQQueue">  
        <constructor-arg value="sessionAwareQueue">  
           <!--  <value>sessionAwareQueue</value>   -->
        </constructor-arg>  
    </bean>
	
	<!-- 可以获取session的MessageListener -->  
    <bean id="consumerSessionAwareMessageListener" class="com.springmvc.jms.JMSConsumerSessionAwareMessageListener">  
      <!--   <property name="destination" ref="queueDestination"/>   -->
    </bean>
    
    <bean id="sessionAwareListenerContainer"  
        class="org.springframework.jms.listener.DefaultMessageListenerContainer">  
        <property name="connectionFactory" ref="connectionFactory" />  
        <property name="destination" ref="sessionAwareQueue" />  
        <property name="messageListener" ref="consumerSessionAwareMessageListener" />  
    </bean>  
    
    <!-- 以下配置消息监听适配器， 这种监听方式可以将消息传递给普通的java类使用，并且可以自动返回消息 -->
    
    <!-- 消息监听适配器 -->  
	<bean id="messageListenerAdapter" class="org.springframework.jms.listener.adapter.MessageListenerAdapter">  
	    <!-- <constructor-arg>  
	        <bean class="com.tiantian.springintejms.listener.ConsumerListener"/>  
	    </constructor-arg> -->  
	    <property name="delegate">  
	        <bean class="com.springmvc.jms.JMSConsumerMessageListenerAdapter"/>  
	    </property>  
	    <property name="defaultListenerMethod" value="receiveMessage"/>  
	    <property name="defaultResponseDestination" ref="defaultResponseQueue"/>  
	</bean>
	
	<!--这个adapterQueue是队列目的地，点对点的-->  
	<bean id="adapterQueue" name="adapterQueue" class="org.apache.activemq.command.ActiveMQQueue">  
	    <constructor-arg value="adapterQueue" />  
	        <!-- <value>queue</value>  
	    </constructor-arg>   -->
	</bean> 
	
	<!-- 消息监听适配器对应的监听容器 -->  
	<bean id="messageListenerAdapterContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">  
	    <property name="connectionFactory" ref="connectionFactory"/>  
	    <property name="destination" ref="adapterQueue"/>  
	    <property name="messageListener" ref="messageListenerAdapter"/><!-- 使用MessageListenerAdapter来作为消息监听器 -->  
	</bean> 
	
	<!-- defaultResponseQueue默认的消息回复队列 -->  
	<bean id="defaultResponseQueue" class="org.apache.activemq.command.ActiveMQQueue">  
	    <constructor-arg>  
	        <value>defaultResponseQueue</value>  
	    </constructor-arg>  
	</bean>
	
	<!-- defaultResponseQueue对应的监听器 -->  
	<bean id="defaultResponseQueueListener" class="com.springmvc.jms.JMSDefaultResponseQueueListener"/>  
	  
	<!-- defaultResponseQueue对应的监听容器 -->  
	<bean id="defaultResponseQueueMessageListenerContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">  
	    <property name="connectionFactory" ref="connectionFactory"/>  
	    <property name="destination" ref="defaultResponseQueue"/>  
	    <property name="messageListener" ref="defaultResponseQueueListener"/>  
	</bean> 
</beans>

再贴 JMSConsumerMessageListener :

package com.springmvc.jms;

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

public class JMSConsumerMessageListener implements MessageListener {

	@Override
	public void onMessage(Message message) {
		// TODO Auto-generated method stub
		System.out.println("----收到一个消息------------");
		try {
			System.out.println("消息是===>"+((TextMessage)message).getText());
		} catch (JMSException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}

再贴 JMSConsumerMessageListenerAdapter ：

package com.springmvc.jms;

public class JMSConsumerMessageListenerAdapter {
	
	public void receiveMessage(String message){
		System.out.println("消息配置器收到消息，消息是："+message);
	}
}

再贴 JMSConsumerSessionAwareMessageListener ：

package com.springmvc.jms;

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

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jms.listener.SessionAwareMessageListener;


public class JMSConsumerSessionAwareMessageListener implements SessionAwareMessageListener<TextMessage> {
	
	@Override
	public void onMessage(TextMessage textMessage, Session session) throws JMSException {
		// TODO Auto-generated method stub
		System.out.println("SessionAware接收到一个消息……");
		System.out.println("消息是："+textMessage.getText()+"\n");
		System.out.println("**********接收之后，发送一个收到消息*************");
		
		ApplicationContext act =   new ClassPathXmlApplicationContext("applicationContext-jms.xml");//加载applicationContext内容
		Destination queueDestination = (Destination) act.getBean("queueDestination");
		
		MessageProducer producer = session.createProducer(queueDestination);   
        Message textMessage2 = session.createTextMessage("Producer，你好！我已收到你发送之消息，接下来我将……");   
        producer.send(textMessage2);  
		
	}


}