RabbitMQ入门篇

最新推荐文章于 2022-08-24 17:26:44 发布

huihuidage

最新推荐文章于 2022-08-24 17:26:44 发布

阅读量135

点赞数

分类专栏： rabbitMq 文章标签： rabbitmq 中间件

本文链接：https://blog.csdn.net/huihuidage/article/details/111800986

版权

rabbitMq 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

MQ基本概念
Message Queue(消息队列)，是在消息传输过程中保存消息的容器。多用于分布式系统之间进行通信。在这里插入图片描述
MQ的优势
1.应用解耦
系统耦合性越高，容错率就越低，可维护性就越低

2.异步提速

提升用户体验和系统吞吐量（单位时间内处理请求的数目）
3.削峰填谷

提高系统稳定性

MQ的劣势
1.系统的可用性降低
系统引入的外部依赖越多，系统的稳定性越差。MQ一旦宕机，就会对业务造成影响，如何保证MQ的高可用？
2.系统的复杂度提高
MQ的加入大大增加了系统的复杂度，以前是系统的同步远程调用，现在是通过MQ异步调用，如何保证消息不丢失？
RabbitMQ简介
AMQP，即 Advanced Message Queuing Protocol（高级消息队列协议），是一个网络协议，是应用层协议的一个开放标准，为面向消息的中间件设计。基于此协议的客户端与消息中间件可传递消息，并不受客户端/中间件不同产品，不同的开发语言等条件的限制。2006年，AMQP 规范发布。类比HTTP。
2007年，Rabbit 技术公司基于 AMQP 标准开发的 RabbitMQ 1.0 发布。RabbitMQ 采用 Erlang 语言开发。Erlang 语言由 Ericson 设计，专门为开发高并发和分布式系统的一种语言，在电信领域使用广泛。
在这里插入图片描述
RabbitMQ相关概念
Message：消息，消息是不具名的，它由消息头和消息体组成。消息体是不透明的，而消息头则由一系列的可选属性组成，这些属性包括routing-key（路由键）、priority（相对于其他消息的优先权）、delivery-mode（指出该消息可能需要持久性存储）等。

Publisher：消息的生产者，也是一个向交换器发布消息的客户端应用程序。

Exchange：交换器，用来接收生产者发送的消息并将这些消息路由给服务器中的队列。

Queue：消息队列，用来保存消息直到发送给消费者。它是消息的容器，也是消息的终点。一个消息可投入一个或多个队列。消息一直在队列里面，等待消费者连接到这个队列将其取走。

Binding：绑定，用于消息队列和交换器之间的关联。一个绑定就是基于路由键将交换器和消息队列连接起来的路由规则，所以可以将交换器理解成一个由绑定构成的路由表。Exchange 和Queue的绑定可以是多对多的关系。

Channel：信道，多路复用连接中的一条独立的双向数据流通道。信道是建立在真实的TCP连接内的虚拟连接，AMQP 命令都是通过信道发出去的，不管是发布消息、订阅队列还是接收消息，这些动作都是通过信道完成。因为对于操作系统来说建立和销毁TCP 都是非常昂贵的开销，所以引入了信道的概念，以复用一条TCP 连接。

Consumer：消息的消费者，表示一个从消息队列中取得消息的客户端应用程序。

Virtual Host：虚拟主机，表示一批交换器、消息队列和相关对象。虚拟主机是共享相同的身份认证和加密环境的独立服务器域。每个vhost 本质上就是一个mini 版的RabbitMQ 服务器，拥有自己的队列、交换器、绑定和权限机制。vhost 是AMQP 概念的基础，必须在连接时指定，RabbitMQ 默认的vhost 是/。

Broker：表示消息队列服务器实体。

安装RabbitMQ

RabbitMQ官方地址

以centOS-7为例
1.上传软件
erlang18.31.el7.centos.x86_64.rpm
socat1.7.3.25.el7.lux.x86_64.rpm
rabbitmqserver3.6.51.noarch.rpm

2.安装Erlang
rpm -ivh erlang-18.3-1.el7.centos.x86_64.rpm

3.安装RabbitMQ
rpm -ivh socat-1.7.3.2-1.1.el7.x86_64.rpm
如若报错依赖检测失败，则在命令末尾加上–nodeps --force
rpm -ivh rabbitmq-server-3.6.5-1.noarch.rpm

**4. 开启管理界面及配置 **
rabbitmq-plugins enable rabbitmq_management
修改默认配置信息
vim /usr/lib/rabbitmq/lib/rabbitmq_server-3.6.5/ebin/rabbit.app # 比如修改密码、配置等等。loopback_users 中的 <<“guest”>>,只保留guest

