RabbitMQ学习03基本工作模式

使用IDEA创建空的Maven项目。

1、在POM文件中添加依赖：

<?xml version="1.0" encoding="UTF-8"?>
<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>org.yas</groupId>
    <artifactId>RabbitMQDemo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <dependencies>
        <!-- https://mvnrepository.com/artifact/com.rabbitmq/amqp-client -->
        <dependency>
            <groupId>com.rabbitmq</groupId>
            <artifactId>amqp-client</artifactId>
            <version>5.9.0</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/junit/junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <!-- https://mvnrepository.com/artifact/log4j/log4j -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.14</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.21</version>
        </dependency>
    </dependencies>
    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
</project>

2、创建工具类，连接rabbitmq：

package com.yas.config;

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

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

public class RabbitMQClient {
    public static Connection getConnection(){
        //创建Connection工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        factory.setPort(5672);
        factory.setUsername("username");
        factory.setPassword("password");
        factory.setVirtualHost("/");

        //创建Connection
        Connection connection = null;
        try {
            connection = factory.newConnection();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
        return connection;
    }
}

3、测试连接rabbitmq的代码：

package com.yas.test;

import com.rabbitmq.client.Connection;
import com.yas.config.RabbitMQClient;
import org.junit.Test;

import java.io.IOException;

public class Demo1 {
    //测试连接rabbitmq
    @Test
    public void getConnection() throws IOException {
        Connection connection = RabbitMQClient.getConnection();
        connection.close();
    }
}

4、Hello World模式：

模式介绍：生产者将消息发送到队列中，消费者从队列中接受消息。

生产者：1个

交换机：1个(默认)

队列：1个

消费者：1个

生产者代码：

package com.yas.helloworld;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.yas.config.RabbitMQClient;
import org.junit.Test;
public class Publisher {
    @Test
    public void publish() throws  Exception{
        //1.获取连接对象
        Connection connection = RabbitMQClient.getConnection();
        //2.创建Channel
        Channel channel = connection.createChannel();
        //3.发布消息到exchange，同时指定路由规则
        String msg = "Hello World";
        //参数1：指定exchange，使用空字符串，表示默认exchange。
        //参数2：指定路由规则，使用具体的队列名称。
        //参数3：指定传递的消息所携带的properties。
        //参数4：指定发布的具体消息，字节数组类型byte[]
        channel.basicPublish("","HelloWorld",null,msg.getBytes());
        //注意：exchange是不会将消息持久化到本地的，Queue有持久化的功能。
        System.out.println("生产者发布消息成功");
        //4.释放资源
        channel.close();
        connection.close();
    }
}

消费者代码：

package com.yas.helloworld;

import com.rabbitmq.client.*;
import com.yas.config.RabbitMQClient;
import org.junit.Test;

import java.io.IOException;

public class Consumer {
    @Test
    public void consume() throws  Exception{
        //1.获取连接对象
        Connection connection = RabbitMQClient.getConnection();
        //2.创建channel
        Channel channel = connection.createChannel();
        //3.生命队列-Hello World
        //参数1：queue，队列名称
        //参数2：durable，当前队列是否需要持久化
        //参数3：exclusive，是否排外
        //      影响1：当connection.close()时，当前队列会被自动删除
        //      影响2：当前队列只能被一个消费者消费
        //参数4：autoDelete，如果这个队列没有消费者消费，队列自动删除
        //参数5：arguments，指定当前队列的其他信息
        channel.queueDeclare("HelloWorld",true,false,false,null);
        //4.开启监听Queue
        DefaultConsumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //super.handleDelivery(consumerTag, envelope, properties, body);
                System.out.println("接受到消息：" + new String(body,"UTF-8"));
            }
        };
        //参数1：queue，指定消费哪个队列
        //参数2：deliverCallback，指定是否自动ACK，(true表示，接受到消息后，会立即通知RabbitMQ)
        //参数3：consumer，指定消费回调
        channel.basicConsume("HelloWorld",true,consumer);
        System.out.println("消费者开始监听队列");
        System.in.read();
        //5/释放资源
        channel.close();
        connection.close();
    }
}

5、Work Queue模式：

模式介绍：生产者将消息发送到队列中，多个消费者轮流从队列中取出消息，互不重复。

生产者：1个

交换机：1个(默认)

队列：1个

消费者：2个

生产者代码：(与Hello World模式一样)

package com.yas.workqueue;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.yas.config.RabbitMQClient;
import org.junit.Test;

