BlogJava-少年阿宾-随笔分类-ActiveMQ

Apache ActiveMQ or Spring 使用方法

abin — Sun, 26 Aug 2012 12:18:00 GMT

Apache ActiveMQ简介： MQ是Apache出品的一个基于JMS消息处理机制的服务，可以很容易的潜入到Spring中，作为项目消息处理服务。

Apache ActiveMQ用途： jms有两种消息机制一种是消息队列，一种是消息订阅，简单来说就是一对一，和一对多。

一对一可以看做一组消息对应一个或多个消息获取服务，其中每一个单独的消息体都只会被一个消息获取服务获取。

一对多可以看做一组消息对应一个或多个接收服务，其中每一个单独的消息体发出之后都会被所有的接收服务收到一次。

根据以上两种模式我们可以在发送短信的时候使用消息队列模式。也可以在分布式的时候使用消息队列模式

消息订阅模式用的不是很多但是，在分布式中也可以应用同时可以结合WebService进行使用。例如一个新闻需要发给多个系统内的单独服务。

只要深刻理解了他的处理机制在很多情况下都可以应用，如果实在不喜欢这种方式也可以遵照java JMS的API用线程自己模拟消息队列机制。

我个人认为区别不是很大。更何况很多时候MQ的很多功能我们有没有用到，用这么个大家伙就是为了图省事。

这里备注一下：按原有设定在创建连接的时候MQ是不发送消息的。

下面我说以下使用方式：

本人目前只会JAVA

需要的包为

        activemq-all-5.2.0.jar
       log4j-1.2.14.jar
       spring-beans-2.5.5.jar
       spring-context-2.5.5.jar
       spring-jms-2.5.5.jar

spring-core-2.5.5.jar

这些应该就足够了

我做测试的时候用的包为

        activemq-all-5.2.0.jar
       commons-pool-1.4.jar
       log4j-1.2.14.jar
       spring-beans-2.5.5.jar
       spring-context-2.5.5.jar
       spring-core-2.5.5.jar
       spring-jms-2.5.5.jar
       spring-tx-2.5.5.jar
       spring-web-2.5.5.jar
       spring-webmvc-2.5.5.jar
       xbean-spring-3.4.jar
       msbase.jar
       mssqlserver.jar
       msutil.jar
       mysql-connector-java-5.0.4-bin.jar
       mysql.jar

基本配置

下载 Apache ActiveMQ 不知道的googlean

安装服务的文件在

apache-activemq-5.5.0\bin\win32 目录下面Linux版也一样大同小异运行.sh文件就好，如果出现问题请打开运行文件查看里面参数

activemq.bat直接运行启动服务

InstallService.bat安装成windos服务

UninstallService.bat卸载windos服务

安装成功后

在运行中 cmd

netstat -an|find “61616” 查询端口是否已经打开

D:\apache-activemq-5.5.0\conf\activemq.xml 本文件为服务配置文件

这一项为端口设置

默认为 “61616”

目前以windos为例

把spring和项目联系起来

第一步为web.xml

   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
   http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">

       contextConfigLocation

           /WEB-INF/classes/NewFileMQ.xml




           org.springframework.web.context.ContextLoaderListener

index.jsp

先说一下消息队列（也就是一对一）

NewFileMQ.xml

   xmlns:amq="http://activemq.apache.org/schema/core"
   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-2.0.xsd
http://activemq.apache.org/schema/core
http://activemq.apache.org/schema/core/activemq-core.xsd">

           class="org.springframework.jms.listener.DefaultMessageListenerContainer">

发送消息的类

package message;

import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.Session;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;

public class Sender {

   private JmsTemplate jmsTemplate;

   public void setJmsTemplate(JmsTemplate jmsTemplate) {
       this.jmsTemplate = jmsTemplate;
   }

   public void send(final String text){
       System.out.println("---Send:"+text);
       jmsTemplate.send(new MessageCreator(){

           public Message createMessage(Session arg0) throws JMSException {
               // TODO Auto-generated method stub
               return arg0.createTextMessage(text);
           }

       });
   }

    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml");
        JmsTemplate template = (JmsTemplate) ctx.getBean("jmsTemplate");
        Destination destination = (Destination) ctx.getBean("destination");
for(int i=0;i<10;i++){
   final String dd = i+"";
//jmsTemplate.convertAndSend(destination,"发送消息： ActiveMQ Text Message！"+dd);
        template.send(destination, new MessageCreator() {
                public Message createMessage(Session session) throws JMSException {
                        return session.createTextMessage("发送消息： ActiveMQ Text Message！"+dd);
                }
        });
}
        System.out.println("成功发送了一条JMS消息");
}
}
接收消息类

