activemq使用

WHAT?什么地方使用？
思考：
ActiveMQ介绍
特点：
消息通信的基本方式有两种：
消息形式：
why?为什么使用？优缺点
HOW?如何使用？出现什么问题？如何解决？
使用方式：
springboot:引入pom依赖
配置文件：
启动类添加注解@EnableJms：
初始化和配置连接：
生产者：
队列消费者Queue：
topic模式的消费者：
安装和使用问题及解决方法:
问题一：windows环境下载解压后，启动闪退找不到jvm环境，更改配置文件
问题二：与windows本地服务冲突，端口占用
问题三：项目启动异常
文件目录：
WHAT?什么是？

ActiveMQ介绍
MQ是消息中间件，是一种在分布式系统中应用程序借以传递消息的媒介，常用的有ActiveMQ，RabbitMQ，kafka。ActiveMQ是Apache下的开源项目，完全支持JMS1.1和J2EE1.4规范的JMS Provider实现。
特点：
支持多种语言编写客户端
对spring的支持，很容易和spring整合
支持多种传输协议：TCP,SSL,NIO,UDP等
支持AJAX

消息通信的基本方式有两种：
1、同步方式
两个通信应用服务之间必须要进行同步，两个服务之间必须都是正常运行的。发送程序和接收程序都必须一直处于运行状态，并且随时做好相互通信的准备。
发送程序首先向接收程序发起一个请求，称之为发送消息，发送程序紧接着就会堵塞当前自身的进程，不与其他应用进行任何的通信以及交互，等待接收程序的响应，待发送消息得到接收程序的返回消息之后会继续向下运行，进行下一步的业务处理。
2、异步方式
两个通信应用之间可以不用同时在线等待，任何一方只需各自处理自己的业务，比如发送方发送消息以后不用登录接收方的响应，可以接着处理其他的任务。也就是说发送方和接收方都是相互独立存在的，发送方只管方，接收方只能接收，无须去等待对方的响应。
Java中JMS就是典型的异步消息处理机制，JMS消息有两种类型：点对点、发布/订阅。

消息形式：
点对点（queue）
P2P(Ponit to Point)模型，即采用点对点的方式发送消息。P2P模型是基于队列的，消息生产者发送消息到队列，消息消费者从队列中接收消息，队列的存在使得消息的异步传输称为可能，P2P模型在点对点的情况下进行消息传递时采用。

一对多（topic）
Pub/Sub(Publish/Subscribe，即发布-订阅)模型，发布-订阅模型定义了如何向一个内容节点发布和订阅消息，这个内容节点称为topic(主题)。主题可以认为是消息传递的中介，消息发布这将消息发布到某个主题，而消息订阅者则从主题订阅消息。主题使得消息的订阅者与消息的发布者互相保持独立，不需要进行接触即可保证消息的传递，发布-订阅模型在消息的一对多广播时采用。

关于生产者获取消费者返回的问题
1.每个消费者处理完成请求，再发送消息到消息队列中，你的生产者那方再实现消费者来消费这些处理结果信息；
然后处理你的逻辑！

2.将处理结果存于缓存等高性能组件中，通过轮询的方式获取任务处理结果
消息中间件理解：
消息中间件实现系统之间解耦、异步访问。
在微服务架构下，各个业务模块都是独立的系统。整个业务由各个子系统链式调用完成。
消息中间件就充当了各个子系统间的缓冲角色。系统不直接调用系统，而是调用中间件。
适用于不需要即时响应的业务场景。

消息中间件主要功能：
1.发送/接收消息
2.集群/容错配置
3.高可用
4.持久化
5.延时/定时投递消息
6.确认机制

HOW?如何使用？出现什么问题？如何解决？
使用方式：
springboot:引入pom依赖

        <!--ActiveMq-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-activemq</artifactId>
            <version>1.5.0.RELEASE</version>
        </dependency>
        <!--消息队列连接池-->
        <dependency>
            <groupId>org.apache.activemq</groupId>
            <artifactId>activemq-pool</artifactId>
            <version>5.15.0</version>
        </dependency>  

配置文件：
有的spring boot版本对应的jms-starter没有包含activemq-pool的依赖引入，所以不能设置pool.enabled=true，如果要使用需要自己添加activemq-pool的依赖包：

server:
  port: 8080
