RabbitMQ搭建

MQ

Mq存储消息 主要用于分布式系统之间消息传输

应用解耦：提高系统容错性和可维护性。

异步提速：提升用户体验和系统吞吐量。

削峰填谷：提高系统稳定性。

缺点：

消息队列中间件

exchange 交换机 分发消息 分发到不同的容器 queue 通过路由来处理

queue 容器

routes 路由

安装mq

1. 安装依赖环境

在线安装依赖环境：

yum -y install build-essential openssl openssl-devel unixODBC unixODBC-devel make gcc gcc-c++ kernel-devel m4 ncurses-devel tk tc xz

2. 安装Erlang

​# 安装

rpm -ivh erlang-22.0.7-1.el7.x86_64.rpm

3. 安装RabbitMQ

#安装依赖的包

rpm -ivh socat-1.7.3.2-2.el7.x86_64.rpm

#安装rabbitmq

rpm -ivh rabbitmq-server-3.7.18-1.el7.noarch.rpm

RabbitMQ的启动命令

systemctl start rabbitmq-server # 启动服务

systemctl stop rabbitmq-server # 停止服务

systemctl restart rabbitmq-server # 重启服务

systemctl status rabbitmq-server #查看状态

开启管理界面及配置

# 开启管理界面

rabbitmq-plugins enable rabbitmq_management

# 修改默认配置信息

vim /usr/lib/rabbitmq/lib/rabbitmq_server-3.7.18/ebin/rabbit.app

修改大概39行 loopback_users 中的 <<"guest">>,只保留guest

修改之后重启一下rabbitmq

打开客户端（浏览器）

192.168.44.34（自己的端口）:15672

使用guest/guest登录之后出现如下即为安装成功

添加虚拟主机

添加用户

给用户配置虚拟主机

进入之后可以重新配置权限

工作模式

Mq = 超市 queue 里面的内容 相当于 货物

代码运行完成后信息就没了，被消费了

Ready ： 0

代表消息已经被消费者消费过了

消费者消费消息:

1. 加jar

 <!-- mq-->
<dependency>
  <groupId>com.rabbitmq</groupId>
  <artifactId>amqp-client</artifactId>
  <version>5.6.0</version>
</dependency>
 <dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter</artifactId>
      <version>RELEASE</version>
      <scope>compile</scope>
    </dependency>

1. 编写代码

思路：先连接mq

创建channel

消费消息

package org.example.test;
import com.rabbitmq.client.*;
import org.junit.jupiter.api.Test;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
public class MyTest {
     @Test
    public void aaa() throws IOException, TimeoutException {
        //mq 建立连接
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setUsername("root");
        connectionFactory.setPassword("root");
        connectionFactory.setHost("192.168.44.34");  //mq主机
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("root");
        //管道连接
        Connection connection = connectionFactory.newConnection();
        //创建管道
        Channel channel = connection.createChannel();
        //消费信息
       Consumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //获取队列里面的消息  body是字节
                //->字符串
                String s = new String(body);
                System.out.println("mq中的消息:"+s);
            }
        };
        channel.basicConsume("test",true,consumer);
    }
}

生产者生产消息

package org.example.Test;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import org.junit.jupiter.api.Test;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.TimeoutException;
    /**
     * @author xiaowu
     */
    public class producer {
        @Test
        public void peoducter()throws IOException, TimeoutException {
            //1.创建工厂
            ConnectionFactory conn=new ConnectionFactory();
            //2.设置参数
            conn.setHost("192.168.44.34");
            conn.setPort(5672);// 5672
            conn.setUsername("root");//
            conn.setPassword("root");
            conn.setVirtualHost("root");
            //3.建理连接
            Connection connection = conn.newConnection();
            //4.创建channel
            Channel channel = connection.createChannel();
            //5.创建 队列
            channel.queueDeclare("hello",true,false,false,null);
            //queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
            /**
             * 对应的参数 queue 队列
             * durable 是都为持久化
             * exclusive
             *   是否独占  一个生产者只有一个消费者
             *   管理连接的时候删除队列
             * autodelete 是都自动删除
             * 参数  null
             *
             */
            //6.发送消息
            /**
             *         basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body)
             *         参数：
             *             1. exchange：交换机名称。简单模式下交换机会使用默认的 ""
             *             2. routingKey：路由名称
             *             3. props：配置信息
             *             4. body：发送消息数据
             */
            String body="hello rabbit";
            channel.basicPublish("","hello",null,body.getBytes());
            //关闭资源
            //channel.close();
            // connection.close();
        }
}

