- 浏览: 405917 次
- 性别:
- 来自: 广州
文章分类
最新评论
-
liyuanhoa_:
...
struts2.0中struts.xml配置文件详解 -
chenmingde:
...
Velocity应用(一) -
weizhikai_ai:
第二十六,当一个线程进入一个对象的一个synchronized ...
Java常见面试题(含答案) -
Aurora_lr:
...
Spring宠物商店学习笔记(一) - -
zs911zs:
all copy from http://www.iteye ...
Mule入门文档
什么是消息
消息是一个用于在组件和应用程序之间通讯的的方法。消息之间的传递是点对点的。任何终端之间都可以相互接受和发送消息。并且每个终端都必须遵守如下的规则
-> 创建消息 -> 发送消息 -> 接收消息 -> 读取消息
为什么要使用消息
理由很简单,消息是一个分布式的低耦合通讯方案。A发送一个消息到一个agent ,B作为接受者去agent上获取消息。但是A,B不需要同时到agent上去注册。agent作为一个中转为A,B提供搞效率的通讯服务。
开发者的关注点
走到这里,我也不想去解释jms spec上那些抽象且复杂的概念了,说的很白,1年多了我自己也没弄懂是个什么东西,也没时间从头到尾去仔细的看,同时我认为没必要,我所关注的是如何让jms跑起来,并且工作正常,所以spec只是个字典,当我需要用的时候才去查。
开发者的jms环境
遵守简单明了的原则,所谓jms环境只是2个对象
1> ConnectionFactory
2> Destination
通常Provider会提供JNDI的对象获取,具体方法可以去Privider的网站上搜索jndi support
下面我以jbossMq为介质跑一个简单的jms,为了保证jms的本质清晰,我没有使用jbossMq的Api,而是直接调用的jms Api.
java 代码
package com.javaeye.jms.jboss;
import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.MessageConsumer;
import javax.jms.MessageProducer;
import javax.jms.Queue;
import javax.jms.QueueSender;
import javax.jms.Session;
import javax.jms.TextMessage;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
public class JbossNativeJmsImpl {
/**
* @author zuly
*
* following jms ptp domain, use an simple text message to test
*
* A jms ptp sender will following the steps below!
* 1> get an ConnectionFactory use JNDI Lookup Or Initial it yourself
* 2> use this ConnectionFactory to start a jms connection
* [spec to jms 1.1 apito get the main idea of it ]
* 3> use connection to create a jms session
* 4> get a queue destination / messege agent
* 5> start the Producer[jms1.1 spec] by a session
* 6> get messege Object or initial it yourself by implements the messegeor
* it's sub interfaces
* 7> call sender or send it selfing
* 8> finallized the connection object or it will throw a warning to you!
*
* @param messege
* @throws NamingException
* @throws JMSException
*/
public void sendingProcessing(String messege) throws NamingException, JMSException{
Context ctx = new InitialContext();
ConnectionFactory cf = (ConnectionFactory) ctx.lookup("java:JmsXA");
Connection conn = cf.createConnection();
Session session = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
Destination dest = (Queue) ctx.lookup("queue/A");
MessageProducer msgp = session.createProducer(dest);
QueueSender sender = (QueueSender) msgp;
TextMessage msg = session.createTextMessage();
msg.setText(messege);
sender.send(msg);
conn.close();
}
/**
* @author zuly
*
* following jms ptp domain, use an simple text message to test
*
* A jms ptp retriver will following the steps below!
* 1> get an ConnectionFactory use JNDI Lookup Or Initial it yourself
* 2> use this ConnectionFactory to start a jms connection
* [spec to jms 1.1 api to get the main idea of it ]
* 3> use connection to create a jms session
* 4> get a queue destination / messege agent
* 5> retrive a consumer from session
* 6> start the jms connection to retrivte the message
* 7> get message from consumer
*
* @return textMessege
* @throws NamingException
* @throws JMSException
*/
public String retriveingProcessing() throws NamingException, JMSException{
Context ctx = new InitialContext();
ConnectionFactory cf = (ConnectionFactory) ctx.lookup("java:JmsXA");
Connection conn = cf.createConnection();
Session session = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
Destination dest = (Queue) ctx.lookup("queue/A");
MessageConsumer msgconsumer = session.createConsumer(dest);
//MessageListener ml = new JmsListenner();
//msgconsumer.setMessageListener(ml);
conn.start();
TextMessage msg = (TextMessage) msgconsumer.receive();
conn.close();
System.out.println("messege is" + msg.getText());
return msg.getText();
}
}
注意retrive函数中comment的掉的两行,消息Listener的作用是实现异步通讯,但是它有一个约定,必须和发送者
保持物理上的分离,针对于jboss而言,就要求这个Listener必须跑在容器外面。这是一个很搞的问题,每天Jms的邮件列表里面都有无数的这样的问题发过来。但是回复的人很少。我自己也从来不回复。 其实我也不清楚写这篇文章到底是出于什么目的,怕只是让这么一个简单的问题有一个回答而已。
把下面这个程序跑起来就可以异步接受消息了。
java 代码
package com.javaeye.jms.jboss;
import java.util.Properties;
import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.MessageConsumer;
import javax.jms.MessageListener;
import javax.jms.Session;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import com.javaeye.spring.services.jms.mdp.JmsListenner;
public class JbossJmsAsync {
/**
* @param args
* @throws NamingException
* @throws JMSException
*/
public static void main(String[] args) throws NamingException, JMSException {
Properties pops = new Properties();
pops.setProperty("jboss.bind.address", "0.0.0.0");
pops.setProperty("java.naming.factory.initial", "org.jnp.interfaces.NamingContextFactory");
pops.setProperty("java.naming.factory.url.pkgs", "org.jboss.naming:org.jnp.interfaces");
pops.setProperty("java.naming.provider.url", "localhost");
Context ctx = new InitialContext(pops);
ConnectionFactory cf = (ConnectionFactory) ctx.lookup("ConnectionFactory");
Connection conn = cf.createConnection();
Session session = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
Destination dest = (Destination) ctx.lookup("queue/A");
MessageConsumer msgConsumer = session.createConsumer(dest);
MessageListener ml = new JmsListenner();
msgConsumer.setMessageListener(ml);
conn.start();
}
}
javaeye的主题好像是spring,为了迎合领导,下面我把这套东西跑在spring里面。同时我发现spring对jms的包装真的简单,而且还提供了一个模版,虽然这个模版的接口是在是很罗唆。
ps:今天是第1次用spring在reference里找了半天找不到方法注入的办法,于是google了一个注入办法,不合理的地方请大家指出。首先我通过方法来注入ConnectionFactory和Destination这两个对象来支撑jms环境
java 代码
package com.javaeye.spring.services.jms.mdp;
import java.util.Properties;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.Queue;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
public class UserJmsTransactionUtil {
private String connectionFactoryJndiLookUp;
private String destinationJndiLookUp;
private String localConnectionFactoryJndiLookUp;
private String containerType;
public String getConnectionFactoryJndiLookUp() {
return connectionFactoryJndiLookUp;
}
public void setConnectionFactoryJndiLookUp(String connectionFactoryJndiLookUp) {
this.connectionFactoryJndiLookUp = connectionFactoryJndiLookUp;
}
public String getDestinationJndiLookUp() {
return destinationJndiLookUp;
}
public void setDestinationJndiLookUp(String destinationJndiLookUp) {
this.destinationJndiLookUp = destinationJndiLookUp;
}
public ConnectionFactory getConnectionFactory() throws NamingException{
Context ctx = new InitialContext();
ConnectionFactory cf = (ConnectionFactory) ctx.lookup(connectionFactoryJndiLookUp);
return cf;
}
public Destination getJmsDestination() throws NamingException{
Context ctx = new InitialContext();
Destination dest = (Queue) ctx.lookup(destinationJndiLookUp);
return dest;
}
public ConnectionFactory getQueueConnectionFactory() throws NamingException{
Properties pops = new Properties();
pops.setProperty("jboss.bind.address", "0.0.0.0");
pops.setProperty("java.naming.factory.initial", "org.jnp.interfaces.NamingContextFactory");
pops.setProperty("java.naming.factory.url.pkgs", "org.jboss.naming:org.jnp.interfaces");
pops.setProperty("java.naming.provider.url", "localhost");
Context ctx = new InitialContext(pops);
ConnectionFactory cf = (ConnectionFactory) ctx.lookup(localConnectionFactoryJndiLookUp);
return cf;
}
public Destination getLocalJmsDestination() throws NamingException{
Properties pops = new Properties();
pops.setProperty("jboss.bind.address", "0.0.0.0");
pops.setProperty("java.naming.factory.initial", "org.jnp.interfaces.NamingContextFactory");
pops.setProperty("java.naming.factory.url.pkgs", "org.jboss.naming:org.jnp.interfaces");
pops.setProperty("java.naming.provider.url", "localhost");
Context ctx = new InitialContext(pops);
Destination dest = (Destination) ctx.lookup(destinationJndiLookUp);
return dest;
}
public String getLocalConnectionFactoryJndiLookUp() {
return localConnectionFactoryJndiLookUp;
}
public void setLocalConnectionFactoryJndiLookUp(
String localConnectionFactoryJndiLookUp) {
this.localConnectionFactoryJndiLookUp = localConnectionFactoryJndiLookUp;
}
}
发送端的配置如下
xml 代码
<beans>
<bean id="userJmsUtil" class="com.javaeye.spring.services.jms.mdp.UserJmsTransactionUtil">
<property name="connectionFactoryJndiLookUp" value="java:JmsXA">property>
<property name="destinationJndiLookUp" value="queue/A">property>
<property name="localConnectionFactoryJndiLookUp" value="ConnectionFactory">property>
bean>
<bean id="connectionFactory" class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">
<property name="targetObject" ref="userJmsUtil">property>
<property name="targetMethod" value="getConnectionFactory">property>
bean>
<bean id="queue" class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">
<property name="targetObject" ref="userJmsUtil">property>
<property name="targetMethod" value="getJmsDestination">property>
bean>
<bean id="jmsQueue" class="org.springframework.jms.core.JmsTemplate">
<property name="connectionFactory" ref="connectionFactory">property>
<property name="defaultDestination" ref="queue">property>
<property name="messageConverter">
<bean class="org.springframework.jms.support.converter.SimpleMessageConverter">bean>
property>
bean>
beans>
ps:javaeye的模版工具bug还真多,不管了.
如果使用Listenner的化,一样需要遵守发送者和接收者物理隔离的原则,我的做法是把发送者配到一个xml中,在把接受者配到另外一个xml中去,发送的配置绑定到容器里,接收者的跑在本地.否则spring初始化是过不去的.
下面这个程序是发送消息的程序.使用了spring的模版,发条消息比new个对象还简单.同时spring还提供了适配器的接口,一样通过声明式的配置,这样可以在同一个接口里发送各种类型的消息了.同时支持事务,我还不知道这个有什么用呵呵,第1次使用嘛!但是就使用上来说,spring是最简单的.2者都只需要注入一个对象而已.
java 代码
@Test public void send(){
ApplicationContext ac = new FileSystemXmlApplicationContext("jms.xml");
BeanFactory bf = ac;
JmsTemplate jt = (JmsTemplate) bf.getBean("jmsQueue");
jt.convertAndSend("2132134");
}
接收端的配置如下
xml 代码
xml version="1.0" encoding="UTF-8"?>
>
<beans>
<bean id="listenner" class="com.javaeye.spring.services.jms.mdp.JmsListenner">bean>
<bean id="userJmsUtil" class="com.javaeye.spring.services.jms.mdp.UserJmsTransactionUtil">
<property name="connectionFactoryJndiLookUp" value="java:JmsXA">property>
<property name="destinationJndiLookUp" value="queue/A">property>
<property name="localConnectionFactoryJndiLookUp" value="ConnectionFactory">property>
bean>
<bean id="localConnectionFactory" class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">
<property name="targetObject" ref="userJmsUtil">property>
<property name="targetMethod" value="getQueueConnectionFactory">property>
bean>
<bean id="localDestination" class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">
<property name="targetObject" ref="userJmsUtil">property>
<property name="targetMethod" value="getLocalJmsDestination">property>
bean>
<bean id="listenerContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
<property name="concurrentConsumers" value="5">property>
<property name="connectionFactory" ref="localConnectionFactory">property>
<property name="destination" ref="localDestination">property>
<property name="messageListener" ref="listenner">property>
bean>
beans>
接收端由于需要从jbossmq里取ConnectionFactory和Destination,所以,我调用的是userJmsUtil的localLookup.这个函数的作用等同于发送者的那个函数,只不过前者是容器外获取,而后者是容器内的而已.
java 代码
package com.javaeye.spring.services.jms.mdp;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;
public class JmsListenner implements MessageListener {
public void onMessage(Message message) {
try {
TextMessage msg = (TextMessage) message;
System.out.println(msg.getText());
} catch (JMSException e) { e.printStackTrace(); }
}
}
spring对jms的整合里提到了一个jms provider ActiveMQ,要用一个开源框架要做的第一件事就是先跑一个demo起来,同样,我们要做的事还是获取ConnectionFactory和Destination对象,还好,ActiveMQ的JNDI实现比jbossMQ还要简单,直接通过一个本地的Context就可以查到了,具体的可以参照ActiveMQ官方的支持文档.
消息是一个用于在组件和应用程序之间通讯的的方法。消息之间的传递是点对点的。任何终端之间都可以相互接受和发送消息。并且每个终端都必须遵守如下的规则
-> 创建消息 -> 发送消息 -> 接收消息 -> 读取消息
为什么要使用消息
理由很简单,消息是一个分布式的低耦合通讯方案。A发送一个消息到一个agent ,B作为接受者去agent上获取消息。但是A,B不需要同时到agent上去注册。agent作为一个中转为A,B提供搞效率的通讯服务。
开发者的关注点
走到这里,我也不想去解释jms spec上那些抽象且复杂的概念了,说的很白,1年多了我自己也没弄懂是个什么东西,也没时间从头到尾去仔细的看,同时我认为没必要,我所关注的是如何让jms跑起来,并且工作正常,所以spec只是个字典,当我需要用的时候才去查。
开发者的jms环境
遵守简单明了的原则,所谓jms环境只是2个对象
1> ConnectionFactory
2> Destination
通常Provider会提供JNDI的对象获取,具体方法可以去Privider的网站上搜索jndi support
下面我以jbossMq为介质跑一个简单的jms,为了保证jms的本质清晰,我没有使用jbossMq的Api,而是直接调用的jms Api.
java 代码
package com.javaeye.jms.jboss;
import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.MessageConsumer;
import javax.jms.MessageProducer;
import javax.jms.Queue;
import javax.jms.QueueSender;
import javax.jms.Session;
import javax.jms.TextMessage;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
public class JbossNativeJmsImpl {
/**
* @author zuly
*
* following jms ptp domain, use an simple text message to test
*
* A jms ptp sender will following the steps below!
* 1> get an ConnectionFactory use JNDI Lookup Or Initial it yourself
* 2> use this ConnectionFactory to start a jms connection
* [spec to jms 1.1 apito get the main idea of it ]
* 3> use connection to create a jms session
* 4> get a queue destination / messege agent
* 5> start the Producer[jms1.1 spec] by a session
* 6> get messege Object or initial it yourself by implements the messegeor
* it's sub interfaces
* 7> call sender or send it selfing
* 8> finallized the connection object or it will throw a warning to you!
*
* @param messege
* @throws NamingException
* @throws JMSException
*/
public void sendingProcessing(String messege) throws NamingException, JMSException{
Context ctx = new InitialContext();
ConnectionFactory cf = (ConnectionFactory) ctx.lookup("java:JmsXA");
Connection conn = cf.createConnection();
Session session = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
Destination dest = (Queue) ctx.lookup("queue/A");
MessageProducer msgp = session.createProducer(dest);
QueueSender sender = (QueueSender) msgp;
TextMessage msg = session.createTextMessage();
msg.setText(messege);
sender.send(msg);
conn.close();
}
/**
* @author zuly
*
* following jms ptp domain, use an simple text message to test
*
* A jms ptp retriver will following the steps below!
* 1> get an ConnectionFactory use JNDI Lookup Or Initial it yourself
* 2> use this ConnectionFactory to start a jms connection
* [spec to jms 1.1 api to get the main idea of it ]
* 3> use connection to create a jms session
* 4> get a queue destination / messege agent
* 5> retrive a consumer from session
* 6> start the jms connection to retrivte the message
* 7> get message from consumer
*
* @return textMessege
* @throws NamingException
* @throws JMSException
*/
public String retriveingProcessing() throws NamingException, JMSException{
Context ctx = new InitialContext();
ConnectionFactory cf = (ConnectionFactory) ctx.lookup("java:JmsXA");
Connection conn = cf.createConnection();
Session session = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
Destination dest = (Queue) ctx.lookup("queue/A");
MessageConsumer msgconsumer = session.createConsumer(dest);
//MessageListener ml = new JmsListenner();
//msgconsumer.setMessageListener(ml);
conn.start();
TextMessage msg = (TextMessage) msgconsumer.receive();
conn.close();
System.out.println("messege is" + msg.getText());
return msg.getText();
}
}
注意retrive函数中comment的掉的两行,消息Listener的作用是实现异步通讯,但是它有一个约定,必须和发送者
保持物理上的分离,针对于jboss而言,就要求这个Listener必须跑在容器外面。这是一个很搞的问题,每天Jms的邮件列表里面都有无数的这样的问题发过来。但是回复的人很少。我自己也从来不回复。 其实我也不清楚写这篇文章到底是出于什么目的,怕只是让这么一个简单的问题有一个回答而已。
把下面这个程序跑起来就可以异步接受消息了。
java 代码
package com.javaeye.jms.jboss;
import java.util.Properties;
import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.MessageConsumer;
import javax.jms.MessageListener;
import javax.jms.Session;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import com.javaeye.spring.services.jms.mdp.JmsListenner;
public class JbossJmsAsync {
/**
* @param args
* @throws NamingException
* @throws JMSException
*/
public static void main(String[] args) throws NamingException, JMSException {
Properties pops = new Properties();
pops.setProperty("jboss.bind.address", "0.0.0.0");
pops.setProperty("java.naming.factory.initial", "org.jnp.interfaces.NamingContextFactory");
pops.setProperty("java.naming.factory.url.pkgs", "org.jboss.naming:org.jnp.interfaces");
pops.setProperty("java.naming.provider.url", "localhost");
Context ctx = new InitialContext(pops);
ConnectionFactory cf = (ConnectionFactory) ctx.lookup("ConnectionFactory");
Connection conn = cf.createConnection();
Session session = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
Destination dest = (Destination) ctx.lookup("queue/A");
MessageConsumer msgConsumer = session.createConsumer(dest);
MessageListener ml = new JmsListenner();
msgConsumer.setMessageListener(ml);
conn.start();
}
}
javaeye的主题好像是spring,为了迎合领导,下面我把这套东西跑在spring里面。同时我发现spring对jms的包装真的简单,而且还提供了一个模版,虽然这个模版的接口是在是很罗唆。
ps:今天是第1次用spring在reference里找了半天找不到方法注入的办法,于是google了一个注入办法,不合理的地方请大家指出。首先我通过方法来注入ConnectionFactory和Destination这两个对象来支撑jms环境
java 代码
package com.javaeye.spring.services.jms.mdp;
import java.util.Properties;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.Queue;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
public class UserJmsTransactionUtil {
private String connectionFactoryJndiLookUp;
private String destinationJndiLookUp;
private String localConnectionFactoryJndiLookUp;
private String containerType;
public String getConnectionFactoryJndiLookUp() {
return connectionFactoryJndiLookUp;
}
public void setConnectionFactoryJndiLookUp(String connectionFactoryJndiLookUp) {
this.connectionFactoryJndiLookUp = connectionFactoryJndiLookUp;
}
public String getDestinationJndiLookUp() {
return destinationJndiLookUp;
}
public void setDestinationJndiLookUp(String destinationJndiLookUp) {
this.destinationJndiLookUp = destinationJndiLookUp;
}
public ConnectionFactory getConnectionFactory() throws NamingException{
Context ctx = new InitialContext();
ConnectionFactory cf = (ConnectionFactory) ctx.lookup(connectionFactoryJndiLookUp);
return cf;
}
public Destination getJmsDestination() throws NamingException{
Context ctx = new InitialContext();
Destination dest = (Queue) ctx.lookup(destinationJndiLookUp);
return dest;
}
public ConnectionFactory getQueueConnectionFactory() throws NamingException{
Properties pops = new Properties();
pops.setProperty("jboss.bind.address", "0.0.0.0");
pops.setProperty("java.naming.factory.initial", "org.jnp.interfaces.NamingContextFactory");
pops.setProperty("java.naming.factory.url.pkgs", "org.jboss.naming:org.jnp.interfaces");
pops.setProperty("java.naming.provider.url", "localhost");
Context ctx = new InitialContext(pops);
ConnectionFactory cf = (ConnectionFactory) ctx.lookup(localConnectionFactoryJndiLookUp);
return cf;
}
public Destination getLocalJmsDestination() throws NamingException{
Properties pops = new Properties();
pops.setProperty("jboss.bind.address", "0.0.0.0");
pops.setProperty("java.naming.factory.initial", "org.jnp.interfaces.NamingContextFactory");
pops.setProperty("java.naming.factory.url.pkgs", "org.jboss.naming:org.jnp.interfaces");
pops.setProperty("java.naming.provider.url", "localhost");
Context ctx = new InitialContext(pops);
Destination dest = (Destination) ctx.lookup(destinationJndiLookUp);
return dest;
}
public String getLocalConnectionFactoryJndiLookUp() {
return localConnectionFactoryJndiLookUp;
}
public void setLocalConnectionFactoryJndiLookUp(
String localConnectionFactoryJndiLookUp) {
this.localConnectionFactoryJndiLookUp = localConnectionFactoryJndiLookUp;
}
}
发送端的配置如下
xml 代码
<beans>
<bean id="userJmsUtil" class="com.javaeye.spring.services.jms.mdp.UserJmsTransactionUtil">
<property name="connectionFactoryJndiLookUp" value="java:JmsXA">property>
<property name="destinationJndiLookUp" value="queue/A">property>
<property name="localConnectionFactoryJndiLookUp" value="ConnectionFactory">property>
bean>
<bean id="connectionFactory" class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">
<property name="targetObject" ref="userJmsUtil">property>
<property name="targetMethod" value="getConnectionFactory">property>
bean>
<bean id="queue" class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">
<property name="targetObject" ref="userJmsUtil">property>
<property name="targetMethod" value="getJmsDestination">property>
bean>
<bean id="jmsQueue" class="org.springframework.jms.core.JmsTemplate">
<property name="connectionFactory" ref="connectionFactory">property>
<property name="defaultDestination" ref="queue">property>
<property name="messageConverter">
<bean class="org.springframework.jms.support.converter.SimpleMessageConverter">bean>
property>
bean>
beans>
ps:javaeye的模版工具bug还真多,不管了.
如果使用Listenner的化,一样需要遵守发送者和接收者物理隔离的原则,我的做法是把发送者配到一个xml中,在把接受者配到另外一个xml中去,发送的配置绑定到容器里,接收者的跑在本地.否则spring初始化是过不去的.
下面这个程序是发送消息的程序.使用了spring的模版,发条消息比new个对象还简单.同时spring还提供了适配器的接口,一样通过声明式的配置,这样可以在同一个接口里发送各种类型的消息了.同时支持事务,我还不知道这个有什么用呵呵,第1次使用嘛!但是就使用上来说,spring是最简单的.2者都只需要注入一个对象而已.
java 代码
@Test public void send(){
ApplicationContext ac = new FileSystemXmlApplicationContext("jms.xml");
BeanFactory bf = ac;
JmsTemplate jt = (JmsTemplate) bf.getBean("jmsQueue");
jt.convertAndSend("2132134");
}
接收端的配置如下
xml 代码
xml version="1.0" encoding="UTF-8"?>
>
<beans>
<bean id="listenner" class="com.javaeye.spring.services.jms.mdp.JmsListenner">bean>
<bean id="userJmsUtil" class="com.javaeye.spring.services.jms.mdp.UserJmsTransactionUtil">
<property name="connectionFactoryJndiLookUp" value="java:JmsXA">property>
<property name="destinationJndiLookUp" value="queue/A">property>
<property name="localConnectionFactoryJndiLookUp" value="ConnectionFactory">property>
bean>
<bean id="localConnectionFactory" class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">
<property name="targetObject" ref="userJmsUtil">property>
<property name="targetMethod" value="getQueueConnectionFactory">property>
bean>
<bean id="localDestination" class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">
<property name="targetObject" ref="userJmsUtil">property>
<property name="targetMethod" value="getLocalJmsDestination">property>
bean>
<bean id="listenerContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
<property name="concurrentConsumers" value="5">property>
<property name="connectionFactory" ref="localConnectionFactory">property>
<property name="destination" ref="localDestination">property>
<property name="messageListener" ref="listenner">property>
bean>
beans>
接收端由于需要从jbossmq里取ConnectionFactory和Destination,所以,我调用的是userJmsUtil的localLookup.这个函数的作用等同于发送者的那个函数,只不过前者是容器外获取,而后者是容器内的而已.
java 代码
package com.javaeye.spring.services.jms.mdp;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;
public class JmsListenner implements MessageListener {
public void onMessage(Message message) {
try {
TextMessage msg = (TextMessage) message;
System.out.println(msg.getText());
} catch (JMSException e) { e.printStackTrace(); }
}
}
spring对jms的整合里提到了一个jms provider ActiveMQ,要用一个开源框架要做的第一件事就是先跑一个demo起来,同样,我们要做的事还是获取ConnectionFactory和Destination对象,还好,ActiveMQ的JNDI实现比jbossMQ还要简单,直接通过一个本地的Context就可以查到了,具体的可以参照ActiveMQ官方的支持文档.
发表评论
-
java关键字native,volatile,transient
2009-02-25 15:12 13341.volatile:为了获得最佳速度,java允许线程保存共 ... -
quartz+spring
2009-02-12 14:48 3326Quartz 是一个强大的企业级 Schedule 工具,也是 ... -
Java虚拟机(JVM)参数配置说明
2009-01-08 16:02 2490在Java、J2EE大型应用中,JVM非标准参数的配置直接关系 ... -
@SuppressWarnings 详解
2009-01-08 15:27 932@SuppressWarnings J2SE 提供的最后一个 ... -
批量反编译java类文件
2009-01-08 10:30 1532所使用的软件是 DJ Java Decompiler 3.7。 ... -
LDAP定义
2008-12-23 10:20 1151LDAP是轻量目录访问协议 ... -
JMS总结和参考资料
2008-12-22 17:33 1785结束语 第 1 页(共3 页) 本教程提供了对 Ja ... -
JMS--Pub/Sub编程
2008-12-22 17:27 1049相同又不同 第 1 页(共1 页) 附录中有这两个 ... -
JMS--Pub/Sub接口
2008-12-22 17:24 1837介绍 第 1 页(共7 页) 现在让我们来查看 Pub/s ... -
JMS点对点编程
2008-12-22 17:15 1599介绍 第 1 页(共10 页) ... -
JMS点对点接口
2008-12-22 17:03 1451介绍 第 1 页(共8 页) ... -
JMS用公用接口进行客户机编程
2008-12-22 17:01 930绍 第 1 页(共11 页) 在这一节中,我们将查看 ... -
JMS公用接口
2008-12-19 18:01 1047在这一节中,我们将介绍 JMS 客户机编程的每一个重要 JMS ... -
JMS学习教程概述
2008-12-19 17:55 3087应用程序 第 1 页(共15 页) http://liy ... -
JNDI定义
2008-12-19 09:56 1028Java术语 英文全称是:Java Naming and ... -
Java 编程的动态性,第 8 部分: 用代码生成取代反射
2008-12-18 11:52 970运行时代码生成为获得 ... -
Java 编程的动态性,第 7 部分: 用 BCEL 设计字节码
2008-12-18 11:51 1202Apache BCEL 让您深入 JVM 汇编语言进行类操作的 ... -
Java 编程的动态性,第 6 部分: 利用 Javassist 进行面向方面的更改
2008-12-18 11:50 1080用 Javassist 进行字节码 ... -
Java 编程的动态性,第 5 部分: 动态转换类
2008-12-18 11:48 1013学习如何在使用 Javassist ... -
Java 编程的动态性, 第四部分: 用 Javassist 进行类转换
2008-12-18 11:47 1018用 Javassist 转换字节码中的方法 文档 ...
相关推荐
NULL 博文链接:https://seaizon.iteye.com/blog/801927
理由很简单,消息是一个分布式的低耦合通讯方案。A发送一个消息到一个agent ,B作为接受者去agent上获取消息。但是A,B不需要同时到agent上去注册。agent作为一个中转为A,B提供搞效率的通讯服务。
JMS(JMS(JMS(JMS(JMS(JMS(JMS(JMS(JMS(JMS(JMS(JMS(JMS(JMS(JMS(JMS(JMS(JMS(JMS(JMS(JMS(JMS(JMS(JMS(JMS(JMS(JMS(JMS(JMS(JMS(JMS(JMS(JMS(JMS(JMS
Classes contained in javax.jms.jar: javax.transaction.xa.XAResource.class javax.jms.BytesMessage.class javax.jms.Message.class javax.jms.JMSException.class javax.jms.Destination.class javax.jms....
javax.jms.BytesMessage.class javax.jms.Connection.class javax.jms.ConnectionConsumer.class javax.jms.ConnectionFactory.class javax.jms.ConnectionMetaData.class javax.jms.DeliveryMode.class javax.jms....
jms工具jar包,使用jms需要的jar包(jms工具jar包,使用jms需要的jar包)
文件包含: 13个不同固件 两个固件升级工具 其中一个是量产工具可以修改休眠时间和盒子信息 TRIM检查工具 有几个固件版本为全网首发,别人没有的资源 固件列表: JMS578_00.01.00.05 ...JMS578_254.02.03.09_NoUAS
JMS学习好的帮助文档。需要的同学下载。 概述……………………………………………………………………………………………..3 体系结构………………………………………………………………………………………..4 JMS...
JMS 简介以及Weblogic配置JMS图解
JMicron JMS578 USB/SATA bridge JMS578介绍手册JMS578_Product+Brief.pdf JMS578固件(支持Android系统/linux系统) JMS578 windows的烧录工具和JMS578FwUpdate JMS578-Hardkenel-Release-v173.01.00.02-20190306....
java消息服务学习必备,JMS基础知识了解
JMS简明教程 JMS文档 JMS标准规范
三分关于jms的入门文档,适合初步了解jms的基本概念,和浅层的架构体系。
was jms配置was jms配置was jms配置was jms配置was jms配置was jms配置was jms配置was jms配置was jms配置was jms配置was jms配置was jms配置was jms配置was jms配置was jms配置was jms配置was jms配置was jms配置...
本人开发的spring jms项目,已经上线近一年了,这里是我项目jms配置文件,使用的是spring jms 整合weblogic jms。如果真的需要,请咨询我,并且附上我上传的这个配置文件,附近中没有带有这个文件,一律不作任何回答...
Jmicron JMS583 Datasheet USB 3.1 Gen 2 to PCIe Gen3x2 Bridge
JMS583编程器固件备份,用于USB-NVME的固态硬盘桥接方案。nvme USB硬盘盒JMS583方案在市面上占有率很高,出现掉固件的情况可能会有,可以用编程器烧录试试。
JMS demo 及 资料 jms入门 JMS入门级的蹩脚篇.ppt
JMS JMS Topic(1) 1.消息的生产者 import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import javax.jms.JMSException; import javax.jms.ObjectMessage; import javax...