SpringAMQP发送与接收消息

同步调用的优点：时效性较强，可以立即得到结果

同步调用的问题：
1.耦合度高
2.性能和吞吐能力下降
3.有额外的资源消耗
4.有级联失败问题

异步通信的优点：
1.耦合度低
2.吞吐量提升
3.故障隔离
4.流量削峰

异步通信的缺点：
1.依赖于Broker的可靠性、安全性、吞吐能力
2.架构复杂了，业务没有明显的流程线，不好追踪管理

什么是AMQP？
应用间消息通信的一种协议，与语言和平台无关。

SpringAMQP如何发送消息？

1.引入amqp的starter依赖
2.配置RabbitMQ地址
3.利用RabbitTemplate的convertAndSend方法

1.在父工程中引入spring-amqp的依赖

        <!--AMQP依赖，包含RabbitMQ-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>

2.在publisher服务中利用RabbitTemplate发送消息到simple.queue这个队列

1.在publisher服务中编写application.yml，添加mq连接信息：

spring:
  rabbitmq:
    host: 192.168.64.131  #rabbitMQ的ip地址
    port: 5672  #端口
    username: itcast
    password: 123321
    virtual-host: / #虚拟主机

2.在publisher服务中新建一个测试类，编写测试方法：

@SpringBootTest
@RunWith(SpringRunner.class)
public class SpringAmqpTest {
    @Autowired
    private RabbitTemplate rabbitTemplate;
    @Test
    public void testSendMessage2SimpleQueue(){
        String queueName="simple.queue";//队列名称
        String message="hello,spring amqp";//消息
        rabbitTemplate.convertAndSend(queueName,message);
    }
}

 成功发送消息

SpringAMQP如何接收消息？

1.引入amqp的starter依赖
2.配置RabbitMQ地址
3.定义类，添加@Component注解
类中声明方法，添加@RabbitListener注解，方法参数就时消息

注意：消息一旦消费就会从队列删除，RabbitMQ没有消息回溯功能

1.在consumer中编写消费逻辑，监听simple.queue

1.在consumer服务中编写application.yml，添加mq连接信息：

spring:
  rabbitmq:
    host: 192.168.64.131  #rabbitMQ的ip地址
    port: 5672  #端口
    username: itcast
    password: 123321
    virtual-host: /

2.在consumer服务中新建一个类，编写消费逻辑：

@Component
public class SpringRabbitListener {
    @RabbitListener(queues = "simple.queue")
    public void listenSimpleQueue(String msg){
        System.out.println("消费者接收到simple.queue："+msg);

    }
}

 模拟WorkQueue，实现一个队列绑定多个消费者

1.在publisher服务中定义测试方法，每秒产生50条消息，发送到simple.queue
2.在consumer服务中定义两个消息监听者，都监听simple.queue队列
3.消费者1每秒处理50条消息，消费者2每秒处理10条消息

1.生产者循环发送消息到simple.queue

在publisher服务中添加一个测试方法，循环发送50条消息到simple.queue队列

    @Test
    public void testSendMessage2WorkQueue() throws InterruptedException {
        String queueName="simple.queue";//队列名称
        String message="hello,message--";//消息
        for (int i = 1; i < 50; i++) {
            rabbitTemplate.convertAndSend(queueName,message+i);
            Thread.sleep(20);
        }
    }

2.编写两个消费者，都监听simple.queue

在consumer服务中添加一个消费者，也监听simple.queue：

    @RabbitListener(queues = "simple.queue")
    public void listenSimpleQueue1(String msg) throws InterruptedException {
        System.out.println("消费者1接收到消息："+msg+ LocalTime.now());
        Thread.sleep(20);
    }
    @RabbitListener(queues = "simple.queue")
    public void listenSimpleQueue2(String msg) throws InterruptedException {
        System.err.println("消费者2222接收到消息："+msg+LocalTime.now());
        Thread.sleep(200);
    }

3.消费预取限制

修改application.yml文件，设置preFetch这个值，可以控制预取消息的上限

spring:
  rabbitmq:
    host: 192.168.64.131  #rabbitMQ的ip地址
    port: 5672  #端口
    username: itcast
    password: 123321
    virtual-host: /
    listener:
      simple:
        prefetch: 1 #每次只能获取一条消息，处理完成才能获取下一个消息

开始测试

发布（ Publish ）、订阅（ Subscribe ）