运行后

内容

在一个队列中如果有多个消费者，那么消费者之间对于同一个消息的关系是竞争的关系。

订阅模式类型☆

订阅模式示例图：

前面2个案例中，只有3个角色：

• P：生产者，也就是要发送消息的程序
• C：消费者：消息的接受者，会一直等待消息到来。
• queue：消息队列，图中红色部分

而在订阅模型中，多了一个exchange角色，而且过程略有变化：

生产者发消息给交换机，交换机将消息路由分发给队列，消费者监听队列接收信息

• P：生产者，也就是要发送消息的程序，但是不再发送到队列中，而是发给X（交换机）
• C：消费者，消息的接受者，会一直等待消息到来。
• Queue：消息队列，接收消息、缓存消息。
• Exchange：交换机，图中的X。一方面，接收生产者发送的消息。另一方面，知道如何处理消息，例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。到底如何操作，取决于Exchange的类型。Exchange有常见以下3种类型：
  • Fanout：广播，将消息交给所有绑定到交换机的队列
  • Direct：定向，把消息交给符合指定routing key 的队列
  • Topic：通配符，把消息交给符合routing pattern（路由模式） 的队列

Exchange（交换机）只负责转发消息，不具备存储消息的能力，因此如果没有任何队列与Exchange绑定，或者没有符合路由规则的队列，那么消息会丢失！

例子：

消费者1 将日志的消息打印到控制台

消费者2 将日志的信息保存到数据库

创建一个交换机两个队列

bindings

发布订阅测试

都可消费接收

package org.example.Test;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import org.junit.jupiter.api.Test;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * @author xiaowu
 */
public class producerEx {
    @Test
    public void peoducter()throws IOException, TimeoutException {
        //1.创建工厂
        ConnectionFactory conn=new ConnectionFactory();
        //2.设置参数
        conn.setHost("192.168.44.34");
        conn.setPort(5672);// 5672
        conn.setUsername("root");//
        conn.setPassword("root");
        conn.setVirtualHost("/root");
        //3.建理连接
        Connection connection = conn.newConnection();
        //4.创建channel
        Channel channel = connection.createChannel();
        //5.创建 队列
        channel.queueDeclare("hello",true,false,false,null);
        //queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
        /**
         * String queue队列名称对应的参数 queue 队列
         * boolean durable 是否持久化
         * boolean exclusive 是否独占
         * boolean autoDelete 是否自动删除
         * Map<String, Object> arguments 参数
         * exclusive
         *   是否独占  一个生产者只有一个消费者
         *   管理连接的时候删除队列
         * autodelete 是都自动删除
         * 参数  null
         */
        //6.发送消息
        /**
         *         basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body)
         *         参数：
         *             1. exchange：交换机名称。简单模式下交换机会使用默认的 ""
         *             2. routingKey：路由名称
         *             3. props：配置信息
         *             4. body：发送消息数据
         */
//        for (int i = 0; i < 10; i++) {
//            String body="hello rabbit";
//            channel.basicPublish("","test22",null,body.getBytes());
//        }
        /**
         * 发布订阅时
         * 交换机-》fanout
         * 队列-》两个队列
         */
        //1 创建交换机
        /**
         * String exchange,BuiltinExchangeType type, boolean durable
         */
        channel.exchangeDeclare("myex1", BuiltinExchangeType.FANOUT,false);
        //2 创建队列
        channel.queueDeclare("testqiu3",false,false,false,null);
        channel.queueDeclare("testqiu4",false,false,false,null);
        //3 交换机绑定队列String destination , String source , String routingkey
        channel.queueBind("testqiu3","myex1","");
        channel.queueBind("testqiu4","myex1","");
        channel.basicPublish("myex1","",null,"xixixixix".getBytes());
        //关闭资源
        //channel.close();
        // connection.close();
    }
}

测试成功

队列

发布订阅

路由

主题