package message;

import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;

import org.apache.xbean.spring.context.ClassPathXmlApplicationContext;
import org.springframework.context.ApplicationContext;
import org.springframework.jms.core.JmsTemplate;

public class Receiver implements MessageListener {
//接听接收
   public void onMessage(Message message) {
       if (message instanceof TextMessage) {
           TextMessage text = (TextMessage) message;

           try {
               System.out.println("Receive:第四个接收者" + text.getText());
           } catch (JMSException e) {
               // TODO Auto-generated catch block
               e.printStackTrace();
           }

       }
   }
    //手动接收
       public static void main(String[] args) throws JMSException {
           ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml");
           JmsTemplate template = (JmsTemplate) ctx.getBean("jmsTemplate");
           Destination destination = (Destination) ctx.getBean("destination");
           while (true) {
                   TextMessage txtmsg = (TextMessage) template.receive(destination);
                   if (null != txtmsg)
                           System.out.println("收到消息内容为: " + txtmsg.getText());
                   else
                           break;
           }
   }
}

发布者模式

其实两种模式其它设置基本相同

唯一不用的就是 Spring配置文件中把一下这段替换一下就可以了

http://hi.baidu.com/wu_chao/blog/item/1d9aa2772e663107b051b9cc.html

abin 2012-08-26 20:18 发表评论

spring-activemq

abin — Sat, 25 Aug 2012 13:34:00 GMT

1,项目中所引的包

2，发送和接受消息的代码，每个都是一个Junit函数

package test;

import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.Session;
import javax.jms.TextMessage;

import junit.framework.TestCase;

import org.apache.xbean.spring.context.ClassPathXmlApplicationContext;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;

public class ActivemqTest extends TestCase {
@Test
public void testJmsTemplateSend() {

  ApplicationContext ctx = new FileSystemXmlApplicationContext(
    "WebRoot/WEB-INF/applicationContext.xml");
  JmsTemplate template = (JmsTemplate) ctx.getBean("jmsTemplate");
  Destination destination = (Destination) ctx.getBean("destination");

  template.send(destination, new MessageCreator() {
   public Message createMessage(Session session) throws JMSException {
    return session.createTextMessage("发送消息：Hello ActiveMQ Text Message！");
   }
  });
  System.out.println("成功发送了一条JMS消息");
}

@Test
public void testJmsTemplateReceive() throws JMSException {
  ApplicationContext ctx = new FileSystemXmlApplicationContext(
    "WebRoot/WEB-INF/applicationContext.xml");
  JmsTemplate template = (JmsTemplate) ctx.getBean("jmsTemplate");
  Destination destination = (Destination) ctx.getBean("destination");
  while (true) {
   TextMessage txtmsg = (TextMessage) template.receive(destination);
   if (null != txtmsg)
    System.out.println("收到消息内容为: " + txtmsg.getText());
   else
    break;
  }
}

public static void main(String[] args) throws Exception{
  new ActivemqTest().testJmsTemplateSend();

  new ActivemqTest().testJmsTemplateReceive();
}
}

3，applicationContext.xml文件内容

http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-2.5.xsd">

















http://blog.csdn.net/hnzhangshilong/article/details/6629780

abin 2012-08-25 21:34 发表评论

ActiveMQ StreamMessage

abin — Thu, 02 Aug 2012 08:35:00 GMT

package org.abin.lee.activemq;

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.DeliveryMode;
import javax.jms.Destination;
import javax.jms.MapMessage;
import javax.jms.MessageProducer;
import javax.jms.Session;

import org.apache.activemq.ActiveMQConnection;
import org.apache.activemq.ActiveMQConnectionFactory;

