java消息服务，JMS 和 ActiveMQ

最新推荐文章于 2024-07-27 17:56:15 发布

weixin_34040079

最新推荐文章于 2024-07-27 17:56:15 发布

阅读量62

点赞数

文章标签： java 网络 python

原文链接：https://my.oschina.net/mengyuankan/blog/781986

版权

2019独角兽企业重金招聘Python工程师标准>>>

JMS支持两种消息传送模式，点对点模式和发布订阅模式，

点对点模式：

发布订阅模式：

JMS API：

共公的API：

ConnectionFactory

Connection

Destination

Session

Message

MessageProducer

MessageConsumer

点对点 API:

QueueConnectionFactory

QueueConnection

Queue

QueueSession

Message

QueueSender

QueueReceiver

发布订阅 API (Publish-Subscribe):

TopicConnectionFactory

TopicConnection

Topic

TopicSession

Message

TopicPublisher

TopicSubscriber

下面是实例：

公共的 API 实例：

首先从 http://activemq.apache.org/activemq-5141-release.html 下载 ActiveMQ ，解压，然后运行activemq.bat 启动。

然后在浏览器输入 http://localhost:8161/admin/，密码和用户名都是 admin，

然后创建一个 Queue，名字随意

新建项目，把 jar 包拷进项目 activemq-all-5.14.1.jar

公共的 API :

//消息的发送者
public class Sender {

    public static void main(String[] args) throws JMSException {
        //连接工厂，JMS用它来创建连接
        ConnectionFactory connectionFactory =
                new ActiveMQConnectionFactory(
                        ActiveMQConnectionFactory.DEFAULT_USER,
                        ActiveMQConnectionFactory.DEFAULT_PASSWORD,
                        "tcp://localhost:61616");
        //连接对象
        Connection connection = connectionFactory.createConnection();
        connection.start();
        //一个用来发送或者接受消息的线程
        Session session = connection.createSession(true, Session.AUTO_ACKNOWLEDGE);
        //消息的目的地，即消息发送给谁
        Destination destination = session.createQueue("FisrstQueue");
        //消息的发送者
        MessageProducer producer = session.createProducer(destination);
        producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);
        for (int i = 0; i < 5; i++) {
            Date date = new Date();
            TextMessage textMessage = session.createTextMessage("ActiveMQ 发送的消息: " + date);
            System.out.println("发送的消息: " + "ActiveMQ 发送的消息: " + date);
            producer.send(textMessage);
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        session.commit();
        //关闭连接
    }
}

//消息的接收者
public class Receive {

    public static void main(String[] args) throws JMSException{
        //连接工厂，JMS用它来创建连接
        ConnectionFactory connectionFactory =
                new ActiveMQConnectionFactory(
                        ActiveMQConnectionFactory.DEFAULT_USER,
                        ActiveMQConnectionFactory.DEFAULT_PASSWORD,
                        "tcp://localhost:61616");
        //连接对象
        Connection connection = connectionFactory.createConnection();
        connection.start();
        //一个用来发送或者接受消息的线程
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        //消息的目的地，即消息发送给谁
        Destination destination = session.createQueue("FisrstQueue");
        //消息的发送者
        MessageConsumer consumer = session.createConsumer(destination);
        while (true) {
            //设置接收者接收消息的时间，为了便于测试，这里谁定为100s
            TextMessage message = (TextMessage) consumer.receive(10000);
            if (null != message) {
                System.out.println("收到消息" + message.getText());
            } else {
                break;
            }
        }
        //关闭连接
    }
}

效果：

点对点消息传输模式:

//消息接收者
public class MyQueueReceiver {

    public static void main(String[] args) throws JMSException {

        final String DEFAULT_USER = ActiveMQConnectionFactory.DEFAULT_USER;
        final String DEFAULT_PASSWORD = ActiveMQConnectionFactory.DEFAULT_PASSWORD;
        final String DEFAULT_URI = ActiveMQConnectionFactory.DEFAULT_BROKER_URL;

        QueueConnectionFactory connectionFactory
                = new ActiveMQConnectionFactory(DEFAULT_USER,DEFAULT_PASSWORD,DEFAULT_URI);
        QueueConnection connection = connectionFactory.createQueueConnection();
        connection.start();
        QueueSession session = connection.createQueueSession(true, Session.AUTO_ACKNOWLEDGE);
        Queue queue = session.createQueue("myQueue");
        QueueReceiver receiver = session.createReceiver(queue);
        while (true) {
            //设置接收者接收消息的时间，为了便于测试，这里谁定为100s
            TextMessage message = (TextMessage) receiver.receive(10000);
            if (null != message) {
                System.out.println("收到消息" + message.getText());
            } else {
                break;
            }
        }
    }
    //关闭连接
}

