ActionMQ

特性

ActiveMQ

RabbitMQ

RocketMQ

Kafka

对于广播模式
activet会照成数据丢失
rabbit是多队列单监听 activet是单队列多监听

docker 安装

docker search activemq
docker pull webcenter/activemq
docker run -d --name activemq -p 61617:61616 -p 8162:8161 webcenter/activemq

* 61616是 activemq 的容器使用端口（映射为61617）
* 8161是 web 页面管理端口（对外映射为8162）
* 访问 http://ip:8161        默认账号密码 amdin   http://121.43.149.217:8161/admin/queues.jsp

两种模式 一种队列 一种广播

生产者

<!--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>

yml

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

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);
    }

}

创建队列 可以网页 也可以用配置文件创建

队列

@Configuration
public class MyMqConfig {
	@Bean
	public Queue queue() {
		return new ActiveMQQueue("sms.queue");
	}}

广播

@Bean
public Topic topic() {
	return new ActiveMQTopic("sms.topic");
}

队列

@Component
public class Producer {
	@Resource
	private JmsMessagingTemplate jmsMessagingTemplate;
	@Resource
	private Queue queue;
	public void sendMsg(String msg) {
		System.out.println("发送消息内容 :" + msg);
		this.jmsMessagingTemplate.convertAndSend(this.queue, msg);
	}}

广播

@Resource
private Topic topic;
public void sendTopic(String msg) {
	System.out.println("发送Topic消息内容 :"+msg);
	this.jmsMessagingTemplate.convertAndSend(this.topic, msg);
}

消费者

队列

@Component
public class Consumer {
	@JmsListener(destination = "sms.queue")
	public void receiveMsg(String text) {
		System.out.println("接收到消息 : "+text);
	}}

广播

@JmsListener(destination = "sms.topic")
public void receiveTopic1(String text) {
	System.out.println("receiveTopic1接收到Topic消息 : " + text);
}@JmsListener(destination = "sms.topic")
public void receiveTopic2(String text) {
	System.out.println("receiveTopic2接收到Topic消息 : " + text);
}

同时支持两种形式
在上面的实例中，要么支持队列模式要么支持广播模式，如果在生产环境中两者都需要支持，那么就需要自定义JmsListenerContainerFactory实例。当然，如果Spring Boot默认的配置无法满足需求，也可以自定义该类，这里只是其中场景之一。

基本配置和使用步骤：通过DefaultJmsListenerContainerFactory创建自定义的JmsListenerContainerFactory实例，在@JmsListener注解中通过containerFactory属性进行引用。

在MyMqConfig配置类中新增如下配置：

@Bean("queueListenerFactory")
public JmsListenerContainerFactory<?> queueListenerFactory(ConnectionFactory connectionFactory) {
	DefaultJmsListenerContainerFactory factory = new DefaultJmsListenerContainerFactory();	factory.setConnectionFactory(connectionFactory);	factory.setPubSubDomain(false);
	return factory;
}@Bean("topicListenerFactory")
public JmsListenerContainerFactory<?> topicListenerFactory(ConnectionFactory connectionFactory) {
	DefaultJmsListenerContainerFactory factory = new DefaultJmsListenerContainerFactory();	factory.setConnectionFactory(connectionFactory);	//设置为发布订阅方式, 默认情况下使用的生产消费者方式
	factory.setPubSubDomain(true);
	return factory;
}

这里分别实例化了基于队列和订阅的工厂类。然后分别在对应的消费者方法上添加containerFactory属性。示例代码如下：

@JmsListener(destination = "sms.queue", containerFactory = "queueListenerFactory")
public void receiveMsg(String text) {
	System.out.println("接收到消息 : " + text);
}@JmsListener(destination = "sms.topic", containerFactory = "topicListenerFactory")
public void receiveTopic1(String text) {
	System.out.println("receiveTopic1接收到Topic消息 : " + text);
}

分别执行两种形式的消息，发现都正常互利。同时，此时配置文件中的项spring.jms.pub-sub-domain也无效了。

接收数据

package com.eagle.opd.datacharge.config;


import cn.hutool.http.HttpUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.eagle.opd.lglutil.stutil.StrUtil;
import com.eagle.opd.redis.config.RedisUtil;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.jms.annotation.JmsListener;
import org.springframework.stereotype.Component;


/**
 * @Author LiGuangLong
 * @Date 2022-01-14 13:37
 **/

@Slf4j
@Component
@AllArgsConstructor
public class ReceiveLaneActiveMq {
    @Value("${message.datacapture}")
    private final String iP;
    private final RedisUtil redis;
    @JmsListener(destination  = "MESSAGE_SERVER_CHARGE_DOCKING_LANE")
    public void handler(String message){
        log.debug("------监听到activemq的[车道]数据:{}", message);
        if (StrUtil.notIsBlank(message)){
            JSONObject result = JSON.parseObject(message);
            String exitVlp = result.getString("exitVlp");
            log.debug("车牌:{}",exitVlp);
            JSONObject redisResult = JSON.parseObject(redis.get(exitVlp));
            if (StrUtil.notIsEmpty(redisResult)){
                log.debug("存在车牌:{}",exitVlp);
                log.debug("对应用户信息{}",redisResult.get("userId"));
                log.debug("判断mq的出入口把消息htpp 发送到消息后台,插入待待推送消息列表  高数公路欢迎......");
                HttpUtil.post(iP,"");

            }
        }
    }
}