public class MapSender {

private static final int SEND_NUMBER = 5;

public static void main(String[] args) {
  ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(
    ActiveMQConnection.DEFAULT_USER,
    ActiveMQConnection.DEFAULT_PASSWORD, "tcp://localhost:61616");
  Connection connection = null;
  Session session;
  Destination destination = null;
  MessageProducer messageProducer;
  try {
   connection=connectionFactory.createConnection();
   connection.start();
   session=connection.createSession(Boolean.TRUE, Session.AUTO_ACKNOWLEDGE);
   destination=session.createQueue("FirstQueue");
   messageProducer=session.createProducer(destination);
   messageProducer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);

   MapMessage map=session.createMapMessage();
   map.setBoolean("flag", true);
   map.setDouble("dou", 1.01);
   map.setInt("zx", 88);
   map.setString("zifu", "zzzzzz");
   messageProducer.send(map);
   session.commit();
  } catch (Exception e) {
   e.printStackTrace();
  }
}

}

package org.abin.lee.activemq;

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.MapMessage;
import javax.jms.MessageConsumer;
import javax.jms.Session;

import org.apache.activemq.ActiveMQConnection;
import org.apache.activemq.ActiveMQConnectionFactory;

public class MapReceiver {public static void main(String[] args) {
ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(
   ActiveMQConnection.DEFAULT_USER,
   ActiveMQConnection.DEFAULT_PASSWORD, "tcp://localhost:61616");
Connection connection = null;
Session session;
Destination destination;
MessageConsumer consumer;
try {
  connection = connectionFactory.createConnection();
  connection.start();
  session = connection.createSession(Boolean.FALSE,
    Session.AUTO_ACKNOWLEDGE);
  destination = session.createQueue("FirstQueue");
  consumer = session.createConsumer(destination);
  while(true){
   MapMessage map=(MapMessage)consumer.receive(500000);
   if (null != map) {
    boolean flag=map.getBoolean("falg");
    System.out.println("AcitveMQ 接收到的消息 flag="+flag);
    double dou=map.getDouble("dou");
    System.out.println("AcitveMQ 接收到的消息 dou="+dou);
    int zx=map.getInt("zx");
    System.out.println("AcitveMQ 接收到的消息 zx="+zx);
    String zifu=map.getString("zifu");
    System.out.println("AcitveMQ 接收到的消息 zifu="+zifu);
   }else
    break;

  }

} catch (Exception e) {
e.printStackTrace();
}

}
}

abin 2012-08-02 16:35 发表评论

ActiveMQ入门示例

abin — Thu, 02 Aug 2012 06:59:00 GMT

企业中各项目中相互协作的时候可能用得到消息通知机制。比如有东西更新了，可以通知做索引。

在 Java 里有 JMS 的多个实现。其中 apache 下的 ActiveMQ 就是不错的选择。ActiveMQ 是Apache出品，最流行的，能力强劲的开源消息总线。ActiveMQ 是一个完全支持JMS1.1和J2EE 1.4规范的 JMS Provider实现。这里示例下使用 ActiveMQ

用 ActiveMQ 最好还是了解下 JMS

JMS 公共	点对点域	发布/订阅域
ConnectionFactory	QueueConnectionFactory	TopicConnectionFactory
Connection	QueueConnection	TopicConnection
Destination	Queue	Topic
Session	QueueSession	TopicSession
MessageProducer	QueueSender	TopicPublisher
MessageConsumer	QueueReceiver	TopicSubscriber

JMS 定义了两种方式：Quere（点对点）；Topic（发布/订阅）。

ConnectionFactory 是连接工厂，负责创建Connection。

Connection 负责创建 Session。

Session 创建 MessageProducer（用来发消息）和 MessageConsumer（用来接收消息）。

Destination 是消息的目的地。

详细的可以网上找些 JMS 规范（有中文版）。

下载 apache-activemq-5.3.0。http://activemq.apache.org/download.html ，解压，然后双击 bin/activemq.bat。运行后，可以在 http://localhost:8161/admin 观察。也有 demo， http://localhost:8161/demo 。把 activemq-all-5.3.0.jar 加入 classpath。

Jms 发送代码：

public static void main(String[] args) throws Exception {
    ConnectionFactory connectionFactory = new ActiveMQConnectionFactory();

    Connection connection = connectionFactory.createConnection();
    connection.start();

    Session session = connection.createSession(Boolean.TRUE, Session.AUTO_ACKNOWLEDGE);
    Destination destination = session.createQueue("my-queue");

    MessageProducer producer = session.createProducer(destination);
    for(int i=0; i<3; i++) {
        MapMessage message = session.createMapMessage();
        message.setLong("count", new Date().getTime());
        Thread.sleep(1000);
        //通过消息生产者发出消息
        producer.send(message);
    }
    session.commit();
    session.close();
    connection.close();
}