//消息的发送者
public class MyQueueSender {

    public static void main(String[] args) throws JMSException {
        final String DEFAULT_USER = ActiveMQConnectionFactory.DEFAULT_USER;
        final String DEFAULT_PASSWORD = ActiveMQConnectionFactory.DEFAULT_PASSWORD;
        final String DEFAULT_URI = ActiveMQConnectionFactory.DEFAULT_BROKER_URL;

        QueueConnectionFactory connectionFactory
                = new ActiveMQConnectionFactory(DEFAULT_USER,DEFAULT_PASSWORD,DEFAULT_URI);
        QueueConnection connection = connectionFactory.createQueueConnection();
        connection.start();
        QueueSession session = connection.createQueueSession(true, Session.AUTO_ACKNOWLEDGE);
        Queue queue = session.createQueue("myQueue");
        QueueSender sender = session.createSender(queue);
        sender.setDeliveryMode(DeliveryMode.NON_PERSISTENT);
        TextMessage message = session.createTextMessage();
        Date date = new Date();
        message.setText("this'time is :" + date);
        System.out.println("MyQueueSender send message : " + date);
        sender.send(message);
        session.commit();
        //关闭连接
    }

发布订阅模式

在 http://localhost:8161/admin/ 上创建一个 topic ，名字随意, 我的是 myTopic

一个发布者，三个订阅者

/**发布订阅模式:
 * 一个发布者对应三个订阅者
 * 消息的发送者
 */
public class Publisher {

    public static void main(String[] args) throws Exception{
        TopicConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://localhost:61616");
        TopicConnection connection = connectionFactory.createTopicConnection();
        connection.start();
        TopicSession session = connection.createTopicSession(true, Session.AUTO_ACKNOWLEDGE);
        Topic topic = session.createTopic("myTopic");
        TopicPublisher publisher = session.createPublisher(topic);
        publisher.setDeliveryMode(DeliveryMode.NON_PERSISTENT);
        for (int i = 0; i < 5; i++) {
            TextMessage message = session.createTextMessage();
            Date date = new Date();
            message.setText("this'time is :" + date);
            System.out.println("Publisher send message : " + date);
            publisher.send(message);
            Thread.sleep(3000);
        }
        session.commit();
        //关闭连接
    }
}

//消息订阅者1（消费者）
public class Subscriber_01 {

    public static void main(String[] args) throws JMSException{
        TopicConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://localhost:61616");
        TopicConnection connection = connectionFactory.createTopicConnection();
        connection.start();
        TopicSession session = connection.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);
        Topic topic = session.createTopic("myTopic");
        //TopicSubscription subscription = session.createSubscriber(topic);
        MessageConsumer consumer = session.createConsumer(topic);
        consumer.setMessageListener(new MessageListener() {
            public void onMessage(Message message) {
                TextMessage tm = (TextMessage) message;
                try {
                    System.out.println("Subscriber_01 received message :" + tm.getText());
                }catch (JMSException e){
                    e.printStackTrace();
                }
            }
        });
    }
}

//消息订阅者2
public class Subscriber_02 {
    public static void main(String[] args) throws JMSException {
        TopicConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://localhost:61616");
        TopicConnection connection = connectionFactory.createTopicConnection();
        connection.start();
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        Topic topic = session.createTopic("myTopic");
        MessageConsumer consumer = session.createConsumer(topic);
        consumer.setMessageListener(new MessageListener() {
            public void onMessage(Message message) {
                TextMessage tm = (TextMessage) message;
                try {
                    System.out.println("Subscriber_02 received message :" + tm.getText());
                }catch (JMSException e){
                    e.printStackTrace();
                }
            }
        });
    }
}

//消息订阅者3
public class Subscriber_03 {
    public static void main(String[] args) throws JMSException {
        TopicConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://localhost:61616");
        TopicConnection connection = connectionFactory.createTopicConnection();
        connection.start();
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        Topic topic = session.createTopic("myTopic");
        MessageConsumer consumer = session.createConsumer(topic);
        consumer.setMessageListener(new MessageListener() {
            public void onMessage(Message message) {
                TextMessage tm = (TextMessage) message;
                try {
                    System.out.println("Subscriber_03 received message :" + tm.getText());
                }catch (JMSException e){
                    e.printStackTrace();
                }
            }
        });
    }
}

启动运行程序：