85-java-rabbitMQ(2)-rabbitMQ的javaAPI

最新推荐文章于 2024-05-25 19:51:54 发布
最新推荐文章于 2024-05-25 19:51:54 发布
阅读量155 收藏
点赞数
分类专栏： 分布式 组件 MQ
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45449911/article/details/106903968
版权
分布式 同时被 3 个专栏收录
22 篇文章 0 订阅
订阅专栏
组件
7 篇文章 0 订阅
订阅专栏
MQ
4 篇文章 0 订阅
订阅专栏

本文按照两部分来说明

java连接rabbitMQ的工作模式


基础部分
(1) pom依赖

<dependencies>
        <!-- 这是java连接rabbitMQ的原生api依赖 -->
        <dependency>
            <groupId>com.rabbitmq</groupId>
            <artifactId>amqp-client</artifactId>
            <version>5.6.0</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.28</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.25</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
        </dependency>

    </dependencies>

(2) 基础连接对象

package com.gl.rabbitmq.original;

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

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

/**
 * @author gl
 * @time 2020-06-21 15:53
 * @function : 这是我们创建连接到rabbitMQ的工具类
 * @step :
 */
public class ConnUtil {

    public static Connection getConnection() throws IOException, TimeoutException {
        //1.连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //2.设置主机
        factory.setHost("127.0.0.1");
        //3.设置端口
        factory.setPort(5672);
        //4.设置vhost也就是连接哪个库,这里使用我们自定义的虚拟机
            factory.setVirtualHost("/vhost_rabbitMQ");
        //5.设置用户名,使用我们自定义的用户
        factory.setUsername("rabbitMQ");
        //6.设置密码
        factory.setPassword("rabbitMQ");
        //7.获取连接
        Connection connection = factory.newConnection();

        return connection;
    }
}
1.work queues模式

在这里插入图片描述

1.1 架构
work queues模式是生产者生产消息发送到queue队列中,可以有一个或者多个消费者去读取这个queue,读取的方式可以为轮询等策略.注意,一条消息只会有一个消费者消费,不会同时发送给多个消费者.例如queue中有10条消息,以轮询的方式发送给两个消费者,则每个消费者5条消息.
1.2 应用场景
适用于处理复杂业务,相当于实现了一个消费端集群的模式,可以让多个消费者来处理共同的一项业务.
1.3 代码

package com.gl.rabbitmq.original;

import com.rabbitmq.client.*;
import org.junit.Test;

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

/**
 * @author gl
 * @time 2020-06-21 16:04
 * @function : 第一种模式: 工作队列
 * @step :
 */
public class WorkQueueDemo {
    private static final String QUEUE_NAME = "queue_test1";
    private CountDownLatch countDownLatch = new CountDownLatch(1);

    /**
     * 生产者
     * @throws IOException
     * @throws TimeoutException
     */
    @Test
    public void producer() throws IOException, TimeoutException {
        //1.通过util对象创建connection对象
        Connection connection = ConnUtil.getConnection();

        //2.获取channel
        Channel channel = connection.createChannel();
        //3.声明队列
        /**
         * queue:声明队列的名称
         * durable: 是否持久化
         * exclusive: 是否独占连接,如果连接关闭则自动删除,如果将此参数设置为true可用于临时队列的创建
         * autoDelete: 是否自动删除此队列,如果将自参数和exclusive都设置为true就可实现临时队列.
         * arguments: 可以设置一个队列的扩展参数,比如: 设置队列存活时间
         */
        channel.queueDeclare(QUEUE_NAME,true,false,false,null);
        //4.发送消息
        /**
         * String exchange, String routingKey, BasicProperties props, byte[] body
         * exchange: 交换机,如果传递""空串表示使用默认的交换机
         * routingKey: 路由key,交换机根据路由key来将消息转发到指定的队列,如果使用默认的交换机,routingKey设置队列的名字
         * props: 消息的属性
         * body: 消息的内容
         */
        String msg = "hello world";
        channel.basicPublish("",QUEUE_NAME,null,msg.getBytes());
        System.out.println("发送成功!!");
        channel.close();

    }

