一、Direct exchange（直连交换机）

 

当交换机类型为direct类型时，根据队列绑定的路由建转发到具体的队列中存放消息

 

 

 

 1.Producer

 1 package com.miaoshaProject.mq.exchange.demo_direct;
 2 
 3 import com.miaoshaProject.mq.util.RabbitMQConnection;
 4 import com.rabbitmq.client.Channel;
 5 import com.rabbitmq.client.Connection;
 6 
 7 import java.io.IOException;
 8 import java.util.concurrent.TimeoutException;
 9 
10 /**
11  * @Author wangshuo
12  * @Date 2022/5/7, 14:05
13  * Please add a comment
14  */
15 public class Producer {
16 
17     private static final String EXCHANGE_NAME = "direct_exchange";
18 
19     public static void main(String[] args) throws IOException, TimeoutException {
20 
21         Connection connection = RabbitMQConnection.getConnection();
22         Channel channel = connection.createChannel();
23         //绑定交换机
24         channel.exchangeDeclare(EXCHANGE_NAME, "direct", true);
25         String msg = "测试direct交换机";
26         //指定key发送消息
27         channel.basicPublish(EXCHANGE_NAME, "sms", null, msg.getBytes());
28         channel.close();
29         connection.close();
30     }
31 }

2.ConsumerC

 1 package com.miaoshaProject.mq.exchange.demo_direct;
 2 
 3 import com.miaoshaProject.mq.util.RabbitMQConnection;
 4 import com.rabbitmq.client.*;
 5 
 6 import java.io.IOException;
 7 import java.util.concurrent.TimeoutException;
 8 
 9 /**
10  * @Author wangshuo
11  * @Date 2022/5/7, 14:08
12  * Please add a comment
13  */
14 public class ConsumerC {
15 
16     private static final String EXCHANGE_NAME = "direct_exchange";
17     private static final String A_QUEUE_NAME = "queueC";
18 
19     public static void main(String[] args) throws IOException, TimeoutException {
20         Connection connection = RabbitMQConnection.getConnection();
21         Channel channel = connection.createChannel();
22         //关联交换机、队列、路由key
23         channel.queueBind(A_QUEUE_NAME, EXCHANGE_NAME, "email");
24         DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
25 
26             //重写收到消息后的动作
27             @Override
28             public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
29 
30                 String msg = new String(body, "UTF-8");
31                 System.out.println("消费者C收到消息： " + msg);
32             }
33         };
34         channel.basicConsume(A_QUEUE_NAME, true, defaultConsumer);
35     }
36 }

3.ConsumerD

 1 package com.miaoshaProject.mq.exchange.demo_direct;
 2 
 3 import com.miaoshaProject.mq.util.RabbitMQConnection;
 4 import com.rabbitmq.client.*;
 5 
 6 import java.io.IOException;
 7 import java.util.concurrent.TimeoutException;
 8 
 9 /**
10  * @Author wangshuo
11  * @Date 2022/5/7, 14:08
12  * Please add a comment
13  */
14 public class ConsumerD {
15 
16     private static final String EXCHANGE_NAME = "direct_exchange";
17     private static final String B_QUEUE_NAME = "queueD";
18 
19     public static void main(String[] args) throws IOException, TimeoutException {
20         Connection connection = RabbitMQConnection.getConnection();
21         Channel channel = connection.createChannel();
22         //关联交换机、队列、路由key
23         channel.queueBind(B_QUEUE_NAME, EXCHANGE_NAME, "sms");
24         DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
25 
26             //重写收到消息后的动作
27             @Override
28             public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
29 
30                 String msg = new String(body, "UTF-8");
31                 System.out.println("消费者D收到消息： " + msg);
32             }
33         };
34         channel.basicConsume(B_QUEUE_NAME, true, defaultConsumer);
35     }
36 }

二、Fanout exchange（扇型交换机）

 

