workman 做消息队列

转载

月光倾城美 2025-03-12 11:07:26

文章标签 workman 做消息队列 java 大数据数据库 spring 文章分类 运维

概念:

分布式消息队列

‘分布式消息队列’包含两个概念

一是‘消息队列’，二是‘分布式’

那么就先看下消息队列的概念，和为什么需要分布式

消息队列的定义

“消息”指进程间传送的数据

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

消息被发送到队列中，消息队列充当中间人，将消息从源发送给目标

当系统中出现“生产“和“消费“的速度或稳定性等因素不一致时，就需要消息队列，作为抽象层，弥合双方的差异

例如

（1）服务员点菜快，厨师做菜慢，服务员只需要下单给厨师，然后就可以继续去服务顾客，不需要等待厨师把菜做完

点菜单就相当于消息，放单子的位置就相当于队列

（2）业务系统需要发短信，但短信发送模块速度跟不上，业务系统就可以把发送短信的相关信息封装为一个消息，放入队列，短信发送模块从队列中获取消息进行处理

消息队列的好处

（1）提高系统响应速度

使用了消息队列，生产者一方，把消息往队列里一扔，就可以立马返回响应用户了，无需等待处理结果

（2）保证消息的传递

如果发送消息时接收者不可用，消息队列会保留消息，直到成功地传递它

（3）解耦

只要消息格式不变，即使接收者的接口、位置、或者配置改变，也不会给发送者带来任何改变

消息发送者无需知道消息接收者是谁，使得系统设计更清晰

为什么需要分布式消息队列

（1）多系统协作需要分布式

例如消息队列中的数据需要在多个系统间共享，所以需要提供分布式通信机制、协同机制

（2）可靠

消息会被持久化到分布式存储中，这样避免了单台机器存储的消息由于机器问题导致消息的丢失

（3）可扩展

分布式消息队列，会随着访问量的增加而方便的增加处理服务器

2. 消息队列技术是分布式应用间交换信息的一种技术

现在电商网站某个抢购活动，并发怎么办？消息队列

AMQP，即Advanced Message Queuing Protocol，高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。消息中间件主要用于组件之间的解耦，消息的发送者无需知道消息使用者的存在，反之亦然。
AMQP的主要特征是面向消息、队列、路由（包括点对点和发布/订阅）、可靠性、安全。
RabbitMQ是一个开源的AMQP实现，服务器端用Erlang语言编写，支持多种客户端，如：Python、Ruby、.NET、Java、JMS、C、PHP、ActionScript、XMPP、STOMP等，支持AJAX。用于在分布式系统中存储转发消息，在易用性、扩展性、高可用性等方面表现不俗。有玩RabbitMq的哥们，多多交流！

用户请求会post到后台一些信息如（用户信息，商品信息）到消息队列中。

消息队列通过Windows服务去处理解析过来的信息，单线程处理（多线程可能会出现问题，你懂得）！

成功的话，插入到本次活动的成功记录表里面；失败的话，插入到有意购买表（方便业务人员销售）！

怎样通知用户？

1，ajax异步去请求（隔两分钟去请求一次成功记录,如果不请求库的话我们会用Redis缓存）

2，长连接的方式（websocket，signalr之类的）

在整套的微服务架构中, 消息队列是不可或缺的部分, 它能够起到线程内同步或者异步调用无法达到的作用,优缺点分别是:
优点：

解耦
i. 只依赖消息的格式, 而不依赖发送者的ip和端口
ii. 多消费者的情况下, 发送者不需要关注消费者的任何信息
路由
不能互相访问的网络之间可以消息队列实现访问, 可以减少对现有网络的修改。
消息可靠性
当消费者发生故障时, 消息可以被有效保存下来, 等待恢复后继续访问.
异步调用
发送者异步发送消息, 不等待消息ack,不会对发送者本身产生响应速度的影响, 当然异步调用也是可以实现的。
方便扩展
集群部署消息队列, 当流量增大和减小是可以通过调整部署来实现和发送方, 消费方无关。

