RabbitMQ 03 简单模式/工作模式

rabbitmq六种工作模式

1.简单模式

RabbitMQ是一个消息中间件,你可以想象它是一个邮局。当你把信件放到邮箱里时,能够确信邮递员会正确地递送你的信件。RabbitMq就是一个邮箱、一个邮局和一个邮递员。

  • 发送消息的程序是生产者
  • 队列就代表一个邮箱。虽然消息会流经RbbitMQ和你的应用程序,但消息只能被存储在队列里。队列存储空间只受服务器内存和磁盘限制,它本质上是一个大的消息缓冲区。多个生产者可以向同一个队列发送消息,多个消费者也可以从同一个队列接收消息.
  • 消费者等待从队列接收消息

简单模式

1).pom.xml

添加 slf4j 依赖, 和 rabbitmq依赖

<project xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.tedu</groupId>
    <artifactId>rabbitmq</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <dependencies>
        <dependency>
            <groupId>com.rabbitmq</groupId>
            <artifactId>amqp-client</artifactId>
            <version>5.4.3</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.8.0-alpha2</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.8.0-alpha2</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.0</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>
2).生产者发送消息
public class Test1 {
    public static void main(String[] args) throws Exception {
        //创建连接工厂,并设置连接信息
        ConnectionFactory f = new ConnectionFactory();
        f.setHost("192.168.64.140");
        f.setPort(5672);//可选,5672是默认端口
        f.setUsername("admin");
        f.setPassword("admin");

        /*
         * 与rabbitmq服务器建立连接,
         * rabbitmq服务器端使用的是nio,会复用tcp连接,
         * 并开辟多个信道与客户端通信
         * 以减轻服务器端建立连接的开销
         */
        Connection c = f.newConnection();
        //建立信道
        Channel ch = c.createChannel();

        /*
         * 声明队列,会在rabbitmq中创建一个队列
         * 如果已经创建过该队列,就不能再使用其他参数来创建
         * 
         * 参数含义:
         *   -queue: 队列名称
         *   -durable: 队列持久化,true表示RabbitMQ重启后队列仍存在
         *   -exclusive: 排他,true表示限制仅当前连接可用
         *   -autoDelete: 当最后一个消费者断开后,是否删除队列
         *   -arguments: 其他参数
         */
        ch.queueDeclare("helloworld", false,false,false,null);

        /*
         * 发布消息
         * 这里把消息向默认交换机发送.
         * 默认交换机隐含与所有队列绑定,routing key即为队列名称
         * 
         * 参数含义:
         *     -exchange: 交换机名称,空串表示默认交换机"(AMQP default)",不能用 null 
         *     -routingKey: 对于默认交换机,路由键就是目标队列名称
         *     -props: 其他参数,例如头信息
         *     -body: 消息内容byte[]数组
         */
        ch.basicPublish("", "helloworld", null, "Hello world!".getBytes());

        System.out.println("消息已发送");
        c.close();
    }
}
3).消费者接收队列
public class Test2 {
    public static void main(String[] args) throws Exception {
        //连接工厂
        ConnectionFactory f = new ConnectionFactory();
        f.setHost("192.168.64.140");
        f.setUsername("admin");
        f.setPassword("admin");
        //建立连接
        Connection c = f.newConnection();
        //建立信道
        Channel ch = c.createChannel();
        //声明队列,如果该队列已经创建过,则不会重复创建
        ch.queueDeclare("helloworld",false,false,false,null);
        System.out.println("等待接收数据");
        
        //收到消息后用来处理消息的回调对象
        DeliverCallback callback = new DeliverCallback() {
            @Override
            public void handle(String consumerTag, Delivery message) throws IOException {
                String msg = new String(message.getBody(), "UTF-8");
                System.out.println("收到: "+msg);
            }
        };
        
        //消费者取消时的回调对象
        CancelCallback cancel = new CancelCallback() {
            @Override
            public void handle(String consumerTag) throws IOException {
            }
        };
        
        ch.basicConsume("helloworld", true, callback, cancel);
    }
}

2.工作模式

