spring的jms:用spring的JmsTemplate发送和接收消息 .

Spring是一个完整的J2EE框架和解决方案，完整并且模块化，你可以用的他的全部也可以只用他的一部分特性，Spring 包含 IoC, AOP, 事务处理，ORM, 也包括一个简单的MVC框架.

用Spring，自我感觉，可以使你的代码至少节约30%，它的很多template很不错的，比如简单封装后的jdbctemplate,jmstemplate等。

ioc用后就会爱不释手，它让你的代码风格完全改观。以前我要产生个对象，绝大多数时候只回想到new一个对象，而用spring的ioc，beanfactory，只需要配置一个xml文件即可。这种方式实现了松偶合，对单元测试非常有利。

还有它的aop，也是很不错的，

用spring的感觉,正如它的名字一样：如沐春风.

关于spring中的jms,最近一个项目用到,刚好研究了一下,在这里做一个整理备份.在此感谢同事Eric的帮助.

spring把jms进行了简单的封装,用它的JmsTemplate可以很方便的发送和接收消息,并且资源的管理都由template来管理了.

1:在web.xml文件中配置一个spring用的上下文:

<context-param>

<param-name>contextConfigLocation</param-name>

<param-value>

/WEB-INF/jmsconfig.xml

</param-value>

</context-param>
jmsconfig.xml用来装配jms,内容如下:

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE beans PUBLIC "-//SPRING/DTD BEAN/EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>

<bean id="jmsConnectionFactory"

class="org.springframework.jndi.JndiObjectFactoryBean">

<property name="jndiName">

<value>jms/Ntelagent/RequestQCF</value>

</property>

</bean>

<bean id="destination"

class="org.springframework.jndi.JndiObjectFactoryBean">

<property name="jndiName">

<value>jms/Ntelagent/RequestQ</value>

</property>

</bean>

<bean id="jmsConnectionFactoryForReceive"

class="org.springframework.jndi.JndiObjectFactoryBean">

<property name="jndiName">

<value>jms/Ntelagent/ResponseQCF</value>

</property>

</bean>

<bean id="destinationForReceive"

class="org.springframework.jndi.JndiObjectFactoryBean">

<property name="jndiName">

<value>jms/Ntelagent/ResponseQ</value>

</property>

</bean>

<bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate102">

<property name="connectionFactory">

<ref bean="jmsConnectionFactory"/>

</property>

<property name="defaultDestination">

<ref bean="destination"/>

</property>

<property name="messageConverter">

<ref bean="jmsTrxConverter"/>

</property>

<property name="receiveTimeout">

<value>1</value>

</property>

</bean>

<bean id="jmsTemplateForReceive" class="org.springframework.jms.core.JmsTemplate102">

<property name="connectionFactory">

<ref bean="jmsConnectionFactoryForReceive"/>

</property>

<property name="defaultDestination">

<ref bean="destinationForReceive"/>

</property>

<property name="messageConverter">

<ref bean="jmsTrxConverter"/>

</property>

<property name="receiveTimeout">

<value>1</value>

</property>

</bean>

<bean id="jmsTrxConverter" class="co.transport.jms.JmsTransactionConverter">

<property name="rspQueue">

<ref bean="destinationForReceive"/>

</property>

</bean>

<bean id="jmsRequestTransport" class="co.transport.jms.JmsRequestTransport">

<property name="jmsTemplate">

<ref bean="jmsTemplate"/>

</property>

<property name="jmsTemplateForReceive">

<ref bean="jmsTemplateForReceive"/>

</property>

</bean>

</beans>

其中:

jmsConnectionFactory为jms连接工厂,属性jndiName的value为server服务配置的jndi名称.

destination为消息队列,属性jndiName为消息队列的jndi名称.

jmsTemplate为配置spring消息模版:采用JmsTemplate102(如果你的JMS实现符合JMS规范1.1版，则应该使用JmsTemplate)，其中的messageConverter属性配置了一个消息转换器，因为通常消息在发送前和接收后都需要进行一个前置和后置处理，转换器便进行这个工作。

由于我的sendQueue很receiveRueue是不同的queue，所以我配置了两个jmsTemplate：

jmsTemplateForReceive负责接收消息,jmsTemplate负责发发送消息.

发送消息的代码很简单:

jmsTemplate.convertAndSend(request);

接收消息也很简单:

Object obj = jmsTemplate.receiveAndConvert();

如果需要用一个过滤器接收特定的消息,则:

Object obj = this.jmsTemplateForReceive.receiveSelectedAndConvert(this.messageSelector);

发送和接收消息的class如下:

public class JmsRequestTransport implements RequestTransport {

private JmsTemplate jmsTemplate;

private JmsTemplate jmsTemplateForReceive;

private String messageSelector;

private String destinationName;

public void setJmsTemplate(JmsTemplate template){

this.jmsTemplate = template;

}

public void request(Object request) {

jmsTemplate.convertAndSend(request);

}

public Object receive() {

System.out.println("in JmsRequestTransport: destinationName = " + this.jmsTemplateForReceive.getDefaultDestinationName());

System.out.println("in JmsRequestTransport: messageSelector = " + messageSelector);

Object obj = this.jmsTemplateForReceive.receiveSelectedAndConvert(this.messageSelector);

return obj;

}

public String getMessageSelector() {

return messageSelector;

}

public void setMessageSelector(String string) {

messageSelector = string;

}

public String getDestinationName() {

return destinationName;

}

public void setDestinationName(String string) {

destinationName = string;

}

public JmsTemplate getJmsTemplateForReceive() {

return jmsTemplateForReceive;

}

public void setJmsTemplateForReceive(JmsTemplate template) {

jmsTemplateForReceive = template;

}

}