public class Publisher {
    @Test
    public void publish() throws  Exception{
        //1.获取连接对象
        Connection connection = RabbitMQClient.getConnection();
        //2.创建Channel
        Channel channel = connection.createChannel();
        //3.发布消息到exchange，同时指定路由规则
        for(int i =0;i<10;i++) {
            String msg = "Work Queue" + i;
        //参数1：指定exchange，使用空字符串，表示默认exchange。
        //参数2：指定路由规则，使用具体的队列名称。
        //参数3：指定传递的消息所携带的properties。
        //参数4：指定发布的具体消息，字节数组类型byte[]

            channel.basicPublish("", "WorkQueue", null, msg.getBytes());
        }
        //注意：exchange是不会将消息持久化到本地的，Queue有持久化的功能。
        System.out.println("生产者发布消息成功");
        //4.释放资源
        channel.close();
        connection.close();
    }
}

消费者1代码：

package com.yas.workqueue;

import com.rabbitmq.client.*;
import com.yas.config.RabbitMQClient;
import org.junit.Test;

import java.io.IOException;

public class Consumer1 {
    @Test
    public void consume() throws  Exception{
        //1.获取连接对象
        Connection connection = RabbitMQClient.getConnection();
        //2.创建channel
        Channel channel = connection.createChannel();
        //3.生命队列-Hello World
        //参数1：queue，队列名称
        //参数2：durable，当前队列是否需要持久化
        //参数3：exclusive，是否排外
        //      影响1：当connection.close()时，当前队列会被自动删除
        //      影响2：当前队列只能被一个消费者消费
        //参数4：autoDelete，如果这个队列没有消费者消费，队列自动删除
        //参数5：arguments，指定当前队列的其他信息
        channel.queueDeclare("WorkQueue",true,false,false,null);

        //3.5指定当前消费者，一次消费多少个消息
        channel.basicQos(1);;

        //4.开启监听Queue
        DefaultConsumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //super.handleDelivery(consumerTag, envelope, properties, body);
                try {
                    Thread.sleep(50);//性能好
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("消费者1接受到消息：" + new String(body,"UTF-8"));

                //通知RabbitMQ已经消费完成，向rabbitmq发送ack消息
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        };
        //参数1：queue，指定消费哪个队列
        //参数2：deliverCallback，指定是否自动ACK，(true表示，接受到消息后，会立即通知RabbitMQ)
        //参数3：consumer，指定消费回调
//        channel.basicConsume("WorkQueue",true,consumer);
        channel.basicConsume("WorkQueue",false,consumer);//配合3.5节，手动ack通知

        System.out.println("消费者1开始监听队列");
        System.in.read();
        //5/释放资源
        channel.close();
        connection.close();
    }
}

消费者2代码：

package com.yas.workqueue;

import com.rabbitmq.client.*;
import com.yas.config.RabbitMQClient;
import org.junit.Test;

import java.io.IOException;

public class Consumer2 {
    @Test
    public void consume() throws  Exception{
        //1.获取连接对象
        Connection connection = RabbitMQClient.getConnection();
        //2.创建channel
        Channel channel = connection.createChannel();
        //3.生命队列-Hello World
        //参数1：queue，队列名称
        //参数2：durable，当前队列是否需要持久化
        //参数3：exclusive，是否排外
        //      影响1：当connection.close()时，当前队列会被自动删除
        //      影响2：当前队列只能被一个消费者消费
        //参数4：autoDelete，如果这个队列没有消费者消费，队列自动删除
        //参数5：arguments，指定当前队列的其他信息
        channel.queueDeclare("WorkQueue",true,false,false,null);

        //3.5指定当前消费者，一次消费多少个消息
        channel.basicQos(1);;

        //4.开启监听Queue
        DefaultConsumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //super.handleDelivery(consumerTag, envelope, properties, body);

                try {
                    Thread.sleep(200);//性能差
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("消费者2接受到消息：" + new String(body,"UTF-8"));

                //通知RabbitMQ已经消费完成，可以消费下一个消息了
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        };
        //参数1：queue，指定消费哪个队列
        //参数2：deliverCallback，指定是否自动ACK，(true表示，接受到消息后，会立即通知RabbitMQ)
        //参数3：consumer，指定消费回调
//        channel.basicConsume("WorkQueue",true,consumer);
        channel.basicConsume("WorkQueue",false,consumer);//配合3.5节，手动ack通知

        System.out.println("消费者2开始监听队列");
        System.in.read();
        //5/释放资源
        channel.close();
        connection.close();
    }
}

