JMS入门之实例

合集下载

消息中间件JMS入门

消息中间件JMS⼊门1. JMS⼊门1.1消息中间件什么是消息中间件消息中间件利⽤⾼效可靠的消息传递机制进⾏平台⽆关的数据交流，并基于数据通信来进⾏的集成。

通过提供消息传递和消息排队模型，它可以在分布式环境下扩展进程间的通信。

对于消息中间件，常见的⾓⾊⼤致也就有Producer（⽣产者）、Consumer（消费者）常见的消息中间件产品:（1）ActiveMQActiveMQ 是Apache出品，最流⾏的，能⼒强劲的开源消息总线。

ActiveMQ 是⼀个完全⽀持JMS1.1和J2EE 1.4规范的 JMS Provider实现。

我们在本次课程中介绍 ActiveMQ的使⽤。

（2）RabbitMQAMQP协议的领导实现，⽀持多种场景。

淘宝的MySQL集群内部有使⽤它进⾏通讯，OpenStack开源云平台的通信组件，最先在⾦融⾏业得到运⽤。

（3）ZeroMQ史上最快的消息队列系统（4）KafkaApache下的⼀个⼦项⽬。

特点：⾼吞吐，在⼀台普通的服务器上既可以达到10W/s的吞吐速率；完全的分布式系统。

适合处理海量数据。

1.2 JMS简介1.2.1什么是JMSJMS（Messaging Service）是Java平台上有关⾯向消息中间件的技术规范，它便于消息系统中的Java应⽤程序进⾏消息交换,并且通过提供标准的产⽣、发送、接收消息的接⼝简化企业应⽤的开发。

JMS本⾝只定义了⼀系列的接⼝规范，是⼀种与⼚商⽆关的 API，⽤来访问消息收发系统。

它类似于 JDBC(Database Connectivity)：这⾥，JDBC 是可以⽤来访问许多不同关系的 API，⽽ JMS 则提供同样与⼚商⽆关的访问⽅法，以访问消息收发服务。

许多⼚商⽬前都⽀持JMS，包括 IBM 的 MQSeries、BEA的 Weblogic JMS service和 Progress 的 SonicMQ，这只是⼏个例⼦。

JMS 使您能够通过消息收发服务（有时称为消息中介程序或路由器）从⼀个 JMS 客户机向另⼀个 JML 客户机发送消息。

JMS基础教程实例(内部)

JMS基础示例教程需求分析在很多实际应用中，不只是简单地要求用户需要注册登录。

还要求不同的用户对不同资源拥有不同的权限。

某单位的新闻部门的某些人才拥有对外发布新闻的权限；每个部门只有对自己部门内部资源才拥有创建、修改权限，对于其他部门创建的资源如网页等只有浏览的权限。

这些复杂的用户权限验证需要可以总结为如下几点：∙用户资料管理系统：对用户的注册资料进行管理。

可进行用户资料的新增修改，能够查询获取丢失的密码。

∙权限的验证和授权：拦截所有访问受保护资源的请求，检查该用户是否被授权访问该资源。

∙可控制的资源限制访问：对于系统的资源，无论是数据或行为动作，对确定的一组用户都有限制访问。

例如对于有的用户只允许读操作，不能进行写操作；有些资源只有创建者才可以访问和操作等。

这3种需求适合大部分应用系统，通过它们的实现，可以形成一个用户安全管理方面的组件框架，并且能够重复地在不同的应用系统中使用。

2架构设计实现一个完整的用户安全管理框架，可以有两种实现途径。

在J2EE出现以前，大部分是由应用系统本身实现。

因此，很多有经验的软件商都拥有自己成熟的用户安全管理系统，但是缺点也是比较明显，自己设计的用户安全管理系统可重用性低，有的和具体应用程序过分紧密地绑定在一起，无法移植到其他系统上。

但是，随着业务量上升，应用系统的不断增加，会出现不同应用系统拥有不同的用户登录验证体系，很显然，这给用户访问带来了不方便，用户不可能为每个系统注册一套用户和密码，定制一套用户角色。

因此，整个服务器群中需要统一的用户权限验证体系。

而J2EE容器的用户安全管理框架再辅助以LDAP或数据库系统，可以很方便地达到这个目标。

2.1角色J2EE容器的用户安全框架是基于RBAC（Roled-Based Access Control，相关网址：/rbac/）设计模型建立的，这是一个基于角色的访问权限控制模型。

首先必须了解角色的含义，在RBAC中角色Role的定义是：Role是明确表达访问控制（Aceess Control）策略的一种语义构建词。

ActiveMq-JMS简单实例使用tomcat

ActiveMq初级操作（工具：tomcat6.0、activeMq5.3.2、Myeclipse7.0，java1。

5）这是本人第一次发表个人使用ActiveMq，如有错误，请指出。

只为与众人共享我的心得。

activeMq是一个开源的支持JMS的框架：（以下为考录他人的信息，如有版权问题，请联系）一、特性及优势1、实现JMS1.1规范，支持J2EE1.4以上2、可运行于任何jvm和大部分web容器（ActiveMQ works great in any JVM）3、支持多种语言客户端（java, C, C++, AJAX, ACTIONSCRIPT等等）4、支持多种协议（stomp，openwire，REST）5、良好的spring支持（ActiveMQ has great Spring Support）6、速度很快，JBossMQ的十倍（ActiveMQ is very fast; often 10x faster than JBossMQ.）7、与OpenJMS、JbossMQ等开源jms provider相比，ActiveMQ有Apache的支持，持续发展的优势明显。

二、下载安装1、下载/download.html，在这个页面里有你所需要的各个版本，我用的是最新的版本-ActiveMQ 5.3.2。

2、安装直接解压至任意目录（如：d:\ apache-activemq-5.1.0），但是我用的时候是解压到D盘的根目录下，我建议各位也这样，不用对它的一些bat进行修改。