要实现一个消息转换器,只需要实现MessageConverter接口,MessageConverter很简单,它只有两个方法需要实现:

public Object fromMessage(Message msg){}

public Message toMessage(Object obj, Session session) throws JMSException{}

fromMessage为接收消息后,对消息进行的转换(通常是把一个message转化为一个Object对象)

toMessage为发送消息前需要的转化(通常为把一个Object转化为一个message对象)

我的JmsTransactionConverter转换器如下:

public class JmsTransactionConverter implements MessageConverter {

private Queue rspQueue;

public JmsTransactionConverter(){}

public Object fromMessage(Message msg){

MessageBean msgBean = new MessageBean();

TextMessage massage = (TextMessage)msg;

try {

String str = massage.getText();

msgBean.setHead("HeadTest");

msgBean.setOutput(str);

msgBean.setStatus("success");

} catch (JMSException e) {

// TODO Auto-generated catch block

msgBean = null;

e.printStackTrace();

}

finally {

return msgBean;

}

}

public Message toMessage(Object obj, Session session) throws JMSException{

String s = (String)obj;

TextMessage message = session.createTextMessage(s);

message.setStringProperty("mytype","java");

return message;

}

public Queue getRspQueue() {

return rspQueue;

}

public void setRspQueue(Queue queue) {

rspQueue = queue;

}

}

其中:MessageBean是一个简单javabean:

public class MessageBean {

private String head;

private String output;

private String status;

public String getHead() {

return head;

}

public String getOutput() {

return output;

}

public String getStatus() {

return status;

}

public void setHead(String string) {

head = string;

}

public void setOutput(String string) {

output = string;

}

public void setStatus(String string) {

status = string;

}

}

然后就可以用两个servlet来测试发送和接收消息:

发送消息:

public class JMSTestServlet extends HttpServlet {

/**

* @see javax.servlet.http.HttpServlet#void (javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)

*/

public void doPost(HttpServletRequest req, HttpServletResponse resp)

throws ServletException, IOException

{

doGet(req, resp);

}

public void doGet(HttpServletRequest req, HttpServletResponse resp)

throws ServletException, IOException{

ServletOutputStream out = resp.getOutputStream();

try {

ServletContext servletContext = this.getServletContext();

WebApplicationContext wac = WebApplicationContextUtils.getRequiredWebApplicationContext(servletContext);

JmsRequestTransport transport = (JmsRequestTransport)wac.getBean("jmsRequestTransport");

System.out.println("in JMSTestServlet.doGet:begin send message");

String messageToSend = req.getParameter("message");

if(messageToSend == null)

{

messageToSend = "Default Message";

}

transport.request(messageToSend);

String s = "in JMSTestServlet.doGet:after send message and message is: " + messageToSend;

out.println("<HTML><BODY>");

out.println(s);

out.println("<br><input type=button name=back value=back onclick=history.back()>");

out.println("<br><a href=receiveServlet>receive</a>");

out.println("</HTML></BODY>");

} catch(Exception e) {

out.println("<HTML><BODY>");

out.println(e.toString());

out.println("</HTML></BODY>");

}

}

接收消息:

public class receiveServlet extends HttpServlet {

/**

* @see javax.servlet.http.HttpServlet#void (javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)

*/

public void doPost(HttpServletRequest req, HttpServletResponse resp)

throws ServletException, IOException

{

doGet(req, resp);

}

public void doGet(HttpServletRequest req, HttpServletResponse resp)

throws ServletException, IOException {

ServletOutputStream out = resp.getOutputStream();

String selector = req.getParameter("selector");

String distination = req.getParameter("distination");

try {

String s = "nothing";

ServletContext servletContext = this.getServletContext();

WebApplicationContext wac = WebApplicationContextUtils.getRequiredWebApplicationContext(servletContext);

JmsRequestTransport transport = (JmsRequestTransport)wac.getBean("jmsRequestTransport");

System.out.println("selector = " + selector);

System.out.println("distination = " + distination);

transport.setDestinationName(distination);

transport.setMessageSelector(selector);

Object obj = transport.receive();

if(obj != null) {

MessageBean msgBean = (MessageBean)obj;

//System.out.println("in receiveServlet:");

s = "receive the message is: " + msgBean.getHead() + "," +

msgBean.getOutput() + ", " +

msgBean.getStatus();

} else {

s = "there is no message where " + selector;

}

out.println("<HTML><BODY>");

out.println(s);

out.println("<br>selector is :" + selector);

out.println("<br>distination is :" + distination);

out.println("<br><a href=jsp/sendMessage.jsp>sendMessage</a>");

out.println("</HTML></BODY>");

} catch(Exception e) {

out.println("<HTML><BODY>");

out.println("<br>selector is :" + selector);

out.println("<br>distination is :" + distination);

out.println("<br>" + e.toString());

out.println("</HTML></BODY>");

}

}

}