6、发布订阅模式：

模式介绍：生产者将消息发送到fanout交换机中，交换机会将信息发送给所有队列，消费者从它监听的队列接受全部的信息。每个消费者受到的信息都是一样的。

生产者：1个

交换机：1个(自定义fanout)

队列：2个

消费者：2个

生产者代码：

package com.yas.pubsub;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.yas.config.RabbitMQClient;
import org.junit.Test;

public class Publisher {
    @Test
    public void publish() throws  Exception{
        //1.获取连接对象
        Connection connection = RabbitMQClient.getConnection();
        //2.创建Channel
        Channel channel = connection.createChannel();

        //2.5创建exchange
        //参数1：exchange的名称
        //参数2：exchange的类型
        //      BuiltinExchangeType.FANOUT  对应pub-sub模式
        //      BuiltinExchangeType.DIRECT  对应routing模式
        //      BuiltinExchangeType.TOPIC   对应topics模式
        channel.exchangeDeclare("pubsub-exchange", BuiltinExchangeType.FANOUT);

        //绑定某一个队列
        //参数1：quque的名称
        //参数2：exchange的名称
        //参数3：路由规则，对于发布订阅模式，没有规则
        channel.queueBind("pubsub-queue1","pubsub-exchange","");
        channel.queueBind("pubsub-queue2","pubsub-exchange","");

        //3.发布消息到exchange，同时指定路由规则
        for(int i =0;i<10;i++) {
            String msg = "PUBSUB Queue" + i;
        //参数1：指定exchange，使用空字符串，表示默认exchange。
        //参数2：指定路由规则，使用具体的队列名称。
        //参数3：指定传递的消息所携带的properties。
        //参数4：指定发布的具体消息，字节数组类型byte[]
            channel.basicPublish("pubsub-exchange", "PUBSUBQueue", null, msg.getBytes());
        }
        //注意：exchange是不会将消息持久化到本地的，Queue有持久化的功能。
        System.out.println("生产者发布消息成功");
        //4.释放资源
        channel.close();
        connection.close();
    }
}

消费者1代码：

package com.yas.pubsub;

import com.rabbitmq.client.*;
import com.yas.config.RabbitMQClient;
import org.junit.Test;

import java.io.IOException;

public class Consumer1 {
    @Test
    public void consume() throws  Exception{
        //1.获取连接对象
        Connection connection = RabbitMQClient.getConnection();
        //2.创建channel
        Channel channel = connection.createChannel();
        //3.生命队列-Hello World
        //参数1：queue，队列名称
        //参数2：durable，当前队列是否需要持久化
        //参数3：exclusive，是否排外
        //      影响1：当connection.close()时，当前队列会被自动删除
        //      影响2：当前队列只能被一个消费者消费
        //参数4：autoDelete，如果这个队列没有消费者消费，队列自动删除
        //参数5：arguments，指定当前队列的其他信息
        channel.queueDeclare("pubsub-queue1",true,false,false,null);

        //3.5指定当前消费者，一次消费多少个消息
        channel.basicQos(1);;

        //4.开启监听Queue
        DefaultConsumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //super.handleDelivery(consumerTag, envelope, properties, body);
                try {
                    Thread.sleep(50);//性能好
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("消费者1接受到消息：" + new String(body,"UTF-8"));

                //通知RabbitMQ已经消费完成，向rabbitmq发送ack消息
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        };
        //参数1：queue，指定消费哪个队列
        //参数2：deliverCallback，指定是否自动ACK，(true表示，接受到消息后，会立即通知RabbitMQ)
        //参数3：consumer，指定消费回调
//        channel.basicConsume("WorkQueue",true,consumer);
        channel.basicConsume("pubsub-queue1",false,consumer);//配合3.5节，手动ack通知

        System.out.println("消费者1开始监听队列");
        System.in.read();
        //5/释放资源
        channel.close();
        connection.close();
    }
}

消费者2代码：

package com.yas.pubsub;

import com.rabbitmq.client.*;
import com.yas.config.RabbitMQClient;
import org.junit.Test;

import java.io.IOException;