生产者发送一条消息，经过交换机转发到多个不同的队列，多个不同的队列就多个不同的消费者。

 

 

 

 1.Producer

 1 package com.miaoshaProject.mq.exchange.demo_fanout;
 2 
 3 import com.miaoshaProject.mq.util.RabbitMQConnection;
 4 import com.rabbitmq.client.Channel;
 5 import com.rabbitmq.client.Connection;
 6 
 7 import java.io.IOException;
 8 import java.util.concurrent.TimeoutException;
 9 
10 /**
11  * @Author wangshuo
12  * @Date 2022/5/7, 13:23
13  * Please add a comment
14  */
15 public class Producer {
16 
17     private static final String EXCHANGE_NAME = "fanout_exchange";
18 
19     public static void main(String[] args) throws IOException, TimeoutException {
20         Connection connection = RabbitMQConnection.getConnection();
21         Channel channel = connection.createChannel();
22         //通道关联交换机
23         channel.exchangeDeclare(EXCHANGE_NAME, "fanout", true);
24         String msg = "测试fanout交换机";
25         channel.basicPublish(EXCHANGE_NAME, "", null, msg.getBytes());
26         channel.close();
27         connection.close();
28     }
29 }

2.ConsumerA

 1 package com.miaoshaProject.mq.exchange.demo_fanout;
 2 
 3 import com.miaoshaProject.mq.util.RabbitMQConnection;
 4 import com.rabbitmq.client.*;
 5 
 6 import java.io.IOException;
 7 import java.util.concurrent.TimeoutException;
 8 
 9 /**
10  * @Author wangshuo
11  * @Date 2022/5/7, 13:36
12  * Please add a comment
13  */
14 public class ConsumerA {
15 
16     private static final String EXCHANGE_NAME = "fanout_exchange";
17     private static final String A_QUEUE_NAME = "queueA";
18 
19     public static void main(String[] args) throws IOException, TimeoutException {
20 
21         Connection connection = RabbitMQConnection.getConnection();
22         Channel channel = connection.createChannel();
23         //关联交换机与队列
24         channel.queueBind(A_QUEUE_NAME, EXCHANGE_NAME, "");
25         DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
26             //重写收到消息后的动作
27             @Override
28             public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
29                 String msg = new String(body, "UTF-8");
30                 System.out.println("消费者A收到消息： " + msg);
31             }
32         };
33         //绑定队列，监听消息并自动删除已收到的消息
34         channel.basicConsume(A_QUEUE_NAME, true, defaultConsumer);
35     }
36 }

3.ConsumerB

 1 package com.miaoshaProject.mq.exchange.demo_fanout;
 2 
 3 import com.miaoshaProject.mq.util.RabbitMQConnection;
 4 import com.rabbitmq.client.*;
 5 
 6 import java.io.IOException;
 7 import java.util.concurrent.TimeoutException;
 8 
 9 /**
10  * @Author wangshuo
11  * @Date 2022/5/7, 13:44
12  * Please add a comment
13  */
14 public class ConsumerB {
15 
16     private static final String EXCHANGE_NAME = "fanout_exchange";
17     private static final String B_QUEUE_NAME = "queueB";
18 
19     public static void main(String[] args) throws IOException, TimeoutException {
20 
21         Connection connection = RabbitMQConnection.getConnection();
22         Channel channel = connection.createChannel();
23         //关联交换机与队列
24         channel.queueBind(B_QUEUE_NAME, EXCHANGE_NAME, "");
25         DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
26 
27             //重写收到消息后的动作
28             @Override
29             public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
30                 String msg = new String(body, "UTF-8");
31                 System.out.println("消费者B收到消息： " + msg);
32             }
33         };
34         channel.basicConsume(B_QUEUE_NAME, true, defaultConsumer);
35     }
36 }

三、Topic exchange（主题交换机）

 

· 当交换机类型为topic类型时，根据队列绑定的路由建模糊转发到具体的队列中存放。

 

 # 号表示支持匹配多个词； * 号表示只能匹配一个词

 

 

 