image
工作队列(即任务队列)背后的主要思想是避免立即执行资源密集型任务,并且必须等待它完成。相反,我们将任务安排在稍后完成。

我们将任务封装为消息并将其发送到队列。后台运行的工作进程将获取任务并最终执行任务。当运行多个消费者时,任务将在它们之间分发。

使用任务队列的一个优点是能够轻松地并行工作。如果我们正在积压工作任务,我们可以添加更多工作进程,这样就可以轻松扩展。

简单来说就是可以简易的实现负载均衡

1).生产者发送消息

这里模拟耗时任务,发送的消息中,每个点使工作进程暂停一秒钟,例如"Hello…"将花费3秒钟来处理

public class Test1 {
    public static void main(String[] args) throws Exception {
        ConnectionFactory f = new ConnectionFactory();
        f.setHost("192.168.64.140");
        f.setPort(5672);
        f.setUsername("admin");
        f.setPassword("admin");
        
        Connection c = f.newConnection();
        Channel ch = c.createChannel();
        //参数:queue,durable,exclusive,autoDelete,arguments
        ch.queueDeclare("helloworld", false,false,false,null);

        while (true) {
            //控制台输入的消息发送到rabbitmq
            System.out.print("输入消息: ");
            String msg = new Scanner(System.in).nextLine();
            //如果输入的是"exit"则结束生产者进程
            if ("exit".equals(msg)) {
                break;
            }
            //参数:exchage,routingKey,props,body
            ch.basicPublish("", "helloworld", null, msg.getBytes());
            System.out.println("消息已发送: "+msg);
        }

        c.close();
    }
}
2).消费者接收消息
public class Consumer {
    public static void main(String[] args) throws Exception {
        //建立连接
         ConnectionFactory f = new ConnectionFactory();
         f.setHost("192.168.64.140");
         f.setPort(5672);
         f.setUsername("admin");
         f.setPassword("admin");
         Connection con = f.newConnection();
         Channel c = con.createChannel();
         //定义队列
         c.queueDeclare("helloworld",
         false, //是否是持久队列
         false, //是否是独占队列(消费者能否共享)
         false, //自动删除
         null); //其他的属性设置map类型
         DeliverCallback deliverCallback = new DeliverCallback() {
                    @Override
         public void handle(String consumerTag, Delivery message) throws IOException {
                        String msg = new String(message.getBody());
         System.out.println("收到:" + msg);
         for (int i = 0; i<msg.length();i++){
                            if(msg.charAt(i)=='.'){
                                try {
                                    Thread.sleep(1000);
         } catch (InterruptedException e) {
                                }
                            }
                        }
                        c.basicAck(message.getEnvelope().getDeliveryTag(), false);
         System.out.println("消息处理结束");
         }
                };
         CancelCallback cancelCallback = new CancelCallback() {
                    @Override
         public void handle(String consumerTag) throws IOException {
                    }
                };
         //合理分发
         c.basicQos(1);
         //消费数据,接收数据
         c.basicConsume("helloworld",
         false, //关闭自动确认ack,改为手动确认
         deliverCallback,
         cancelCallback);
         }
}
3).消息确认

一个消费者接收消息后,在消息没有完全处理完时就挂掉了,那么这时会发生什么呢?

就现在的代码来说,rabbitmq把消息发送给消费者后,会立即删除消息,那么消费者挂掉后,它没来得及处理的消息就会丢失,

为了确保消息不会丢失,rabbitmq支持消息确认(回执)。当一个消息被消费者接收到并且执行完成后,消费者会发送一个ack (acknowledgment) 给rabbitmq服务器, 告诉他我已经执行完成了,你可以把这条消息删除了。

如果一个消费者没有返回消息确认就挂掉了(信道关闭,连接关闭或者TCP链接丢失),rabbitmq就会明白,这个消息没有被处理完成,rebbitmq就会把这条消息重新放入队列,如果在这时有其他的消费者在线,那么rabbitmq就会迅速的把这条消息传递给其他的消费者,这样就确保了没有消息会丢失。

这里不存在消息超时, rabbitmq只在消费者挂掉时重新分派消息, 即使消费者花非常久的时间来处理消息也可以