public class Consumer2 {
    @Test
    public void consume() throws  Exception{
        //1.获取连接对象
        Connection connection = RabbitMQClient.getConnection();
        //2.创建channel
        Channel channel = connection.createChannel();
        //3.生命队列-Hello World
        //参数1：queue，队列名称
        //参数2：durable，当前队列是否需要持久化
        //参数3：exclusive，是否排外
        //      影响1：当connection.close()时，当前队列会被自动删除
        //      影响2：当前队列只能被一个消费者消费
        //参数4：autoDelete，如果这个队列没有消费者消费，队列自动删除
        //参数5：arguments，指定当前队列的其他信息
        channel.queueDeclare("pubsub-queue2",true,false,false,null);

        //3.5指定当前消费者，一次消费多少个消息
        channel.basicQos(1);;

        //4.开启监听Queue
        DefaultConsumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //super.handleDelivery(consumerTag, envelope, properties, body);
                try {
                    Thread.sleep(50);//性能好
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("消费者1接受到消息：" + new String(body,"UTF-8"));

                //通知RabbitMQ已经消费完成，向rabbitmq发送ack消息
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        };
        //参数1：queue，指定消费哪个队列
        //参数2：deliverCallback，指定是否自动ACK，(true表示，接受到消息后，会立即通知RabbitMQ)
        //参数3：consumer，指定消费回调
//        channel.basicConsume("WorkQueue",true,consumer);
        channel.basicConsume("pubsub-queue2",false,consumer);//配合3.5节，手动ack通知

        System.out.println("消费者1开始监听队列");
        System.in.read();
        //5/释放资源
        channel.close();
        connection.close();
    }
}

7、路由模式：

模式介绍：生产者将信息发送到direct交换机中，每个消息带一个routingKey与队列相对应。消息只能发送到匹配的队列上。消费者监听某个队列，只能接收与队列routingKey匹配的消息。

生产者：1个

交换机：1个(自定义direct)

队列：2个

消费者：2个

生产者代码：

package com.yas.routing;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.yas.config.RabbitMQClient;
import org.junit.Test;

public class Publisher {
    @Test
    public void publish() throws Exception {
        //1.获取连接对象
        Connection connection = RabbitMQClient.getConnection();
        //2.创建Channel
        Channel channel = connection.createChannel();

        //2.5创建exchange
        //参数1：exchange的名称
        //参数2：exchange的类型
        //      BuiltinExchangeType.FANOUT  对应pub-sub模式
        //      BuiltinExchangeType.DIRECT  对应routing模式
        //      BuiltinExchangeType.TOPIC   对应topics模式
        channel.exchangeDeclare("routing-exchange", BuiltinExchangeType.DIRECT);

        //绑定某一个队列
        //参数1：quque的名称
        //参数2：exchange的名称
        //参数3：路由规则，对于发布订阅模式，没有规则
        channel.queueBind("routing-queue-error", "routing-exchange", "ERROR");
        channel.queueBind("routing-queue-info", "routing-exchange", "INFO");

        //3.发布消息到exchange，同时指定路由规则
        String RoutingKey = "";
        for (int i = 0; i < 10; i++) {
            if (i < 3) {
                RoutingKey = "ERROR";
            } else {
                RoutingKey = "INFO";
            }
            String msg = "Routing Queue" + i;
            //参数1：指定exchange，使用空字符串，表示默认exchange。
            //参数2：指定路由规则，使用具体的队列名称。
            //参数3：指定传递的消息所携带的properties。
            //参数4：指定发布的具体消息，字节数组类型byte[]
            channel.basicPublish("routing-exchange", RoutingKey, null, msg.getBytes());
        }
        //注意：exchange是不会将消息持久化到本地的，Queue有持久化的功能。
        System.out.println("生产者发布消息成功");
        //4.释放资源
        channel.close();
        connection.close();
    }
}

消费者1代码：

package com.yas.routing;

import com.rabbitmq.client.*;
import com.yas.config.RabbitMQClient;
import org.junit.Test;

import java.io.IOException;

public class Consumer1 {
    @Test
    public void consume() throws  Exception{
        //1.获取连接对象
        Connection connection = RabbitMQClient.getConnection();
        //2.创建channel
        Channel channel = connection.createChannel();
        //3.生命队列-Hello World
        //参数1：queue，队列名称
        //参数2：durable，当前队列是否需要持久化
        //参数3：exclusive，是否排外
        //      影响1：当connection.close()时，当前队列会被自动删除
        //      影响2：当前队列只能被一个消费者消费
        //参数4：autoDelete，如果这个队列没有消费者消费，队列自动删除
        //参数5：arguments，指定当前队列的其他信息
        channel.queueDeclare("routing-queue-error",true,false,false,null);

        //3.5指定当前消费者，一次消费多少个消息
        channel.basicQos(1);;

        //4.开启监听Queue
        DefaultConsumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //super.handleDelivery(consumerTag, envelope, properties, body);
                try {
                    Thread.sleep(50);//性能好
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("消费者error接受到消息：" + new String(body,"UTF-8"));

                //通知RabbitMQ已经消费完成，向rabbitmq发送ack消息
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        };
        //参数1：queue，指定消费哪个队列
        //参数2：deliverCallback，指定是否自动ACK，(true表示，接受到消息后，会立即通知RabbitMQ)
        //参数3：consumer，指定消费回调
//        channel.basicConsume("WorkQueue",true,consumer);
        channel.basicConsume("routing-queue-error",false,consumer);//配合3.5节，手动ack通知

        System.out.println("消费者error开始监听队列");
        System.in.read();
        //5/释放资源
        channel.close();
        connection.close();
    }
}