spring:
  activemq:
    broker-url: tcp://127.0.0.1:61616
    user: admin
    password: admin
    close-timeout: 15s   # 在考虑结束之前等待的时间
    in-memory: true      # 默认代理URL是否应该在内存中。如果指定了显式代理，则忽略此值。
    non-blocking-redelivery: false  # 是否在回滚回滚消息之前停止消息传递。这意味着当启用此命令时，消息顺序不会被保留。
    send-timeout: 0     # 等待消息发送响应的时间。设置为0等待永远。
    queue-name: active.queue
    topic-name: active.topic.name.model
#  packages:
#    trust-all: true #不配置此项，会报错
  pool:
    enabled: true
    max-connections: 10   #连接池最大连接数
    idle-timeout: 30000   #空闲的连接过期时间，默认为30秒

 # jms:
 #   pub-sub-domain: true  #默认情况下activemq提供的是queue模式，若要使用topic模式需要配置下面配置

# 是否信任所有包
#spring.activemq.packages.trust-all=
# 要信任的特定包的逗号分隔列表（当不信任所有包时）
#spring.activemq.packages.trusted=
# 当连接请求和池满时是否阻塞。设置false会抛“JMSException异常”。
#spring.activemq.pool.block-if-full=true
# 如果池仍然满，则在抛出异常前阻塞时间。
#spring.activemq.pool.block-if-full-timeout=-1ms
# 是否在启动时创建连接。可以在启动时用于加热池。
#spring.activemq.pool.create-connection-on-startup=true
# 是否用Pooledconnectionfactory代替普通的ConnectionFactory。
#spring.activemq.pool.enabled=false
# 连接过期超时。
#spring.activemq.pool.expiry-timeout=0ms
# 连接空闲超时
#spring.activemq.pool.idle-timeout=30s
# 连接池最大连接数
#spring.activemq.pool.max-connections=1
# 每个连接的有效会话的最大数目。
#spring.activemq.pool.maximum-active-session-per-connection=500
# 当有"JMSException"时尝试重新连接
#spring.activemq.pool.reconnect-on-exception=true
# 在空闲连接清除线程之间运行的时间。当为负数时，没有空闲连接驱逐线程运行。
#spring.activemq.pool.time-between-expiration-check=-1ms

是否只使用一个MessageProducer

#spring.activemq.pool.use-anonymous-producers=true

启动类添加注解@EnableJms：
@EnableJms会启动jms的注解扫描即发现@JmsListener注释的方法创建消息监听容器，相当于<jms:annotation-d riven/>，可是我后来发现没有@EnableJms程序也可以正常运行，网上也有人有这样的疑惑https://stackoverflow.com/questions/45796021/how-does-spring-look-for-enablejms-methods-if-i-dont-have-class-marked-enable，可能是spring boot检测到了JMS的存在并自动启用JMS处理，可能该注解仅适用于非Spring Boot应用程序

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.jms.annotation.EnableJms;

@SpringBootApplication
@EnableJms    //启动消息队列
public class SpringbootActivemqApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringbootActivemqApplication.class, args);
    }

}

初始化和配置连接：

import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.activemq.command.ActiveMQQueue;
import org.apache.activemq.command.ActiveMQTopic;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jms.config.JmsListenerContainerFactory;
import org.springframework.jms.config.SimpleJmsListenerContainerFactory;
import org.springframework.jms.core.JmsMessagingTemplate;
import javax.jms.ConnectionFactory;
import javax.jms.Queue;
import javax.jms.Topic;