5. 启动
service rabbitmq-server start 启动服务
service rabbitmq-server stop 停止服务
service rabbitmq-server restart 重启服务

6.设置配置文件
cd /usr/share/doc/rabbitmq-server-3.6.5/
cp rabbitmq.config.example /etc/rabbitmq/rabbitmq.config

7.关闭防火墙
systemctl stop firewalld

RabbitMQ工作模式
RabbitMQ提供了6种工作模式：

简单模式

单个生产者，单个消费者。
在这里插入图片描述
p:表示生产者，消息发送者。
c:表示消费者，消息接收者，会一直等待消息到来。
中间黄色部分：queue，消息队列，p向里面投递消息，c从里面取消息。
代码示例
pom文件添加依赖：

 <!--rabbitmq -->
    <dependency>
      <groupId>com.rabbitmq</groupId>
      <artifactId>amqp-client</artifactId>
      <version>5.3.0</version>
    </dependency>
    <!--json -->
    <dependency>
      <groupId>com.google.code.gson</groupId>
      <artifactId>gson</artifactId>
      <version>2.8.5</version>
    </dependency>

生产者：

package com.cshg.rabbitmq.helloworld;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
public class Producer {

    public static void main(String[] args) throws IOException,TimeoutException{
      	Connection conn = RabbitUtil.getConn();
        //创建通信通道，相当于TCP的虚拟连接
        Channel channel = conn.createChannel();
        //第一个参数：队列名称
        //第二个参数：是否持久化 false就是不持久化，mq停掉数据就会消失
        //第三个参数：是否队列私有化，false代表所有消费者都可以访问，true代表只有第一次拥有它的消费者才可以一直使用
        //第四个参数：是否自动删除，false代表连接停掉后不自动删除这个队列
        //其他额外参数，null
        channel.queueDeclare("helloworld",false,false,false,null);
        String message = "辉辉大哥";
        channel.basicPublish("","helloworld",null,message.getBytes());
        RabbitUtil.close(conn,channel);
        System.out.println("==========数据发送成功========");
    }
}

消费者

package com.cshg.rabbitmq.helloworld;

import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * Created by  on 2020/12/27.
 */
public class Consumer {

    public static void main(String[] args) throws IOException,TimeoutException {
        Connection conn = RabbitUtil.getConn();
        //创建通信通道，相当于TCP的虚拟连接
        Channel channel = conn.createChannel();
        channel.queueDeclare("helloworld",false,false,false,null);
        //创建一个消息消费者
        //第一个参数：队列名
        //第二个参数：是否自动确认收到消息，false代表手动编程来确认消息，这是MQ的推荐做法
        //第三个参数：要传入defaultConsumer的实现类
        channel.basicConsume("helloworld",false,new Reciver(channel));
    }
}
class  Reciver extends DefaultConsumer{
    private Channel channel;

    public Reciver(Channel channel) {
        super(channel);
        this.channel = channel;
    }

    @Override
    public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
        String message = new String(body);
        System.out.println("消费者接收的消息："+message);
        System.out.println("消息的tagId："+envelope.getDeliveryTag());
        envelope.getDeliveryTag();
        //false只确认签收当前的消息 设置为true则代表签收消费者所有为签收的消息
        channel.basicAck(envelope.getDeliveryTag(),false);

    }
}

连接工具类

package com.cshg.rabbitmq.utils;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

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

/**
 * Created by 王辉Acer on 2020/12/28.
 */
public class RabbitUtil {

    public static Connection getConn() throws IOException,TimeoutException {
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置主机信息
        connectionFactory.setHost("192.168.0.11");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        connectionFactory.setVirtualHost("wanghui1228");
        //获得TCP的长连接
        Connection conn = connectionFactory.newConnection();
        return conn;
    }
    public static void close(Connection conn, Channel channel) throws IOException,TimeoutException {
        channel.close();
        conn.close();
    }
}

工作队列模式（Work queues）

单个生产者，多个消费者。
在这里插入图片描述
代码示例
工具类RabbitUtil同上。
生产者

package com.cshg.rabbitmq.workqueues;

import com.cshg.rabbitmq.constant.RabbitConstant;
import com.cshg.rabbitmq.utils.RabbitUtil;
import com.google.gson.Gson;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;

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

/**
 * Created by  on 2020/12/28.
 */