消费者2代码：

package com.yas.routing;

import com.rabbitmq.client.*;
import com.yas.config.RabbitMQClient;
import org.junit.Test;

import java.io.IOException;

public class Consumer2 {
    @Test
    public void consume() throws  Exception{
        //1.获取连接对象
        Connection connection = RabbitMQClient.getConnection();
        //2.创建channel
        Channel channel = connection.createChannel();
        //3.生命队列-Hello World
        //参数1：queue，队列名称
        //参数2：durable，当前队列是否需要持久化
        //参数3：exclusive，是否排外
        //      影响1：当connection.close()时，当前队列会被自动删除
        //      影响2：当前队列只能被一个消费者消费
        //参数4：autoDelete，如果这个队列没有消费者消费，队列自动删除
        //参数5：arguments，指定当前队列的其他信息
        channel.queueDeclare("routing-queue-info",true,false,false,null);

        //3.5指定当前消费者，一次消费多少个消息
        channel.basicQos(1);;

        //4.开启监听Queue
        DefaultConsumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //super.handleDelivery(consumerTag, envelope, properties, body);
                try {
                    Thread.sleep(50);//性能好
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("消费者info接受到消息：" + new String(body,"UTF-8"));

                //通知RabbitMQ已经消费完成，向rabbitmq发送ack消息
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        };
        //参数1：queue，指定消费哪个队列
        //参数2：deliverCallback，指定是否自动ACK，(true表示，接受到消息后，会立即通知RabbitMQ)
        //参数3：consumer，指定消费回调
//        channel.basicConsume("WorkQueue",true,consumer);
        channel.basicConsume("routing-queue-info",false,consumer);//配合3.5节，手动ack通知

        System.out.println("消费者info开始监听队列");
        System.in.read();
        //5/释放资源
        channel.close();
        connection.close();
    }
}

8、主题模式：

模式介绍：生产者将信息发送到topic交换机中，每个队列有一个主题的模式，每条消息包含具体的主题，消息会发送都所有能匹配的队列上。消费者监听队列，接受消息。

生产者：1个

交换机：1个(自定义topic)

队列：2个

消费者：2个

生产者代码：

package com.yas.topic;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.yas.config.RabbitMQClient;
import org.junit.Test;

public class Publisher {
    @Test
    public void publish() throws Exception {
        //1.获取连接对象
        Connection connection = RabbitMQClient.getConnection();
        //2.创建Channel
        Channel channel = connection.createChannel();

        //2.5创建exchange
        //参数1：exchange的名称
        //参数2：exchange的类型
        //      BuiltinExchangeType.FANOUT  对应pub-sub模式
        //      BuiltinExchangeType.DIRECT  对应routing模式
        //      BuiltinExchangeType.TOPIC   对应topics模式
        channel.exchangeDeclare("topic-exchange", BuiltinExchangeType.TOPIC);

        //绑定某一个队列
        //参数1：quque的名称
        //参数2：exchange的名称
        //参数3：路由规则，
        //动物信息：<speed> <color> <what>
        // 动物1：*.red.*   -> *占位符，代表1个
        // 动物2：fast.#    -> # 通配符，代表多个
        // 动物3：*.*.rabbit
        channel.queueBind("topic-queue-1", "topic-exchange", "*.red.*");
        channel.queueBind("topic-queue-2", "topic-exchange", "fast.#");
        channel.queueBind("topic-queue-2", "topic-exchange", "*.*.rabbit");
        //3.发布消息到exchange，同时指定路由规则
        String RoutingKey = "";
        String msg = "";
        for (int i = 0; i < 10; i++) {
            if (i < 3) {
                RoutingKey = "fast.red.monkey";//fast匹配队列2，red匹配队列1
                msg = "快红猴";
            } else if (i < 7) {
                RoutingKey = "slow.white.rabbit";//rabbit匹配队列3
                msg = "慢白兔";
            } else {
                RoutingKey = "fast.blue.cat";//fast匹配队列2
                msg = "快蓝猫";
            }

            //参数1：指定exchange，使用空字符串，表示默认exchange。
            //参数2：指定路由规则，使用具体的队列名称。
            //参数3：指定传递的消息所携带的properties。
            //参数4：指定发布的具体消息，字节数组类型byte[]
            channel.basicPublish("topic-exchange", RoutingKey, null, msg.getBytes());
        }
        //注意：exchange是不会将消息持久化到本地的，Queue有持久化的功能。
        System.out.println("生产者发布消息成功");
        //4.释放资源
        channel.close();
        connection.close();
    }
}