    /**
     * 消费者
     * @throws IOException
     * @throws TimeoutException
     * @throws InterruptedException
     */
    @Test
    public void consumer1() throws IOException, TimeoutException, InterruptedException {
        //1.通过util对象创建connection对象
        Connection connection = ConnUtil.getConnection();

        //2.获取channel
        Channel channel = connection.createChannel();
        //3.声明队列
        /**
         * 这里可以不用声明队列,但是要确定该队列一定是在mq中存在的,不然就会代码报错.
         * queue:声明队列的名称
         * durable: 是否持久化
         * exclusive: 是否独占连接,如果连接关闭则自动删除,如果将此参数设置为true可用于临时队列的创建
         * autoDelete: 是否自动删除此队列,如果将自参数和exclusive都设置为true就可实现临时队列.
         * arguments: 可以设置一个队列的扩展参数,比如: 设置队列存活时间
         */
        channel.queueDeclare(QUEUE_NAME,true,false,false,null);

        //声明一个消费者
        DefaultConsumer consumer = new DefaultConsumer(channel){
            /**
             * 接收到消息时,调用此方法
             * @param consumerTag 消费者标签
             * @param envelope  信封---其实就是mq对于此消息的封装的东西,比如消息id,exchange等
             * @param properties 消息属性
             * @param body 消息内容
             * @throws IOException
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //交换机
                java.lang.String exchange = envelope.getExchange();
                long deliveryTag = envelope.getDeliveryTag();
                System.out.println("exchange:" + exchange);
                System.out.println("deliveryTag:" + deliveryTag);

                //接收消息
                String msg = new String(body, "utf-8");
                System.out.println("receive msg: "+ msg);
                //使主线程执行,不阻塞了
                countDownLatch.countDown();
            }
        };

        //4.监听队列,消费消息
        /**
         * String queue, boolean autoAck, Consumer callback
         * 参数明细:
         * queue: 队列名
         * autoAck: 自动回复,当消费者受到消息之后,要告诉mq已接收到消息,true表示自动回复,false,表示不自动回复,需要代码回复
         * callback: 消费方法,当前消费者受到消息后要执行的方法.
         */
        channel.basicConsume(QUEUE_NAME,true,consumer);
        //这是模拟,客户端阻塞,因为不这样做,客户端程序直接执行完毕,则不能执行consumer中的handleDelivery回调方法.
        //阻塞当前线程
        countDownLatch.await();
        while (true){

        }
    }
}
2.Publish/Subscribe(发布/订阅)模式

在这里插入图片描述

2.1 架构
生产者先将消息发送给交换机,交换机在发送给绑定这个交换机的队列,然后消费者去读取不同的queue,就可实现一条消息发给不同的用户.
发布订阅模式完全可以实现工作队列模式的功能.
2.2 应用场景
适用于一条消息需要交给两个不同的业务去处理,并且每个业务互不影响
2.3 代码

package com.gl.rabbitmq.original;

import com.rabbitmq.client.*;
import org.junit.Test;

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

/**
 * @author gl
 * @time 2020-06-21 22:14
 * @function :第二种模式:   发布订阅模式
 * @step :  相对于workqueue多了exchange
 */
public class PublishSubscribeDemo {
    private static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
    private static final String QUEUE_INFORM_SMS = "queue_inform_sms";
    private static final String EXCHANGE_FANOUT_INFORM = "exchange_fanout_inform";
    private CountDownLatch countDownLatch = new CountDownLatch(1);

    /**
     * 生产者
     * @throws IOException
     * @throws TimeoutException
     */
    @Test
    public void producer() throws IOException, TimeoutException {
        //1.通过util对象创建connection对象
        Connection connection = ConnUtil.getConnection();

        //2.获取channel
        Channel channel = connection.createChannel();
        //3.声明队列,这里就需要声明两个队列了
        /**
         * queue:声明队列的名称
         * durable: 是否持久化
         * exclusive: 是否独占连接,如果连接关闭则自动删除,如果将此参数设置为true可用于临时队列的创建
         * autoDelete: 是否自动删除此队列,如果将自参数和exclusive都设置为true就可实现临时队列.
         * arguments: 可以设置一个队列的扩展参数,比如: 设置队列存活时间
         */
        channel.queueDeclare(QUEUE_INFORM_EMAIL,true,false,false,null);
        channel.queueDeclare(QUEUE_INFORM_SMS,true,false,false,null);

        //4 声明交换机
        /**
         * 参数明细
         * 参数1: 交换机名称
         * 参数2: 交换机类型
         *      fanout: 对应发布订阅模式
         *      direct: 对应routing路由模式
         *      topic: 对应通配符模式
         *      header: 对应header模式
         */
        channel.exchangeDeclare(EXCHANGE_FANOUT_INFORM,BuiltinExchangeType.FANOUT);

        //5.将2个队列绑定在交换机上面
        /**
         * 参数1: 队列名字
         * 参数2: 交换机名字
         * 路由key: 在发布订阅模式中使用空串;在路由模式和通配符模式中会根据路由key将消息发送到指定的queue中去
         */
        channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_FANOUT_INFORM,"");
        channel.queueBind(QUEUE_INFORM_SMS,EXCHANGE_FANOUT_INFORM,"");