手动消息确认默认是开启的,前面的例子我们通过autoAck=ture把它关闭了。我们现在要把它设置为autoAck=false,然后工作进程处理完意向任务时,发送一个消息确认(回执)

如上述代码所示.

4).合理地分发

rabbitmq会一次把多个消息分发给消费者, 这样可能造成有的消费者非常繁忙, 而其它消费者空闲. 而rabbitmq对此一无所知, 仍然会均匀的分发消息

我们可以使用 basicQos(1) 方法, 这告诉rabbitmq一次只向消费者发送一条消息, 在返回确认回执前, 不要向消费者发送新消息. 而是把消息发给下一个空闲的消费者

5).消息持久化

当rabbitmq关闭时, 我们队列中的消息仍然会丢失, 除非明确要求它不要丢失数据

要求rabbitmq不丢失数据要做如下两点: 把队列和消息都设置为可持久化(durable)

队列设置为可持久化, 可以在定义队列时指定参数durable为true

由于之前我们已经定义过队列"helloworld"是不可持久化的, 对已存在的队列, rabbitmq不允许对其定义不同的参数, 否则会出错,有两种方式进行修改:1.删除重建队列,2.另起一个名字 所以这里我们定义一个不同名字的队列"task_queue"

//定义队列
c.queueDeclare("task_queue",
 true, //是否是持久队列
 false, //是否是独占队列(消费者能否共享)
 false, //自动删除
 null); //其他的属性设置map类型

生产者和消费者代码都要修改

这样即使rabbitmq重新启动, 队列也不会丢失. 现在我们再设置队列中消息的持久化, 使用MessageProperties.PERSISTENT_TEXT_PLAIN参数

整体代码如下:
1.生产者

public class Producer {
    public static void main(String[] args) throws Exception {
        //建立连接
 ConnectionFactory f = new ConnectionFactory();
 f.setHost("192.168.64.140");
 f.setPort(5672);
 f.setUsername("admin");
 f.setPassword("admin");
 Connection con = f.newConnection();
 Channel c = con.createChannel();
 //定义队列
 c.queueDeclare("task_queue",
 true, //是否是持久队列
 false, //是否是独占队列(消费者能否共享)
 false, //自动删除
 null); //其他的属性设置map类型
 while (true){
            System.out.print("输入消息:");
 String msg = new Scanner(System.in).nextLine();
 //发送消息
 c.basicPublish("",
 "task_queue",
 MessageProperties.PERSISTENT_TEXT_PLAIN, //持久化纯文本消息 //其他消息属性
 msg.getBytes());
 }
    }
}

2.消费者

public class Consumer {
    public static void main(String[] args) throws Exception {
        //建立连接
 ConnectionFactory f = new ConnectionFactory();
 f.setHost("192.168.64.140");
 f.setPort(5672);
 f.setUsername("admin");
 f.setPassword("admin");
 Connection con = f.newConnection();
 Channel c = con.createChannel();
 //定义队列
 c.queueDeclare("task_queue",
 true, //是否是持久队列
 false, //是否是独占队列(消费者能否共享)
 false, //自动删除
 null); //其他的属性设置map类型
 DeliverCallback deliverCallback = new DeliverCallback() {
            @Override
 public void handle(String consumerTag, Delivery message) throws IOException {
                String msg = new String(message.getBody());
 System.out.println("收到:" + msg);
 for (int i = 0; i<msg.length();i++){
                    if(msg.charAt(i)=='.'){
                        try {
                            Thread.sleep(1000);
 } catch (InterruptedException e) {
                        }
                    }
                }
                c.basicAck(message.getEnvelope().getDeliveryTag(), false);
 System.out.println("消息处理结束");
 }
        };
 CancelCallback cancelCallback = new CancelCallback() {
            @Override
 public void handle(String consumerTag) throws IOException {
            }
        };
 c.basicQos(1);
 //消费数据,接收数据
 c.basicConsume("task_queue",
 false, //关闭自动确认ack,改为手动确认
 deliverCallback,
 cancelCallback);
 }
}
阅读 90

推荐阅读