rabbitMQ基本知识

rabbitMQ基本知识

mq是常见的物理解耦+逻辑解耦
provider提供服务只需要对着mq进行发布消息，mq会转发给comsumer就可以接触耦合（逻辑上解耦了，物理上也解耦了）
为什么需要使用mq
1.流量消峰 # 在访问量突然增长的时候，mq就可以当做一个缓存的队列。
2.应用解耦 # 应用之间中间多了一个mq，假如订单系统坏了，消息会缓存在mq中，不会直接导致其他的系统也受到影响。
3.异步处理 # 如果应用A调用了B的服务，但是B需要一段时间才可以处理结束，但是A需要知道B什么时候才可以执行完成，这时候一般可以采用两种方式，1.A调用B的查询api，查询什么时候执行完成。2.B提供一个callback的api，B执行完后调用callback通知A。使用mq，B执行完发送消息给mq，mq再把消息通知A，A即可以及时的处理信息，也不用一直去询问B
四大核心概念
生产者、
交换机 交换机接收来自生产者的消息，又把消息推送到队列中,(交换机必须确切知道如何处理它接收到的消息，是将这些消息推送到特定队列还是推送到多个队列，亦或者是把消息丢弃，这个得有交换机类型决定)
队列 队列是一种数据结构，先进先出，是一个缓存区
消费者

rabbitMQ执行原理图

创建provider

``java

        //通过工厂创建连接
        private final static String QUEUE_NAME = "hello";
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("8.130.15.205");
        factory.setUsername("guest");
        factory.setPassword("guest");

        //channel实现类close接口自动关闭，不用手动关闭
        Channel channel = factory.newConnection().createChannel();
        /**
         *
         生成一个队列
         * 1.队列名称
         * 2.队列里面的消息是否持久化 默认消息存储在内存中
         * 3.该队列是否只供一个消费者进行消费 是否进行共享 true可以多个消费者消费
         * 4.是否自动删除 最后一个消费者端开连接以后 该队列是否自动删除 true
         自动删除
         * 5.其他参数
         */
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        String message="hello world";
        /**
         *
         发送一个消息
         * 1.发送到那个交换机
         * 2.路由的 key
         是哪个
         * 3.其他的参数信息
         * 4.发送消息的消息体
         */
        channel.basicPublish("",QUEUE_NAME,null,message.getBytes());
        System.out.println("消息发送完毕");