        //6.发送消息
        /**
         * channel.basicPublish(EXCHANGE_FANOUT_INFORM,"",null,msg.getBytes());
         * String exchange, String routingKey, BasicProperties props, byte[] body
         * exchange: 交换机,如果传递""空串表示使用默认的交换机
         * routingKey: 路由key,交换机根据路由key来将消息转发到指定的队列,如果使用默认的交换机,routingKey设置队列的名字
         * props: 消息的属性
         * body: 消息的内容
         */
        String msg = "send message 消费成功";
        for (int i = 0;i < 10 ; i ++){
            //因为这里采用的是发布订阅模式,我们把消息是发给交换机,交换机去发给queue,所以这里指定交换机及即可,queue为空串
            channel.basicPublish(EXCHANGE_FANOUT_INFORM,"",null,(msg + i).getBytes());
            System.out.println("发送成功!!消息内容:" + (msg + i));
        }

        channel.close();
    }


    /**
     * email消费者
     * @throws IOException
     * @throws TimeoutException
     * @throws InterruptedException
     * 这里可以同时开启两次测试
     */
    @Test
    public void consumerEmail() throws IOException, TimeoutException, InterruptedException {
       publishSuvscirbeConsume(QUEUE_INFORM_EMAIL,EXCHANGE_FANOUT_INFORM);
    }

    /**
     * SMS消费者
     * @throws IOException
     * @throws TimeoutException
     * @throws InterruptedException
     * 这里可以同时开启两次测试
     */
    @Test
    public void consumerSMS() throws IOException, TimeoutException, InterruptedException {
        publishSuvscirbeConsume(QUEUE_INFORM_SMS,EXCHANGE_FANOUT_INFORM);
    }

    /**
     * 这是提取公共的发布订阅的consumer方法
     */
    public void publishSuvscirbeConsume(String queue,String exchange) throws IOException, TimeoutException, InterruptedException {
        //1.通过util对象创建connection对象
        Connection connection = ConnUtil.getConnection();

        //2.获取channel
        Channel channel = connection.createChannel();
        //3.声明队列
        /**
         * 这里可以不用声明队列,但是要确定该队列一定是在mq中存在的,不然就会代码报错.
         * queue:声明队列的名称
         * durable: 是否持久化
         * exclusive: 是否独占连接,如果连接关闭则自动删除,如果将此参数设置为true可用于临时队列的创建
         * autoDelete: 是否自动删除此队列,如果将自参数和exclusive都设置为true就可实现临时队列.
         * arguments: 可以设置一个队列的扩展参数,比如: 设置队列存活时间
         */
        channel.queueDeclare(queue,true,false,false,null);

        //4.声明交换机
        channel.exchangeDeclare(exchange,BuiltinExchangeType.FANOUT);
        //5.绑定queue到exchange上
        channel.queueBind(queue,exchange,"");

        //声明一个消费者
        DefaultConsumer consumer = new DefaultConsumer(channel){
            /**
             * 接收到消息时,调用此方法
             * @param consumerTag 消费者标签
             * @param envelope  信封---其实就是mq对于此消息的封装的东西,比如消息id,exchange等
             * @param properties 消息属性
             * @param body 消息内容
             * @throws IOException
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //交换机
                java.lang.String exchange = envelope.getExchange();
                long deliveryTag = envelope.getDeliveryTag();
                System.out.println("exchange:" + exchange);
                System.out.println("deliveryTag:" + deliveryTag);

                //接收消息
                String msg = new String(body, "utf-8");
                System.out.println("receive msg: "+ msg);
                //使主线程执行,不阻塞了
                countDownLatch.countDown();
            }
        };

        //4.监听队列,消费消息
        /**
         * String queue, boolean autoAck, Consumer callback
         * 参数明细:
         * queue: 队列名
         * autoAck: 自动回复,当消费者受到消息之后,要告诉mq已接收到消息,true表示自动回复,false,表示不自动回复,需要代码回复
         * callback: 消费方法,当前消费者受到消息后要执行的方法.
         */
        channel.basicConsume(queue,true,consumer);
        //这是模拟,客户端阻塞,因为不这样做,客户端程序直接执行完毕,则不能执行consumer中的handleDelivery回调方法.
        //阻塞当前线程
        countDownLatch.await();
        while (true){

        }
    }
}
3.Routing(路由)模式

在这里插入图片描述

3.1 架构
生产者先将消息发送给交换机,交换机再根据路由key相等发送到不同的queue中,然后消费者去读取不同的queue,就可实现一条消息发给不同的用户.
路由模式完全可以实现发布订阅模式的功能
3.2 应用场景
适用于一条消息,需要发送给不同的业务,并且根据业务的不同还需要对消息做不同的发送策略.
3.3 代码

package com.gl.rabbitmq.original;

import com.rabbitmq.client.*;
import org.junit.Test;

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

/**
 * @author gl
 * @time 2020-06-21 22:14
 * @function :第三种模式:   routing路由模式
 * @step : 相对于发布订阅模式多了routingKey
 */
public class RoutingDemo {
    private static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
    private static final String QUEUE_INFORM_SMS = "queue_inform_sms";
    private static final String EXCHANGE_ROUTING_INFORM = "exchange_routing_inform";
    private static final String ROUTING_EMAIL = "inform_email";
    private static final String ROUTING_SMS = "inform_sms";