@Configuration
publicclass BeanConfig
{

    @Value("${spring.activemq.broker-url}")
    private String brokerUrl;

    @Value("${spring.activemq.user}")
    private String username;

    @Value("${spring.activemq.topic-name}")
    private String password;

    @Value("${spring.activemq.queue-name}")
    private String queueName;

    @Value("${spring.activemq.topic-name}")
    private String topicName;

    @Bean(name = "queue")
    public Queue queue() {
        return new ActiveMQQueue(queueName);
    }

    @Bean(name = "topic")
    public Topic topic() {
        return new ActiveMQTopic(topicName);
    }

    @Bean
    public ConnectionFactory connectionFactory(){
        return new ActiveMQConnectionFactory(username, password, brokerUrl);    }

    @Bean
    public JmsMessagingTemplate jmsMessageTemplate(){
        return new JmsMessagingTemplate(connectionFactory());
    }

    // 在Queue模式中，对消息的监听需要对containerFactory进行配置
    @Bean("queueListener")
    public JmsListenerContainerFactory<?> queueJmsListenerContainerFactory(ConnectionFactory connectionFactory){
        SimpleJmsListenerContainerFactory factory = new SimpleJmsListenerContainerFactory();
        factory.setConnectionFactory(connectionFactory);
        factory.setPubSubDomain(false);
        return factory;
    }

    //在Topic模式中，对消息的监听需要对containerFactory进行配置
    @Bean("topicListener")
    public JmsListenerContainerFactory<?> topicJmsListenerContainerFactory(ConnectionFactory connectionFactory){
        SimpleJmsListenerContainerFactory factory = new SimpleJmsListenerContainerFactory();
        factory.setConnectionFactory(connectionFactory);
        factory.setPubSubDomain(true);
        return factory;
    }
}

生产者：
注：这里的jmsMessagingTemplate和queue都是用@Autowired注解自动注入的。注意这里的jmsMessagingTemplate，在整个工程里都没有配置实例化的地方。
其实，jmsMessagingTemplate的实例化是spring boot的autoconfigure自动注入的。
实现可以参见JmsAutoConfiguration.java的代码。大概意思就是当我们引入了jms相关的包，比如activemq的包，又定义了ConnectionFactory的实例，那么他就会自动生成一个JmsTemplate实例。
ConnectionFactory在哪里自动创建的呢？看这个ActiveMQConnectionFactoryConfiguration.java。大概意思是，如果没有ConnectionFactory实例，就自动创建一个实例。
所以说，只要引入了spring-boot-starter-activemq那么就会给我们自动创建一个JmsTemplate，相关的连接配置从application.properties，如果里面没有配置的话就会使用ActiveMQProperties.java的默认值。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jms.core.JmsMessagingTemplate;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import javax.jms.Destination;
import javax.jms.Queue;
import javax.jms.Topic;

@RestController
public class ProducerController
{
    @Autowired
    private JmsMessagingTemplate jmsMessagingTemplate;

    @Autowired
    private Queue queue;

    @Autowired
    private Topic topic;

    @PostMapping("/queue/test")
    public String sendQueue(@RequestBody String str) {
        this.sendMessage(this.queue, str);
        return "success";
    }

    @PostMapping("/topic/test")
    public String sendTopic(@RequestBody String str) {
        this.sendMessage(this.topic, str);
        return "success";
    }

    // 发送消息，destination是发送到的队列，message是待发送的消息
    private void sendMessage(Destination destination, final String message){
        jmsMessagingTemplate.convertAndSend(destination, message);
    }
}

队列消费者Queue：
JmsListener是spring-jms提供的一个注解，会实例化一个Jms的消息监听实例，也就是一个异步的消费者。

import org.springframework.jms.annotation.JmsListener;
import org.springframework.stereotype.Component;
@Component
public class QueueConsumerListener
{
    //queue模式的消费者
    @JmsListener(destination="${spring.activemq.queue-name}", containerFactory="queueListener")
    public void readActiveQueue(String message) {
        System.out.println("queue接受到：" + message);
    }
}

topic模式的消费者：
JmsListener是spring-jms提供的一个注解，会实例化一个Jms的消息监听实例，也就是一个异步的消费者。

import org.springframework.jms.annotation.JmsListener;
import org.springframework.stereotype.Component;

@Component
public class TopicConsumerListener
{
    //topic模式的消费者
    @JmsListener(destination="${spring.activemq.topic-name}", containerFactory="topicListener")
    public void readActiveQueue(String message) {
        System.out.println("topic接受到：" + message);
    }
}

安装和使用问题及解决方法:
问题一：windows环境下载解压后，启动闪退找不到jvm环境，更改配置文件

两种写法可以尝试一下（待确认不同写法用途）
问题二：与windows本地服务冲突，端口占用
关闭Internet Connection Sharing (ICS)服务
或者
修改activeMQ启动端口，避免出现类似问题，在下图activemq.xml文件中

问题三：项目启动异常
要先启动amq再启动项目，不然会在项目启动中不断尝试连接amq，导致启动异常