发布订阅模式与之前案例的区别就是允许将同一消息发送给多个消费者。实现方式是加入了exchange（交换机）。exchange负责消息路由，而不是存储，路由失败则消息丢失

常见exchange类型包括：
Fanout：广播
Direct：路由
Topic：话题

发布订阅-Fanout Exchange
Fanout Exchange 会将接收到的消息广播到每一个跟其绑定的queue

发布订阅-DirectExchange
Direct Exchange 会将接收到的消息根据规则路由到指定的Queue，因此称为路由模式（routes）。
每一个Queue都与Exchange设置一个BindingKey
发布者发送消息时，指定消息的RoutingKey
Exchange将消息路由到BindingKey与消息RoutingKey一致的队列

发布订阅-TopicExchange​​​​​​​
TopicExchange与DirectExchange类似，区别在于routingKey必须是多个单词的列表，并且以 . 分割。
Queue与Exchange指定BindingKey时可以使用通配符：
#：代指0个或多个单词
*：代指一个单词

1.利用SpringAMQP演示FanoutExchange的使用

1.实现思路如下：

1.在consumer服务中，利用代码声明队列、交换机，并将两者绑定
2.在consumer服务中，编写两个消费者方法，分别监听fanout.queue1和fanout.queue2
3.在publisher中编写测试方法，向itcast.fanout发送消息

2.在consumer服务声明Exchange、Queue、Binding

在consumer服务创建一个类，添加@Configuration注解，并声明FanoutExchange、Queue和绑定关系对象Binding，代码如下：

@Configuration
public class FanoutConfig {
    //声明FanoutExchange交换机
    @Bean
    public FanoutExchange fanoutExchange(){
        return new FanoutExchange("itcast.fanout");
    }
    //声明第1个队列
    @Bean
    public Queue fanoutQueue1(){
        return new Queue("fanout.queue1");
    }
    //绑定队列1和交换机
    @Bean
    public Binding fanoutBinding1(Queue fanoutQueue1,FanoutExchange fanoutExchange){
        return BindingBuilder
                .bind(fanoutQueue1)
                .to(fanoutExchange);
    }
    //声明第2个队列
    @Bean
    public Queue fanoutQueue2(){
        return new Queue("fanout.queue2");
    }
    //绑定队列2和交换机
    @Bean
    public Binding fanoutBinding2(Queue fanoutQueue2,FanoutExchange fanoutExchange){
        return BindingBuilder
                .bind(fanoutQueue2)
                .to(fanoutExchange);
    }

}

3.在consumer服务声明两个消费者

在consumer服务的SpringRabbitListener类中，添加两个方法，分别监听fanout.queue1和fanout.queue2：

    @RabbitListener(queues = "fanout.queue1")
    public void listenFanoutQueue1(String msg){
        System.out.println("消费者接收到fanout.queue1："+msg);
    }
    @RabbitListener(queues = "fanout.queue2")
    public void listenFanoutQueue2(String msg){
        System.out.println("消费者接收到fanout.queue2："+msg);
    }

4.在publisher服务发送消息到FanoutExchange

在publisher服务的SpringAmqpTest类中添加测试方法：

    @Test
    public void testSendFanoutExchange(){
        //交换机名称
        String exchangeName="itcast.fanout";
        //消息
        String message="hellow every one";
        //发送
        rabbitTemplate.convertAndSend(exchangeName,"",message);
    }

5.重启consumer测试

2.利用SpringAMQP演示DirectExchange的使用

实现思路如下：
1.利用@RabbitListener声明Exchange、Queue、RoutingKey
2.在consumer服务中，编写两个消费者方法，分别监听direct.queue1和direct.queue2
3.在publisher中编写测试方法，向itcast. direct发送消息

1.在consumer服务声明Exchange、Queue

1.在consumer服务中，编写两个消费者方法，分别监听direct.queue1和direct.queue2，
2.并利用@RabbitListener声明Exchange、Queue、RoutingKey

    @RabbitListener(bindings =@QueueBinding(
            value = @Queue(name = "direct.queue1"),
            exchange = @Exchange(name = "itcast.direct",type = ExchangeTypes.DIRECT),
            key = {"red","blue"}
    ))
    public void listerDirecrtQueue1(String msg){
        System.out.println("消费者接收到direct.queue1的消息："+msg);
    }
    @RabbitListener(bindings =@QueueBinding(
            value = @Queue(name = "direct.queue2"),
            exchange = @Exchange(name = "itcast.direct",type = ExchangeTypes.DIRECT),
            key = {"red","yellow"}
    ))
    public void listerDirecrtQueue2(String msg){
        System.out.println("消费者接收到direct.queue2的消息："+msg);
    }