    /**
     * 生产者
     * @throws IOException
     * @throws TimeoutException
     */
    @Test
    public void producer() throws IOException, TimeoutException {
        //1.通过util对象创建connection对象
        Connection connection = ConnUtil.getConnection();

        //2.获取channel
        Channel channel = connection.createChannel();
        //3.声明队列,这里就需要声明两个队列了
        /**
         * queue:声明队列的名称
         * durable: 是否持久化
         * exclusive: 是否独占连接,如果连接关闭则自动删除,如果将此参数设置为true可用于临时队列的创建
         * autoDelete: 是否自动删除此队列,如果将自参数和exclusive都设置为true就可实现临时队列.
         * arguments: 可以设置一个队列的扩展参数,比如: 设置队列存活时间
         */
        channel.queueDeclare(QUEUE_INFORM_EMAIL,true,false,false,null);
        channel.queueDeclare(QUEUE_INFORM_SMS,true,false,false,null);

        //4 声明交换机
        /**
         * 参数明细
         * 参数1: 交换机名称
         * 参数2: 交换机类型
         *      fanout: 对应发布订阅模式
         *      direct: 对应routing路由模式
         *      topic: 对应通配符模式
         *      header: 对应header模式
         */
        channel.exchangeDeclare(EXCHANGE_ROUTING_INFORM,BuiltinExchangeType.DIRECT);

        //5.将2个队列绑定在交换机上面
        /**
         * 参数1: 队列名字
         * 参数2: 交换机名字
         * 路由key: 在发布订阅模式中使用空串;在路由模式和通配符模式中会根据路由key将消息发送到指定的queue中去
         */
        channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_ROUTING_INFORM,ROUTING_EMAIL);
        channel.queueBind(QUEUE_INFORM_SMS,EXCHANGE_ROUTING_INFORM,ROUTING_SMS);
        //同一个queue可以绑定多个routingKey
        //如果两个queue绑定相同的exchange交换机,相同的routingKey,则我们就可以实现发发布订阅的功能
        //只需要我们发送消息时,指定发送到这个交换机的这个routingKey下节课
        channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_ROUTING_INFORM,"inform");
        channel.queueBind(QUEUE_INFORM_SMS,EXCHANGE_ROUTING_INFORM,"inform");

        //6.发送消息
        /**
         * channel.basicPublish(EXCHANGE_FANOUT_INFORM,"",null,msg.getBytes());
         * String exchange, String routingKey, BasicProperties props, byte[] body
         * exchange: 交换机,如果传递""空串表示使用默认的交换机
         * routingKey: 路由key,交换机根据路由key来将消息转发到指定的队列,如果使用默认的交换机,routingKey设置队列的名字
         * props: 消息的属性
         * body: 消息的内容
         */
        for (int i = 0;i < 10 ; i ++){
            if(i % 2 == 0){
                String msg = "发送消息到email!!";
                //因为这里采用的是发布订阅模式,我们把消息是发给交换机,交换机去发给queue,所以这里指定交换机及即可,queue为空串
                channel.basicPublish(EXCHANGE_ROUTING_INFORM,ROUTING_EMAIL,null,(msg + i).getBytes());
                System.out.println("发送成功!!消息内容:" + (msg + i));
            }else{
                String msg = "发送消息到SMS!!";
                //因为这里采用的是发布订阅模式,我们把消息是发给交换机,交换机去发给queue,所以这里指定交换机及即可,queue为空串
                channel.basicPublish(EXCHANGE_ROUTING_INFORM,ROUTING_SMS,null,(msg + i).getBytes());
                System.out.println("发送成功!!消息内容:" + (msg + i));
            }
        }

