jms双系统应用
- - 行业应用 - ITeye博客==============发送方配置（与接受方配置差别在于不要配置服务器）=======. . . . . . DataListener内容如下：.
jms双系统应用
标签：
jms
系统
应用
| 发表时间：2014-11-20 17:43 | 作者：y806839048
出处：http://www.iteye.com
==============发送方配置（与接受方配置差别在于不要配置服务器）=======
http://hellohank.iteye.com/blog/1341290
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:amq="http://activemq.org/config/1.0"
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
http://activemq.org/config/1.0 http://activemq.apache.org/schema/core/activemq-core-5.0.0.xsd">
<!-- 配置ActiveMQ服务 -->
<amq:broker useJmx="false" persistent="false">
<amq:transportConnectors>
<!-- 提供的连接方式有:VM Transport、TCP Transport、SSL Transport、
Peer Transport、UDP Transport、Multicast Transport、HTTP and HTTPS Transport、
Failover Transport、Fanout Transport、Discovery Transport、ZeroConf Transport等 -->
<amq:transportConnector uri="tcp://127.0.0.1:61616" />
</amq:transportConnectors>
</amq:broker>
<!-- 配置JMS连接工厂（注：brokerURL是关键，
它应该是上面的amq:transportConnectors里面的值之一） -->
<amq:connectionFactory id="jmsConnectionFactory"
brokerURL="tcp://127.0.0.1:61616" />
<!-- 消息发送的目的地（注：amq:queue是用于指定是发送topic不是queue，对应上面配置中的amq:destinations） -->
<amq:queue name="destination" physicalName="ossQueue" />
<!-- 创建JMS的Session生成类 -->
<bean id="jmsTemplate"
class="org.springframework.jms.core.JmsTemplate">
<property name="connectionFactory">
<bean
class="org.springframework.jms.connection.SingleConnectionFactory">
<property name="targetConnectionFactory"
ref="jmsConnectionFactory" />
</bean>
</property>
<!-- 指定发送信息时使用的消息转换类.
这个选项不填的话,默认的是:SimpleMessageConverter,它只支持4种类型的对象:String, byte[],Map,Serializable
-->
<!-- 如果加上下面这段配置就会出错, 错误原因是Book不是一个原始类, 但我已经将它继承Serializable了,可还是不行, 我想可能有其他什么原因吧, 但我现在不清楚 -->
<!-- <property name="messageConverter"
ref="resourceMessageConverter" /> -->
</bean>
<!-- 发送消息的转换类
（这个类要继承org.springframework.jms.support.converter.MessageConverter） -->
<bean id="resourceMessageConverter"
class="com.focustech.jms.ResourceMessageConverter" />
<!-- 消息生产者(通过指定目的地, 就可以同时指定其发送的消息模式是topic还是queue) -->
<bean id="resourceMessageProducer"
class="com.focustech.jms.ResourceMessageProducer">
<property name="template" ref="jmsTemplate" />
<property name="destination" ref="destination" />
</bean>
<!-- 消息接收类(这个类需要继承,当然也可以通过MessageListenerAdapter指定消息转换器来实现用户自定义的消息收发) -->
<bean id="resourceMessageListener"
class="org.springframework.jms.listener.adapter.MessageListenerAdapter">
<constructor-arg>
<bean
class="com.focustech.jms.ResourceMessageConsumer">
</bean>
</constructor-arg>
<property name="defaultListenerMethod" value="recieve" />
<!-- 自定义接收类与接收的方法 -->
<property name="messageConverter"
ref="resourceMessageConverter" />
</bean>
<!-- 消息监听容器，其各属性的意义为：
connectionFactory：指定所监听的对象，在这里就是监听连接到tcp://127.0.0.1:61616上面的ActiveMQ；
destination：监听的消息模式；
messageListener：接收者
-->
<bean id="listenerContainer"
class="org.springframework.jms.listener.DefaultMessageListenerContainer">
<property name="connectionFactory" ref="jmsConnectionFactory" />
<property name="destination" ref="destination" />
<property name="messageListener" ref="resourceMessageListener" />
</bean>
</beans>
===========接收方配置============
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:amq="http://activemq.org/config/1.0"
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
http://activemq.org/config/1.0 http://activemq.apache.org/schema/core/activemq-core-5.0.0.xsd">
<!-- 配置JMS连接工厂（注：brokerURL是关键，
它应该是上面的amq:transportConnectors里面的值之一） -->
<amq:connectionFactory id="jmsConnectionFactory"
brokerURL="tcp://127.0.0.1:61616" />
<!-- 消息发送的目的地（注：amq:queue是用于指定是发送topic不是queue，对应上面配置中的amq:destinations） -->
<amq:queue name="destination" physicalName="ossQueue" />
<!-- 创建JMS的Session生成类 -->
<bean id="jmsTemplate"
class="org.springframework.jms.core.JmsTemplate">
<property name="connectionFactory">
<bean
class="org.springframework.jms.connection.SingleConnectionFactory">
<property name="targetConnectionFactory"
ref="jmsConnectionFactory" />
</bean>
</property>
<!-- 指定发送信息时使用的消息转换类.
这个选项不填的话,默认的是:SimpleMessageConverter,它只支持4种类型的对象:String, byte[],Map,Serializable
-->
<!-- 如果加上下面这段配置就会出错, 错误原因是Book不是一个原始类, 但我已经将它继承Serializable了,可还是不行, 我想可能有其他什么原因吧, 但我现在不清楚 -->
<!-- <property name="messageConverter"
ref="resourceMessageConverter" /> -->
</bean>
<!-- 发送消息的转换类
（这个类要继承org.springframework.jms.support.converter.MessageConverter） -->
<bean id="resourceMessageConverter"
class="com.focustech.jms.ResourceMessageConverterb" />
<!-- 消息生产者(通过指定目的地, 就可以同时指定其发送的消息模式是topic还是queue) -->
<bean id="resourceMessageProducer"
class="com.focustech.jms.ResourceMessageProducerb">
<property name="template" ref="jmsTemplate" />
<property name="destination" ref="destination" />
</bean>
<!-- 消息接收类(这个类需要继承,当然也可以通过MessageListenerAdapter指定消息转换器来实现用户自定义的消息收发) -->
<bean id="resourceMessageListener"
class="org.springframework.jms.listener.adapter.MessageListenerAdapter">
<constructor-arg>
<bean
class="com.focustech.jms.ResourceMessageConsumerb">
</bean>
</constructor-arg>
<property name="defaultListenerMethod" value="recieve" />
<!-- 自定义接收类与接收的方法 -->
<property name="messageConverter"
ref="resourceMessageConverter" />
</bean>
<!-- 消息监听容器，其各属性的意义为：
connectionFactory：指定所监听的对象，在这里就是监听连接到tcp://127.0.0.1:61616上面的ActiveMQ；
destination：监听的消息模式；
messageListener：接收者
-->
<bean id="listenerContainer"
class="org.springframework.jms.listener.DefaultMessageListenerContainer">
<property name="connectionFactory" ref="jmsConnectionFactory" />
<property name="destination" ref="destination" />
<property name="messageListener" ref="resourceMessageListener" />
</bean>
</beans>
==========web.xml=====
<!-- spring配置 -->
<context-param>
<param-name>spring.profiles.default</param-name>
<param-value>development</param-value>
</context-param>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/applicationContext*.xml,classpath*:*.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
=====java===
package com.focustech.jms;
import java.io.Serializable;
public class Book implements Serializable
{
/**
*
*/
private static final long serialVersionUID = -6988445616774288928L;
long id;
String name;
String author;
public String getAuthor()
{
return author;
}
public void setAuthor(String author)
{
this.author = author;
}
public long getId()
{
return id;
}
public void setId(long id)
{
this.id = id;
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
}
package com.focustech.jms;
public class ResourceMessageConsumer
{
public void recieve(Object obj)
{
Book book = (Book) obj;
System.out.println("============qqqqq===========================");
System.out.println("receiveing message qqqq...");
System.out.println(book.toString());
System.out.println("here to invoke our business methodqqqq...");
System.out.println("====================qqq===================");
}
}
package com.focustech.jms;
import java.awt.print.Book;
import java.util.HashMap;
import java.util.Map;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.ObjectMessage;
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 ResourceMessageConverter implements MessageConverter
{
@SuppressWarnings("unchecked")
public Message toMessage(Object obj, Session session) throws JMSException, MessageConversionException
{
// check Type
if (obj instanceof Book)
{
// 采用ActiveMQ的方式传递消息
ActiveMQObjectMessage objMsg = (ActiveMQObjectMessage) session.createObjectMessage();
Map map = new HashMap();
map.put("Book", obj);
// objMsg.setObjectProperty里面放置的类型只能是:String, Map, Object, List
objMsg.setObjectProperty("book", map);
return objMsg;
}
else
{
throw new JMSException("Object:[" + obj + "] is not Book");
}
}
public Object fromMessage(Message msg) throws JMSException, MessageConversionException
{
if (msg instanceof ObjectMessage)
{
Object obj = ((ObjectMessage) msg).getObject();
return obj;
}
else
{
throw new JMSException("Msg:[" + msg + "] is not Map");
}
}
}
package com.focustech.jms;
import javax.jms.Destination;
import org.springframework.jms.JmsException;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;
public class ResourceMessageProducer
{
private JmsTemplate template;
private Destination destination;
public JmsTemplate getTemplate()
{
return template;
}
public void setTemplate(JmsTemplate template)
{
this.template = template;
}
public Destination getDestination()
{
return destination;
}
public void setDestination(Destination destination)
{
this.destination = destination;
}
public void send(Book book)
{
System.out.println("=======================================");
System.out.println("do send ......");
long l1 = System.currentTimeMillis();
template.convertAndSend(this.destination, book);
System.out.println("send time:" + (System.currentTimeMillis() - l1) / 1000 + "s");
System.out.println("=======================================");
}
}
==jsp==
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%@ page import="org.springframework.web.context.support.WebApplicationContextUtils" %>
<%@ page import="org.springframework.web.context.WebApplicationContext" %>
<%@ page import="org.springframework.jms.JmsException" %>
<%@ page import="com.focustech.jms.Book" %>
<%@ page import="com.focustech.jms.ResourceMessageProducer" %>
<%@ page import="org.springframework.web.context.support.WebApplicationContextUtils" %>
<%
try {
ServletContext servletContext = this.getServletContext();
WebApplicationContext wac = WebApplicationContextUtils.getRequiredWebApplicationContext(servletContext);
ResourceMessageProducer resourceMessageProducer = (ResourceMessageProducer) wac.getBean("resourceMessageProducer");
Book book = new Book();
book.setId(123);
book.setName("jms test!");
book.setAuthor("taofucheng");
resourceMessageProducer.send(book);
} catch (JmsException e) {
}
%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
</body>
</html>
集成事务
Spring提供的JMS的API中已经有了集成事务的功能，我们只要将上面监听容器的配置改成下面的就行了：
首先，将jmsTemplate设置成支持事务（它默认是不支持事务的）：
<bean id="jmsTemplate"
class="org.springframework.jms.core.JmsTemplate">
<property name="connectionFactory">
<bean
class="org.springframework.jms.connection.SingleConnectionFactory">
<property name="targetConnectionFactory"
ref="jmsConnectionFactory" />
</bean>
</property>
<property name="sessionTransacted" value="true"/>
</bean>
然后再在消息监听容器中设置指定的事务管理：
<bean id="listenerContainer"
class="org.springframework.jms.listener.DefaultMessageListenerContainer">
<property name="connectionFactory" ref="jmsConnectionFactory" />
<property name="destination" ref="destination" />
<property name="messageListener" ref="resourceMessageListener" />
<!—jtaTransactionManager是系统中的事务管理类，在我们的系统中，是由Spring托管的 -->
<property name="transactionManager" ref="jtaTransactionManager" />
</bean>
这样配置之后，当事务发生回滚时，消息也会有回滚，即不发送出去。
4、其它高级应用
ActiveMQ还有许多其它高级的应用，如：自动重连机制，也就是保证当通信双方或多方的链接断裂后它会根据用户的设置自动连接，以保证建立可靠的传输；另外，ActiveMQ还有其它方式嵌入到Spring中，如它可以通过xbean, file等方式建立应用；它还可以通过JMX对消息的发送与接收进行实时查看；消息的确认方式等等，还有很多高级的应用，请参考
已有 0 人发表留言，猛击->> 这里<<-参与讨论
ITeye推荐
http://hellohank.iteye.com/blog/1341290
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:amq="http://activemq.org/config/1.0"
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
http://activemq.org/config/1.0 http://activemq.apache.org/schema/core/activemq-core-5.0.0.xsd">
<!-- 配置ActiveMQ服务 -->
<amq:broker useJmx="false" persistent="false">
<amq:transportConnectors>
<!-- 提供的连接方式有:VM Transport、TCP Transport、SSL Transport、
Peer Transport、UDP Transport、Multicast Transport、HTTP and HTTPS Transport、
Failover Transport、Fanout Transport、Discovery Transport、ZeroConf Transport等 -->
<amq:transportConnector uri="tcp://127.0.0.1:61616" />
</amq:transportConnectors>
</amq:broker>
<!-- 配置JMS连接工厂（注：brokerURL是关键，
它应该是上面的amq:transportConnectors里面的值之一） -->
<amq:connectionFactory id="jmsConnectionFactory"
brokerURL="tcp://127.0.0.1:61616" />
<!-- 消息发送的目的地（注：amq:queue是用于指定是发送topic不是queue，对应上面配置中的amq:destinations） -->
<amq:queue name="destination" physicalName="ossQueue" />
<!-- 创建JMS的Session生成类 -->
<bean id="jmsTemplate"
class="org.springframework.jms.core.JmsTemplate">
<property name="connectionFactory">
<bean
class="org.springframework.jms.connection.SingleConnectionFactory">
<property name="targetConnectionFactory"
ref="jmsConnectionFactory" />
</bean>
</property>
<!-- 指定发送信息时使用的消息转换类.
这个选项不填的话,默认的是:SimpleMessageConverter,它只支持4种类型的对象:String, byte[],Map,Serializable
-->
<!-- 如果加上下面这段配置就会出错, 错误原因是Book不是一个原始类, 但我已经将它继承Serializable了,可还是不行, 我想可能有其他什么原因吧, 但我现在不清楚 -->
<!-- <property name="messageConverter"
ref="resourceMessageConverter" /> -->
</bean>
<!-- 发送消息的转换类
（这个类要继承org.springframework.jms.support.converter.MessageConverter） -->
<bean id="resourceMessageConverter"
class="com.focustech.jms.ResourceMessageConverter" />
<!-- 消息生产者(通过指定目的地, 就可以同时指定其发送的消息模式是topic还是queue) -->
<bean id="resourceMessageProducer"
class="com.focustech.jms.ResourceMessageProducer">
<property name="template" ref="jmsTemplate" />
<property name="destination" ref="destination" />
</bean>
<!-- 消息接收类(这个类需要继承,当然也可以通过MessageListenerAdapter指定消息转换器来实现用户自定义的消息收发) -->
<bean id="resourceMessageListener"
class="org.springframework.jms.listener.adapter.MessageListenerAdapter">
<constructor-arg>
<bean
class="com.focustech.jms.ResourceMessageConsumer">
</bean>
</constructor-arg>
<property name="defaultListenerMethod" value="recieve" />
<!-- 自定义接收类与接收的方法 -->
<property name="messageConverter"
ref="resourceMessageConverter" />
</bean>
<!-- 消息监听容器，其各属性的意义为：
connectionFactory：指定所监听的对象，在这里就是监听连接到tcp://127.0.0.1:61616上面的ActiveMQ；
destination：监听的消息模式；
messageListener：接收者
-->
<bean id="listenerContainer"
class="org.springframework.jms.listener.DefaultMessageListenerContainer">
<property name="connectionFactory" ref="jmsConnectionFactory" />
<property name="destination" ref="destination" />
<property name="messageListener" ref="resourceMessageListener" />
</bean>
</beans>
===========接收方配置============
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:amq="http://activemq.org/config/1.0"
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
http://activemq.org/config/1.0 http://activemq.apache.org/schema/core/activemq-core-5.0.0.xsd">
<!-- 配置JMS连接工厂（注：brokerURL是关键，
它应该是上面的amq:transportConnectors里面的值之一） -->
<amq:connectionFactory id="jmsConnectionFactory"
brokerURL="tcp://127.0.0.1:61616" />
<!-- 消息发送的目的地（注：amq:queue是用于指定是发送topic不是queue，对应上面配置中的amq:destinations） -->
<amq:queue name="destination" physicalName="ossQueue" />
<!-- 创建JMS的Session生成类 -->
<bean id="jmsTemplate"
class="org.springframework.jms.core.JmsTemplate">
<property name="connectionFactory">
<bean
class="org.springframework.jms.connection.SingleConnectionFactory">
<property name="targetConnectionFactory"
ref="jmsConnectionFactory" />
</bean>
</property>
<!-- 指定发送信息时使用的消息转换类.
这个选项不填的话,默认的是:SimpleMessageConverter,它只支持4种类型的对象:String, byte[],Map,Serializable
-->
<!-- 如果加上下面这段配置就会出错, 错误原因是Book不是一个原始类, 但我已经将它继承Serializable了,可还是不行, 我想可能有其他什么原因吧, 但我现在不清楚 -->
<!-- <property name="messageConverter"
ref="resourceMessageConverter" /> -->
</bean>
<!-- 发送消息的转换类
（这个类要继承org.springframework.jms.support.converter.MessageConverter） -->
<bean id="resourceMessageConverter"
class="com.focustech.jms.ResourceMessageConverterb" />
<!-- 消息生产者(通过指定目的地, 就可以同时指定其发送的消息模式是topic还是queue) -->
<bean id="resourceMessageProducer"
class="com.focustech.jms.ResourceMessageProducerb">
<property name="template" ref="jmsTemplate" />
<property name="destination" ref="destination" />
</bean>
<!-- 消息接收类(这个类需要继承,当然也可以通过MessageListenerAdapter指定消息转换器来实现用户自定义的消息收发) -->
<bean id="resourceMessageListener"
class="org.springframework.jms.listener.adapter.MessageListenerAdapter">
<constructor-arg>
<bean
class="com.focustech.jms.ResourceMessageConsumerb">
</bean>
</constructor-arg>
<property name="defaultListenerMethod" value="recieve" />
<!-- 自定义接收类与接收的方法 -->
<property name="messageConverter"
ref="resourceMessageConverter" />
</bean>
<!-- 消息监听容器，其各属性的意义为：
connectionFactory：指定所监听的对象，在这里就是监听连接到tcp://127.0.0.1:61616上面的ActiveMQ；
destination：监听的消息模式；
messageListener：接收者
-->
<bean id="listenerContainer"
class="org.springframework.jms.listener.DefaultMessageListenerContainer">
<property name="connectionFactory" ref="jmsConnectionFactory" />
<property name="destination" ref="destination" />
<property name="messageListener" ref="resourceMessageListener" />
</bean>
</beans>
==========web.xml=====
<!-- spring配置 -->
<context-param>
<param-name>spring.profiles.default</param-name>
<param-value>development</param-value>
</context-param>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/applicationContext*.xml,classpath*:*.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
=====java===
package com.focustech.jms;
import java.io.Serializable;
public class Book implements Serializable
{
/**
*
*/
private static final long serialVersionUID = -6988445616774288928L;
long id;
String name;
String author;
public String getAuthor()
{
return author;
}
public void setAuthor(String author)
{
this.author = author;
}
public long getId()
{
return id;
}
public void setId(long id)
{
this.id = id;
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
}
package com.focustech.jms;
public class ResourceMessageConsumer
{
public void recieve(Object obj)
{
Book book = (Book) obj;
System.out.println("============qqqqq===========================");
System.out.println("receiveing message qqqq...");
System.out.println(book.toString());
System.out.println("here to invoke our business methodqqqq...");
System.out.println("====================qqq===================");
}
}
package com.focustech.jms;
import java.awt.print.Book;
import java.util.HashMap;
import java.util.Map;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.ObjectMessage;
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 ResourceMessageConverter implements MessageConverter
{
@SuppressWarnings("unchecked")
public Message toMessage(Object obj, Session session) throws JMSException, MessageConversionException
{
// check Type
if (obj instanceof Book)
{
// 采用ActiveMQ的方式传递消息
ActiveMQObjectMessage objMsg = (ActiveMQObjectMessage) session.createObjectMessage();
Map map = new HashMap();
map.put("Book", obj);
// objMsg.setObjectProperty里面放置的类型只能是:String, Map, Object, List
objMsg.setObjectProperty("book", map);
return objMsg;
}
else
{
throw new JMSException("Object:[" + obj + "] is not Book");
}
}
public Object fromMessage(Message msg) throws JMSException, MessageConversionException
{
if (msg instanceof ObjectMessage)
{
Object obj = ((ObjectMessage) msg).getObject();
return obj;
}
else
{
throw new JMSException("Msg:[" + msg + "] is not Map");
}
}
}
package com.focustech.jms;
import javax.jms.Destination;
import org.springframework.jms.JmsException;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;
public class ResourceMessageProducer
{
private JmsTemplate template;
private Destination destination;
public JmsTemplate getTemplate()
{
return template;
}
public void setTemplate(JmsTemplate template)
{
this.template = template;
}
public Destination getDestination()
{
return destination;
}
public void setDestination(Destination destination)
{
this.destination = destination;
}
public void send(Book book)
{
System.out.println("=======================================");
System.out.println("do send ......");
long l1 = System.currentTimeMillis();
template.convertAndSend(this.destination, book);
System.out.println("send time:" + (System.currentTimeMillis() - l1) / 1000 + "s");
System.out.println("=======================================");
}
}
==jsp==
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%@ page import="org.springframework.web.context.support.WebApplicationContextUtils" %>
<%@ page import="org.springframework.web.context.WebApplicationContext" %>
<%@ page import="org.springframework.jms.JmsException" %>
<%@ page import="com.focustech.jms.Book" %>
<%@ page import="com.focustech.jms.ResourceMessageProducer" %>
<%@ page import="org.springframework.web.context.support.WebApplicationContextUtils" %>
<%
try {
ServletContext servletContext = this.getServletContext();
WebApplicationContext wac = WebApplicationContextUtils.getRequiredWebApplicationContext(servletContext);
ResourceMessageProducer resourceMessageProducer = (ResourceMessageProducer) wac.getBean("resourceMessageProducer");
Book book = new Book();
book.setId(123);
book.setName("jms test!");
book.setAuthor("taofucheng");
resourceMessageProducer.send(book);
} catch (JmsException e) {
}
%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
</body>
</html>
集成事务
Spring提供的JMS的API中已经有了集成事务的功能，我们只要将上面监听容器的配置改成下面的就行了：
首先，将jmsTemplate设置成支持事务（它默认是不支持事务的）：
<bean id="jmsTemplate"
class="org.springframework.jms.core.JmsTemplate">
<property name="connectionFactory">
<bean
class="org.springframework.jms.connection.SingleConnectionFactory">
<property name="targetConnectionFactory"
ref="jmsConnectionFactory" />
</bean>
</property>
<property name="sessionTransacted" value="true"/>
</bean>
然后再在消息监听容器中设置指定的事务管理：
<bean id="listenerContainer"
class="org.springframework.jms.listener.DefaultMessageListenerContainer">
<property name="connectionFactory" ref="jmsConnectionFactory" />
<property name="destination" ref="destination" />
<property name="messageListener" ref="resourceMessageListener" />
<!—jtaTransactionManager是系统中的事务管理类，在我们的系统中，是由Spring托管的 -->
<property name="transactionManager" ref="jtaTransactionManager" />
</bean>
这样配置之后，当事务发生回滚时，消息也会有回滚，即不发送出去。
4、其它高级应用
ActiveMQ还有许多其它高级的应用，如：自动重连机制，也就是保证当通信双方或多方的链接断裂后它会根据用户的设置自动连接，以保证建立可靠的传输；另外，ActiveMQ还有其它方式嵌入到Spring中，如它可以通过xbean, file等方式建立应用；它还可以通过JMX对消息的发送与接收进行实时查看；消息的确认方式等等，还有很多高级的应用，请参考
已有 0 人发表留言，猛击->> 这里<<-参与讨论
ITeye推荐
相关 [jms 系统 应用] 推荐：
JMS实践总结
- - 行业应用 - ITeye博客1.消息类型的选择. 2.是使用queue还是topic. 3.1 用JMS来解决并发问题. 3.2用JMS来解决分布的问题. 第二中是指消息也是分布的.很多消息中间件都提供了消息路由的功能,即消息发送到一个消息服务器后,这个消息服务器根据定义的规则再把这条消息路由转发到 其它的消息服务器.例如,可能在北京的一个数据中心部署了数据采集系统,采集到数据后以消息的方式发送到消息服务器,然后消息服务器再把这条消息路由到上 海的数据中心,再由上海数据中心部署的数据处理系统来处理这条消息.
潜入掌握JMS
- - zzm深入掌握JMS（一）：JSM基础. JMS(Java Message Service) 即Java消息服务. 它提供标准的产生、发送、接收消息的接口简化. 它支持两种消息通信模型：点到点（point-to-point）（P2P）模型和发布/订阅（Pub/Sub）模型. P2P 模型规定了一个消息只能有一个接收者;Pub/Sub 模型允许一个消息可以有多个接收者.
初涉 JMS 值得学习别人的
- - ITeye博客 JMS(Java Message
Service) 即Java消息服务. 它提供标准的产生、发送、接收消息的接口简化企业应用的开发. 它支持两种消息通信模型：点到点（point-to-point）（P2P）模型和发布/订阅（Pub/Sub）模型. P2P模型规定了一个消息只能有一个接收者;Pub/Sub
模型允许一个消息可以有多个接收者.
7.3 使用JMS实现请求/应答程序
- - 开源软件 - ITeye博客7.3 使用JMS实现请求/应答程序. 通过前面几章我们了解到,消息是用来为其发送者和接收者解耦的.消息通过一个进程发送给代理,然后. 代理在另外一个进程异步的接收消息.一种可以利用JMS来实现的系统架构被称为请求/应答.概括的说,. 一个请求/应答场景包括一个发送消息(请求)并期望接收消息返回值(应答)的应用程序.通常,这样的系统.
开源jms服务ActiveMQ的负载均衡+高可用部署方案探索
- - Java - 编程语言 - ITeye博客最近公司做项目需要用到jms消息服务，最终选择了apache的activemq这个开源消息总线，但是在activemq的官网没能找到既满足高可用又满足集群部署的方案，所以探索了其集群+高可用部署方案，经试用验证ok，这里和大家分享下. ActiveMQ 是Apache出品，最流行的，能力强劲的开源消息总线.
分布式通信的几种方式（EJB、RMI、RPC、JMS、web service杂谈）
- - CSDN博客互联网推荐文章RPC是远程过程调用协议，它是基于C/S模型调用的机制，客户机向服务器端发送调用请求等待服务器应答，是一种典型的请求应答机制，大致过程可以理解为本地分布式对象向本机发请求，不用自己编写底层通信本机会通过网络向服务器发送请求，服务器对象接受参数后，经过处理再把处理后的结果发送回客户端. 它是早期的支持分布式一些，缺点rpc是面向过程的远程调用，不支持面向对象，所以现在用的人就少了.
MacOptimizer-Mac系统优化清理应用
- - 无名小卒 Windows系统共可以使用360清理垃圾，是系统保持在一个最优状态. 同样Mac系统也需要一款优化软件. MacOptimizer 就是款 Mac 专用的最优化系统清理工具. 如果你感觉系统速度不如以前顺畅、程序常常运行缓慢，建议你用MacOptimizer来进行修复和优化. MacOptimizer 提供包括清理缓存（Cache）、优化、维护、系统设定等主要功能，最大的目标就是帮助使用者实现 Mac 系统的良好体验.