2.在publisher服务发送消息到DirectExchange

在publisher服务的SpringAmqpTest类中添加测试方法：

    @Test
    public void testSendDirectExchange(){
        //交换机名称
        String exchangeName="itcast.direct";
        //消息
        String message="hellow blue";
        //发送
        rabbitTemplate.convertAndSend(exchangeName,"blue",message);
    }

只有Routingkey含blue的队列才能接收到此消息

描述下Direct交换机与Fanout交换机的差异？

Fanout交换机将消息路由给每一个与之绑定的队列
Direct交换机根据RoutingKey判断路由给哪个队列
如果多个队列具有相同的RoutingKey，则与Fanout功能类似

3.利用SpringAMQP演示TopicExchange的使用

实现思路如下：
1.并利用@RabbitListener声明Exchange、Queue、RoutingKey
2.在consumer服务中，编写两个消费者方法，分别监听topic.queue1和topic.queue2
3.在publisher中编写测试方法，向itcast. topic发送消息

1.在consumer服务声明Exchange、Queue

1.在consumer服务中，编写两个消费者方法，分别监听topic.queue1和topic.queue2，
2.并利用@RabbitListener声明Exchange、Queue、RoutingKey

    @RabbitListener(bindings =@QueueBinding(
            value = @Queue(name = "topic.queue1"),
            exchange = @Exchange(name = "itcast.topic",type = ExchangeTypes.TOPIC),
            key = "china.#"
    ))
    public void listerTopicQueue1(String msg){
        System.out.println("消费者接收到topic.queue1的消息："+msg);
    }
    @RabbitListener(bindings =@QueueBinding(
            value = @Queue(name = "topic.queue2"),
            exchange = @Exchange(name = "itcast.topic",type = ExchangeTypes.TOPIC),
            key = "#.news"
    ))
    public void listerTopicQueue2(String msg){
        System.out.println("消费者接收到topic.queue2的消息："+msg);
    }

2.在publisher服务发送消息到TopicExchange

在publisher服务的SpringAmqpTest类中添加测试方法：

    @Test
    public void testSendTopicExchange(){
        //交换机名称
        String exchangeName="itcast.topic";
        //消息
        String message="你好我好大家好";
        //发送
        rabbitTemplate.convertAndSend(exchangeName,"china.news",message);
    }

两个队列都能接收到消息

4.SpringAMQP-消息转换器

在SpringAMQP的发送方法中，接收消息的类型是Object，也就是说我们可以发送任意对象类型的消息，SpringAMQP会帮我们序列化为字节后发送。

1.测试发送Object类型消息

1.我们在consumer中利用@Bean声明一个队列：

    @Bean
    public Queue ObjectQueue(){
        return new Queue("object.queue");
    }

2.在publisher中发送消息以测试：

    @Test
    public void testSendObjectQueue() {
        Map<String,Object> msg=new HashMap<>();
        msg.put("name", "坏女人");
        msg.put("age", 18);
        rabbitTemplate.convertAndSend("object.queue",msg);
    }

Spring的对消息对象的处理是由org.springframework.amqp.support.converter.MessageConverter来处理的。而默认实现是SimpleMessageConverter，基于JDK的ObjectOutputStream完成序列化。

2.如果要修改只需要定义一个MessageConverter 类型的Bean即可。推荐用JSON方式序列化，步骤如下：

1.我们在父工程引入依赖

        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
        </dependency>

2.我们在publisher服务声明MessageConverter：

    @Bean
    public MessageConverter messageConverter(){
        return new Jackson2JsonMessageConverter();
    }

3.接收消息

1.我们在consumer服务定义MessageConverter：

    @Bean
    public MessageConverter messageConverter(){
        return new Jackson2JsonMessageConverter();
    }

2.然后定义一个消费者，监听object.queue队列并消费消息：

    @RabbitListener(queues = "object.queue")
    public void listenObjectQueue(Map<String,Object> msg){
        System.out.println("接收到object.queue的消息"+msg);
    }

重启服务