        channel.close();
    }


    /**
     * email消费者
     * @throws IOException
     * @throws TimeoutException
     * @throws InterruptedException
     * 这里可以同时开启两次测试
     */
    @Test
    public void consumerEmail() throws IOException, TimeoutException, InterruptedException {
       publishSuvscirbeConsume(QUEUE_INFORM_EMAIL,EXCHANGE_ROUTING_INFORM,ROUTING_EMAIL);
    }

    /**
     * SMS消费者
     * @throws IOException
     * @throws TimeoutException
     * @throws InterruptedException
     * 这里可以同时开启两次测试
     */
    @Test
    public void consumerSMS() throws IOException, TimeoutException, InterruptedException {
        publishSuvscirbeConsume(QUEUE_INFORM_SMS,EXCHANGE_ROUTING_INFORM,ROUTING_SMS);
    }

    /**
     * 这是提取公共的发布订阅的consumer方法
     */
    public void publishSuvscirbeConsume(String queue,String exchange,String routingKey) throws IOException, TimeoutException, InterruptedException {
        //1.通过util对象创建connection对象
        Connection connection = ConnUtil.getConnection();

        //2.获取channel
        Channel channel = connection.createChannel();
        //3.声明队列
        /**
         * 这里可以不用声明队列,但是要确定该队列一定是在mq中存在的,不然就会代码报错.
         * queue:声明队列的名称
         * durable: 是否持久化
         * exclusive: 是否独占连接,如果连接关闭则自动删除,如果将此参数设置为true可用于临时队列的创建
         * autoDelete: 是否自动删除此队列,如果将自参数和exclusive都设置为true就可实现临时队列.
         * arguments: 可以设置一个队列的扩展参数,比如: 设置队列存活时间
         */
        channel.queueDeclare(queue,true,false,false,null);

        //4.声明交换机
        channel.exchangeDeclare(exchange,BuiltinExchangeType.DIRECT);
        //5.绑定queue到exchange上
        channel.queueBind(queue,exchange,routingKey);

        //声明一个消费者
        DefaultConsumer consumer = new DefaultConsumer(channel){
            /**
             * 接收到消息时,调用此方法
             * @param consumerTag 消费者标签
             * @param envelope  信封---其实就是mq对于此消息的封装的东西,比如消息id,exchange等
             * @param properties 消息属性
             * @param body 消息内容
             * @throws IOException
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //交换机
                String exchange = envelope.getExchange();
                long deliveryTag = envelope.getDeliveryTag();
                System.out.println("exchange:" + exchange);
                System.out.println("deliveryTag:" + deliveryTag);

                //接收消息
                String msg = new String(body, "utf-8");
                System.out.println("receive msg: "+ msg);
            }
        };

        //4.监听队列,消费消息
        /**
         * String queue, boolean autoAck, Consumer callback
         * 参数明细:
         * queue: 队列名
         * autoAck: 自动回复,当消费者受到消息之后,要告诉mq已接收到消息,true表示自动回复,false,表示不自动回复,需要代码回复
         * callback: 消费方法,当前消费者受到消息后要执行的方法.
         */
        channel.basicConsume(queue,true,consumer);
        //这是模拟,客户端阻塞,因为不这样做,客户端程序直接执行完毕,则不能执行consumer中的handleDelivery回调方法.
        //阻塞当前线程
        while (true){

        }
    }
}
4.Topics(通配符)模式

在这里插入图片描述

4.1 架构
生产者先将消息发送给交换机,交换机再根据路由key匹配发送到不同的queue中,然后消费者去读取不同的queue,就可实现一条消息发给不同的用户.
路由模式完全可以实现发布订阅模式的功能

4.2 应用场景
适用于一条消息,需要发送给不同的业务,并且根据业务的不同还需要对消息做不同的发送策略.

4.3 Topics与Routing模式的区别
在这里插入图片描述
4.4 代码

package com.gl.rabbitmq.original;

import com.rabbitmq.client.*;
import org.junit.Test;

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

/**
 * @author gl
 * @time 2020-06-21 22:14
 * @function :第四种模式:   topic通配符模式
 * @step : 相对于路由模式,只是routingkey不是相等匹配了,而是通配符匹配了
 */
public class TopicDemo {
    private static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
    private static final String QUEUE_INFORM_SMS = "queue_inform_sms";
    private static final String EXCHANGE_TOPIC_INFORM = "exchange_topic_inform";
    private static final String ROUTING_EMAIL = "inform.#.email.#";
    private static final String ROUTING_SMS = "inform.#.sms.#";