Jms 接收代码：

public static void main(String[] args) throws Exception {
    ConnectionFactory connectionFactory = new ActiveMQConnectionFactory();

    Connection connection = connectionFactory.createConnection();
    connection.start();

    final Session session = connection.createSession(Boolean.TRUE, Session.AUTO_ACKNOWLEDGE);
    Destination destination = session.createQueue("my-queue");

    MessageConsumer consumer = session.createConsumer(destination);
    int i=0;
    while(i<3) {
        i++;
        MapMessage message = (MapMessage) consumer.receive();
        session.commit();

        //TODO something....
        System.out.println("收到消息：" + new Date(message.getLong("count")));
    }

    session.close();
    connection.close();
}

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

转自：http://chenjumin.javaeye.com/blog/687124

1、消息发送

//连接工厂
ConnectionFactory connFactory = new ActiveMQConnectionFactory(
        ActiveMQConnection.DEFAULT_USER,
        ActiveMQConnection.DEFAULT_PASSWORD,
        "tcp://localhost:61616");

//连接到JMS提供者
Connection conn = connFactory.createConnection();
conn.start();

//事务性会话，自动确认消息
Session session = conn.createSession(true, Session.AUTO_ACKNOWLEDGE);

//消息的目的地
Destination destination = session.createQueue("queue.hello");

//消息生产者
MessageProducer producer = session.createProducer(destination);
producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT); //不持久化

//文本消息
TextMessage textMessage = session.createTextMessage("文本消息");
producer.send(textMessage);

//键值对消息
MapMessage mapMessage = session.createMapMessage();
mapMessage.setLong("age", new Long(32));
mapMessage.setDouble("sarray", new Double(5867.15));
mapMessage.setString("username", "键值对消息");
producer.send(mapMessage);

//流消息
StreamMessage streamMessage = session.createStreamMessage();
streamMessage.writeString("streamMessage流消息");
streamMessage.writeLong(55);
producer.send(streamMessage);

//字节消息
String s = "BytesMessage字节消息";
BytesMessage bytesMessage = session.createBytesMessage();
bytesMessage.writeBytes(s.getBytes());
producer.send(bytesMessage);

//对象消息
User user = new User("cjm", "对象消息"); //User对象必须实现Serializable接口
ObjectMessage objectMessage = session.createObjectMessage();
objectMessage.setObject(user);
producer.send(objectMessage);

session.commit(); //在事务性会话中，只有commit之后，消息才会真正到达目的地
producer.close();
session.close();
conn.close();

2、消息接收：通过消息监听器的方式接收消息

public class Receiver implements MessageListener{
    private boolean stop = false;

    public void execute() throws Exception {
        //连接工厂
        ConnectionFactory connFactory = new ActiveMQConnectionFactory(
                ActiveMQConnection.DEFAULT_USER,
                ActiveMQConnection.DEFAULT_PASSWORD,
                "tcp://localhost:61616");

        //连接到JMS提供者
        Connection conn = connFactory.createConnection();
        conn.start();

        //事务性会话，自动确认消息
        Session session = conn.createSession(true, Session.AUTO_ACKNOWLEDGE);

        //消息的来源地
        Destination destination = session.createQueue("queue.hello");

        //消息消费者
        MessageConsumer consumer = session.createConsumer(destination);
        consumer.setMessageListener(this);

        //等待接收消息
        while(!stop){
            Thread.sleep(5000);
        }

        session.commit();

        consumer.close();
        session.close();
        conn.close();
    }

    public void onMessage(Message m) {
        try{
            if(m instanceof TextMessage){ //接收文本消息
                TextMessage message = (TextMessage)m;
                System.out.println(message.getText());
            }else if(m instanceof MapMessage){ //接收键值对消息
                MapMessage message = (MapMessage)m;
                System.out.println(message.getLong("age"));
                System.out.println(message.getDouble("sarray"));
                System.out.println(message.getString("username"));
            }else if(m instanceof StreamMessage){ //接收流消息
                StreamMessage message = (StreamMessage)m;
                System.out.println(message.readString());
                System.out.println(message.readLong());
            }else if(m instanceof BytesMessage){ //接收字节消息
                byte[] b = new byte[1024];
                int len = -1;
                BytesMessage message = (BytesMessage)m;
                while((len=message.readBytes(b))!=-1){
                    System.out.println(new String(b, 0, len));
                }
            }else if(m instanceof ObjectMessage){ //接收对象消息
                ObjectMessage message = (ObjectMessage)m;
                User user = (User)message.getObject();
                System.out.println(user.getUsername() + " _ " + user.getPassword());
            }else{
                System.out.println(m);
            }

            stop = true;
        }catch(JMSException e){
            stop = true;
            e.printStackTrace();
        }
    }
}

