ActiveMQ简介

---

我们都知道ActiveMQ是消息中间件，首先我们先来了解下一些相关的概念；

消息

“消息”是在两台计算机间传送的数据单位。消息可以非常简单，例如只包含文本字符串；也可以更复杂，可能包含嵌入对象。

消息队列

“消息队列”是在消息的传输过程中保存消息的容器，

消息队列管理器在将消息从它的源中继到它的目标时充当中间人，

队列的主要目的是提供路由并保证消息的传递；如果发送消息时接收者不可用，消息队列会保留消息，直到可以成功地传递它。

消息队列的特点

消息队列的主要特点是异步处理，主要目的是减少请求响应时间和解耦。

所以主要的使用场景就是将比较耗时而且不需要即时（同步）返回结果的操作作为消息放入消息队列。

同时由于使用了消息队列，只要保证消息格式不变，消息的发送方和接收方并不需要彼此联系，也不需要受对方的影响，即解耦和。

ActiveMQ简介

ActiveMQ是Apache软件基金会所研发的开放源代码消息中间件；由于ActiveMQ是一个纯Java程序，因此只需要操作系统支持Java虚拟机，ActiveMQ便可执行。

对Spring的支持，ActiveMQ可以很容易内嵌到使用Spring的系统里面去通过了常见J2EE服务器的测试

ActiveMQ角色介绍

1，Destination 目的地，消息发送者需要指定 Destination才能发送消息，接收者需要指定 Destination才能接收消息。**

**2,Producer 消息生产者，负责发送Message到目的地**

**3,Consumer/Receiver 消息消费者，负责从目的地中消费（处理/监听/订阅）Message**

**4,Message 消息 消息封装一次通信的内容。**

****

这里我们在spring整合ActiveMQ来写个小例子.

先创建一个maven项目，并在pom.xml添加相关依赖,如下：

<dependencies>
        <!-- ActiveMQ客户端完整jar包依赖 -->
        <dependency>
            <groupId>org.apache.activemq</groupId>
            <artifactId>activemq-all</artifactId>
            <version>5.9.0</version>
        </dependency>
        <!-- ActiveMQ和Spring整合配置文件标签处理jar包依赖 -->
        <dependency>
            <groupId>org.apache.xbean</groupId>
            <artifactId>xbean-spring</artifactId>
            <version>4.5</version>
        </dependency>
        <!-- Spring-JMS插件相关jar包依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jms</artifactId>
            <version>4.1.6.RELEASE</version>
        </dependency>
        <!-- Spring框架上下文jar包依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.1.6.RELEASE</version>
        </dependency>
    </dependencies>

然后定义消息载体类型. 即要在ActiveMQ中传递的数据实体类型，

消息载体对象必须实现接口java.io.Serializable, 因为消息需要在网络中传递,要求必须可序列化。

代码如下：

public class Order implements Serializable {
    private static final long serialVersionUID = 1L;

    private String id;
    private String nick;
    private Long price;
    private Date createTime;
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getNick() {
        return nick;
    }
    public void setNick(String nick) {
        this.nick = nick;
    }
    public Long getPrice() {
        return price;
    }
    public void setPrice(Long price) {
        this.price = price;
    }
    public Date getCreateTime() {
        return createTime;
    }
    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }
    public static long getSerialversionuid() {
        return serialVersionUID;
    }
    @Override
    public String toString() {
        return "Order [id=" + id + ", nick=" + nick + ", price=" + price + ", createTime=" + createTime + "]";
    }
}

定义生产者

public class OrderProducer {
    private JmsTemplate template;

    public JmsTemplate getTemplate() {
        return template;
    }

    public void setTemplate(JmsTemplate template) {
        this.template = template;
    }
    /**
     * 生产者发送消息
     * @param destinationName  目的地名称
     * @param order  需要发送的订单数据
     */
    public void sendOrder(String destinationName, Order order){
        try{
            template.send(destinationName, new MessageCreator() {

                /**
                 * 通过模板模式暴露的方法设置发送的信息
                 */
                @Override
                public Message createMessage(Session session) throws JMSException {
                    ObjectMessage objectMessage = session.createObjectMessage(order);
                    return objectMessage;
                }
            });
        }catch(Exception e){
            e.printStackTrace();
            throw new RuntimeException("send order to MQ server error!!");
        }
    }

再来定义消费者：

public class OrderConsumer implements MessageListener {

