首先可以到网站上下载最新的openjms版本，然后启动bin下的startup.bat就启动服务了，然后可以启动admin.bat进入管理界面（非必要步骤），然后分别运行samples下的basic例子就可以看到效果了，当然以前有篇文章介绍的不错，可以参考一下，不过时间上比较老了，做为参考还是可以的。
　　介绍开源的JMS服务器openJms，及怎样使用openJms来构建系统之间健全、高度可用的通从而简化企业级应用的开发。 openJms符合SUN的JMS API 1.0.2规范，支持消息队列，还支持消息传递的发布/订阅模式，本文先就系统服务的搭建及JMS的非结构化消息发送和接收进行说明。
　　JMS 有五种消息类型。三种结构化或半结构化的消息类型（MapMessage、ObjectMessage 和 StreamMessage）以及两种非结构化的或自由格式的消息类型（TextMessage 和 BytesMessage）。而这里虽然我们只对非结构化消息进行说明，但非结构化的消息格式却能够更好地进行交互操作，因为它们在消息上很少利用结构，在此基础上与XML再进行结合，将能方便的进行更好的扩展，XML相关简化操作参考《Jaxb来实现Java-XML的转换》。
　　下面具体来介绍服务器搭建，在http://openjms.sourceforge.net/downloads.html下载openJms，解压后可以直接使用，在 “openjms-0.7.6.1“bin 里，有openJms的运行脚本，执行 startup 启动，弹出一个新的窗口，服务就运行在新窗口内，shutdown 为停止命令：
　　服务运行后，就可以开始使用JMS服务了，至此服务搭建完毕，简单得不能再简单了。
　　下面是消息发送和接收的开发，开发中需要的jar包在“openjms-0.7.6.1“lib里可以找到：
　　openjms-0.7.6.1.jar
　　jms-1.0.2a.jar
　　exolabcore-0.3.7.jar
　　commons-logging-1.0.3.jar
　　把上面的类包加入到项目中，下面是消息发送服务的代码：
　　package javayou.demo.openjms;
　　import java.util.*;
　　import javax.jms.*;
　　import javax.naming.*;
　　public class QueueSend {
　　public static void main(String args) {
　　try {
　　//取得JNDI上下文和连接
　　Hashtable properties = new Hashtable();
　　properties.put(
　　Context.INITIAL_CONTEXT_FACTORY，
　　"org.exolab.jms.jndi.InitialContextFactory");
　　//openJms默认的端口是1099
　　properties.put(Context.PROVIDER_URL，
　　"rmi://localhost:1099/");
　　Context context = new InitialContext(properties);
　　//获得JMS信息连接队列工厂
　　QueueConnectionFactory queueConnectionFactory =
　　(QueueConnectionFactory) context.lookup(
　　"JmsQueueConnectionFactory");
　　//获得JMS信息连接队列
　　QueueConnection queueConnection =
　　queueConnectionFactory.createQueueConnection();
　　//产生队列Session，设置事务为false，自动应答消息接收
　　QueueSession queueSession =
　　queueConnection.createQueueSession(
　　false，
　　Session.AUTO_ACKNOWLEDGE);
　　//获得默认内建在JMS里的队列之一：queue1
　　Queue queue = (Queue) context.lookup("queue1");
　　//产生JMS队列发送器
　　QueueSender queueSender =
　　queueSession.createSender(queue);
　　//发送数据到JMS
　　TextMessage message = queueSession.createTextMessage();
　　message.setText("Hello， I‘m openJms.");
　　queueSender.send(message);
　　System.out.println(
　　""信息写入JMS服务器队列");
　　//以下做清除工作，代码略
　　// ... ...
　　} catch (Exception e) {
　　e.printStackTrace();
　　}
　　}
　　}
　　执行程序发
　　送消息，然后打开JMS控制台，用 admin 命令启动管理平台，菜单Actions－Connections－online，出现界面
　　可以看到JSM默认的队列queue1里已经有1条消息了，而其他的队列还是空着的。
　　下面我们来看看消息接收服务的代码：
　　package javayou.demo.openjms;
　　import java.util.*;
　　import javax.jms.*;
　　import javax.naming.*;
　　public class QueueReceiveSynchronous {
　　public static void main(String args) {
　　try {
　　//取得JNDI上下文和连接
　　Hashtable properties = new Hashtable();
　　properties.put(
　　Context.INITIAL_CONTEXT_FACTORY，
　　"org.exolab.jms.jndi.InitialContextFactory");
　　properties.put(Context.PROVIDER_URL，
　　"rmi://localhost:1099/");
　　Context context = new InitialContext(properties);
　　//获得JMS信息连接队列工厂
　　QueueConnectionFactory queueConnectionFactory =
　　(QueueConnectionFactory) context.lookup(
　　"JmsQueueConnectionFactory");
　　//获得JMS信息连接队列
　　QueueConnection queueConnection =
　　queueConnectionFactory.createQueueConnection();
　　//启动接收队列线程
　　queueConnection.start();
　　//产生队列Session，设置事务为false，自动应答消息接收
　　QueueSession queueSession =
　　queueConnection.createQueueSession(
　　false，
　　Session.AUTO_ACKNOWLEDGE);
　　//获得默认内建在JMS里的队列之一：queue1
　　Queue queue = (Queue) context.lookup("queue1");
　　//产生JMS队列接收器
　　QueueReceiver queueReceiver =
　　queueSession.createReceiver(queue);
　　//通过同步的方法接收消息
　　Message message = queueReceiver.receive();
　　String messageText = null;
　　if (message instanceof TextMessage)
　　messageText = ((TextMessage) message).
　　getText();
　　System.out.println(messageText);
　　//以下做清除工作，代码略
　　// ... ...
　　} catch (Exception e) {
　　e.printStackTrace();
　　}
　　}
　　}
　　编译后运行接收信息服务，可以看到接收到并打印之前发送的消息，再看看控制台，发现queue1的消息队列变为0，消息已被读取，消息发送和接收到此结束。
　　上篇openJms介绍 (一) 提到了openJms的构建及消息的发送和接收，这篇主要了解消息的发布和订阅。JMS 的发布/订阅模型定义了如何向一个内容节点发布和订阅消息，内容节点也叫主题(topic)，主题是为发布者(publisher)和订阅者 (subscribe) 提供传输的中介。发布/订阅模型使发布者和订阅者之间不需要直接通讯（如RMI）就可保证消息的传送，有效解决系统间耦合问题（当然有这个需要才行），还有就是提供了一对一、一对多的通讯方式，比较灵活。
　　先介绍JMS里2个概念，持久订阅模式和非持久订阅模式，其实也是发布/订阅模型在可靠性上提供的2种方式：
　　非持久订阅模式：只有当客户端处于激活状态，也就是和JMS 服务器保持连接的状态下，才能接收到发送到某个Topic的消息，而当客户端处于离线状态时，则这个时间段发到Topic的消息将会永远接收不到。
　　持久订阅模式：客户端向JMS 注册一个识别自己身份的ID，当这个客户端处于离线时，JMS 服务器会为这个ID 保存所有发送到主题的消息，当客户再次连接到JMS 服务器时，会根据自己的ID 得到所有当自己处于离线时发送到主题的消息，即消息永远能接收到。
　　下面我们就接着来看openJms在发布/订阅模式上的表现，由于篇幅关系，在这里只讲述非持久订阅模式，持久订阅模式可以根据JMS的标准来试。
　　消息发布的代码
　　package javayou.demo.openjms;
　　import java.util.*;
　　import javax.jms.*;
　　import javax.naming.*;
　　public class TopicPublish {
　　public static void main(String args) {
　　try {
　　//取得JNDI上下文和连接
　　Hashtable properties = new Hashtable();
　　properties.put(
　　Context.INITIAL_CONTEXT_FACTORY，
　　"org.exolab.jms.jndi.InitialContextFactory");
　　//openJms默认的端口是1099
　　properties.put(Context.PROVIDER_URL， "rmi://localhost:1099/");
　　Context context = new InitialContext(properties);
　　//获得JMS Topic连接队列工厂
　　TopicConnectionFactory factory =
　　(TopicConnectionFactory) context.lookup(
　　"JmsTopicConnectionFactory");
　　//创建一个Topic连接，并启动
　　TopicConnection topicConnection = factory.createTopicConnection();
　　topicConnection.start();
　　//创建一个Topic会话，并设置自动应答
　　TopicSession topicSession =
　　topicConnection.createTopicSession(false，
　　Session.AUTO_ACKNOWLEDGE);
　　//lookup 得到 topic1
　　Topic topic = (Topic) context.lookup("topic1");
　　//用Topic会话生成Topic发布器
　　TopicPublisher topicPublisher = topicSession.createPublisher(topic);
　　//发布消息到Topic
　　System.out.println("消息发布到Topic");
　　TextMessage message = topicSession.createTextMessage
　　("你好，定购Topic类消息");
　　topicPublisher.publish(message);
　　//资源清除，代码略 ... ...
　　} catch (NamingException e) {
　　e.printStackTrace();
　　} catch (JMSException e) {
　　e.printStackTrace();
　　}
　　}
　　}
　　而订阅消息的接收有同步的和异步2种，他们分别使用receive()和onMessage(Message message)方法来接收消息，具体代码：
　　同步接收：
　　package javayou.demo.openjms;
　　import java.util.*;
　　import javax.jms.*;
　　import javax.naming.*;
　　public class TopicSubscribeSynchronous {
　　public static void main(String args) {
　　try {
　　System.out.println("定购消息接收启动：");
　　//取得JNDI上下文和连接
　　Hashtable properties = new Hashtable();
　　properties.put(Context.INITIAL_CONTEXT_FACTORY，
　　"org.exolab.jms.jndi.InitialContextFactory");
　　properties.put(Context.PROVIDER_URL， "rmi://localhost:1099/");
　　Context context = new InitialContext(properties);
　　//获得Topic工厂和Connection
　　TopicConnectionFactory factory =
　　(TopicConnectionFactory) context.lookup(
　　"JmsTopicConnectionFactory");
　　TopicConnection topicConnection = factory.createTopicConnection();
　　topicConnection.start();
　　//创建Topic的会话，用于接收信息
　　TopicSession topicSession =
　　topicConnection.createTopicSession(
　　false，
　　Session.AUTO_ACKNOWLEDGE);
　　//lookup topic1
　　Topic topic = (Topic) context.lookup("topic1");
　　//创建Topic subscriber
　　TopicSubscriber topicSubscriber =
　　topicSession.createSubscriber(topic);
　　//收满10条订阅消息则退出
　　for (int i=0; i10; i++) {
　　//同步消息接收，使用receive方法，堵塞等待，直到接收消息
　　TextMessage message = (TextMessage) topicSubscriber.receive();
　　System.out.println("接收订阅消息["+i+"]: " + message.getText());
　　}
　　//资源清除，代码略 ... ...
　　System.out.println("订阅接收结束.");
　　} catch (NamingException e) {
　　e.printStackTrace();
　　} catch (JMSException e) {
　　e.printStackTrace();
　　}
　　}
　　}
　　非同步接收：
　　package javayou.demo.openjms;
　　import java.util.*;
　　import javax.jms.*;
　　import javax.naming.*;
　　public class TopicSubscribeAsynchronous implements MessageListener {
　　private TopicConnection topicConnection;
　　private TopicSession topicSession;
　　private Topic topic;
　　private TopicSubscriber topicSubscriber;
　　TopicSubscribeAsynchronous() {
　　try {
　　//取得JNDI上下文和连接
　　Hashtable properties = new Hashtable();
　　properties.put(
　　Context.INITIAL_CONTEXT_FACTORY，
　　"org.exolab.jms.jndi.InitialContextFactory");
　　properties.put(Context.PROVIDER_URL， "rmi://localhost:1099/");
　　Context context = new InitialContext(properties);
　　//取得Topic的连接工厂和连接
　　TopicConnectionFactory topicConnectionFactory =
　　(TopicConnectionFactory) context.lookup(
　　"JmsTopicConnectionFactory");
　　topicConnection = topicConnectionFactory.createTopicConnection();
　　//创建Topic的会话，用于接收信息
　　topicSession =
　　topicConnection.createTopicSession(false，
　　Session.AUTO_ACKNOWLEDGE);
　　topic = (Topic) context.lookup("topic1");
　　//创建Topic subscriber
　　topicSubscriber = topicSession.createSubscriber(topic);
　　//设置订阅监听
　　topicSubscriber.setMessageListener(this);
　　//启动信息接收
　　topicConnection.start();
　　} catch (NamingException e) {
　　e.printStackTrace();
　　} catch (JMSException e) {
　　e.printStackTrace();
　　}
　　}
　　public static void main(String args) {
　　System.out.println("非同步定购消息的接收：");
　　try {
　　TopicSubscribeAsynchronous listener =
　　new TopicSubscribeAsynchronous();
　　Thread.sleep(1000);
　　} catch (InterruptedException e) {
　　e.printStackTrace();
　　}
　　}
　　//收到订阅信息后自动调用此方法
　　public void onMessage(Message message) {
　　try {
　　String messageText = null;
　　if (message instanceof TextMessage)
　　messageText = ((TextMessage) message).getText();
　　System.out.println(messageText);
　　} catch (JMSException e) {
　　e.printStackTrace();
　　}
　　}
　　}
　　编译好后，启动openJms服务，打开admin管理台，为了运行方便，这里先列出三个类的运行命令：
　　java -cp .“; -Djava.ext.dirs=.“lib; javayou.demo.openjms.TopicPublish
　　java -cp .“; -Djava.ext.dirs=.“lib; javayou.demo.openjms.TopicSubscribeSynchronous
　　java -cp .“; -Djava.ext.dirs=.“lib; javayou.demo.openjms.TopicSubscribeAsynchronous
　　先运行2个接收命令，再运行发布命令，可以看到控制台的Topic有消息接收，并且接收1和2都有消息接收的提示，到此完成演示，由于是非持久订阅，所以可以看到控制台上的Topic消息条数不会减少。
　　:JMS服务器openJms入门