http://blog.csdn.net/caihaijiang/article/details/5903296

abin 2012-08-02 14:59 发表评论

ActiveMQ入门实例

abin — Sat, 07 Jul 2012 06:47:00 GMT

1.下载ActiveMQ

去官方网站下载：http://activemq.apache.org/

2.运行ActiveMQ

解压缩apache-activemq-5.5.1-bin.zip，然后双击apache-activemq-5.5.1\bin\activemq.bat运行ActiveMQ程序。

启动ActiveMQ以后，登陆：http://localhost:8161/admin/，创建一个Queue，命名为FirstQueue。

3.创建Eclipse项目并运行

创建project：ActiveMQ-5.5，并导入apache-activemq-5.5.1\lib目录下需要用到的jar文件，项目结构如下图所示：

3.1.Sender.java

package com.xuwei.activemq;

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 {
    private static final int SEND_NUMBER = 5;

    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的实现jar
        connectionFactory = 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");
            // 得到消息生成者【发送者】
            producer = session.createProducer(destination);
            // 设置不持久化，此处学习，实际根据项目决定
            producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);
            // 构造消息，此处写死，项目就是参数，或者方法获取
            sendMessage(session, producer);
            session.commit();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (null != connection)
                    connection.close();
            } catch (Throwable ignore) {
            }
        }
    }

    public static void sendMessage(Session session, MessageProducer producer)
            throws Exception {
        for (int i = 1; i <= SEND_NUMBER; i++) {
            TextMessage message = session
                    .createTextMessage("ActiveMq 发送的消息" + i);
            // 发送消息到目的地方
            System.out.println("发送消息：" + "ActiveMq 发送的消息" + i);
            producer.send(message);
        }
    }
}

3.2.Receiver.java

package com.xuwei.activemq;

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");
            consumer = session.createConsumer(destination);
            while (true) {
                //设置接收者接收消息的时间，为了便于测试，这里谁定为100s
                TextMessage 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) {
            }
        }
    }
}

4.注意事项

最后接收者跟发送者在不同的机器上测试
项目所引用的jar最后在ActiveMQ下的lib中找，这样不会出现版本冲突。

5.测试过程

因为是在单机上测试，所以需要开启两个eclipse，每一个eclipse都有自身的workspace。我们在eclipse1中运行Receiver，在eclipse2中运行Sender。

刚开始eclipse1中运行Receiver以后console介面没有任何信息，在eclipse2中运行Sender以后，eclipse2中的console显示如下信息：

发送消息：ActiveMq 发送的消息1
发送消息：ActiveMq 发送的消息2
发送消息：ActiveMq 发送的消息3
发送消息：ActiveMq 发送的消息4
发送消息：ActiveMq 发送的消息5

而回到eclipse1中发现console界面出现如下信息：

收到消息ActiveMq 发送的消息1
收到消息ActiveMq 发送的消息2
收到消息ActiveMq 发送的消息3
收到消息ActiveMq 发送的消息4
收到消息ActiveMq 发送的消息5

PS:2012-2-27

今天发现测试并不需要开启两个eclipse，在一个eclipse下页可以启动多个程序，并且有多个console，在上面的Receiver.java中，设置一个较大的时间，比如receive(500000)，如下代码所示：

TextMessage message = (TextMessage) consumer.receive(500000);

这个时候运行Receiver.java的话，会使得这个Receiver.java一直运行500秒，在eclipse中可以发现：

点击那个红色方块可以手动停止运行程序。

运行玩receiver以后我们在运行sender，在运行完sender以后，我们要切换到receiver的console，如下图所示：

http://www.cnblogs.com/xwdreamer/archive/2012/02/21/2360818.html

abin 2012-07-07 14:47 发表评论