    @Override
    public void onMessage(Message message) {
        try {
            ObjectMessage objectMessage=(ObjectMessage)message;
            Order order=(Order)objectMessage.getObject();
            System.out.println("order:"+order);
        } catch (JMSException e) {
            e.printStackTrace();
        }
    }
}

在spring配置文件applicationContext.xml整合ActiveMQ,如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:amq="http://activemq.apache.org/schema/core"
       xmlns:jms="http://www.springframework.org/schema/jms"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-4.0.xsd
        http://www.springframework.org/schema/jms
        http://www.springframework.org/schema/jms/spring-jms-4.0.xsd
        http://activemq.apache.org/schema/core
        http://activemq.apache.org/schema/core/activemq-core-5.9.0.xsd">

    <!-- 添加扫描 -->
    <context:component-scan base-package="sn.sxt.*"></context:component-scan>

    <!-- ActiveMQ 连接工厂 -->
    <!-- 真正可以产生Connection的ConnectionFactory,由对应的 JMS服务厂商提供 -->
    <!-- 需提供访问路径tcp://ip:61616;以及用户名,密码 -->
    <amq:connectionFactory id="amqConnectionFactory"
                           brokerURL="tcp://192.168.142.190:61616" userName="admin" password="admin" />

    <!-- Spring Caching连接工厂 -->
    <!-- Spring用于管理真正的ConnectionFactory的ConnectionFactory -->
    <bean id="connectionFactory"
          class="org.springframework.jms.connection.CachingConnectionFactory">
        <!-- 目标ConnectionFactory对应真实的可以产生JMS Connection的ConnectionFactory -->
        <property name="targetConnectionFactory" ref="amqConnectionFactory"></property>
        <!-- Session缓存数量 -->
        <property name="sessionCacheSize" value="100" />
    </bean>

    <!-- 消息生产者 start -->

    <!-- 定义JmsTemplate对象. 此类型由Spring框架JMS组件提供. 用于访问ActiveMQ使用. -->
    <bean id="jmsQueueTemplate" class="org.springframework.jms.core.JmsTemplate">
        <!-- 这个connectionFactory对应的是我们定义的Spring提供的那个ConnectionFactory对象 -->
        <constructor-arg ref="connectionFactory" />
        <!-- 非pub/sub模型（发布/订阅）,即队列模式, 默认数据可省略配置 -->
        <!-- <property name="pubSubDomain" value="false" /> -->
    </bean>

    <!-- 定义生成者对象 -->
    <bean id="orderProducer" class="sn.sxt.activemq.OrderProducer">
        <!-- 为属性赋值 -->
        <property name="template" ref="jmsQueueTemplate"></property>
    </bean>

    <!--消息生产者 end -->

    <!-- 消息消费者 start -->

    <!-- 定义消息监听器, 此组件为spring-jms组件定义. 可以一次注册若干消息监听器.
        属性解释:
            destination-type - 目的地类型, queue代表消息队列
                可选值: queue | topic | durableTopic
                queue - 默认值. 代表消息队列
                topic - 代表消息队列集合
                durableTopic - 持久化的消息队列集合. ActiveMQ会保证消息的消费者一定接收到此消息.
            container-type - 容器类型
                可选值: default | simple
                default - 默认值. 默认容器类型, 对应DefaultMessageListenerContainer
                simple - 简单容器类型, 对应SimpleMessageListenerContainer
            connection-factory - 链接工厂, 注入的是Spring-JMS组件提供的链接工厂对象.
            acknowledge - 确认方式
                可选值: auto | client | dups-ok | transacted
                auto - 默认值, 即自动确认消息
                client - 客户端确认消息
                dups-ok - 可使用副本的客户端确认消息
                transacted - 有事务的持久化消息确认机制. 需开启对ActiveMQ的事务控制才可应用.
     -->
    <jms:listener-container destination-type="queue"
                            container-type="default" connection-factory="connectionFactory"
                            acknowledge="auto">
        <!-- 注册消息监听器. 如果需要注册多个, 重复定义下述标签. -->
        <jms:listener destination="test-spring" ref="orderReciver" />
    </jms:listener-container>

    <!-- 容器管理消息监听器实现类对象 -->
    <bean id="orderReciver" class="sn.sxt.activemq.OrderConsumer"/>

    <!-- 消息消费者 end -->

</beans>

然后我们就可以进行测试了

public class Test {
    public static void main(String[] args) {
        ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
        OrderProducer op=ac.getBean("orderProducer",OrderProducer.class);
        Order order=new Order();
        order.setId("666");
        order.setNick("我很强");
        order.setPrice(999l);
        order.setCreateTime(new Date());
        op.sendOrder("test-spring",order);
    }
}

在Linux启动ActiveMQ后，运行测试结果如下：

order:Order [id=666, nick=我很强, price=999, createTime=Wed Aug 14 16:11:35 CST 2019]

测试完毕！！！！

---

---

原文链接：https://www.cnblogs.com/zzjlxy-225223/p/11345543.html

---