JMS学习二（简单的ActiveMQ实例）

前一篇文章我们整体上学习了JMS，这篇文章我们来写写小demo实践一下

在写之前我们要下载安装ActiveMQ服务，下载地址当然可以去官网下载，但我下载下来的有Linux 和win两个版本但是win的只有32位的，所以这里给一个win32、64的下载地址

下载ActiveMQ5.9

ActiveMQ安装很简单，下载解压后到bin目录就有win32 和win64两个目录按照自己的系统进入后就有activemq.bat来启动ActiveMQ服务

一、点对点消息模型实例

使用queue作为目的之

1、消息发送端

[java] view plain copy

print ?

1. package mqtest1;  
2.   
3. import javax.jms.Connection;  
4. import javax.jms.ConnectionFactory;  
5. import javax.jms.DeliveryMode;  
6. import javax.jms.JMSException;  
7. import javax.jms.MessageProducer;  
8. import javax.jms.Queue;  
9. import javax.jms.Session;  
10. import javax.jms.TextMessage;  
11.   
12. import org.apache.activemq.ActiveMQConnectionFactory;  
13.   
14. public class Producer {  
15.     public static void main(String[] args) {  
16.         int i =0;  
17.         //链接工厂  
18.         ActiveMQConnectionFactory connectionFactory = null;  
19.         //链接对象  
20.         Connection connection = null;  
21.         //会话  
22.         Session session = null;  
23.         //队列（目的地、生产者发送消息的目的地）  
24.         Queue  queue = null;  
25.         //消息生产者  
26.         MessageProducer producer = null;  
27.         connectionFactory = new ActiveMQConnectionFactory(“admin”,“admin”,“tcp://192.168.1.120:61616”);  
28.         try {  
29.             connection = connectionFactory.createConnection();  
30.             connection.start();  
31.             //第一个参数是否开启事务 true开启 ,false不开启事务，如果开启记得手动提交  
32.             //参数二，表示的是签收模式，一般使用的有自动签收和客户端自己确认签收  
33.             session = connection.createSession(true, Session.AUTO_ACKNOWLEDGE);  
34.             queue  = session.createQueue(”test_queue”);  
35.             //为队列创建消息生产者  
36.              producer =  session.createProducer(queue);  
37.             //消息是否为持久性的，这个不设置也是可以的，默认是持久的  
38.             //producer.setDeliveryMode(DeliveryMode.PERSISTENT); //消息设置为持久的发送后及时服务关闭了再次开启消息也不会丢失。  
39.             //producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT); //发送后如果服务关闭再次开启则消息会丢失。  
40.             while (true){  
41.                 //创建消息  
42.                 TextMessage message = session.createTextMessage();  
43.                 message.setText(”测试队列消息”+i);  
44.                 //发送消息到目的地  
45.                 producer.send(message);  
46.                 i++;  
47.                 if(i>10) {  
48.                     break;  
49.                 }  
50.             }  
51.             session.commit();  
52.             System.out.println(”呵呵消息发送结束”);  
53.         } catch (JMSException e) {  
54.             // TODO Auto-generated catch block  
55.             e.printStackTrace();  
56.         } finally  {  
57.             //释放资源  
58.                 //producer.close();  
59.                 //session.close();  
60.                 //connection.close();  
61.         }  
62.     }  
63. }  

package mqtest1;

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.DeliveryMode;
import javax.jms.JMSException;
import javax.jms.MessageProducer;
import javax.jms.Queue;
import javax.jms.Session;
import javax.jms.TextMessage;

import org.apache.activemq.ActiveMQConnectionFactory;

public class Producer {
    public static void main(String[] args) {
        int i =0;
        //链接工厂
        ActiveMQConnectionFactory connectionFactory = null;
        //链接对象
        Connection connection = null;
        //会话
        Session session = null;
        //队列（目的地、生产者发送消息的目的地）
        Queue  queue = null;
        //消息生产者
        MessageProducer producer = null;
        connectionFactory = new ActiveMQConnectionFactory("admin","admin","tcp://192.168.1.120:61616");
        try {
            connection = connectionFactory.createConnection();
            connection.start();
            //第一个参数是否开启事务 true开启 ,false不开启事务，如果开启记得手动提交
            //参数二，表示的是签收模式，一般使用的有自动签收和客户端自己确认签收
            session = connection.createSession(true, Session.AUTO_ACKNOWLEDGE);
            queue  = session.createQueue("test_queue");
            //为队列创建消息生产者
             producer =  session.createProducer(queue);
            //消息是否为持久性的，这个不设置也是可以的，默认是持久的
            //producer.setDeliveryMode(DeliveryMode.PERSISTENT); //消息设置为持久的发送后及时服务关闭了再次开启消息也不会丢失。
            //producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT); //发送后如果服务关闭再次开启则消息会丢失。
            while (true){
                //创建消息
                TextMessage message = session.createTextMessage();
                message.setText("测试队列消息"+i);
                //发送消息到目的地
                producer.send(message);
                i++;
                if(i>10) {
                    break;
                }
            }
            session.commit();
            System.out.println("呵呵消息发送结束");
        } catch (JMSException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally  {
            //释放资源
                //producer.close();
                //session.close();
                //connection.close();
        }
    }
}

2、消息消费端

[java] view plain copy

print ?

1. package mqtest1;  
2.   
3. import javax.jms.Connection;  
4. import javax.jms.JMSException;  
5. import javax.jms.Message;  
6. import javax.jms.MessageConsumer;  
7. import javax.jms.MessageListener;  
8. import javax.jms.MessageProducer;  
9. import javax.jms.Queue;  
10. import javax.jms.Session;  
11. import javax.jms.TextMessage;  
12.   
13. import org.apache.activemq.ActiveMQConnectionFactory;  
14.   
15. public class Receive {  
16.     public static void main(String[] args) {  
17.         // 链接工厂  
18.         ActiveMQConnectionFactory connectionFactory = null;  
19.         // 链接对象  
20.         Connection connection = null;  
21.         // 会话  
22.         Session session = null;  
23.         // 队列（目的地，消费者消费消息的地方）  
24.         Queue queue = null;  
25.         // 消息消费者  
26.         MessageConsumer consumer = null;  
27.         connectionFactory = new ActiveMQConnectionFactory(“admin”, “admin”,  
28.                 ”tcp://192.168.1.120:61616”);  
29.         try {  
30.             connection = connectionFactory.createConnection();  
31.             connection.start();  
32.             // 创建session是的true 和false  
33.             session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);  
34.             queue = session.createQueue(”test_queue”); // 队列（目的地，消费者消费消息的地方）  
35.             consumer = session.createConsumer(queue); // 消息消费者  
36.             // Message message = consumer.receive(); //同步方式接收  
37.             consumer.setMessageListener(new MessageListener() {  
38.                 @Override  
39.                 public void onMessage(Message message) {  
40.                     TextMessage textMessage = (TextMessage) message;  
41.                     try {  
42.                         String value = textMessage.getText();  
43.                         System.out.println(”value: ” + value);  
44.                     } catch (JMSException e) {  
45.                         // TODO Auto-generated catch block  
46.                         e.printStackTrace();  
47.                     }  
48.                 }  
49.             });  
50.         } catch (JMSException e) {  
51.             // TODO Auto-generated catch block  
52.             e.printStackTrace();  
53.         }  
54.     }  
55. }  

package mqtest1;

import javax.jms.Connection;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageListener;
import javax.jms.MessageProducer;
import javax.jms.Queue;
import javax.jms.Session;
import javax.jms.TextMessage;

import org.apache.activemq.ActiveMQConnectionFactory;

public class Receive {
    public static void main(String[] args) {
        // 链接工厂
        ActiveMQConnectionFactory connectionFactory = null;
        // 链接对象
        Connection connection = null;
        // 会话
        Session session = null;
        // 队列（目的地，消费者消费消息的地方）
        Queue queue = null;
        // 消息消费者
        MessageConsumer consumer = null;
        connectionFactory = new ActiveMQConnectionFactory("admin", "admin",
                "tcp://192.168.1.120:61616");
        try {
            connection = connectionFactory.createConnection();
            connection.start();
            // 创建session是的true 和false
            session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
            queue = session.createQueue("test_queue"); // 队列（目的地，消费者消费消息的地方）
            consumer = session.createConsumer(queue); // 消息消费者
            // Message message = consumer.receive(); //同步方式接收
            consumer.setMessageListener(new MessageListener() {
                @Override
                public void onMessage(Message message) {
                    TextMessage textMessage = (TextMessage) message;
                    try {
                        String value = textMessage.getText();
                        System.out.println("value: " + value);
                    } catch (JMSException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            });
        } catch (JMSException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

点对点模型Destination作为目的地

1、消息发送端

[java] view plain copy

print ?

1. package mq;  
2.   
3. import javax.jms.Connection;  
4. import javax.jms.ConnectionFactory;  
5. import javax.jms.DeliveryMode;  
6. import javax.jms.Destination;  
7. import javax.jms.JMSException;  
8. import javax.jms.MessageProducer;  
9. import javax.jms.Queue;  
10. import javax.jms.Session;  
11. import javax.jms.Topic;  
12.   
13. import org.apache.activemq.ActiveMQConnectionFactory;  
14.   
15. public class TestMQ {  
16.     public static void main(String[] args) {  
17.         int i =0;  
18.         //链接工厂  
19.         ConnectionFactory connectionFactory = null;  
20.         // 链接对象  
21.         Connection connection = null;  
22.         // 会话对象  
23.         Session session = null;  
24.         // 目的地  
25.         Destination destination = null;  
26.         // 消息生产者  
27.         MessageProducer producer = null;  
28.         connectionFactory = new ActiveMQConnectionFactory(“admin”,“admin”,“tcp://192.168.1.120:61616”);  
29.         try {  
30.             connection = connectionFactory.createConnection();  
31.             connection.start();  
32.             //第一个参数是否开启事务 true开启 ,false不开启事务，如果开启记得手动提交  
33.             //参数二，表示的是签收模式，一般使用的有自动签收和客户端自己确认签收  
34.             session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);  
35.             destination = session.createQueue(”test-queue”);  
36.             //为目的地创建消息生产者  
37.             producer = session.createProducer(destination);  
38.             //消息是否为持久性的，这个不设置也是可以的，默认是持久的  
39.             producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);  
40.             while(true) {  
41.                 TestBean tbean = new TestBean();  
42.                 tbean.setAge(25);  
43.                 tbean.setName(”hellojava” +i);  
44.                 producer.send(session.createObjectMessage(tbean));  
45.                 i++;  
46.                 if( i>10) {  
47.                     break;  
48.                 }  
49.             }  
50.             System.out.println(”呵呵消息已发送”);  
51.         } catch (JMSException e) {  
52.             // TODO Auto-generated catch block  
53.             e.printStackTrace();  
54.         } finally {  
55.             try {  
56.                 producer.close();  
57.                 session.close();  
58.                 connection.close();  
59.             } catch (JMSException e) {  
60.                 // TODO Auto-generated catch block  
61.                 e.printStackTrace();  
62.             }  
63.         }  
64.     }  
65. }  

package mq;

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.DeliveryMode;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.MessageProducer;
import javax.jms.Queue;
import javax.jms.Session;
import javax.jms.Topic;

import org.apache.activemq.ActiveMQConnectionFactory;

public class TestMQ {
    public static void main(String[] args) {
        int i =0;
        //链接工厂
        ConnectionFactory connectionFactory = null;
        // 链接对象
        Connection connection = null;
        // 会话对象
        Session session = null;
        // 目的地
        Destination destination = null;
        // 消息生产者
        MessageProducer producer = null;
        connectionFactory = new ActiveMQConnectionFactory("admin","admin","tcp://192.168.1.120:61616");
        try {
            connection = connectionFactory.createConnection();
            connection.start();
            //第一个参数是否开启事务 true开启 ,false不开启事务，如果开启记得手动提交
            //参数二，表示的是签收模式，一般使用的有自动签收和客户端自己确认签收
            session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
            destination = session.createQueue("test-queue");
            //为目的地创建消息生产者
            producer = session.createProducer(destination);
            //消息是否为持久性的，这个不设置也是可以的，默认是持久的
            producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);
            while(true) {
                TestBean tbean = new TestBean();
                tbean.setAge(25);
                tbean.setName("hellojava" +i);
                producer.send(session.createObjectMessage(tbean));
                i++;
                if( i>10) {
                    break;
                }
            }
            System.out.println("呵呵消息已发送");
        } catch (JMSException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            try {
                producer.close();
                session.close();
                connection.close();
            } catch (JMSException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

2、消息消费端

[java] view plain copy

print ?

1. package mq;  
2.   
3. import javax.jms.Connection;  
4. import javax.jms.ConnectionFactory;  
5. import javax.jms.Destination;  
6. import javax.jms.JMSException;  
7. import javax.jms.Message;  
8. import javax.jms.MessageConsumer;  
9. import javax.jms.MessageListener;  
10. import javax.jms.ObjectMessage;  
11. import javax.jms.Queue;  
12. import javax.jms.Session;  
13.   
14. import org.apache.activemq.ActiveMQConnectionFactory;  
15.   
16. public class AcceptMq {  
17. public static void main(String[] args) {  
18.     ConnectionFactory connectionFactory;  
19.     // Connection ：JMS 客户端到JMS Provider 的连接    
20.     Connection connection = null;  
21.     // Session： 一个发送或接收消息的线程    
22.     Session session = null;  
23.     // Destination ：消息的目的地;消息发送给谁.    
24.     Destination destination = null;  
25.     // 消费者，消息接收者    
26.     //MessageConsumer consumer = null;  
27.     connectionFactory = new ActiveMQConnectionFactory(“admin”, “admin”, “tcp://192.168.1.120:61616”);  
28.     try {  
29.         //通过工厂创建链接  
30.         connection = connectionFactory.createConnection();  
31.         //启动链接  
32.         connection.start();  
33.         //创建会话  
34.         session = connection.createSession(Boolean.FALSE, Session.AUTO_ACKNOWLEDGE);  
35.         //消息目的地  
36.         destination = session.createQueue(”test-queue”);  
37.         //消息消费者  
38.         MessageConsumer consumer = session.createConsumer(destination);  
39.         //同步方式接受信息,如果还没有获取到则会阻塞直到接收到信息  
40.         /*Message messages = consumer.receive(); 
41.         TestBean  value  =(TestBean)((ObjectMessage)messages).getObject(); 
42.                  String name = value.getName();*/  
43.         consumer.setMessageListener(new MessageListener(){  
44.             @Override  
45.             public void onMessage(Message message){  
46.                 try {  
47.                 TestBean  tbean =(TestBean)((ObjectMessage)message).getObject();  
48.                 System.out.println(”tbean: ”+tbean);  
49.                 if(null != message) {  
50.                      System.out.println(”收到信息1： ”+tbean.getName());  
51.                 }  
52.                 } catch (JMSException e) {  
53.                     // TODO Auto-generated catch block  
54.                     e.printStackTrace();  
55.                 }  
56.             }  
57.         });  
58.     } catch (JMSException e) {  
59.         // TODO Auto-generated catch block  
60.         e.printStackTrace();  
61.     }   
62. }  
63. }  

package mq;

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageListener;
import javax.jms.ObjectMessage;
import javax.jms.Queue;
import javax.jms.Session;

import org.apache.activemq.ActiveMQConnectionFactory;

public class AcceptMq {
public static void main(String[] args) {
    ConnectionFactory connectionFactory;
    // Connection ：JMS 客户端到JMS Provider 的连接  
    Connection connection = null;
    // Session： 一个发送或接收消息的线程  
    Session session = null;
    // Destination ：消息的目的地;消息发送给谁.  
    Destination destination = null;
    // 消费者，消息接收者  
    //MessageConsumer consumer = null;
    connectionFactory = new ActiveMQConnectionFactory("admin", "admin", "tcp://192.168.1.120:61616");
    try {
        //通过工厂创建链接
        connection = connectionFactory.createConnection();
        //启动链接
        connection.start();
        //创建会话
        session = connection.createSession(Boolean.FALSE, Session.AUTO_ACKNOWLEDGE);
        //消息目的地
        destination = session.createQueue("test-queue");
        //消息消费者
        MessageConsumer consumer = session.createConsumer(destination);
        //同步方式接受信息,如果还没有获取到则会阻塞直到接收到信息
        /*Message messages = consumer.receive();
        TestBean  value  =(TestBean)((ObjectMessage)messages).getObject();
                 String name = value.getName();*/
        consumer.setMessageListener(new MessageListener(){
            @Override
            public void onMessage(Message message){
                try {
                TestBean  tbean =(TestBean)((ObjectMessage)message).getObject();
                System.out.println("tbean: "+tbean);
                if(null != message) {
                     System.out.println("收到信息1： "+tbean.getName());
                }
                } catch (JMSException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        });
    } catch (JMSException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } 
}
}

3、bean 类

[java] view plain copy

print ?

1. package mq;  
2.   
3. import java.io.Serializable;  
4.   
5. public class TestBean implements Serializable{  
6. private int age;  
7. private String name;  
8. public TestBean() {};  
9. public TestBean(int age, String name) {  
10.     this.age = age;  
11.     this.name = name;  
12. }  
13. public int getAge() {  
14.     return age;  
15. }  
16. public void setAge(int age) {  
17.     this.age = age;  
18. }  
19. public String getName() {  
20.     return name;  
21. }  
22. public void setName(String name) {  
23.     this.name = name;  
24. }  
25. }  

package mq;

import java.io.Serializable;

public class TestBean implements Serializable{
private int age;
private String name;
public TestBean() {};
public TestBean(int age, String name) {
    this.age = age;
    this.name = name;
}
public int getAge() {
    return age;
}
public void setAge(int age) {
    this.age = age;
}
public String getName() {
    return name;
}
public void setName(String name) {
    this.name = name;
}
}

二、发布/订阅消息模型实例

1、消息发布端

[java] view plain copy

print ?

1. package mq;  
2.   
3. import javax.jms.Connection;  
4. import javax.jms.DeliveryMode;  
5. import javax.jms.JMSException;  
6. import javax.jms.MessageProducer;  
7. import javax.jms.Session;  
8. import javax.jms.TextMessage;  
9. import javax.jms.Topic;  
10. import org.apache.activemq.ActiveMQConnectionFactory;  
11. public class PSMQ {  
12.     public static void main(String[] args) throws JMSException {    
13.         ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory(“admin”,“admin”,“tcp://192.168.1.101:61616”);    
14.         Connection connection = factory.createConnection();    
15.         connection.start();    
16.         Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);    
17.         //创建话题  
18.         Topic topic = session.createTopic(”myTopic.messages”);    
19.         //为话题创建消息生产者  
20.         MessageProducer producer = session.createProducer(topic);    
21.         producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);    
22.         while(true) {    
23.             TextMessage message = session.createTextMessage();    
24.             message.setText(”message_” + System.currentTimeMillis());    
25.             producer.send(message);    
26.             System.out.println(”Sent message: ” + message.getText());    
27.         }    
28.     }    
29. }  

package mq;

import javax.jms.Connection;
import javax.jms.DeliveryMode;
import javax.jms.JMSException;
import javax.jms.MessageProducer;
import javax.jms.Session;
import javax.jms.TextMessage;
import javax.jms.Topic;
import org.apache.activemq.ActiveMQConnectionFactory;
public class PSMQ {
    public static void main(String[] args) throws JMSException {  
        ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory("admin","admin","tcp://192.168.1.101:61616");  
        Connection connection = factory.createConnection();  
        connection.start();  
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);  
        //创建话题
        Topic topic = session.createTopic("myTopic.messages");  
        //为话题创建消息生产者
        MessageProducer producer = session.createProducer(topic);  
        producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);  
        while(true) {  
            TextMessage message = session.createTextMessage();  
            message.setText("message_" + System.currentTimeMillis());  
            producer.send(message);  
            System.out.println("Sent message: " + message.getText());  
        }  
    }  
}

2、消息订阅端

[java] view plain copy

print ?

1. package mq;  
2. import javax.jms.Connection;  
3. import javax.jms.JMSException;  
4. import javax.jms.Message;  
5. import javax.jms.MessageConsumer;  
6. import javax.jms.Session;  
7. import javax.jms.TextMessage;  
8. import javax.jms.Topic;  
9. import javax.jms.MessageListener;  
10. import org.apache.activemq.ActiveMQConnectionFactory;  
11. public class PSAccept {  
12.      public static void main(String[] args) throws JMSException {    
13.             ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory(“admin”,“admin”,“tcp://192.168.1.101:61616”);    
14.             Connection connection = factory.createConnection();    
15.             connection.start();    
16.             Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);    
17.             //创建话题  
18.             Topic topic = session.createTopic(”myTopic.messages”);   
19.             //为话题创建消费者  
20.             MessageConsumer consumer = session.createConsumer(topic);   
21.             consumer.setMessageListener(new MessageListener() {   
22.                 @Override  
23.                 public void onMessage(Message message) {  
24.                     TextMessage tm = (TextMessage) message;    
25.                     try {    
26.                         System.out.println(”Received message: ” + tm.getText());    
27.                     } catch (JMSException e) {    
28.                         e.printStackTrace();    
29.                     }    
30.                 }    
31.             });    
32.         }   
33. }  

package mq;
import javax.jms.Connection;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.Session;
import javax.jms.TextMessage;
import javax.jms.Topic;
import javax.jms.MessageListener;
import org.apache.activemq.ActiveMQConnectionFactory;
public class PSAccept {
     public static void main(String[] args) throws JMSException {  
            ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory("admin","admin","tcp://192.168.1.101:61616");  
            Connection connection = factory.createConnection();  
            connection.start();  
            Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);  
            //创建话题
            Topic topic = session.createTopic("myTopic.messages"); 
            //为话题创建消费者
            MessageConsumer consumer = session.createConsumer(topic); 
            consumer.setMessageListener(new MessageListener() { 
                @Override
                public void onMessage(Message message) {
                    TextMessage tm = (TextMessage) message;  
                    try {  
                        System.out.println("Received message: " + tm.getText());  
                    } catch (JMSException e) {  
                        e.printStackTrace();  
                    }  
                }  
            });  
        } 
}

ok 三个demo很简单，在项目中导入jms相关的jar包，代码复制过去就能跑了，在看看第一篇文章就大体上能明白各个类是干什么用的。

点对点消息模型和发布/订阅消息模型两种方式其实不同的就是使用队列、还是使用话题创建目的地不同其他的都一样。

[java] view plain copy

print ?

1. connectionFactory = new ActiveMQConnectionFactory(“admin”,“admin”,“tcp://192.168.1.120:61616”);  

connectionFactory = new ActiveMQConnectionFactory("admin","admin","tcp://192.168.1.120:61616");

其中第一个admin是用户名第二个是密码而第三个参数就是协议+ip+port(端口)，这几个参数两个客户端都是一样的不然消费端就获取不到了……

在消息消费者中我们接收消息有两种方式即同步接收和异步接收，同步接受就是使用receive()方法来接受而异步就是设置一个监听对象。

说到密码我们顺便来看看ActiveMQ访问密码的设置

三、ActiveMQ访问密码设置

在ActiveMQ的conf目录的activemq.xml中添加账号密码

[html] view plain copy

print ?

1. <plugins>    
2.            <simpleAuthenticationPlugin>    
3.                <users>    
4.                    <authenticationUser username=“whd” password=“123” groups=“users,admins”/>    
5.                </users>    
6.            </simpleAuthenticationPlugin>    
7.        </plugins>   

 <plugins>  
            <simpleAuthenticationPlugin>  
                <users>  
                    <authenticationUser username="whd" password="123" groups="users,admins"/>  
                </users>  
            </simpleAuthenticationPlugin>  
        </plugins> 

activemq.xml中添加位置：

ok这样我们对这个ActiveMQ设置了一个用户名密码，所以在创建链接的时候要修改admin这个默认的用户名密码为修改后的用户名密码。

[html] view plain copy

print ?

1. connectionFactory = new ActiveMQConnectionFactory(“whd”, “123”,”tcp://192.168.0.104:61616”);  

connectionFactory = new ActiveMQConnectionFactory("whd", "123","tcp://192.168.0.104:61616");

这样我们就能正常的向服务器发送消息而消费端也能从服务商消费消息了……

差点忘了，还有一个ActiveMQ管理页面地址：http://127.0.0.1:8161/admin/ 访问这个地址登陆管理页面，默认用户名密码都是admin

好了先就小高兴一下吧，之后接着来深入学习……