3、启动ActiveMQ服务器方法1：直接运行bin\activemq.bat方法2（在JVM中嵌套启动）：（这个我没用过，你可以试试）cd exampleant embedBroker4、ActiveMQ消息管理后台系统：http://localhost:8161/admin打开主页后，你可以看到activeMq中带的一些实例，三、详细实例以下为本人的一个简单的实例，希望对各位有所帮助，我是利用网上的资料，将tomcat和activeMq整合在一起做的一个发送接受的发布订阅的例子（我用的是tomcat6.0，activeMq5.3.2）：首先整合tomcat和activeMq：1、准备jar包：将ActiveMQ lib目录下的5个jar包复制到Tomcat lib目录下：activemq-core-5.1.0.jaractivemq-web-5.1.0.jargeronimo-j2ee-management_1.0_spec-1.0.jargeronimo-jms_1.1_spec-1.1.1.jargeronimo-jta_1.0.1B_spec-1.0.1.jar2、修改配置文件：2.1 修改Tomcat的conf/context.xml文件：在<context></context>节点中添加以下内容：<Resourcename="jms/FailoverConnectionFactory"auth="Container"type="org.apache.activemq.ActiveMQConnectionFactory"description="JMS Connection Factory"factory="org.apache.activemq.jndi.JNDIReferenceFactory"brokerURL="failover:(tcp://localhost:61616)?initialReconnectDelay=10 0&maxReconnectAttempts=5"brokerName="localhost"useEmbeddedBroker="false"/><Resourcename="jms/NormalConnectionFactory"auth="Container"type="org.apache.activemq.ActiveMQConnectionFactory"description="JMS Connection Factory"factory="org.apache.activemq.jndi.JNDIReferenceFactory"brokerURL="tcp://localhost:61616"brokerName="localhost"useEmbeddedBroker="false"/><Resource name="jms/topic/MyTopic"auth="Container"type="mand.ActiveMQTopic"factory="org.apache.activemq.jndi.JNDIReferenceFactory"physicalName="MY.TEST.FOO"/><Resource name="jms/queue/MyQueue"auth="Container"type="mand.ActiveMQQueue"factory="org.apache.activemq.jndi.JNDIReferenceFactory"physicalName="MY.TEST.FOO.QUEUE"/>配置说明：以JNDI的方式定义了ActiveMQ的broker连接url、Topic和Queue。

JBOSS建立JMS应用实例

JBOSS建立JMS应用实例
JBOSS创建JMS应用程序实例
环境配置描述
Jboss4.2.3 Java ee 5 MySql5.0
安装jdk，我的目录是C:\\Sun\\SDK安装jboss。

我的目录是D:\\jboss4.2.3安装mysql
配置环境变量JBOSS_HOME D:\\jboss4.2.3配置环境变量JA V A_HOME C:\\Sun\\SDK\\jdk
JBOSS JMS配置
由于没有使用集群，JBOSS的默认应用程序就足够了。

1.配置MySQL 数据库的JNDI
将MySQL数据库驱动程序复制到默认\\lib JBOSS没有自己的MySQL数据库驱动程序。

在D: \ \ JBoss 4.2.3 \ \ DOCS \ \示例\ \ JCA 下的文件夹下，有许多数据源定义模板被不同的数据库引用。

将mysql-ds.xml文件复制到您正在使用的服务器，如D: \ \ JBoss 4.2.3 \ \服务器\ \默认\ \部署。

修改mysql-ds.xml文件的内容，以便它可以通过JDBC正确访问您的mysql数据库，如下所示:。

JMS应用的简单例子

JMS应用的简单例子JMS应用的简单例子September 16, 2006 – 9:54 pm No TagsJ2EE应用客户端通常是用来访问安装在服务器端的J2EE组件。

客户端是一个类文件，是一个简单的、独立的、运行在服务器外的程序。

它描述了JMS应用必须完成的基本工作：•创建连接和会话•创建消息生产者和消费者•发送和接收消息在J2EE应用中，以上工作全部或者部分由EJB容器完成。

