activeMQ

最新推荐文章于 2023-12-09 23:57:31 发布

qq_39013701

最新推荐文章于 2023-12-09 23:57:31 发布

阅读量81

点赞数

分类专栏： jsm

jsm 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

一.JMS

1.什么是JMS

JMS即Java消息服务（Java Message Service）应用程序接口，是一个Java平台中关于面向消息中间件（MOM）的API，用于在两个应用程序之间，或分布式系统中发送消息，进行异步通信。Java消息服务是一个与具体平台无关的API，绝大多数MOM提供商都对JMS提供支持。

2.为什么要学JMS

在JAVA中，如果两个应用程序之间对各自都不了解，甚至这两个程序可能部署在不同的大洲上，那么它们之间如何发送消息呢？举个例子，一个应用程序A部署在印度，另一个应用程序部署在美国，然后每当A触发某件事后，B想从A获取一些更新信息。当然，也有可能不止一个B对A的更新信息感兴趣，可能会有N个类似B的应用程序想从A中获取更新的信息。在这种情况下，JAVA提供了最佳的解决方案-JMS，完美解决了上面讨论的问题。
JMS与RMI不同，发送消息的时候，接收者不需要在线。服务器发送了消息，然后就不管了；等到客户端上线的时候，能保证接收到服务器发送的消息。这是一个很强大的解决方案，能处理当今世界很多普遍问题。

3.JMS有什么优势

异步：JMS天生就是异步的，客户端获取消息的时候，不需要主动发送请求，消息会自动发送给可用的客户端。

可靠：JMS保证消息只会递送一次。大家都遇到过重复创建消息问题，而JMS能帮你避免该问题，只是避免而不是杜绝，所以在一些糟糕的环境下还是有可能会出现重复。

4.JMS数据交互的两种方式

(1)点对点消息模型

1、每个消息只有一个接受者（自己测试了一下，可以有多个接受者，但是当有多个接收者时，每个接收者只能获取随机的几条信息）
2、消息发送者和消息接受者并没有时间依赖性。
3、当消息发送者发送消息的时候，无论接收者程序在不在运行，都能获取到消息；
4、当接收者收到消息的时候，会发送确认收到通知（acknowledgement）。

点对点消息模型图
在这里插入图片描述
(2)发布/订阅消息模型

1、一个消息可以传递给多个订阅者
2、发布者和订阅者有时间依赖性，只有当客户端创建订阅后才能接受消息，且订阅者需一直保持活动状态以接收消息。
3、为了缓和这样严格的时间相关性，JMS允许订阅者创建一个可持久化的订阅。这样，即使订阅者没有被激活（运行），它也能接收到发布者的消息。

发布/订阅消息模型图：
在这里插入图片描述

5.ActiveMQ的消息形式

JMS定义了五种不同的消息正文格式，以及调用的消息类型，允许你发送并接收以一些不同形式的数据，提供现有消息格式的一些级别的兼容性。
　　· StreamMessage – Java原始值的数据流
　　· MapMessage–一套名称-值对
　　· TextMessage–一个字符串对象
　　· ObjectMessage–一个序列化的 Java对象
　　· BytesMessage–一个字节的数据流

二.ActiveMQ

1.什么是ActiveMQ

ActiveMQ 是Apache出品，最流行的，能力强劲的开源消息总线。ActiveMQ 是一个完全支持JMS1.1和J2EE 1.4规范的 JMS Provider实现，尽管JMS规范出台已经是很久的事情了，但是JMS在当今的J2EE应用中间仍然扮演着特殊的地位。

2.启动

启动：进入你解压后的目录下的bin目录，运行
./activemq start

访问地址：
ActiveMQ 服务启动后台地址：http://127.0.0.1:8161/admin/ 用户名/密码 admin/admin

消息模式

(1)ActiveMQ的点对点使用
消息生产者发送消息到队列中消费者去队列中拉取自己要的消息

(2)demo
首先启动ActiveMQ

然后编写Producter代码：JMSProducer.java

package com.miracle.one2one;

import org.apache.activemq.ActiveMQConnection;
import org.apache.activemq.ActiveMQConnectionFactory;
import javax.jms.*;

@SuppressWarnings("all")
public class JMSProducer {
    private static final String USERNAME= ActiveMQConnection.DEFAULT_USER; // 默认的连接用户名
    private static final String PASSWORD= ActiveMQConnection.DEFAULT_PASSWORD; // 默认的连接密码
    private static final String BROKEURL= ActiveMQConnection.DEFAULT_BROKER_URL; // 默认的连接地址