    /**
     * 生产者
     * @throws IOException
     * @throws TimeoutException
     */
    @Test
    public void producer() throws IOException, TimeoutException {
        //1.通过util对象创建connection对象
        Connection connection = ConnUtil.getConnection();

        //2.获取channel
        Channel channel = connection.createChannel();
        //3.声明队列,这里就需要声明两个队列了
        /**
         * queue:声明队列的名称
         * durable: 是否持久化
         * exclusive: 是否独占连接,如果连接关闭则自动删除,如果将此参数设置为true可用于临时队列的创建
         * autoDelete: 是否自动删除此队列,如果将自参数和exclusive都设置为true就可实现临时队列.
         * arguments: 可以设置一个队列的扩展参数,比如: 设置队列存活时间
         */
        channel.queueDeclare(QUEUE_INFORM_EMAIL,true,false,false,null);
        channel.queueDeclare(QUEUE_INFORM_SMS,true,false,false,null);

        //4 声明交换机
        /**
         * 参数明细
         * 参数1: 交换机名称
         * 参数2: 交换机类型
         *      fanout: 对应发布订阅模式
         *      direct: 对应routing路由模式
         *      topic: 对应通配符模式
         *      header: 对应header模式
         */
        channel.exchangeDeclare(EXCHANGE_TOPIC_INFORM,BuiltinExchangeType.TOPIC);

        //5.将2个队列绑定在交换机上面
        /**
         * 参数1: 队列名字
         * 参数2: 交换机名字
         * 路由key: 在发布订阅模式中使用空串;在路由模式和通配符模式中会根据路由key将消息发送到指定的queue中去
         */
        channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_TOPIC_INFORM,ROUTING_EMAIL);
        channel.queueBind(QUEUE_INFORM_SMS,EXCHANGE_TOPIC_INFORM,ROUTING_SMS);
        //同一个queue可以绑定多个routingKey
        //如果两个queue绑定相同的exchange交换机,相同的routingKey,则我们就可以实现发发布订阅的功能
        //只需要我们发送消息时,指定发送到这个交换机的这个routingKey下节课
        //channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_ROUTING_INFORM,"inform");
        //channel.queueBind(QUEUE_INFORM_SMS,EXCHANGE_ROUTING_INFORM,"inform");

        //6.发送消息
        /**
         * channel.basicPublish(EXCHANGE_FANOUT_INFORM,"",null,msg.getBytes());
         * String exchange, String routingKey, BasicProperties props, byte[] body
         * exchange: 交换机,如果传递""空串表示使用默认的交换机
         * routingKey: 路由key,交换机根据路由key来将消息转发到指定的队列,如果使用默认的交换机,routingKey设置队列的名字
         * props: 消息的属性
         * body: 消息的内容
         */
        for (int i = 0;i < 5 ; i ++){
                String msg = "发送消息到email!!";
                //因为这里采用的是发布订阅模式,我们把消息是发给交换机,交换机去发给queue,所以这里指定交换机及即可,queue为空串
                channel.basicPublish(EXCHANGE_TOPIC_INFORM,"inform.email",null,(msg + i).getBytes());
                System.out.println("发送成功!!消息内容:" + (msg + i));
        }
        for (int i = 0;i < 5 ; i ++){
            String msg = "发送消息到sms!!";
            //因为这里采用的是发布订阅模式,我们把消息是发给交换机,交换机去发给queue,所以这里指定交换机及即可,queue为空串
            channel.basicPublish(EXCHANGE_TOPIC_INFORM,"inform.sms",null,(msg + i).getBytes());
            System.out.println("发送成功!!消息内容:" + (msg + i));
        }
        for (int i = 0;i < 5 ; i ++){
            String msg = "发送消息到email和sms!!";
            //因为这里采用的是发布订阅模式,我们把消息是发给交换机,交换机去发给queue,所以这里指定交换机及即可,queue为空串
            channel.basicPublish(EXCHANGE_TOPIC_INFORM,"inform.email.sms",null,(msg + i).getBytes());
            System.out.println("发送成功!!消息内容:" + (msg + i));
        }