消费者1代码：

package com.yas.topic;

import com.rabbitmq.client.*;
import com.yas.config.RabbitMQClient;
import org.junit.Test;

import java.io.IOException;

public class Consumer1 {
    @Test
    public void consume() throws  Exception{
        //1.获取连接对象
        Connection connection = RabbitMQClient.getConnection();
        //2.创建channel
        Channel channel = connection.createChannel();
        //3.生命队列-Hello World
        //参数1：queue，队列名称
        //参数2：durable，当前队列是否需要持久化
        //参数3：exclusive，是否排外
        //      影响1：当connection.close()时，当前队列会被自动删除
        //      影响2：当前队列只能被一个消费者消费
        //参数4：autoDelete，如果这个队列没有消费者消费，队列自动删除
        //参数5：arguments，指定当前队列的其他信息
        channel.queueDeclare("topic-queue-1",true,false,false,null);

        //3.5指定当前消费者，一次消费多少个消息
        channel.basicQos(1);;

        //4.开启监听Queue
        DefaultConsumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //super.handleDelivery(consumerTag, envelope, properties, body);
                try {
                    Thread.sleep(50);//性能好
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("消费者1接受到消息：" + new String(body,"UTF-8"));

                //通知RabbitMQ已经消费完成，向rabbitmq发送ack消息
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        };
        //参数1：queue，指定消费哪个队列
        //参数2：deliverCallback，指定是否自动ACK，(true表示，接受到消息后，会立即通知RabbitMQ)
        //参数3：consumer，指定消费回调
//        channel.basicConsume("WorkQueue",true,consumer);
        channel.basicConsume("topic-queue-1",false,consumer);//配合3.5节，手动ack通知

        System.out.println("消费者1开始监听队列");
        System.in.read();
        //5/释放资源
        channel.close();
        connection.close();
    }
}

消费者2代码：

package com.yas.topic;

import com.rabbitmq.client.*;
import com.yas.config.RabbitMQClient;
import org.junit.Test;

import java.io.IOException;

public class Consumer2 {
    @Test
    public void consume() throws  Exception{
        //1.获取连接对象
        Connection connection = RabbitMQClient.getConnection();
        //2.创建channel
        Channel channel = connection.createChannel();
        //3.生命队列-Hello World
        //参数1：queue，队列名称
        //参数2：durable，当前队列是否需要持久化
        //参数3：exclusive，是否排外
        //      影响1：当connection.close()时，当前队列会被自动删除
        //      影响2：当前队列只能被一个消费者消费
        //参数4：autoDelete，如果这个队列没有消费者消费，队列自动删除
        //参数5：arguments，指定当前队列的其他信息
        channel.queueDeclare("topic-queue-2",true,false,false,null);

        //3.5指定当前消费者，一次消费多少个消息
        channel.basicQos(1);;

        //4.开启监听Queue
        DefaultConsumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //super.handleDelivery(consumerTag, envelope, properties, body);
                try {
                    Thread.sleep(50);//性能好
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("消费者2接受到消息：" + new String(body,"UTF-8"));

                //通知RabbitMQ已经消费完成，向rabbitmq发送ack消息
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        };
        //参数1：queue，指定消费哪个队列
        //参数2：deliverCallback，指定是否自动ACK，(true表示，接受到消息后，会立即通知RabbitMQ)
        //参数3：consumer，指定消费回调
//        channel.basicConsume("WorkQueue",true,consumer);
        channel.basicConsume("topic-queue-2",false,consumer);//配合3.5节，手动ack通知

        System.out.println("消费者2开始监听队列");
        System.in.read();
        //5/释放资源
        channel.close();
        connection.close();
    }
}