public class Producer {
    public static void main(String[] args) throws IOException,TimeoutException {
        Connection conn = RabbitUtil.getConn();
        //创建通信通道，相当于TCP的虚拟连接
        Channel channel = conn.createChannel();
        //第一个参数：队列名称
        //第二个参数：是否持久化 false就是不持久化，mq停掉数据就会消失
        //第三个参数：是否队列私有化，false代表所有消费者都可以访问，true代表只有第一次拥有它的消费者才可以一直使用
        //第四个参数：是否自动删除，false代表连接停掉后不自动删除这个队列
        //其他额外参数，null
        channel.queueDeclare(RabbitConstant.QUEUE_WORKQUEUES,false,false,false,null);
        Salary salary = null;
        String json = null;
        for(int i = 1 ; i <= 100 ; i++) {
            salary = new Salary("员工" + i, "13900000" + i, "成功发放8000元");
            json = new Gson().toJson(salary);
            channel.basicPublish("" , RabbitConstant.QUEUE_WORKQUEUES , null , json.getBytes());
        }
        RabbitUtil.close(conn,channel);
        System.out.println("==========数据发送成功========");
    }

}

消费者1

package com.cshg.rabbitmq.workqueues;

import com.cshg.rabbitmq.constant.RabbitConstant;
import com.cshg.rabbitmq.utils.RabbitUtil;
import com.rabbitmq.client.*;

import java.io.IOException;

/**
 * Created by  on 2020/12/28.
 */
public class Consumer1 {

    public static void main(String[] args) throws Exception {
        Connection conn = RabbitUtil.getConn();
        final Channel channel = conn.createChannel();

        channel.queueDeclare(RabbitConstant.QUEUE_WORKQUEUES, false, false, false, null);

        //如果不写basicQos（1），则自动MQ会将所有请求平均发送给所有消费者
        //basicQos,MQ不再对消费者一次发送多个请求，而是消费者处理完一个消息后（确认后），在从队列中获取一个新的
        channel.basicQos(1);//处理完一个取一个

        channel.basicConsume(RabbitConstant.QUEUE_WORKQUEUES, false, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String json = new String(body);
                System.out.println("consumer-工资发放成功:" + json);

                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        });
    }
}

消费者2

package com.cshg.rabbitmq.workqueues;

import com.cshg.rabbitmq.constant.RabbitConstant;
import com.cshg.rabbitmq.utils.RabbitUtil;
import com.rabbitmq.client.*;

import java.io.IOException;

/**
 * Created by on 2020/12/28.
 */
public class Consumer2 {

    public static void main(String[] args) throws Exception {
        Connection conn = RabbitUtil.getConn();
        final Channel channel = conn.createChannel();

        channel.queueDeclare(RabbitConstant.QUEUE_WORKQUEUES, false, false, false, null);

        //如果不写basicQos（1），则自动MQ会将所有请求平均发送给所有消费者
        //basicQos,MQ不再对消费者一次发送多个请求，而是消费者处理完一个消息后（确认后），在从队列中获取一个新的
        channel.basicQos(1);//处理完一个取一个

        channel.basicConsume(RabbitConstant.QUEUE_WORKQUEUES, false, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String json = new String(body);
                System.out.println("consumer-工资发放成功:" + json);

                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        });
    }
}

消费者3

package com.cshg.rabbitmq.workqueues;

import com.cshg.rabbitmq.constant.RabbitConstant;
import com.cshg.rabbitmq.utils.RabbitUtil;
import com.rabbitmq.client.*;

import java.io.IOException;

/**
 * Created by on 2020/12/28.
 */
public class Consumer3 {

    public static void main(String[] args) throws Exception {
        Connection conn = RabbitUtil.getConn();
        final Channel channel = conn.createChannel();

        channel.queueDeclare(RabbitConstant.QUEUE_WORKQUEUES, false, false, false, null);

        //如果不写basicQos（1），则自动MQ会将所有请求平均发送给所有消费者
        //basicQos,MQ不再对消费者一次发送多个请求，而是消费者处理完一个消息后（确认后），在从队列中获取一个新的
        channel.basicQos(1);//处理完一个取一个

        channel.basicConsume(RabbitConstant.QUEUE_WORKQUEUES, false, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String json = new String(body);
                System.out.println("consumer-工资发放成功:" + json);

                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        });
    }
}

注意basicQos方法，如果不写basicQos（1），则自动MQ会将所有请求平均发送给所有消费者；如果写上basicQos（1），则MQ不再对消费者一次发送多个请求，而是消费者处理完一个消息后（确认后），在从队列中获取一个新的。
至此，基本入门，后续模式（Publish/Subscribe 发布与订阅模式、Routing 路由模式、Topics 主题模式、RPC 远程调用模式）下期续讲。