        channel.close();
    }


    /**
     * email消费者
     * @throws IOException
     * @throws TimeoutException
     * @throws InterruptedException
     * 这里可以同时开启两次测试
     */
    @Test
    public void consumerEmail() throws IOException, TimeoutException, InterruptedException {
       publishSuvscirbeConsume(QUEUE_INFORM_EMAIL,EXCHANGE_TOPIC_INFORM,ROUTING_EMAIL);
    }

    /**
     * SMS消费者
     * @throws IOException
     * @throws TimeoutException
     * @throws InterruptedException
     * 这里可以同时开启两次测试
     */
    @Test
    public void consumerSMS() throws IOException, TimeoutException, InterruptedException {
        publishSuvscirbeConsume(QUEUE_INFORM_SMS,EXCHANGE_TOPIC_INFORM,ROUTING_SMS);
    }

    /**
     * 这是提取公共的发布订阅的consumer方法
     */
    public void publishSuvscirbeConsume(String queue,String exchange,String routingKey) throws IOException, TimeoutException, InterruptedException {
        //1.通过util对象创建connection对象
        Connection connection = ConnUtil.getConnection();

        //2.获取channel
        Channel channel = connection.createChannel();
        //3.声明队列
        /**
         * 这里可以不用声明队列,但是要确定该队列一定是在mq中存在的,不然就会代码报错.
         * queue:声明队列的名称
         * durable: 是否持久化
         * exclusive: 是否独占连接,如果连接关闭则自动删除,如果将此参数设置为true可用于临时队列的创建
         * autoDelete: 是否自动删除此队列,如果将自参数和exclusive都设置为true就可实现临时队列.
         * arguments: 可以设置一个队列的扩展参数,比如: 设置队列存活时间
         */
        channel.queueDeclare(queue,true,false,false,null);

        //4.声明交换机
        channel.exchangeDeclare(exchange,BuiltinExchangeType.TOPIC);
        //5.绑定queue到exchange上
        channel.queueBind(queue,exchange,routingKey);

        //声明一个消费者
        DefaultConsumer consumer = new DefaultConsumer(channel){
            /**
             * 接收到消息时,调用此方法
             * @param consumerTag 消费者标签
             * @param envelope  信封---其实就是mq对于此消息的封装的东西,比如消息id,exchange等
             * @param properties 消息属性
             * @param body 消息内容
             * @throws IOException
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //交换机
                String exchange = envelope.getExchange();
                long deliveryTag = envelope.getDeliveryTag();
                System.out.println("exchange:" + exchange);
                System.out.println("deliveryTag:" + deliveryTag);

                //接收消息
                String msg = new String(body, "utf-8");
                System.out.println("receive msg: "+ msg);
            }
        };

        //4.监听队列,消费消息
        /**
         * String queue, boolean autoAck, Consumer callback
         * 参数明细:
         * queue: 队列名
         * autoAck: 自动回复,当消费者受到消息之后,要告诉mq已接收到消息,true表示自动回复,false,表示不自动回复,需要代码回复
         * callback: 消费方法,当前消费者受到消息后要执行的方法.
         */
        channel.basicConsume(queue,true,consumer);
        //这是模拟,客户端阻塞,因为不这样做,客户端程序直接执行完毕,则不能执行consumer中的handleDelivery回调方法.
        //阻塞当前线程
        while (true){

        }
    }
}
5.RPC模式

在这里插入图片描述
因为不太常用,故略.

6.Header模式

不常用:略

总结

生产者生产消息的步骤

  1. 获取connection对象
  2. 从connection对象中获取channel
  3. channel声明exchange对象
  4. channel声明queue对象
  5. channel将exchange对象和queue对象绑定在一起
  6. channel.basicPublish() 发送消息

消费者消费消息的步骤

  1. 获取connection对象
  2. 从connection对象中获取channel
  3. channel声明exchange对象
  4. channel声明queue对象
  5. channel将exchange对象和queue对象绑定在一起
  6. 声明consumer对象,并实现handleDelivery()回调方法,这个方法是收到queue中的消息,对这个消息做处理的方法.
  7. channel.basicConsume() 消费消息