缺点：
多出一个环节,需要保证消息队列的可用性。

二. 常用消息队列

目前常用的消息队列大概有三种类型,RabbitMQ等AMQP系列, Kafka, Redis等kev value系列,它们的使用场景分别是：
1.RabbitMQ：相对重量级高并发的情况，比如数据的异步处理任务的串行执行等.
2.Kafka：基于Pull的模式来处理,具体很高的吞吐量,一般用来进行日志的存储和收集.
3.Redis: 轻量级高并发，实时性要求高的情况，比如缓存，秒杀，及时的数据分析(ELK日志分析框架,使用的就是Redis).

三. SpingBoot 集成消息队列

在SpingBoot中对这个三种都有支持

Redis
请参照其他作者的文章 http://www.jianshu.com/p/a2ab17707eff
RabbitMQ
i. 配置

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
 </dependency>

ii.实现方式 RabbitMQDemoConfigration.java

import org.springframework.amqp.core.*;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
* RabbitMQDemo
*
* @author: sunjie
* @date: 16/01/10
*/
@Configuration
@SuppressWarnings("SpringJavaAutowiringInspection")
public class RabbitMQDemoConfigration {
@Bean
 public CachingConnectionFactory myConnectionFactory() {
     CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
     connectionFactory.setUsername("guest");
     connectionFactory.setPassword("guest");
     connectionFactory.setHost("192.168.1.1");
     connectionFactory.setPort(5672);
     connectionFactory.setVirtualHost("/myHost");
     return connectionFactory;
 }
 //  生成CachingConnectionFactory  也可以使用下面的方式,在application.properties
 //  中定义好属性即可
 //     @Autowired
 //    ConnectionFactory connectionFactory;
@Bean
 public DirectExchange myExchange() {
     return new DirectExchange("myExchangeDemo", true, false);
 }
 @Bean
 public Queue myQueue() {
     return new Queue("myQueueDemo", true);
 }
 @Bean
 public Binding myExchangeBinding(@Qualifier("myExchange") DirectExchange directExchange,
                                  @Qualifier("myQueue") Queue queue) {
     return BindingBuilder.bind(queue).to(directExchange).with("routeDemo");
 }
 @Bean
 public RabbitTemplate myExchangeTemlate() {
     RabbitTemplate r = new RabbitTemplate(myConnectionFactory());
     r.setExchange("myExchangeDemo");
     r.setRoutingKey("routeDemo");
     return r;
 }
/**
  *  发送消息,工业使用需要自己做个性化实现
  */
 @Bean
 public void sendMessage(RabbitTemplate myExchangeTemlate) {
     String string = "Hello RabbitmQ";
     myExchangeTemlate.convertAndSend(string);
 }
 /**
  *  接受消息,工业使用时需要在监听类中实现process逻辑
  */
 @RabbitListener(queues = "myQueueDemo")
 public void process(Message message) {
     System.out.println("__________" + message.getBody().toString() + "__________");
     try {
         this.wait(1000);
     } catch (InterruptedException e) {
         e.printStackTrace();
     }
 }
import org.springframework.amqp.core.*;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
* RabbitMQDemo
*
* @author: sunjie
* @date: 16/01/10
*/
@Configuration
@SuppressWarnings("SpringJavaAutowiringInspection")
public class RabbitMQDemoConfigration {
@Bean
 public CachingConnectionFactory myConnectionFactory() {
     CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
     connectionFactory.setUsername("guest");
     connectionFactory.setPassword("guest");
     connectionFactory.setHost("192.168.1.1");
     connectionFactory.setPort(5672);
     connectionFactory.setVirtualHost("/myHost");
     return connectionFactory;
 }
 //  生成CachingConnectionFactory  也可以使用下面的方式,在application.properties
 //  中定义好属性即可
 //     @Autowired
 //    ConnectionFactory connectionFactory;
@Bean
 public DirectExchange myExchange() {
     return new DirectExchange("myExchangeDemo", true, false);
 }
 @Bean
 public Queue myQueue() {
     return new Queue("myQueueDemo", true);
 }
 @Bean
 public Binding myExchangeBinding(@Qualifier("myExchange") DirectExchange directExchange,
                                  @Qualifier("myQueue") Queue queue) {
     return BindingBuilder.bind(queue).to(directExchange).with("routeDemo");
 }
 @Bean
 public RabbitTemplate myExchangeTemlate() {
     RabbitTemplate r = new RabbitTemplate(myConnectionFactory());
     r.setExchange("myExchangeDemo");
     r.setRoutingKey("routeDemo");
     return r;
 }
/**
  *  发送消息,工业使用需要自己做个性化实现
  */
 @Bean
 public void sendMessage(RabbitTemplate myExchangeTemlate) {
     String string = "Hello RabbitmQ";
     myExchangeTemlate.convertAndSend(string);
 }
 /**
  *  接受消息,工业使用时需要在监听类中实现process逻辑
  */
 @RabbitListener(queues = "myQueueDemo")
 public void process(Message message) {
     System.out.println("__________" + message.getBody().toString() + "__________");
     try {
         this.wait(1000);
     } catch (InterruptedException e) {
         e.printStackTrace();
     }
 }

Kafka 使用
i. pom.xml 配置

<dependency>
   <groupId>org.apache.kafka</groupId>
   <artifactId>kafka_2.10</artifactId>
  </dependency>
  <dependency>
    <groupId>org.springframework.integration</groupId>
    <artifactId>spring-integration-kafka</artifactId>
  </dependency>

ii. spring-integration-kafka.xml 也可以研究通过bean方式来实现

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:int="http://www.springframework.org/schema/integration"
    xmlns:int-kafka="http://www.springframework.org/schema/integration/kafka"
    xmlns:task="http://www.springframework.org/schema/task"
    xsi:schemaLocation="http://www.springframework.org/schema/integration/kafka http://www.springframework.org/schema/integration/kafka/spring-integration-kafka.xsd
 http://www.springframework.org/schema/integration http://www.springframework.org/schema/integration/spring-integration.xsd
 http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
 http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task.xsd">
 <int:channel id="inputToKafka">
     <int:queue/>
 </int:channel>
 <int-kafka:outbound-channel-adapter
         id="kafkaOutboundChannelAdapter"
         kafka-producer-context-ref="kafkaProducerContext"
         channel="inputToKafka">
     <int:poller fixed-delay="1000" time-unit="MILLISECONDS" receive-timeout="0" task-executor="taskExecutor"/>
 </int-kafka:outbound-channel-adapter>
 <task:executor id="taskExecutor" pool-size="5" keep-alive="120" queue-capacity="50000"/>
 <int-kafka:producer-context id="kafkaProducerContext">
     <int-kafka:producer-configurations>
         <int-kafka:producer-configuration broker-list="192.168.2.2:9092"
                                           key-class-type="java.lang.String"
                                           value-class-type="java.lang.String"
                                           topic="1_service"
                                           value-encoder="kafkaEncoder"
                                           key-encoder="kafkaEncoder"/>
     </int-kafka:producer-configurations>
 </int-kafka:producer-context>
 <bean id="kafkaEncoder" class="org.springframework.integration.kafka.serializer.common.StringEncoder"/>
</beans>

iii. 客户端实现代码：

@Autowired
 MessageChannel             inputToKafka;
 String value = "Hello Kafka";
 Message<String> mess = MessageBuilder.withPayload(value)
         .setHeader(KafkaHeaders.TOPIC, appSetting.getStrValue("topic")).build();
 inputToKafka.send(mess);
@Autowired
 MessageChannel             inputToKafka;
 String value = "Hello Kafka";
 Message<String> mess = MessageBuilder.withPayload(value)
         .setHeader(KafkaHeaders.TOPIC, appSetting.getStrValue("topic")).build();
 inputToKafka.send(mess);