1.Producer

 1 package com.miaoshaProject.mq.exchange.demo_topic;
 2 
 3 import com.miaoshaProject.mq.util.RabbitMQConnection;
 4 import com.rabbitmq.client.Channel;
 5 import com.rabbitmq.client.Connection;
 6 
 7 import java.io.IOException;
 8 import java.util.concurrent.TimeoutException;
 9 
10 /**
11  * @Author wangshuo
12  * @Date 2022/5/7, 13:23
13  * Please add a comment
14  */
15 public class Producer {
16 
17     private static final String EXCHANGE_NAME = "topic_exchange";
18 
19     public static void main(String[] args) throws IOException, TimeoutException {
20         Connection connection = RabbitMQConnection.getConnection();
21         Channel channel = connection.createChannel();
22         //通道关联交换机
23         channel.exchangeDeclare(EXCHANGE_NAME, "topic", true);
24         String msg = "测试topic交换机";
25         //设置topic
26         // topic匹配规则： #支持匹配多个词 、 *只能匹配一个词
27         channel.basicPublish(EXCHANGE_NAME, "wang.shuo.topic", null, msg.getBytes());
28         channel.close();
29         connection.close();
30     }
31 }

2.ConsumerE

 1 package com.miaoshaProject.mq.exchange.demo_topic;
 2 
 3 import com.miaoshaProject.mq.util.RabbitMQConnection;
 4 import com.rabbitmq.client.*;
 5 
 6 import java.io.IOException;
 7 import java.util.concurrent.TimeoutException;
 8 
 9 /**
10  * @Author wangshuo
11  * @Date 2022/5/7, 13:36
12  * Please add a comment
13  */
14 public class ConsumerE {
15 
16     private static final String EXCHANGE_NAME = "topic_exchange";
17     private static final String E_QUEUE_NAME = "queueE";
18 
19     public static void main(String[] args) throws IOException, TimeoutException {
20 
21         Connection connection = RabbitMQConnection.getConnection();
22         Channel channel = connection.createChannel();
23         //关联交换机、队列、主题
24         // topic匹配规则： #支持匹配多个词 、 *只能匹配一个词
25         channel.queueBind(E_QUEUE_NAME, EXCHANGE_NAME, "wang.*");
26         DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
27             //重写收到消息后的动作
28             @Override
29             public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
30                 String msg = new String(body, "UTF-8");
31                 System.out.println("消费者E收到消息： " + msg);
32             }
33         };
34         //绑定队列，监听消息并自动删除已收到的消息
35         channel.basicConsume(E_QUEUE_NAME, true, defaultConsumer);
36     }
37 }

3.ConsumerF

 1 package com.miaoshaProject.mq.exchange.demo_topic;
 2 
 3 import com.miaoshaProject.mq.util.RabbitMQConnection;
 4 import com.rabbitmq.client.*;
 5 
 6 import java.io.IOException;
 7 import java.util.concurrent.TimeoutException;
 8 
 9 /**
10  * @Author wangshuo
11  * @Date 2022/5/7, 13:44
12  * Please add a comment
13  */
14 public class ConsumerF {
15 
16     private static final String EXCHANGE_NAME = "topic_exchange";
17     private static final String F_QUEUE_NAME = "queueF";
18 
19     public static void main(String[] args) throws IOException, TimeoutException {
20 
21         Connection connection = RabbitMQConnection.getConnection();
22         Channel channel = connection.createChannel();
23         //关联交换机、队列、主题
24         // topic匹配规则： #支持匹配多个词 、 *只能匹配一个词
25         channel.queueBind(F_QUEUE_NAME, EXCHANGE_NAME, "wang.#");
26         DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
27 
28             //重写收到消息后的动作
29             @Override
30             public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
31                 String msg = new String(body, "UTF-8");
32                 System.out.println("消费者F收到消息： " + msg);
33             }
34         };
35         channel.basicConsume(F_QUEUE_NAME, true, defaultConsumer);
36     }
37 }

四、Headers exchange（头交换机）

headers交换机和direct交换机完全一致，目前几乎不用