leokk111
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java RabbitMQ API 对接说明
谁念西风独自凉
06-12 1929
最近研发的物联网底层框架使用了RabbitMQ作为消息队列，如果监控消息队列对其通道是否出现阻塞能够及时获知与让管理员收到预警并及时处理，这里我们会采用RabbitMQ的rabbitmq_management插件。利用其提供的API进行获取信息，从而实现队列监控的目标。
RabbitMQ的Java客户端API指南
coder斗罗的博客
12-13 834
对RabbitMQ的Java客户端API进行介绍。 [x] input来自RabbitMQ官网
RabbitMQ在java中的使用、整合
最新发布
m0_73598900的博客
05-25 1162
学习RabbitMQ作为消息队列中间件，对于理解分布式系统、异步处理、应用解耦和提高系统可扩展性非常有帮助
java 读取mq_java获取rabbitmq服务的统计信息
weixin_34142444的博客
02-25 670
String rabbitmqHost = "192.168.0.100";String rabbitmqPort = "15672";String userName = "xxxx";String password = "password";String url = String.format("http://%s:%s/api/overview",rabbitmqHost,rabbitmqPo...
RabbitMQ支持消息的模式（官方API）
liudachu的博客
07-25 203
由于消息接收者处理消息的能力不同，存在处理快慢的问题，我们就需要能者多劳，处理快的多处理，处理慢的少处理；2、公平分发根据消费者的消费能力进行公平分发，处理快的处理的多，处理慢的处理的少；总结work1和work2的消息处理能力不同，但是最后处理的消息条数相同，是“按均分配”。当有多个消费者时，我们的消息会被哪个消费者消费呢，我们又该如何均衡消费者消费信息的多少呢?Direct模式是fanout模式上的一种叠加，增加了路由RoutingKey的模式。1、轮询模式的分发一个消费者一条，按均分配；...
RabbitMQ java API
1853
03-15 3456
RabbitMQ java API 队列持久化 # 生成一个队列 1、队列名称 2、队列里面的消息是否进行持久化 3、是否共享消息 4、是否自动删除 5、其他高级参 channel.queueDeclare(QUEUE_NAME, true, false, false, null); 消息持久化 # 发送一个消息 1、发送到哪个交换机 2、路由的key 3、其他的参数信息 4、发送消息内容 # 参数3：设置消息持久化 channel.basicPublish("", QUEUE_NAME, Messag
rabbitmq-management-java-client:RabbitMQ 管理 API 的 Java 客户端
07-11
RabbitMQ 管理 API 的 Java 客户端。 这个项目的目的更多是共享代码（fork 并适应你的需要），而不是一个有坚实支持的项目。 无论如何，我会看看你的问题。 已实现的端点在中列出。 并非所有端点都已实现。 该...
rabbitmq-stream-java-client：RabbitMQ流Java客户端
02-18
RabbitMQ流Java客户端 RabbitMQ Stream Java客户端是用于与进行通信的Java库。 它允许创建和删除流，以及发布和使用这些流。 客户还附带了。 请参考（ ）了解更多信息。 项目成熟度 该项目处于开发的早期阶段，被...
Java开发面试-RabbitMQ专区
10-28
其次，对于Java开发者来说，熟悉RabbitMQ的Java客户端API也是必要的。在面试中，可能会涉及到如何使用Java客户端API创建和管理RabbitMQ的队列、交换机和绑定等操作，以及如何发送和接收消息，如何处理消息的确认和...
rest-api-operation:使用Rabbitmq api删除队列和交换
04-29
总结来说，通过RabbitMQ的REST API，我们可以方便地在Java应用程序中进行队列和交换机的管理。这不仅简化了代码，也提高了操作的灵活性。在处理大量队列和交换机的场景下，这种批量操作的方式尤其有用。了解和熟练...
rabbitmq-java (2).zip
01-11
这个名为"rabbitmq-java (2).zip"的压缩包很可能是与Java相关的RabbitMQ客户端库或者一个项目示例，包含了必要的构建文件和源代码。 在RabbitMQ中，核心概念包括生产者、消费者、队列和交换机。生产者是发布消息的...
RabbitMQ-HTTP API 接口列表
12-29
这资料适用于学习，希望对大家的学习有点帮助。
RabbitMQ API文档
02-24
RabbitMQ实现了AMQP协议，RabbitMQ 3.5.6版本的API文档，欢迎下载使用
Java使用RabbitMQ实战，Springboot使用rabbitMQ实战
秃了也弱了
06-27 814
引入依赖： 1、简单实例 2、延迟消息 RabbitMQ实现延迟消息，RabbitMQ使用死信队列实现延迟消息，RabbitMQ延时队列插件 4、消息属性设置 5、消息可靠投递 RabbitMQ保证消息的可靠投递，Java实现RabbitMQ消息的可靠投递，Springboot实现RabbitMQ消息的可靠投递引包： 1、简单实例 （1）引入rabbitMQ.xml （2）生产者 （3）消费者 （4）测试类 三、SpringBoot-API 1、spring-amqp介绍 Spring AMQ
【RabbitMQ】原生Api学习之入门篇
菲林都已拆走
12-06 569
【RabbitMQ】 原生代码学习之入门篇1.总体概述 参考文献：《RabbitMQ实战指南》 1.总体概述
java操作RabbitMQ
热门推荐
卑微的小白
10-27 1万+
1、创建虚拟主机、交换机、队列 RabbitMQ提供了自己的管理界面，可以通过管理界面来完成VirtualHost、Exchange、queue的创建。 1.1创建VirtualHost 1.2创建交换机 创建交换机的时候需要指定虚拟主机以及交换机的类型（direct（路由模式）、fanout（广播）、headers、topic） direct：Exchange通过消息携带的路由键来将消息分发到对应的队列中 fanout：Exchange将消息分发到所有绑定到交换机的队列中 headers：Exchang
java实现RabbitMQ介绍
qq_41730219的博客
11-29 1854
一、初识RabbitMQ ①RabbitMQ是基于AMQP协议（Advanced Message Queuing Protocol）消息队列。 ②AMQP协议：具有现代特征的二进制协议，是一个提供统一消息服务的应用层标准高级消息队列协议,是应用层协议的一个开放标准，为面向消息的中间件设计。 ③AMQP的核心概念： Connection：publisher/consumer和broker之间的TCP连接。 Virhost host:把AMQP的基本组件划分到一个虚拟的分组中，同一个RabbitMQServer
RabbitMQ教程大全看这一篇就够了-java版本
又逢乱世
11-06 2900
rabbitmq
java-rabbitmq
05-14
Java-RabbitMQ 是一个 Java 编写的 RabbitMQ 客户端库，用于在 Java 应用程序中使用 RabbitMQ 消息代理。它提供了简单的 API，使得开发者可以轻松地在应用程序中实现消息队列功能。Java-RabbitMQ 库支持多种消息传输...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值