```

ConnectionFactory factory = new ConnectionFactory();
       factory.setHost("8.130.15.205");
       factory.setUsername("guest");
       factory.setPassword("guest");
       Connection connection = factory.newConnection();
       Channel channel = connection.createChannel();
       System.out.println("等待接收消息....");

       //推送的消息如何进行消费的接口回调
       DeliverCallback deliverCallback = (consumerTag, delivery) -> {
           String message = new String(delivery.getBody());
           System.out.println(message);
       };

       //取消消费的一个回调接口 如在消费的时候队列被删除掉了
       CancelCallback cancelCallback = (consumerTag) -> {
           System.out.println("消息消费被中断");
       };

       /**
        *
        消费者消费消息
        * 1.
        消费哪个队列
        * 2.
        消费成功之后是否要自动应答 true
        代表自动应答 false
        手动应答
        * 3.
        消费者未成功消费的回调
        */
       channel.basicConsume(QUEUE_NAME,true,deliverCallback,cancelCallback);        

工作队列
把消息封装成为任务，分发到队列中，队列会分发到多个消费者中。
默认的分发规则：轮训分发(你一个我一个)；
不公平分发：能者多劳

		//设置成0就是轮序分发，因为int类型默认是0
        //能者多劳 
        channel.basicQos(1);

预期值：信道就是缓冲队列，可以设置缓冲队列的长度，防止无限制的信道中堆积消息。

		//信道的缓冲消息为7
         channel.basicQos(7);

rabbitMQ的手动应答和自动应答
消息应答
消费者在接收到mq的消息或者处理了消息，告诉mq可以在队列中删除消息，（消息应答是消费者和Broker之间的应答）。
如果消息丢失了(消费者关闭连接、宕机了)，消息可以重新进入队列，然后发送给其他的消费者。
应答分类

自动应答：消费者接收到消息就应答rabbitMQ，rabbitmq直接删除消息；

//true代表自动应答
 channel.basicConsume("oneQueue",true,
                (consumerTag, var1) -> {
            String message = new String(var1.getBody());
            System.out.println(message);},
                can ->{
            System.out.println("xiaoxi ");
        });
        

手动应答：在处理完消息才确定应答
手动应答可以分为单个应答和批量应答

 /**
        
         * 1.消息标记 tag
         * 2.是否批量应答未应答消息
         */
         //执行到这行代码的时候就算是应答成功，在basicConsume()被调用
         DeliverCallback deliverCallback = (consumerTag, delivery) -> {
             String message = new String(delivery.getBody());

             System.out.println("接收到消息:" + message);
             //false代表不批量应答、true代表应答在消费者信道中所有消息
             channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
        };
        //采用手动应答
        boolean autoAck = false;
        channel.basicConsume("two", autoAck, deliverCallback, (consumerTag) -> {
            System.out.println(consumerTag + "消费者取消消费接口回调逻辑");

        });

rabbitMQ的持久化

在rabbitMQ宕机或者关掉服务后，保证队列和消息的持久化；

              //true 队列的持久化
            channel.queueDeclare(QUEUE_NAME,true,false,false,null);
              //MessageProperties.PERSISTENT_TEXT_PLAIN  消息持久化
             channel.basicPublish("",QUEUE_NAME,MessageProperties.PERSISTENT_TEXT_PLAIN,message.getBytes());

发布确认原理
发布确认是消费者和提供者之间的关系
消费者告诉提供者消息已经处理好了，消息的回调；
发布确认是在provider中开启的，默认是没有开启；

        //开启发布确认
        channel.confirmSelect();
        //只要消费者收到消息就返回true(但消费者可能还没有处理完)
        boolean flag = channel.waitForConfirms();

发布确认分为单个确认，批量确认，异步确认发布消息；
推荐：异步确认发布消息
不用等到确认后才继续发布消息，可以一边发布，一边确认。效率最高、稳定性最好、可以知道那个消息出了问题；
交换机
provider的消息不会直接发布到队列中，由交换机发布到队列中；
使用交换机完成发布订阅模式；
交换机的绑定规则
可以在生产者和消费者都设置交换机的绑定规则，但是没必要，不好理解、而且代码重复；
推荐：在生产者设置交换机的绑定规则，在消费者绑定队列就可以了；

默认交换机

//默认的交换机、two是和队列绑定在一起
 channel.basicPublish("", "two", null, message.getBytes("UTF-8"));

== Fanout(扇形交换机、广播)==
扇形交换机的和队列可以不用绑定，默认是" ",表示全部的队列都会收到消息(包括和其他交换机已经绑定的队列)

		//生产者
		//设置一个交换机(交换机名称、交换机类型)
        channel.exchangeDeclare("扇形交换机","fanout" );
        //另外一个交换机
        channel.exchangeDeclare("direct","direct" );
        //设置两个队列
        channel.queueDeclare("two", false, false, false, null);
        channel.queueDeclare("thr", false, false, false, null);
 
        //和direct绑定的队列，也可以收到消息
         channel.queueBind("thr","direct","qqqq");
         
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入信息");
        while (sc.hasNext()) {
            String message = sc.nextLine();
            //通过交换机(必须经过这个交换机、理解成为一条道路)推送消息到绑定了ooo规则的队列
            channel.basicPublish("扇形交换机", " ", null, message.getBytes("UTF-8"));
            System.out.println("生产者发出消息" + message);
            if (channel.waitForConfirms()){

                System.out.println("消息确认收到");
            }
        }

				//和队列绑定就可以了，因为是扇形的交换机所以全部队列都会收到消息
       		channel.basicConsume("thr", autoAck, deliverCallback, (consumerTag) -> {
         	  System.out.println(consumerTag + "消费者取消消费接口回调逻辑");

== direct交换机==
只可以和规定的绑定规则的队列发送消息、可以发送多个相同绑定路由的队列；

        //直接交换机
         channel.exchangeDeclare("direct","direct" );
        //设置两个队列
        channel.queueDeclare("two", false, false, false, null);
        channel.queueDeclare("thr", false, false, false, null);
        //设置队列和交换机的绑定规则
       // channel.queueBind("two","direct","");
        channel.queueBind("thr","direct","qqqq");
        channel.queueBind("two","direct","qqqq");
 
         while (sc.hasNext()) {
             String message = sc.nextLine();
             //thr 和two 都可以收到消息
             channel.basicPublish("direct", "qqqq", null, message.getBytes("UTF-8"));
             System.out.println("生产者发出消息" + message);
             if (channel.waitForConfirms()){

                 System.out.println("消息确认收到");
                }
         }

 //和队列绑定就可以了
        channel.basicConsume("thr", autoAck, deliverCallback, (consumerTag) -> {
            System.out.println(consumerTag + "消费者取消消费接口回调逻辑");

        });
        channel.basicConsume("two", autoAck, deliverCallback, (consumerTag) -> {
            System.out.println(consumerTag + "消费者取消消费接口回调逻辑");

        });

Topics(主题交换机)
可以动态的绑定队列，只要发送的消息的路由符合绑定规则就可以发送消息

规则：
1.*代表一个单词
2.#可以代表0个或者多个单词

   //主题交换机
        channel.exchangeDeclare("主题交换机","topic");
        //声明队列
        channel.queueDeclare("four", false, false, false, null);
        //动态的绑定行到队列
        channel.queueBind("four","主题交换机","qqq.*");
          while (sc.hasNext()) {
            String message = sc.nextLine();
            //通过交换机(必须经过这个交换机、理解成为一条道路)推送消息到绑定了ooo规则的信道
            channel.basicPublish("主题交换机", "qqq.zzzz", null, message.getBytes("UTF-8"));
            System.out.println("生产者发出消息" + message);
            if (channel.waitForConfirms()){

                System.out.println("消息确认收到");
            }

 channel.basicConsume("four", autoAck, deliverCallback, (consumerTag) -> {
            System.out.println(consumerTag + "消费者取消消费接口回调逻辑");