rabbitmq最简单使用 四 direct模式

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.TimeoutException;

/**
 * 上一篇使用的exchange fanout模式：消息发送到所有与此交换机绑定的队列
 * 现在：exchange交换机的direct模式
 * 比如：银行卡消费需发送到  微信 ：但是一个队列需要转账类型的交易通知，其他不需要
 *  另一个队列只需要接收 工资和奖金类消息
 * 就可以使用direct模式，消费者绑定到交换机和routing，生产者发送消息给交换
 *
 * 流程：生产者->交换机->routring->队列->消费者
 *
 * 代码中业务关系
 * 1.生产者发送消息，相同的exchange交换机，不同的routing路由
 * 2.消费者绑定到交换机，不同的routing路由及队列
 *          消费者1 ->绑定到QUEUE_NAME  路由:TRANSFER_ROUTING
 *          消费者2->绑定到QUEUE_NAME1    路由：SALARY_ROUTING && 路由：BONUS_ROUTING
 */
public class ExchangeRoutingTest {

    private static final String EXCHANGE_NAME = "direct.exchange";
    private static final String QUEUE_NAME = "wx.queue";
    private static final String QUEUE_NAME1 = "wx.queue1";

    private static final String TRANSFER_ROUTING = "transfer";//转账
    private static final String SALARY_ROUTING = "salary";//工资
    private static final String BONUS_ROUTING = "bonus";//奖金



    public static void main(String[] args) {

        new Thread(
                ()->{
                    /**
                     * 发送消息
                     */
                    ConnectionFactory factory = new ConnectionFactory();
                    factory.setHost("127.0.0.1");
                    factory.setUsername("rabbit");
                    factory.setPassword("rabbit");
                    //创建连接和通道
                    try(Connection conn = factory.newConnection(); Channel channel = conn.createChannel()){

                        //声明交换机  direct模式
                        channel.exchangeDeclare(EXCHANGE_NAME, "direct");
                        for(int i = 0; i <50; i++) {
                            String message = "";
                            if(i%2 == 0) {
                                message = "工资 "+i;
                                //发送消息             默认交换机/队列名称/ /消息内容
                                channel.basicPublish(EXCHANGE_NAME,SALARY_ROUTING,null,message.getBytes(StandardCharsets.UTF_8));
                            } else {
                                message = "支出 "+i;
                                //发送消息             默认交换机/队列名称/ /消息内容
                                channel.basicPublish(EXCHANGE_NAME,TRANSFER_ROUTING,null,message.getBytes(StandardCharsets.UTF_8));
                            }
                            if(i>40) {
                                message = "奖金 "+i;
                                //发送消息             默认交换机/队列名称/ /消息内容
                                channel.basicPublish(EXCHANGE_NAME,BONUS_ROUTING,null,message.getBytes(StandardCharsets.UTF_8));

                            }

                        }
                    } catch(Exception e) {
                        e.printStackTrace();
                    }
                }
        ).start();
        //消费者1  转账路由
        new Thread(
                ()->{

                    //接收消息
                    ConnectionFactory comsumerFacotry = new ConnectionFactory();
                    comsumerFacotry.setHost("127.0.0.1");
                    comsumerFacotry.setUsername("rabbit");
                    comsumerFacotry.setPassword("rabbit");

                    Connection comsumerConn = null;
                    try {
                        //这里不手动关闭连接和通道，因为需要监听器一直监听是否有消息，所以需要一直保持连接
                        comsumerConn = comsumerFacotry.newConnection();
                        Channel channel = comsumerConn.createChannel();
                        channel.exchangeDeclare(EXCHANGE_NAME, "direct");//direct模式
                        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
                        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, TRANSFER_ROUTING);
                        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
                        //消息监听器
                        boolean autoAck = true;//是否自动ack   接收到消息则认为成功

                        channel.basicConsume(QUEUE_NAME, autoAck, (consumerTag, message) -> {
                            System.out.println("转账1 收到消息:QUEUE:"+QUEUE_NAME+"   " + new String(message.getBody(), StandardCharsets.UTF_8));
                        }, consumerTag -> {});
                    } catch (IOException e) {
                        e.printStackTrace();
                    } catch (TimeoutException e) {
                        e.printStackTrace();
                    }
                }
        ).start();

        //收入只接收工资和奖金类型  salary 和bonus
        new Thread(
                ()->{

                    //接收消息
                    ConnectionFactory comsumerFacotry = new ConnectionFactory();
                    comsumerFacotry.setHost("127.0.0.1");
                    comsumerFacotry.setUsername("rabbit");
                    comsumerFacotry.setPassword("rabbit");

                    Connection comsumerConn = null;
                    try {
                        //这里不手动关闭连接和通道，因为需要监听器一直监听是否有消息，所以需要一直保持连接
                        comsumerConn = comsumerFacotry.newConnection();
                        Channel channel = comsumerConn.createChannel();
                        channel.exchangeDeclare(EXCHANGE_NAME, "direct");//direct模式
                        channel.queueDeclare(QUEUE_NAME1, false, false, false, null);
                        channel.queueBind(QUEUE_NAME1, EXCHANGE_NAME, SALARY_ROUTING);//交换机 路由 队列绑定
                        channel.queueBind(QUEUE_NAME1, EXCHANGE_NAME, BONUS_ROUTING);
                        channel.queueDeclare(QUEUE_NAME1, false, false, false, null);
                        //消息监听器
                        boolean autoAck = true;//是否自动ack   接收到消息则认为成功

                        channel.basicConsume(QUEUE_NAME1, autoAck, (consumerTag, message) -> {
                            System.out.println("收入 收到消息:QUEUE"+QUEUE_NAME1+"   " + new String(message.getBody(), StandardCharsets.UTF_8));
                        }, consumerTag -> {});
                    } catch (IOException e) {
                        e.printStackTrace();
                    } catch (TimeoutException e) {
                        e.printStackTrace();
                    }
                }
        ).start();


    }


}