    public static void main(String[] args) {
        // 连接工厂
        ConnectionFactory connectionFactory = null;
        // 连接
        Connection connection = null;
        // 会话
        Session session = null;
        // 消息目的地
        Destination destination = null;
        // 消息生产者
        MessageProducer messageProducer = null;
        try {
            System.out.println(USERNAME);
            System.out.println(PASSWORD);
            System.out.println(BROKEURL);
            // 1.连接MQ
            connectionFactory = new ActiveMQConnectionFactory(USERNAME, PASSWORD, BROKEURL);
            connection = connectionFactory.createConnection();
            connection.start();

            /*
                Session.AUTO_ACKNOWLEDGE。当客户成功的从receive 方法返回的时候，或者从MessageListener.onMessage方法成功返回的时候，会话自动确认客户收到的消息。
                Session.CLIENT_ACKNOWLEDGE。 客户通过消息的 acknowledge 方法确认消息。需要注意的是，在这种模式中，确认是在会话层上进行：确认一个被消费的消息将自动确认所有已被会话消费的消息。例如，如果一个消息消费者消费了 10 个消息，然后确认第 5 个消息，那么所有 10 个消息都被确认。
                Session.DUPS_ACKNOWLEDGE。 该选择只是会话迟钝的确认消息的提交。如果 JMS provider 失败，那么可能会导致一些重复的消息。如果是重复的消息，那么 JMS provider 必须把消息头的 JMSRedelivered 字段设置
                为 true。
             */

            session = connection.createSession(true, Session.AUTO_ACKNOWLEDGE);
            destination = session.createQueue("短信发送");
            messageProducer = session.createProducer(destination);

            // 2.发送消息
            for (int i = 0; i < 10; i++) {
                // 模拟消息
                String txt = "1760829525" + i;
                // 构造消息对象
                TextMessage textMessage = session.createTextMessage(txt);
                // 发送
                messageProducer.send(textMessage);
            }
            // 提交session
            session.commit();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            // 3.断开
            try {
                messageProducer.close();
                session.close();
                connection.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

然后执行，登录ActiveMQ管理页面，可以看到Producter向队列发送的消息
在这里插入图片描述
然后编写Consumer代码：JMSConsumer.java

package com.miracle.one2one;

import org.apache.activemq.ActiveMQConnection;
import org.apache.activemq.ActiveMQConnectionFactory;
import javax.jms.*;

@SuppressWarnings("all")
public class JMSConsumer {
    private static final String USERNAME= ActiveMQConnection.DEFAULT_USER; // 默认的连接用户名
    private static final String PASSWORD= ActiveMQConnection.DEFAULT_PASSWORD; // 默认的连接密码
    private static final String BROKEURL= ActiveMQConnection.DEFAULT_BROKER_URL; // 默认的连接地址

    public static void main(String[] args) {
        // 连接工厂
        ConnectionFactory connectionFactory = null;
        // 连接
        Connection connection = null;
        // 会话
        Session session = null;
        // 消息目的地
        Destination destination = null;
        // 消息消费者
        MessageConsumer messageConsumer = null;
        try {
            System.out.println(USERNAME);
            System.out.println(PASSWORD);
            System.out.println(BROKEURL);
            // 1.连接MQ
            connectionFactory = new ActiveMQConnectionFactory(USERNAME, PASSWORD, BROKEURL);
            connection = connectionFactory.createConnection();
            connection.start();

            /*
                Session.AUTO_ACKNOWLEDGE。当客户成功的从receive 方法返回的时候，或者从MessageListener.onMessage方法成功返回的时候，会话自动确认客户收到的消息。
                Session.CLIENT_ACKNOWLEDGE。 客户通过消息的 acknowledge 方法确认消息。需要注意的是，在这种模式中，确认是在会话层上进行：确认一个被消费的消息将自动确认所有已被会话消费的消息。例如，如果一个消息消费者消费了 10 个消息，然后确认第 5 个消息，那么所有 10 个消息都被确认。
                Session.DUPS_ACKNOWLEDGE。 该选择只是会话迟钝的确认消息的提交。如果 JMS provider 失败，那么可能会导致一些重复的消息。如果是重复的消息，那么 JMS provider 必须把消息头的 JMSRedelivered 字段设置
                为 true。
             */

            session = connection.createSession(true, Session.AUTO_ACKNOWLEDGE);
            destination = session.createQueue("短信发送");
            messageConsumer = session.createConsumer(destination);

            // 2.接收消息,这里只取5条消息,当第二次调用此方法可以取剩余5条消息

            // (1) 主动从队列中取数据
//            for (int i = 0; i < 5; i++) {
//                // 调用一次recevice取一条消息
//                TextMessage textMessage = (TextMessage)messageConsumer.receive();
//                System.out.println(textMessage.getText());
//            }
//          提交session
//          session.commit();

            // (2) 编写监听器，监听队列数据，当队列有数据时，执行监听器的onMessage方法
            messageConsumer.setMessageListener(new MyMessageListener());
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

监听类：MyMessageListener.java

package com.miracle.one2one;

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

public class MyMessageListener implements MessageListener {

    @Override
    public void onMessage(Message message) {
        TextMessage textMessage = (TextMessage)message;
        if (textMessage != null){
            try {
                System.out.println(textMessage.getText());
            } catch (JMSException e) {
                e.printStackTrace();
            }
        }
    }
}

(2)ActiveMQ的发布和订阅

消息生产者发送消息到队列中队列会把消息推送到消费者(需要订阅消息，并监听推送)那里，消费者可能是一个或者多个

编写两个监听：MyMessageListener1.java，MyMessageListener2.java

package com.miracle.subscriber;

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

@SuppressWarnings("all")
public class MyMessageListener1 implements MessageListener {

    @Override
    public void onMessage(Message message) {
        TextMessage textMessage = (TextMessage)message;
        if (textMessage != null){
            try {
                System.out.println("Consumer1从MQ获取的消息" + textMessage.getText());
            } catch (JMSException e) {
                e.printStackTrace();
            }
        }
    }
}

package com.miracle.subscriber;

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

@SuppressWarnings("all")
public class MyMessageListener2 implements MessageListener {

    @Override
    public void onMessage(Message message) {
        TextMessage textMessage = (TextMessage)message;
        if (textMessage != null){
            try {
                System.out.println("Consumer2从MQ获取的消息" + textMessage.getText());
            } catch (JMSException e) {
                e.printStackTrace();
            }
        }
    }
}

编写两个消费者订阅消息：JMSConsumer1.java，JMSConsumer2.java

package com.miracle.subscriber;

import org.apache.activemq.ActiveMQConnection;
import org.apache.activemq.ActiveMQConnectionFactory;
import javax.jms.*;

@SuppressWarnings("all")
public class JMSConsumer1 {
    private static final String USERNAME= ActiveMQConnection.DEFAULT_USER; // 默认的连接用户名
    private static final String PASSWORD= ActiveMQConnection.DEFAULT_PASSWORD; // 默认的连接密码
    private static final String BROKEURL= ActiveMQConnection.DEFAULT_BROKER_URL; // 默认的连接地址

    public static void main(String[] args) {
        // 连接工厂
        ConnectionFactory connectionFactory = null;
        // 连接
        Connection connection = null;
        // 会话
        Session session = null;
        // 消息目的地
        Destination destination = null;
        // 消息消费者
        MessageConsumer messageConsumer = null;
        try {
            System.out.println(USERNAME);
            System.out.println(PASSWORD);
            System.out.println(BROKEURL);
            // 1.连接MQ
            connectionFactory = new ActiveMQConnectionFactory(USERNAME, PASSWORD, BROKEURL);
            connection = connectionFactory.createConnection();
            connection.start();

            /*
                Session.AUTO_ACKNOWLEDGE。当客户成功的从receive 方法返回的时候，或者从MessageListener.onMessage方法成功返回的时候，会话自动确认客户收到的消息。
                Session.CLIENT_ACKNOWLEDGE。 客户通过消息的 acknowledge 方法确认消息。需要注意的是，在这种模式中，确认是在会话层上进行：确认一个被消费的消息将自动确认所有已被会话消费的消息。例如，如果一个消息消费者消费了 10 个消息，然后确认第 5 个消息，那么所有 10 个消息都被确认。
                Session.DUPS_ACKNOWLEDGE。 该选择只是会话迟钝的确认消息的提交。如果 JMS provider 失败，那么可能会导致一些重复的消息。如果是重复的消息，那么 JMS provider 必须把消息头的 JMSRedelivered 字段设置
                为 true。
             */

            session = connection.createSession(true, Session.AUTO_ACKNOWLEDGE);
            destination = session.createTopic("短信发送T");
            messageConsumer = session.createConsumer(destination);

            // 编写监听器，监听队列数据，当队列有数据时，执行监听器的onMessage方法
            messageConsumer.setMessageListener(new MyMessageListener1());
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

package com.miracle.subscriber;

import org.apache.activemq.ActiveMQConnection;
import org.apache.activemq.ActiveMQConnectionFactory;
import javax.jms.*;

@SuppressWarnings("all")
public class JMSConsumer2 {
    private static final String USERNAME= ActiveMQConnection.DEFAULT_USER; // 默认的连接用户名
    private static final String PASSWORD= ActiveMQConnection.DEFAULT_PASSWORD; // 默认的连接密码
    private static final String BROKEURL= ActiveMQConnection.DEFAULT_BROKER_URL; // 默认的连接地址

    public static void main(String[] args) {
        // 连接工厂
        ConnectionFactory connectionFactory = null;
        // 连接
        Connection connection = null;
        // 会话
        Session session = null;
        // 消息目的地
        Destination destination = null;
        // 消息消费者
        MessageConsumer messageConsumer = null;
        try {
            System.out.println(USERNAME);
            System.out.println(PASSWORD);
            System.out.println(BROKEURL);
            // 1.连接MQ
            connectionFactory = new ActiveMQConnectionFactory(USERNAME, PASSWORD, BROKEURL);
            connection = connectionFactory.createConnection();
            connection.start();

            /*
                Session.AUTO_ACKNOWLEDGE。当客户成功的从receive 方法返回的时候，或者从MessageListener.onMessage方法成功返回的时候，会话自动确认客户收到的消息。
                Session.CLIENT_ACKNOWLEDGE。 客户通过消息的 acknowledge 方法确认消息。需要注意的是，在这种模式中，确认是在会话层上进行：确认一个被消费的消息将自动确认所有已被会话消费的消息。例如，如果一个消息消费者消费了 10 个消息，然后确认第 5 个消息，那么所有 10 个消息都被确认。
                Session.DUPS_ACKNOWLEDGE。 该选择只是会话迟钝的确认消息的提交。如果 JMS provider 失败，那么可能会导致一些重复的消息。如果是重复的消息，那么 JMS provider 必须把消息头的 JMSRedelivered 字段设置
                为 true。
             */

            session = connection.createSession(true, Session.AUTO_ACKNOWLEDGE);
            destination = session.createTopic("短信发送T");
            messageConsumer = session.createConsumer(destination);

            // 编写监听器，监听队列数据，当队列有数据时，执行监听器的onMessage方法
            messageConsumer.setMessageListener(new MyMessageListener2());
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

编写一个订阅内容发布者：JMSProducer.java

package com.miracle.subscriber;

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

import javax.jms.*;

@SuppressWarnings("all")
public class JMSProducer {
    private static final String USERNAME= ActiveMQConnection.DEFAULT_USER; // 默认的连接用户名
    private static final String PASSWORD= ActiveMQConnection.DEFAULT_PASSWORD; // 默认的连接密码
    private static final String BROKEURL= ActiveMQConnection.DEFAULT_BROKER_URL; // 默认的连接地址

    public static void main(String[] args) {
        // 连接工厂
        ConnectionFactory connectionFactory = null;
        // 连接
        Connection connection = null;
        // 会话
        Session session = null;
        // 消息目的地
        Destination destination = null;
        // 消息生产者
        MessageProducer messageProducer = null;
        try {
            System.out.println(USERNAME);
            System.out.println(PASSWORD);
            System.out.println(BROKEURL);
            // 1.连接MQ
            connectionFactory = new ActiveMQConnectionFactory(USERNAME, PASSWORD, BROKEURL);
            connection = connectionFactory.createConnection();
            connection.start();

            /*
                Session.AUTO_ACKNOWLEDGE。当客户成功的从receive 方法返回的时候，或者从MessageListener.onMessage方法成功返回的时候，会话自动确认客户收到的消息。
                Session.CLIENT_ACKNOWLEDGE。 客户通过消息的 acknowledge 方法确认消息。需要注意的是，在这种模式中，确认是在会话层上进行：确认一个被消费的消息将自动确认所有已被会话消费的消息。例如，如果一个消息消费者消费了 10 个消息，然后确认第 5 个消息，那么所有 10 个消息都被确认。
                Session.DUPS_ACKNOWLEDGE。 该选择只是会话迟钝的确认消息的提交。如果 JMS provider 失败，那么可能会导致一些重复的消息。如果是重复的消息，那么 JMS provider 必须把消息头的 JMSRedelivered 字段设置
                为 true。
             */

            session = connection.createSession(true, Session.AUTO_ACKNOWLEDGE);
            destination = session.createTopic("短信发送T");
            messageProducer = session.createProducer(destination);

            // 2.发送消息
            for (int i = 0; i < 10; i++) {
                // 模拟消息
                String txt = "1760829525" + i;
                // 构造消息对象
                TextMessage textMessage = session.createTextMessage(txt);
                // 发送
                messageProducer.send(textMessage);
            }
            // 提交session
            session.commit();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            // 3.断开
            try {
                messageProducer.close();
                session.close();
                connection.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

三.spring整合ActiveMQ

1.jar包依赖

<dependency>
    <groupId>org.apache.activemq</groupId>
    <artifactId>activemq-all</artifactId>
</dependency>
<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-jms</artifactId>
</dependency>
<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-context-support</artifactId>
</dependency>

2.配置Activemq整合spring。配置ConnectionFactory

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	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-4.2.xsd
	http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd
	http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd
	http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.2.xsd">


	<!-- 真正可以产生Connection的ConnectionFactory，由对应的 JMS服务厂商提供 -->
	<bean id="targetConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
		<property name="brokerURL" value="tcp://192.168.25.168:61616" />
	</bean>
	<!-- Spring用于管理真正的ConnectionFactory的ConnectionFactory -->
	<bean id="connectionFactory"
		class="org.springframework.jms.connection.SingleConnectionFactory">
		<!-- 目标ConnectionFactory对应真实的可以产生JMS Connection的ConnectionFactory -->
		<property name="targetConnectionFactory" ref="targetConnectionFactory" />
	</bean>

	<!-- 配置生产者 -->
	<!-- Spring提供的JMS工具类，它可以进行消息发送、接收等 -->
	<bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
		<!-- 这个connectionFactory对应的是我们定义的Spring提供的那个ConnectionFactory对象 -->
		<property name="connectionFactory" ref="connectionFactory"/>
	</bean>
	
	<!--这个是队列目的地，点对点的 -->
	<bean id="queueDestination" class="org.apache.activemq.command.ActiveMQQueue">
		<constructor-arg name="name" value="queue"></constructor-arg>
	</bean>
	<!--这个是主题目的地，一对多的 -->
	<bean id="topicDestination" class="org.apache.activemq.command.ActiveMQTopic">
		<constructor-arg name="name" value="topic"></constructor-arg>
	</bean>
</beans>

3.使用JMSTemplate发送消息

@Test
public void testQueueProducer() throws Exception {
	// 第一步：初始化一个spring容器
	ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:spring/applicationContext-activemq.xml");
	// 第二步：从容器中获得JMSTemplate对象。
	JmsTemplate jmsTemplate = applicationContext.getBean(JmsTemplate.class);
	// 第三步：从容器中获得一个Destination对象
	Destination destination = (Destination) applicationContext.getBean("queueDestination");
	// 第四步：使用JMSTemplate对象发送消息，需要知道Destination
	jmsTemplate.send(queue, new MessageCreator() {
		
		@Override
		public Message createMessage(Session session) throws JMSException {
			TextMessage textMessage = session.createTextMessage("spring activemq test");
			return textMessage;
		}
	});
}

4.使用JMSTemplate接收消息

创建一个MessageListener的实现类

public class MyMessageListener implements MessageListener {

	@Override
	public void onMessage(Message message) {
		
		try {
			TextMessage textMessage = (TextMessage) message;
			//取消息内容
			String text = textMessage.getText();
			System.out.println(text);
		} catch (JMSException e) {
			e.printStackTrace();
		}
	}
}

在spring配置中，添加配置监听器和消息监听容器

<!-- 接收消息 -->
<!-- 配置监听器 -->
<bean id="myMessageListener" class="com.taotao.search.listener.MyMessageListener" />
<!-- 消息监听容器 -->
<bean class="org.springframework.jms.listener.DefaultMessageListenerContainer">
	<property name="connectionFactory" ref="connectionFactory" />
	<property name="destination" ref="queueDestination" />
	<property name="messageListener" ref="myMessageListener" />
</bean>

使用代码

@Test
public void testQueueConsumer() throws Exception {
	//初始化spring容器
	ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:spring/applicationContext-activemq.xml");
	//等待
	System.in.read();
}

qq_39013701

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
activeMQ

一.JMS1.什么是JMSJMS即Java消息服务（Java Message Service）应用程序接口，是一个Java平台中关于面向消息中间件（MOM）的API，用于在两个应用程序之间，或分布式系统中发送消息，进行异步通信。Java消息服务是一个与具体平台无关的API，绝大多数MOM提供商都对JMS提供支持。2.为什么要学JMS在JAVA中，如果两个应用程序之间对各自都不了解，甚至这两...
复制链接

扫一扫