本文涵盖以下主题：•配置运行J2EE客户端和应用的环境•同步接收消息的点对点(PTP)例子•使用监听器的订阅/发布(pub/sub）例子每一个例子都包含两个程序：一个发送消息，另一个接收消息。

可以在两个窗口中运行。

1 配置运行应用的环境在运行例子前，必须确定运行环境已经配置好了。

Table 1显示如何配置环境变量。

Before you can run the examples, you need to make sure your environment is set appropriately. Table 1 shows how to set the environment variables needed to run J2EE applications on Windows and UNIX platforms.2 一个简单的PTP例子本节描述了PTP客户端程序怎样发送、接收消息步骤：•编写PTP客户端程序•编译PTP客户端•运行JMS提供者（一般指JMS服务器）•创建JMS管理对象•运行PTP客户端•删除队列2.1 编写 PTP客户端程序消息发送程序SimpleQueueSender.java完成以下任务：1.用JNDI查找队列连接工厂（QueueConnectionFactory）和消息队列（Queue）2.创建连接(connection)和会话(session)3.创建消息发送者(QueueSender)3.创建消息(T extMessage)5.发送消息到队列6.发送控制消息表明消息末尾7.在finally代码块中关闭连接(connection),关闭连接则自动关闭会话和消息发送消息接收程序SimpleQueueReceiver.java完成以下任务：1.通过JNDI查找队列连接工厂(QueueConnectionFactory )和队列（queue）2.创建连接（connection ）和会话（session）3.创建消息接收者（QueueReceiver）4.开始连接，传送消息5.从队列中接收消息，直至消息接受完毕6.在finally代码块中关闭连接，关闭连接则自动关闭消息接收有几种方式调用receive方法实现消息同步接收。

JMS入门小例子+weblogic的安装及在weblogic中配置JMS服务

JMS入门小例子+weblogic的安装及在weblogic中配置JMS服务JMS是一个由AS提供的Message服务。

它能接受消息产生者(Message Provider)所发出的消息，并把消息转发给消息消费者(Message Consumer)。

以下是接收端和发送端的详细布署步骤，适用于初学者的学习接收端需要的包：commons-logging-1.1.1.jarjettison-1.0.jarjms-1.1.jarlog4j-1.2.15.jarspring.jarspring-asm-3.0.5.RELEASE.jarspring-beans-3.0.5.RELEASE.jarspring-context-3.0.5.RELEASE.jarspring-core-3.0.5.RELEASE.jarspring-expression-3.0.5.RELEASE.jarspring-jms-2.5.6.jarspring-transaction-3.0.5.jarspring-web-3.0.5.RELEASE.jarweblogic.jarxml-apis.jar发送端需要的包：commons-logging-1.1.1.jarjettison-1.0.jarjms-1.1.jarlog4j-1.2.15.jarspring-asm-3.0.5.RELEASE.jarspring-beans-3.0.5.RELEASE.jarspring-context-3.0.5.RELEASE.jarspring-core-3.0.5.RELEASE.jarspring-expression-3.0.5.RELEASE.jarspring-jms-2.5.6.jarspring-jms.jarspring-transaction-3.0.5.jarweblogic.jarxml-apis.jar一、新建一个工程用做接收端本例名为jmsMessageReceive1、在Web.xml文件中添加如下内容：<context-param><param-name>contextConfigLocation</param-name><param-value>classpath:spring-jms.xml</param-value></context-param><listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener><listener><listener-class>org.springframework.web.util.Log4jConfigListener</listener-class></listener><context-param><param-name>log4jConfigLocation</param-name><param-value>classpath:log4j.properties</param-value></context-param><context-param><param-name>log4jRefreshInterval</param-name><param-value>60000</param-value></context-param>2、在src文件夹下新建spring-jms.xml文件，内容如下：<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:aop="/schema/aop"xmlns:tx="/schema/tx"xmlns:jaxws="/jaxws"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-2.0.xsd/schema/aop/schema/aop/spring-aop-2.0.xsd/schema/tx/schema/tx/spring-tx-2.0.xsd/jaxws /schemas/jaxws.xsd"> <bean id="jkJndiTemplate"class="org.springframework.jndi.JndiTemplate"><property name="environment"><props><prop key="java.naming.factory.initial">weblogic.jndi.WLInitialContextFactory</prop><prop key="java.naming.provider.url">t3://localhost:7001</prop><prop key="java.naming.security.principal">weblogic</prop><prop key="java.naming.security.credentials">weblogic</prop></props></property></bean><bean id="jkJndiConnectionFactory"class="org.springframework.jndi.JndiObjectFactoryBean"><property name="jndiTemplate" ref="jkJndiTemplate"></property><property name="jndiName" value="JKFC"></property></bean><bean id="jkConnectionFactory"class="org.springframework.jms.connection.CachingConnectionFactory"><property name="targetConnectionFactory"ref="jkJndiConnectionFactory"></property><property name="sessionCacheSize" value="1"></property></bean><bean id="destinationResolver" class="org.springframework.jms.support.destination.JndiDestinationResolver"><property name="jndiTemplate" ref="jkJndiTemplate"></property><property name="cache" value="true"></property><property name="fallbackToDynamicDestination" value="false"></property> </bean><bean id="jkListener" class="com.ylw.jms.JmsMessageListener"></bean><bean id="jkMsgListener" class="org.springframework.jms.listener.adapter.MessageListenerAdapter"><constructor-arg ref="jkListener"/><property name="defaultListenerMethod" value="onMessage"/></bean><bean id="jkJmsContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer"><property name="connectionFactory" ref="jkConnectionFactory"></property><property name="destinationResolver" ref="destinationResolver"></property><property name="concurrentConsumers" value="1"></property><property name="destinationName" value="JKTP"></property><property name="messageListener" ref="jkMsgListener"></property></beans>3、在src下新建包com.ylw.jms在jms包下新建class文件JmsMessageListener.java，内容如下：package com.ylw.jms;import javax.jms.JMSException;import javax.jms.Message;import javax.jms.MessageListener;import javax.jms.TextMessage;/**** 项目名称：jmsMessageReceive* 类名称：JMSMessageListener* 类描述：JMS消息监听* 创建人：ylw* 创建时间：2012-3-2 下午03:47:00* 修改人：ylw* 修改时间：2012-3-2 下午03:47:00* 修改备注：* 版本：**/public class JmsMessageListener implements MessageListener {/* (non-Javadoc)* @see javax.jms.MessageListener#onMessage(javax.jms.Message) */public void onMessage(Message message) {System.out.println("监听成功...");String msg = "";System.out.println( "Message: " + message.toString() );try {msg = ((TextMessage)message).getText();} catch (JMSException e) {// TODO Auto-generated catch blocke.printStackTrace();System.out.println("传入的msg内容为: ");System.out.println(msg);}}除此之外，还要在src文件夹下新建log4j.properties文件，这里为了避免初学者到处找所以加入内容，如下：#'rootLogger' Never expunge! We need it when error!log4j.rootLogger=info, stdout, R.zephyr.validate.dao=info, R.zephyr.idsrv.services.impl=info, R#.zephyr.idsrv.util.ProperiesHelper=info, stdout, R#.zephyr.cis.task.SxccbReadCisPkgTask=debug,stdout,R.hibernate=errorlog4j.appender.stdout=org.apache.log4j.ConsoleAppenderyout=org.apache.log4j.PatternLayout# Pattern to output the caller's file name and line number.yout.ConversionPattern=%-5p [%t] (%F:%L) - %m%nlog4j.appender.console=org.apache.log4j.ConsoleAppenderyout=org.apache.log4j.PatternLayoutyout.ConversionPattern=%d{ISO8601}:%6r:%p:%m%nlog4j.appender.R=org.apache.log4j.DailyRollingFileAppenderlog4j.appender.R.File=logs/imageproserver.log#log4j.appender.R.File=C:\\bits-ios.loglog4j.appender.R.MaxFileSize=10MB# Keep one backup filelog4j.appender.R.MaxBackupIndex=10yout=org.apache.log4j.PatternLayoutyout.ConversionPattern=%d: at %l%n [%t] %-p - %m%n到这里JMS接收端完成。

简单的JMS实例

简单的JMS实例1.⾸先需要⼀台JMS的提供者，在这⾥我选择使⽤的是apache-activemq-5.3.2这个服务器，⾸先下载服务器并通过bin⽬录下的activemq.bat启动服务器，此时可通过http://ocalhost:8161/admin/访问服务器查看是否发布成功2.服务器发布成功之后就可以开始写消息发送者的程序了：import javax.jms.Connection;import javax.jms.ConnectionFactory;import javax.jms.DeliveryMode;import javax.jms.Destination;import javax.jms.MessageProducer;import javax.jms.Session;import javax.jms.TextMessage;import org.apache.activemq.ActiveMQConnection;import org.apache.activemq.ActiveMQConnectionFactory;public class Sender {public static void main(String[] args) {// ConnectionFactory ：连接⼯⼚，JMS ⽤它创建连接ConnectionFactory connectionFactory;// Connection ：JMS 客户端到JMS Provider 的连接Connection connection = null;// Session：⼀个发送或接收消息的线程Session session;// Destination ：消息的⽬的地;消息发送给谁.Destination destination;// MessageProducer：消息发送者MessageProducer producer;// TextMessage message;// 构造ConnectionFactory实例对象，此处采⽤ActiveMq的实现jarconnectionFactory = new ActiveMQConnectionFactory(ActiveMQConnection.DEFAULT_USER, ActiveMQConnection.DEFAULT_PASSWORD, "tcp://localhost:61616");try {// 构造从⼯⼚得到连接对象connection = connectionFactory.createConnection();// 启动connection.start();// 获取操作连接session = connection.createSession(Boolean.TRUE, Session.AUTO_ACKNOWLEDGE);// 获取session注意参数值xingbo.xu-queue是⼀个服务器的queue，须在在ActiveMq的console配置destination = session.createQueue("FirstQueue");//Destination destination1=session.createTopic("Second");//MessageProducer producer1 = session.createProducer(destination1);//TextMessage message1 = session.createTextMessage("我想发送给多个⼈的消息");//producer1.send(message1);// 得到消息⽣成者【发送者】producer = session.createProducer(destination);//创建需要发布的消息TextMessage message = session.createTextMessage("ActiveMq 发送的消息");// 设置不持久化，此处学习，实际根据项⽬决定producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);//发送消息producer.send(message);mit();} catch (Exception e) {e.printStackTrace();} finally {try {if (null != connection)connection.close();} catch (Throwable ignore) {}}}}消息发布者3.此时消息发送者创建完毕之后就可以创建消息接受者的程序了：import javax.jms.Connection;import javax.jms.ConnectionFactory;import javax.jms.Destination;import javax.jms.MessageConsumer;import javax.jms.Session;import javax.jms.TextMessage;import org.apache.activemq.ActiveMQConnection;import org.apache.activemq.ActiveMQConnectionFactory;public class Receiver {public static void main(String[] args) {// ConnectionFactory ：连接⼯⼚，JMS ⽤它创建连接ConnectionFactory connectionFactory;// Connection ：JMS 客户端到JMS Provider 的连接Connection connection = null;// Session：⼀个发送或接收消息的线程Session session;// Destination ：消息的⽬的地;消息发送给谁.Destination destination;// 消费者，消息接收者MessageConsumer consumer;connectionFactory = new ActiveMQConnectionFactory(ActiveMQConnection.DEFAULT_USER, ActiveMQConnection.DEFAULT_PASSWORD, "tcp://localhost:61616");try {// 构造从⼯⼚得到连接对象connection = connectionFactory.createConnection();// 启动connection.start();// 获取操作连接session = connection.createSession(Boolean.FALSE, Session.AUTO_ACKNOWLEDGE);// 获取session注意参数值xingbo.xu-queue是⼀个服务器的queue，须在在ActiveMq的console配置destination = session.createQueue("FirstQueue");//destination = session.createTopic("Second");consumer = session.createConsumer(destination);while (true) {// 设置接收者接收消息的时间，为了便于测试，这⾥设定为100sTextMessage message = (TextMessage) consumer.receive(100000);if (null != message) {System.out.println("收到消息：" + message.getText());} else {break;}}} catch (Exception e) {e.printStackTrace();} finally {try {if (null != connection)connection.close();} catch (Throwable ignore) {}}}}消息接收者。

mq消息队列的java的使用方法实例

mq消息队列的java的使用方法实例下面是一个使用Java的JMS (Java Message Service) API进行消息队列操作的简单示例。

在此示例中，我们将使用ActiveMQ作为消息代理。

注意：您需要将ActiveMQ的依赖项添加到项目的文件中，以便运行此示例。

首先，我们创建一个生产者（发送消息到队列）的类：```javaimport ;import ;public class Producer {public static void main(String[] args) throws JMSException {// 创建连接工厂ConnectionFactory connectionFactory = new ActiveMQConnectionFactory("// 创建连接Connection connection = ();// 开启连接();// 创建会话Session session = (false, _ACKNOWLEDGE); // 创建目标（队列）Destination destination = ("testQueue");// 创建消息生产者MessageProducer producer = (destination); // 创建并发送消息TextMessage message = ("Hello World!"); (message);("Sent message: " + ());// 关闭连接和会话();}}```然后，我们创建一个消费者（从队列接收消息）的类：```javaimport ;import ;public class Consumer {public static void main(String[] args) throws JMSException {// 创建连接工厂ConnectionFactory connectionFactory = new ActiveMQConnectionFactory("// 创建连接Connection connection = ();// 开启连接();// 创建会话Session session = (false, _ACKNOWLEDGE);// 创建目标（队列）Destination destination = ("testQueue");// 创建消息消费者MessageConsumer consumer = (destination);// 接收消息Message message = (); // 这里可以添加一个时间参数以限制等待时间，例如：表示等待10秒。

JMS的两种消息模型P2P模型和PubSub模型实例

factory
=
(QueueConnectionFactory)
ctx.lookup("QueueConnectionFactory");
//创建 QueueConnection 对像
QueueConnection connection = factory.createQueueConnection();
QueueSession.AUTO_ACKNOWLEDGE);
//取得 destination
Queue queue = (Queue) ctx.lookup("queue/myqueue");
//消息生产者
MessageProducer sender = session.createProducer(queue);
//创建会话
//arg1:与事物有关，true 表示最后提交，false 表示自动提交
//arg2:表示消息向中间件发送确认通知，这里采用的是自动通知的类型
QueueSession session = (QueueSession) connection.createQueueSession(false,
propertyValue="topic/myTopic") }
) public class TopicMessageBean implements MessageListener {
public void onMessage(Message msg) { //共有下面几种消息类型 //1 Text //2 Map //3 Object //4 stream //5 byte TextMessage txtMsg = (TextMessage)msg; String s = ""; try { s = txtMsg.getText(); } catch (JMSException e) { e.printStackTrace(); } System.out.println("TopicMessageBean 接收到了消息：" + s);

jms标准测试用例

jms标准测试用例JMS（Java Message Service，Java消息服务）是一种用于在分布式应用程序中发送和接收消息的规范。

以下是一些标准的JMS测试用例：1. 测试发送和接收消息：-创建一个JMS生产者，发送消息到队列或主题。

-创建一个JMS消费者，从队列或主题接收消息。

-验证发送的消息是否被正确接收。

2. 测试消息持久性：-发送一条消息到队列或主题。

-关闭生产者和消费者，模拟应用程序崩溃。

-重新启动生产者和消费者，验证之前发送的消息是否被正确接收。

3. 测试消息顺序：-发送一系列消息到队列或主题。

-验证消费者是否按发送顺序接收消息。

4. 测试消息过滤：-发送多条消息到队列或主题，其中一些消息包含特定属性。

-创建一个消息选择器，根据特定属性过滤消息。

-验证消费者是否仅接收符合过滤条件的消息。

5. 测试并发访问：-创建多个消费者实例，同时从队列或主题接收消息。

-验证消息是否被正确分配给各个消费者实例。

6. 测试消息大小限制：-发送不同大小的消息到队列或主题。

-验证生产者和消费者是否根据配置的消息大小限制进行操作。

7. 测试生产者和消费者故障转移：-创建一个备用生产者或消费者，以防主要生产者或消费者发生故障。

-模拟生产者或消费者故障，验证备用生产者或消费者是否能接管消息处理。

8. 测试集群功能：-创建一个集群，包含多个生产者和消费者实例。

-验证消息是否在集群内部均匀分布。

9. 测试安全性：-配置JMS安全策略，确保只有授权用户可以访问消息。

-验证未经授权的用户是否无法访问消息。

10. 测试性能：-发送和接收大量消息，记录生产者和消费者的处理速度。

-分析性能数据，优化消息处理过程。

以上测试用例可以帮助您确保JMS应用程序的正确性和稳定性。

在实际测试过程中，您可能需要根据具体需求调整测试用例。

JMS入门之实例

JMS入门之实例JMS入门之实例JMS是一个由AS提供的Message服务。

它能接受消息产生者(Message Provider)所发出的消息，并把消息转发给消息消费者(Message Consumer)。

2、JMS提供2种类型的消息服务：(1)Queue，即点对点，每个消息只转发给一个消息消费者使用。

(2)Topic，即发布和订阅，每个消息可以转发给所有的订阅者(消费者)。

3、WEBLOGIC 8下的JMS配置：(1)配置JMS Connection Factory(2)配置JMS File Store(目前所找到的文档都是配置File Store,其实在具体的应用中，可能JMS JDBC Store更广泛，但暂时没有找到资料)(3)配置JMS Server(4)在JMS Server的destinations中配置JMS Queue或者JMS Topic其中提供给消息产生者和消息消费者使用的是JMS Connection Factory的JNDI和JMS Queue或者JMS Topic的JNDI。

4、消息产生者向JMS发送消息的步骤：(1)使用JNDI查询对象JMS ConnectionFactory和Destination(JMS Queue/Topic)(2)使用管理对象JMS ConnectionFactory建立连接Connection(3)使用连接Connection 建立会话Session(4)使用会话Session和管理对象Destination创建消息生产者MessageSender(5)使用消息生产者MessageSender发送消息一个消息发送者的例子：package myjms;import java.util.*;import javax.naming.*;import javax.jms.*;public class MessageProducter {public static void main(String[] args) {String queueConnectionFactoryName = "myjmsconnectionfactory"; //JMS Connection Factory的JNDIString queueName = "myjmsqueue"; //JMS Queue或者JMS Topic的JNDIboolean transacted = false;//transaction模式int acknowledgementMode = Session.AUTO_ACKNOWLEDGE;//acknowledgement模式String message="Message need to send";//模拟需要发送的消息Properties properties = new Properties();properties.put(Context.INITIAL_CONTEXT_FACTORY,"weblogic.jndi.WLInitialContextFactory");properties.put(Context.PROVIDER_URL, "t3://localhost:7001");try {Context context = new InitialContext(properties);Object obj = context.lookup(queueConnectionFactoryName);QueueConnectionFactory queueConnectionFactory = (QueueConnectionFactory) obj;//JMS Connection Factory的获得obj = context.lookup(queueName);Queue queue = (Queue) obj;//JMS Queue或者JMS Topic的获得QueueConnection queueConnection=queueConnectionFactory.createQueueConnection();//产生连接queueConnection.start();QueueSession queueSession = queueConnection.createQueueSession(transacted, acknowledgementMode);TextMessage textMessage = queueSession.createTextMessage();textMessage.clearBody();textMessage.setText(message);QueueSender queueSender = queueSession.createSender(queue);queueSender.send(textMessage);if (transacted) {mit();}if (queueSender != null) {queueSender.close();}if (queueSession != null) {queueSession.close();}if (queueConnection != null) {queueConnection.close();}}catch(Exception ex){ex.printStackTrace();}}}5、消息消费者从JMS接受消息的步骤：(1)使用JNDI查询对象JMS ConnectionFactory和Destination(JMS Queue/Topic)(2)使用管理对象JMS ConnectionFactory建立连接Connection(3)使用连接Connection 建立会话Session(4)使用会话Session和管理对象Destination创建消息消费者MessageReceiver(5)使用消息消费者MessageReceiver接受消息，需要用setMessageListener将MessageListener接口绑定到MessageReceiver消息消费者必须实现了MessageListener接口，需要定义onMessage事件方法。

JMS（Java消息服务）入门教程

JMS（Java消息服务）⼊门教程什么是Jav a消息服务　 Java消息服务指的是两个应⽤程序之间进⾏异步通信的API，它为标准消息协议和消息服务提供了⼀组通⽤接⼝，包括创建、发送、读取消息等，⽤于⽀持JAVA应⽤程序开发。

在J2EE中，当两个应⽤程序使⽤JMS进⾏通信时，它们之间并不是直接相连的，⽽是通过⼀个共同的消息收发服务连接起来，可以达到解耦的效果，我们将会在接下来的教程中详细介绍。

为什么需要JMS 在JAVA中，如果两个应⽤程序之间对各⾃都不了解，甚⾄这两个程序可能部署在不同的⼤洲上，那么它们之间如何发送消息呢？举个例⼦，⼀个应⽤程序A部署在印度，另⼀个应⽤程序部署在美国，然后每当A触发某件事后，B想从A获取⼀些更新信息。

当然，也有可能不⽌⼀个B对A的更新信息感兴趣，可能会有N个类似B的应⽤程序想从A中获取更新的信息。

在这种情况下，JAVA提供了最佳的解决⽅案-JMS，完美解决了上⾯讨论的问题。

JMS同样适⽤于基于事件的应⽤程序，如聊天服务，它需要⼀种发布事件机制向所有与服务器连接的客户端发送消息。

JMS与RMI不同，发送消息的时候，接收者不需要在线。

服务器发送了消息，然后就不管了；等到客户端上线的时候，能保证接收到服务器发送的消息。

这是⼀个很强⼤的解决⽅案，能处理当今世界很多普遍问题。

JMS的优势异步 JMS天⽣就是异步的，客户端获取消息的时候，不需要主动发送请求，消息会⾃动发送给可⽤的客户端。

可靠 JMS保证消息只会递送⼀次。

⼤家都遇到过重复创建消息问题，⽽JMS能帮你避免该问题。

JMS消息传送模型在JMS API出现之前，⼤部分产品使⽤“点对点”和“发布/订阅”中的任⼀⽅式来进⾏消息通讯。

JMS定义了这两种消息发送模型的规范，它们相互独⽴。

任何JMS的提供者可以实现其中的⼀种或两种模型，这是它们⾃⼰的选择。

JMS规范提供了通⽤接⼝保证我们基于JMS API编写的程序适⽤于任何⼀种模型。

理解面向消息中间件及JMS 以及 ActiveMQ例子

理解面向消息中间件及JMS 以及ActiveMQ例子为了帮助你理解ActiveMQ的意义，了解企业消息传送背景和历史是很重要的。

讨论完企业消息传送，你将可以通过一个小例子了解JMS及其使用。

这章的目的是简要回顾企业消息传送及JMS规范。

如果你已经熟悉这些主题，你可以跳过直接到下一章去。

软件开发者经常需要在两个系统之间交流或搬运数据。

这种问题有很多解决办法。

但限于你的条件和需求，选择一种解决方案是一个大决定。

商业需求往往有严格的限制条件，直接影响你的决定的有性能，扩展性，稳定性等。

我们日常使用的很多系统都有这样的要求，比如ATM系统，航班预订系统，信用卡系统，单点销售系统，通信系统等。

如果我们的日常生活没有这些系统会怎样？用一小会的时间想一下这些服务给我们的生活带来了怎样的便利。

这些及其它类似应用能够方便我们的生活在于他们的稳定和安全性。

在这些应用场景背后，是很多应用组合起来的，通常是分布式的，它们之间相互传递事件或消息。

即使是最复杂的金融交易系统也是用这种方式集成的，完全通过消息传送来发送和接收商业信息。

由于各种各样的理由，很多产品都提供消息传送。

必要性是发明之母，这就是消息中间件产生的原因。

当时需要一种软件，能够在各种不同的数据类型，操作系统，协议甚至是不同的编程语言中交流数据。

并且，复杂的消息路由和转移也成为这种解决方案的一部分必备能力。

ActiveMQ就是一个MOM产品，它为上面提到的商业系统提供异步消息传送。

ActiveMQ通过实现JMS规范提供了这样一种可靠性和扩展性。

2.1介绍企业消息传送向上面提及的大多数系统是由许多大型的计算机一起构建的，并且到今天仍然在使用。

那么，这些系统怎么可靠地运作呢？要回答这个问题，我们先简要回顾下这种解决方案的历史及企业消息传送是怎么产生的。

从上世纪60年代开始，许多大型的组织使用大型机来处理一些诸如数据处理，财务处理，静态分析等关键功能。

大型机为商业提供包括高可用性，冗余备份，可靠性，可扩展性，无中断升级等许多关键特性。

[z]JMS简明学习教程

[z]JMS简明学习教程基础篇JMS是应⽤系统或组件之间相互通信的应⽤程序接⼝，利⽤它，我们可以轻易实现在不同JVM之间相互的远程通信。

要实现远程通信，RPC同样也能做到，但RPC却不可避免地增加了不同系统之间的耦合度，JMS能极⼤地降低不同的应⽤系统之间的耦合。

要学习JMS，有⼏个概念必须要搞清楚：l Messaging (消息通知、消息通信)⼀种应⽤系统或组件之间相互通信的⽅式。

l Message (消息)消息即为消息通信的载体，消息包括Message Headers, Message properties, Message bodiesl JMS有两种⽅式进⾏消息通信：Point-to-Point (P2P) 和 Publish/Subscriber (PUB/SUB)P2P⽅式是⼀对⼀的，⼀条消息只有⼀个接收者，默认情况下是P2P消息是持久的，也就是说发送者（sender）产⽣的⼀条消息（message）发送到消息队列（queue）之上后，只有等到消息接收者（receiver）接收到它，才会从消息队列中删除，没有被接收的消息会⼀直存在JMS容器⾥。

这种⽅式有点像邮政通信，信件只有⼀个接收者，信件在接收之前，会⼀直存放在信箱⾥。

PUB/SUB⽅式的⼯作流程，⾸先subscriber（订阅者）向JMS容器订阅(Listen to)⾃⼰感兴趣的topic（主题），多个订阅者可以同时对⼀个主题进⾏订阅，消息发布者发布⼀条消息，所有订阅了该主题的订阅者都能收到这个消息。

默认情况下，pub/sub⽅式下的消息不是持久的，这意味着，消息⼀经发出，不管有没有⼈接收，都不会保存下来，⽽且订阅者只能接收到⾃已订阅之后发布者发出的消息。

这种⽅式有点像订阅报刊杂志，⼀种报刊可以有多⼈同时订阅，但订阅者只能收到开始订阅之后的报社发⾏的期刊。

l JMS（Java Messaging Service）是Java EE中的⼀种技术，它定义⼀套完整的接⼝，来实现不同系统或应⽤之间的消息通信。

JMS规范培训教程

ＪＭＳ规范教程2007年7月声明：本文内容译自SUN JMS1.1规范的主要部分及SUN MQ 参考资料整理制作而成，可供JMS初学者入门。

目录第1章 JMS基本概念 (1)1.1什么是JMS（J A V A M ESSAGE S ERVICE）？ (1)1.2什么是JMS中的消息（M ESSAGING）? (1)1.3如何实现JMS客户端程序的跨平台性？ (2)1.4有关两种消息方式简介 (2)1.5开发一个基于JMS的消息客户端应用的编程步骤 (4)1.6ＪＭＳ有关多线程方面的问题 (4)第2章 JMS 消息模型 (6)2.1背景： (6)2.2目标： (6)2.3JMS消息 (6)2.4消息头字段 (7)2.4.1 JMSDestination (7)2.4.2 JMSDeliveryMode (7)2.4.3 JMSMessageID (7)2.4.4 JMSTimestamp (7)2.4.5 JMSCorrelationID (8)2.4.6 JMSReplyTo (8)2.4.7 JMSRedelivered (9)2.4.8 JMSType (9)2.4.9 JMSExpiration (9)2.4.10 JMSPriority (9)2.4.11 对消息头信息如何被设置的总结 (10)2.4.12 重载消息头字段 (10)2.5消息属性 (10)2.5.1 属性名 (10)2.5.2 属性值 (10)2.5.3 使用属性 (11)2.5.4 属性值的转换 (11)2.5.5 属性值作为对象 (11)2.5.6 属性迭代 (12)2.5.7 清空消息属性值 (12)2.5.8 不存在的属性 (12)2.5.9 JMS定义的属性 (12)2.5.10 提供者指定的属性 (14)2.6M ESSAGE 确认 (14)2.7消息接口 (14)2.8M ESSAGE 选择 (14)2.8.1 Message 选择器 (14)2.8.2 消息选择语法 (15)2.8.3 Null Values 空值 (18)2.8.4 特别说明 (18)2.9访问被发送的消息 (19)2.10改变已接收的消息的值 (19)2.11JMS消息体 (19)2.11.1 清空消息体 (20)2.11.2 “只读消息体” (20)2.11.3 由StreamMessage和MapMessage提供的转换功能 (20)第3章 JMS通用设施 (22)3.1A DMINISTERED O BJECTS被管理的对象 (22)3.1.1 Destination目的地 (22)3.1.2 ConnectionFactory连接工厂。

1ACTIVEMQJMS简单实例使用TOMCAT

1ACTIVEMQJMS简单实例使用TOMCAT 在本文中，我们将介绍如何使用Tomcat构建一个简单的ActiveMQ JMS实例。

ActiveMQ是一个开源的消息中间件，它实现了JMS（Java Message Service）规范，可以帮助我们在分布式系统中进行异步通信。

Tomcat是一个流行的Java Web服务器，可以帮助我们部署和运行Java Web应用程序。

下面是一个基本的步骤，用于使用Tomcat和ActiveMQ构建一个简单的JMS应用程序。

步骤一：安装和配置Tomcat和ActiveMQ2. 配置Tomcat和ActiveMQ的环境变量。

将它们的安装路径添加到系统的PATH变量中。

3. 启动Tomcat服务器。

打开命令行终端，切换到Tomcat的安装目录，运行以下命令：```cd <tomcat_install_dir>/bin./startup.sh (Linux/Mac)startup.bat (Windows)```4. 启动ActiveMQ服务器。

打开另一个命令行终端，切换到ActiveMQ的安装目录，运行以下命令：```cd <activemq_install_dir>/bin./activemq start (Linux/Mac)activemq.bat start (Windows)```步骤二：创建一个简单的ActiveMQ JMS应用程序1. 创建一个新的Java项目，并将以下Maven依赖项添加到项目的pom.xml文件中：```xml<dependencies><dependency><groupId>org.apache.activemq</groupId><artifactId>activemq-all</artifactId><version>5.15.13</version></dependency></dependencies>```2. 创建一个JMS生产者类，用于发送消息。

深入掌握JMS(1-12)

深入掌握JMS（一）：JMS基础1. JMS基本概念JMS(Java Message Service) 即Java消息服务。

它提供标准的产生、发送、接收消息的接口简化企业应用的开发。

它支持两种消息通信模型：点到点（point-to-point）（P2P）模型和发布/订阅（Pub/Sub）模型。

P2P 模型规定了一个消息只能有一个接收者;Pub/Sub 模型允许一个消息可以有多个接收者。

对于点到点模型，消息生产者产生一个消息后，把这个消息发送到一个Queue（队列）中，然后消息接收者再从这个Queue中读取，一旦这个消息被一个接收者读取之后，它就在这个Queue中消失了，所以一个消息只能被一个接收者消费。

与点到点模型不同，发布/订阅模型中，消息生产者产生一个消息后，把这个消息发送到一个Topic中，这个Topic可以同时有多个接收者在监听，当一个消息到达这个Topic之后，所有消息接收者都会收到这个消息。

简单的讲，点到点模型和发布/订阅模型的区别就是前者是一对一，后者是一对多。

2. 几个重要概念Destination：消息发送的目的地，也就是前面说的Queue和Topic。

创建好一个消息之后，只需要把这个消息发送到目的地，消息的发送者就可以继续做自己的事情，而不用等待消息被处理完成。

至于这个消息什么时候，会被哪个消费者消费，完全取决于消息的接受者。

Message：从字面上就可以看出是被发送的消息。

它有下面几种类型：StreamMessage：Java 数据流消息，用标准流操作来顺序的填充和读取。

MapMessage：一个Map类型的消息；名称为string 类型，而值为Java 的基本类型。

TextMessage：普通字符串消息，包含一个String。

ObjectMessage：对象消息，包含一个可序列化的Java 对象BytesMessage：二进制数组消息，包含一个byte[]。

XMLMessage: 一个XML类型的消息。

JMS开发例子

JMS开发例子首先可以到网站上下载最新的openjms版本，然后启动bin下的startup.bat就启动服务了，然后可以启动admin.bat进入管理界面（非必要步骤），然后分别运行samples下的basic 例子就可以看到效果了，当然以前有篇文章介绍的不错，可以参考一下，不过时间上比较老了，做为参考还是可以的。

JMS 有五种消息类型。

三种结构化或半结构化的消息类型（MapMessage、ObjectMessage 和StreamMessage）以及两种非结构化的或自由格式的消息类型（TextMessage 和BytesMessage）。

而这里虽然我们只对非结构化消息进行说明，但非结构化的消息格式却能够更好地进行交互操作，因为它们在消息上很少利用结构，在此基础上与XML再进行结合，将能方便的进行更好的扩展，XML相关简化操作参考《Jaxb来实现Java-XML的转换》。

下面具体来介绍服务器搭建，在/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.jarjms-1.0.2a.jarexolabcore-0.3.7.jarcommons-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默认的端口是1099properties.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里的队列之一：queue1Queue queue = (Queue) context.lookup("queue1");//产生JMS队列发送器QueueSender queueSender =queueSession.createSender(queue);//发送数据到JMSTextMessage 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条消息了，而其他的队列还是空着的。

JMS五种消息的发送接收的例子

JMS五种消息的发送接收的例子1、消息发送Java代码1.//连接工厂2.ConnectionFactory connFactory = new ActiveMQConnect ionFactory(3.ActiveMQConnection.DEFAULT_USER,4.ActiveMQConnection.DEFAULT_PASSWORD,5."tcp://localhost:61616");6.7.//连接到JMS提供者8.Connection conn = connFactory.createConnection();9.conn.start();10.11.//事务性会话，自动确认消息12.Session session = conn.createSession(true, Session.AU TO_ACKNOWLEDGE);13.14.//消息的目的地15.Destination destination = session.createQueue("queue .hello");16.17.//消息生产者18.MessageProducer producer = session.createProducer( destination);19.producer.setDeliveryMode(DeliveryMode.NON_PERSIS TENT); //不持久化20.21.22.//文本消息23.TextMessage textMessage = session.createTextMessag e("文本消息");24.producer.send(textMessage);25.26.//键值对消息27.MapMessage mapMessage = session.createMapMess age();28.mapMessage.setLong("age", new Long(32));29.mapMessage.setDouble("sarray", new Double(5867.15 ));30.mapMessage.setString("username", "键值对消息");31.producer.send(mapMessage);32.33.//流消息34.StreamMessage streamMessage = session.createStrea mMessage();35.streamMessage.writeString("streamMessage流消息");36.streamMessage.writeLong(55);37.producer.send(streamMessage);38.39.//字节消息40.String s = "BytesMessage字节消息";41.BytesMessage bytesMessage = session.createBytesMe ssage();42.bytesMessage.writeBytes(s.getBytes());43.producer.send(bytesMessage);44.45.//对象消息er user = new User("cjm", "对象消息"); //User对象必须实现Serializable接口47.ObjectMessage objectMessage = session.createObject Message();48.objectMessage.setObject(user);49.producer.send(objectMessage);50.51.mit(); //在事务性会话中，只有commit之后，消息才会真正到达目的地53.producer.close();54.session.close();55.conn.close();2、消息接收：通过消息监听器的方式接收消息Java代码1.public class Receiver implements MessageListener{2.private boolean stop = false;3.4.public void execute() throws Exception {5.//连接工厂6.ConnectionFactory connFactory = new ActiveMQConnect ionFactory(7.ActiveMQConnection.DEFAULT_USER,8.ActiveMQConnection.DEFAULT_PASSWORD,9."tcp://localhost:61616");10.11.//连接到JMS提供者12.Connection conn = connFactory.createConnection();13.conn.start();14.15.//事务性会话，自动确认消息16.Session session = conn.createSession(true, Session.AU TO_ACKNOWLEDGE);17.18.//消息的来源地19.Destination destination = session.createQueue("queue .hello");20.21.//消息消费者22.MessageConsumer consumer = session.createConsum er(destination);23.consumer.setMessageListener(this);24.25.//等待接收消息26.while(!stop){27.Thread.sleep(5000);28.}29.mit();31.32.consumer.close();33.session.close();34.conn.close();35.}36.37.public void onMessage(Message m) {38.try{39.if(m instanceof TextMessage){ //接收文本消息40.TextMessage message = (TextMessage)m;41.System.out.println(message.getText());42.}else if(m instanceof MapMessage){ //接收键值对消息43.MapMessage message = (MapMessage)m;44.System.out.println(message.getLong("age"));45.System.out.println(message.getDouble("sarray"));46.System.out.println(message.getString("username"));47.}else if(m instanceof StreamMessage){ //接收流消息48.StreamMessage message = (StreamMessage)m;49.System.out.println(message.readString());50.System.out.println(message.readLong());51.}else if(m instanceof BytesMessage){ //接收字节消息52.byte[] b = new byte[1024];53.int len = -1;54.BytesMessage message = (BytesMessage)m;55.while((len=message.readBytes(b))!=-1){56.System.out.println(new String(b, 0, len));57.}58.}else if(m instanceof ObjectMessage){ //接收对象消息59.ObjectMessage message = (ObjectMessage)m;er user = (User)message.getObject();61.System.out.println(user.getUsername() + " _ " + user.g etPassword());62.}else{63.System.out.println(m);64.}65.66.stop = true;67.}catch(JMSException e){68.stop = true;69. e.printStackTrace();70.}71.}72.}。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

JMS是一个由AS提供的Message服务。

它能接受消息产生者(Message Provider)所发出的消息，并把消息转发给消息消费者(Message Consumer)。

2、JMS提供2种类型的消息服务：(1)Queue，即点对点，每个消息只转发给一个消息消费者使用。

(2)Topic，即发布和订阅，每个消息可以转发给所有的订阅者(消费者)。

4、消息产生者向JMS发送消息的步骤：(1)使用JNDI查询对象JMS ConnectionFactory和Destination(JMS Queue/Topic)(2)使用管理对象JMS ConnectionFactory建立连接Connection(3)使用连接Connection 建立会话Session(4)使用会话Session和管理对象Destination创建消息生产者MessageSender(5)使用消息生产者MessageSender发送消息一个消息发送者的例子：package myjms;import java.util.*;import javax.naming.*;import javax.jms.*;public class MessageProducter {public static void main(String[] args) {String queueConnectionFactoryName = "myjmsconnectionfactory"; //JMS Connection Factory的JNDIString queueName = "myjmsqueue"; //JMS Queue或者JMS Topic的JNDI boolean transacted = false;//transaction模式int acknowledgementMode =Session.AUTO_ACKNOWLEDGE;//acknowledgement模式String message="Message need to send";//模拟需要发送的消息Properties properties = new Properties();properties.put(Context.INITIAL_CONTEXT_FACTORY,"weblogic.jndi.WLIniti alContextFactory");properties.put(Context.PROVIDER_URL, "t3://localhost:7001");try {Context context = new InitialContext(properties);Object obj = context.lookup(queueConnectionFactoryName);QueueConnectionFactory queueConnectionFactory = (QueueConnectionFactory) obj;//JMS Connection Factory的获得obj = context.lookup(queueName);Queue queue = (Queue) obj;//JMS Queue或者JMS Topic的获得QueueConnectionqueueConnection=queueConnectionFactory.createQueueConnection();//产生连接queueConnection.start();QueueSession queueSession =queueConnection.createQueueSession(transacted, acknowledgementMode);TextMessage textMessage = queueSession.createTextMessage();textMessage.clearBody();textMessage.setText(message);QueueSender queueSender = queueSession.createSender(queue);queueSender.send(textMessage);if (transacted) {mit();}if (queueSender != null) {queueSender.close();}if (queueSession != null) {queueSession.close();}if (queueConnection != null) {queueConnection.close();}}catch(Exception ex){ex.printStackTrace();}}}5、消息消费者从JMS接受消息的步骤：(1)使用JNDI查询对象JMS ConnectionFactory和Destination(JMS Queue/Topic)(2)使用管理对象JMS ConnectionFactory建立连接Connection(3)使用连接Connection 建立会话Session(4)使用会话Session和管理对象Destination创建消息消费者MessageReceiver(5)使用消息消费者MessageReceiver接受消息，需要用setMessageListener将MessageListener接口绑定到MessageReceiver消息消费者必须实现了MessageListener接口，需要定义onMessage事件方法。

一个消息消费者的例子：package myjms;import java.util.*;import javax.naming.*;import javax.jms.*;public class MessageRecieverimplements MessageListener {public void onMessage(Message message) {if (message instanceof TextMessage) {TextMessage textMessage = (TextMessage) message;try {System.out.println("Message content is:" + textMessage.getText());}catch (JMSException e) {e.printStackTrace();}}}public static void main(String[] args) {MessageReciever msgRcvr=new MessageReciever();String queueConnectionFactoryName = "myjmsconnectionfactory";String queueName = "myjmsqueue";boolean transacted = false;int acknowledgementMode = Session.AUTO_ACKNOWLEDGE;Properties properties = new Properties();properties.put(Context.INITIAL_CONTEXT_FACTORY,"weblogic.jndi.WLInitialContextFactory");properties.put(Context.PROVIDER_URL, "t3://localhost:7001");try {Context context = new InitialContext(properties);Object obj = context.lookup(queueConnectionFactoryName);QueueConnectionFactory queueConnectionFactory = (QueueConnectionFactory)obj;obj = context.lookup(queueName);Queue queue = (Queue) obj;QueueConnection queueConnection = queueConnectionFactory.createQueueConnection();queueConnection.start();QueueSession queueSession =queueConnection.createQueueSession(transacted,acknowledgementMode);QueueReceiver queueReceiver = queueSession.createReceiver(queue);queueReceiver.setMessageListener(msgRcvr);synchronized(msgRcvr){msgRcvr.wait(100000);}if (queueReceiver != null) {queueReceiver.close();}if (queueSession != null) {queueSession.close();}if (queueConnection != null) {queueConnection.close();}}catch (Exception ex) {ex.printStackTrace();}}}6、Message-driven BeanMDB实际上就是一个消息消费者的客户端程序。

它由AS EJB Container来管理。

在JBUILDER生成一个MDB非常简单。