关闭

基于spring整合activeMQ以及点对点队列的封装

标签: springJAVAMQ
35人阅读 评论(0) 收藏 举报
分类:

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

     配置文件内容
     

  <!-- 队列服务配置项 -->
  	<!-- 配置JMS连接工厂-->
	<bean id="connectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
		<!--将该值开启官方说法是可以取得更高的发送速度(5倍)-->
	    <property name="useAsyncSend" value="true" />  
	   <!-- 对于一个connection如果只有一个session,该值有效,否则该值无效,默认这个参数的值为true。-->
       <property name="alwaysSessionAsync" value="true" />  
   		 <property name="useDedicatedTaskRunner" value="true" />  
		<property name="brokerURL" value="tcp://localhost:61616"/>
	</bean>
	
	
	
  <!--消息转换-->
     <bean id="messageConverter" class="cn.com.do1.component.ability.polycost.common.ObjectMessageConverter"/>
	
  	<!--Spring提供的JMS工具类,它可以进行消息发送、接收等  --> 
	<bean id="jmsTemplate" name="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
		
		<property name="connectionFactory" ref="connectionFactory" />
		<property name="receiveTimeout" value="10000" />
		<!-- <property name="defaultDestination" ref="queueDestination" />-->
		<!--pubSubDomain false表示是队列 --> 
        <property name="pubSubDomain" value="false" />
         <!-- 类转换  --> 
   		 <property name="messageConverter" ref="messageConverter"></property> 
	</bean>
	<!-- 队列服务配置项  end-->
由于activemq传对象消息需要进行转化,所以,要配置一个消息转化器,注意:传对象消息,对象必须进行序列化。

消息转化器代码:

package cn.com.do1.component.ability.polycost.common;
import java.io.Serializable;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.Session;

import org.apache.activemq.command.ActiveMQObjectMessage;
import org.springframework.jms.support.converter.MessageConversionException;
import org.springframework.jms.support.converter.MessageConverter;

public class ObjectMessageConverter implements MessageConverter{

	@Override
	public Message toMessage(Object object, Session session)
			throws JMSException, MessageConversionException {  
        ActiveMQObjectMessage msg = (ActiveMQObjectMessage) session.createObjectMessage();
        msg.setObject((Serializable) object);
        return msg; 
     }


	@Override
	public Object fromMessage(Message message) throws JMSException,
			MessageConversionException {
		 Object object = null;
         if(message instanceof ActiveMQObjectMessage){
             ActiveMQObjectMessage aMsg = (ActiveMQObjectMessage) message; 
             object=(Object) aMsg.getObject();
         }
        return object;  
	}

}

以上就配置了消息链接工厂以及接受处理消息的jms模板,接下来封装生产者,代码如下:

package cn.com.do1.component.ability.polycost.common;


import javax.jms.Connection;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.Session;
import javax.jms.TextMessage;
import org.apache.commons.lang3.RandomStringUtils;
import org.springframework.jms.JmsException;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;
public class BaseProducer {
	
	private JmsTemplate jmsTemplate;
	private String queueName;
	
	public BaseProducer(String queueName,JmsTemplate jmsTemplate) {
		super();
		this.queueName = queueName;
		this.jmsTemplate=jmsTemplate;
		
	}

	public String getQueueName() {
		return queueName;
	}

	public void setQueueName(String queueName) {
		this.queueName = queueName;
	}
	/**
	 * 发送文本消息
	 * @param txtMsg  发送普通文本消息
	 * @param isReply 设置是否发送的是应答消息,true发送repMsg,false发送txtMsg。
	 * @param repMsg 应答消息
	 * */
	public void sendTxtMsg(final String txtMsg, final Boolean isReply,final String repMsg){
	 try {
		Connection connection=	jmsTemplate.getConnectionFactory().createConnection();
		 Session session=connection.createSession(Boolean.TRUE,  
		                Session.AUTO_ACKNOWLEDGE);//消息队列设置自动应答,不需要客户端调用ACKNOWLEDGE来确认消费了消息。
		 final Destination destination=session.createQueue(queueName); // 如果该队列不存在就创建消息队列,否则就连接队列  
		 jmsTemplate.send(destination, new MessageCreator() {
			@Override
			public Message createMessage(Session session) throws JMSException {
				// TODO Auto-generated method stub
				if(isReply){
					 	String correlationId = RandomStringUtils.randomNumeric(5);  
					 	TextMessage message =session.createTextMessage(repMsg);
						message.setJMSReplyTo(destination);//设置回复消息的目的地
						message.setJMSCorrelationID(correlationId);  //设置回复队列消息的id
						return message;
				}
				return session.createTextMessage(txtMsg);
			}
		});
	} catch (JmsException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	} catch (JMSException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
	 
	}
	/**
	 * 发送对象消息*/
	public void sendObjMsg(Object message){
		try {
			Connection connection=	jmsTemplate.getConnectionFactory().createConnection();
			 Session session=connection.createSession(Boolean.TRUE,  
			                Session.AUTO_ACKNOWLEDGE);
			 Destination destination=session.createQueue(queueName); // 如果该队列不存在就创建消息队列,否则就连接队列  
			 jmsTemplate.convertAndSend(destination, message);
		} catch (JmsException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (JMSException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	/**发送对象消息并等待应答
	 * message:发送的消息内容
	 * reciveQueueName:接受应答消息的队列名
	 * */
	public String sendMsgAndRecive(Object message,String reciveQueueName){
		String replyMsg = null;
		try {
			Connection connection=	jmsTemplate.getConnectionFactory().createConnection();
			 Session session=connection.createSession(Boolean.TRUE,  
			                Session.AUTO_ACKNOWLEDGE);
			 Destination destination=session.createQueue(queueName); //如果该队列不存在就创建消息队列,否则就连接队列  
			 jmsTemplate.convertAndSend(destination, message);
			// 发送之后,等待那边发送确认消息  
			 Destination recall_destination=session.createQueue(reciveQueueName); 
			 TextMessage textMsg=(TextMessage) jmsTemplate.receive(recall_destination); 
			 replyMsg=textMsg.getText();
		} catch (JmsException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (JMSException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		 return replyMsg;
	}
}

上面代码封装了生产者的发送普通消息,发送对象消息,发送点对点应答消息,三种模式的生产者。调用代码如下,以应答模式为例:

BaseProducer producer =new BaseProducer("polycost.jhs.queue", jmsTemplate);
String msg=producer.sendMsgAndRecive(orderPO, "jhs.orderReply.queue");
msg就是接受消费者消费消息后的回复消息。

接下来就是配置监听器,配置文件如下:

<bean id="orderListener" class="cn.com.do1.component.ability.polycost.listener.OrderListener" />
	<bean id="orderListenerAdapter" class="org.springframework.jms.listener.adapter.MessageListenerAdapter">
		<property name="delegate" ref="orderListener" />
	</bean>
	<bean class="org.springframework.jms.listener.DefaultMessageListenerContainer">
		<property name="connectionFactory" ref="connectionFactory" />
		<property name="destinationName" value="polycost.jhs.queue" /> <!-- 需要监听的队列-->
		<property name="messageListener" ref="orderListenerAdapter" />
		<property name="sessionTransacted" value="true" />
		<property name="concurrentConsumers" value="1"/><!-- 表示开启一个线程去消费-->
	</bean>


到此,整个基于spring的整合activeMQ就完成了,可以通过 new 封装的生产者,在不同的模块中调用队列服务,配置文件中只需要配置自己模块的监听器就可以了。


0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:1975次
    • 积分:72
    • 等级:
    • 排名:千里之外
    • 原创:5篇
    • 转载:2篇
    • 译文:0篇
    • 评论:0条
    文章分类