java-RabbitMq-交换机

1.rabbitMq有四种类型的交换机：直接(direct), 主题(topic) ,标题(headers) , 扇出(fanout)
不使用交换机

生产者：

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

/**
 * @Description RabbitMQ发送消息,消息生成者
 * @ClassName Producer
 * @Author yangff
 * @date 2021.09.26 20:49
 */
public class Producer {
    //队列名称
    private final static String QUEUE_NAME = "rabbitmq-test";

    public static void main(String[] argv) throws Exception {

        //1.创建一个ConnectionFactory连接工厂connectionFactory
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //2.通过connectionFactory设置RabbitMQ所在IP等信息
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672); //指定端口
        connectionFactory.setUsername("guest");//用户名
        connectionFactory.setPassword("guest");//密码
        //channel 实现了自动 close 接口 自动关闭 不需要显示关闭
        try(Connection connection = connectionFactory.newConnection();Channel channel =
                connection.createChannel()) {
            /**
             * 生成一个队列
             * 1.队列名称
             * 2.队列里面的消息是否持久化 默认消息存储在内存中
             * 3.该队列是否只供一个消费者进行消费 是否进行共享 true 可以多个消费者消费
             * 4.是否自动删除 最后一个消费者端开连接以后 该队列是否自动删除 true 自动删除
             * 5.其他参数
             */
            channel.queueDeclare(QUEUE_NAME,false,false,false,null);
            String message="hello world";
            /**
             * 发送一个消息
             * 1.发送到那个交换机
             * 2.路由的 key 是哪个
             * 3.其他的参数信息
             * 4.发送消息的消息体
             */
            channel.basicPublish("",QUEUE_NAME,null,message.getBytes());
            System.out.println("消息发送完毕");
        }
    }
}

消费者：

import com.rabbitmq.client.*;


/**
 * @Description RabbitMQ接收消息
 * @ClassName Customer
 * @Author yangff
 * @date 2021.09.26 20:49
 */
public class Customer {
    //队列名称
    private final static String QUEUE_NAME = "rabbitmq-test";

    public static void main(String[] argv) throws Exception {
        //1.创建一个ConnectionFactory连接工厂connectionFactory
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //2.通过connectionFactory设置RabbitMQ所在IP等信息
        connectionFactory.setHost("127.0.0.1");
        Connection connection = connectionFactory.newConnection();
        Channel channel = connection.createChannel();
        System.out.println("等待接收消息....");
        //推送的消息如何进行消费的接口回调
        DeliverCallback deliverCallback=(consumerTag, delivery)->{
            String message= new String(delivery.getBody());
            System.out.println(message);
        };
        //取消消费的一个回调接口 如在消费的时候队列被删除掉了
        CancelCallback cancelCallback=(consumerTag)->{
            System.out.println("消息消费被中断");
        };
        /**
         * 消费者消费消息
         * 1.消费哪个队列
         * 2.消费成功之后是否要自动应答 true 代表自动应答 false 手动应答
         * 3.消费者未成功消费的回调
         */
        channel.basicConsume(QUEUE_NAME,true,deliverCallback,cancelCallback);
    }
}

fanout交换机

fanout类型交换机会将接收到的消息广播给所有与之绑定的队列。

消费者1：

import com.cn.mq.utils.ConnectionMq;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;

/**
 * @Description
 * @ClassName ReceiveLogs01
 * @Author yangff
 * @date 2021.09.28 22:13
 */
public class ReceiveLogs01 {
        private static final String EXCHANGE_NAME = "logs";
        public static void main(String[] argv) throws Exception {
            Channel channel = ConnectionMq.getChannel();
            //声明一个交换机
            channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
            /**
             * 生成一个临时的队列 队列的名称是随机的
             * 当消费者断开和该队列的连接时 队列自动删除
             */
            String queueName = channel.queueDeclare().getQueue();
            //把该临时队列绑定我们的 exchange 其中 routingkey(也称之为 binding key)为空字符串
            channel.queueBind(queueName, EXCHANGE_NAME, "");
            System.out.println("ReceiveLogs01等待接收消息,把接收到的消息打印在屏幕.....");

            //接收消息
            DeliverCallback deliverCallback = (consumerTag, delivery) -> {
                String message = new String(delivery.getBody(), "UTF-8");
                System.out.println("ReceiveLogs01控制台打印接收到的消息"+message);
            };
            //消息取消时回调接口
            channel.basicConsume(queueName, true, deliverCallback, consumerTag -> { });
        }
}

消费者2

import com.cn.mq.utils.ConnectionMq;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;

/**
 * @Description
 * @ClassName ReceiveLogs01
 * @Author yangff
 * @date 2021.09.28 22:13
 */
public class ReceiveLogs02 {
        private static final String EXCHANGE_NAME = "logs";
        public static void main(String[] argv) throws Exception {
            Channel channel = ConnectionMq.getChannel();
            //什么一个交换机
            channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
            /**
             * 生成一个临时的队列 队列的名称是随机的
             * 当消费者断开和该队列的连接时 队列自动删除
             */
            String queueName = channel.queueDeclare().getQueue();
            //把该临时队列绑定我们的 exchange 其中 routingkey(也称之为 binding key)为空字符串
            channel.queueBind(queueName, EXCHANGE_NAME, "");
            System.out.println("ReceiveLogs02等待接收消息,把接收到的消息打印在屏幕.....");

            //接收消息
            DeliverCallback deliverCallback = (consumerTag, delivery) -> {
                String message = new String(delivery.getBody(), "UTF-8");
                System.out.println("ReceiveLogs02控制台打印接收到的消息"+message);
            };
            //消息取消时回调接口
            channel.basicConsume(queueName, true, deliverCallback, consumerTag -> { });
        }
}

生产者：

import com.cn.mq.utils.ConnectionMq;
import com.rabbitmq.client.Channel;

import java.util.Scanner;

/**
 * @Description
 * @ClassName EmitLog
 * @Author yangff
 * @date 2021.09.28 22:17
 */
public class EmitLog {
    private static final String EXCHANGE_NAME = "logs";
    public static void main(String[] argv) throws Exception {
        try (Channel channel = ConnectionMq.getChannel()) {
            /**
             * 声明一个 exchange
             * 1.exchange 的名称
             * 2.exchange 的类型
             */
            channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入信息");
            while (sc.hasNext()) {
                String message = sc.nextLine();
                channel.basicPublish(EXCHANGE_NAME, "", null, message.getBytes("UTF-8"));
                System.out.println("生产者发出消息" + message);
            }
        }
    } 
}

direct直接交换机
绑定用参数：routingKey 来表示也可称该参数为 binding key，
创建绑定我们用代码:channel.queueBind(queueName, EXCHANGE_NAME, “routingKey”);绑定之后的
意义由其交换类型决定。

消息会被推送至绑定键（binding key）和消息发布附带的选择键（routing key）完全匹配的队列。
消费者1：

import com.cn.mq.utils.ConnectionMq;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import org.apache.commons.io.FileUtils;

import java.io.File;

/**
 * @Description
 * @ClassName ReceiveLogs01
 * @Author yangff
 * @date 2021.09.28 22:13
 */
public class ReceiveLogsDirect01 {
    private static final String EXCHANGE_NAME = "direct_logs";

    public static void main(String[] argv) throws Exception {
        Channel channel = ConnectionMq.getChannel();
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
        String queueName = "disk";
        channel.queueDeclare(queueName, false, false, false, null);
        channel.queueBind(queueName, EXCHANGE_NAME, "error");
        System.out.println("等待接收消息.....");
        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            message = "接收绑定键:" + delivery.getEnvelope().getRoutingKey() + ",消息:" + message;
            File file = new File("src/main/java/com/cn/mq/exchanges2/rabbitmq_info.txt");
            FileUtils.writeStringToFile(file, message, "UTF-8");
            System.out.println("错误日志已经接收");
        };
        channel.basicConsume(queueName, true, deliverCallback, consumerTag -> {
        });
    }
}

消费者2：

import com.cn.mq.utils.ConnectionMq;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;

/**
 * @Description
 * @ClassName ReceiveLogs01
 * @Author yangff
 * @date 2021.09.28 22:13
 */
public class ReceiveLogsDirect02 {
    private static final String EXCHANGE_NAME = "direct_logsx";

    public static void main(String[] argv) throws Exception {
        Channel channel = ConnectionMq.getChannel();
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
        String queueName = "console";
        channel.queueDeclare(queueName, false, false, false, null);
        channel.queueBind(queueName, EXCHANGE_NAME, "info");
        channel.queueBind(queueName, EXCHANGE_NAME, "warning");
        System.out.println("等待接收消息.....");
        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" 接收绑定键 :" + delivery.getEnvelope().getRoutingKey() + ", 消 息:" + message);
        };
        channel.basicConsume(queueName, true, deliverCallback, consumerTag -> {
        });
    }
}

生产者：

import com.cn.mq.utils.ConnectionMq;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

/**
 * @Description
 * @ClassName EmitLog
 * @Author yangff
 * @date 2021.09.28 22:17
 */
public class EmitLogDirect {
    private static final String EXCHANGE_NAME = "direct_logs";
    public static void main(String[] argv) throws Exception {
        try (Channel channel = ConnectionMq.getChannel();) {
            channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
            //创建多个 bindingKey
            Map<String, String> bindingKeyMap = new HashMap<>();
            bindingKeyMap.put("info", "普通 info 信息");
            bindingKeyMap.put("warning", "警告 warning 信息");
            bindingKeyMap.put("error", "错误 error 信息");
            //debug 没有消费这接收这个消息 所有就丢失了
            bindingKeyMap.put("debug", "调试 debug 信息");
            for (Map.Entry<String, String> bindingKeyEntry : bindingKeyMap.entrySet()) {
                String bindingKey = bindingKeyEntry.getKey();
                String message = bindingKeyEntry.getValue();
                channel.basicPublish(EXCHANGE_NAME, bindingKey, null,
                        message.getBytes("UTF-8"));
                System.out.println("生产者发出消息:" + message);
            }
        }
    }
}

topic主题交换机
结合了 扇出(fanout)直接(direct)两种交换机
发送到类型是 topic 交换机的消息的 routing_key 不能随意写，必须满足一定的要求，它必须是一个单
词列表，以点号分隔开。
这些单词可以是任意单词，比如说：“stock.usd.nyse”, “nyse.vmw”,
“quick.orange.rabbit”.这种类型的。
列表最多不能超过 255 个字节。
在这个规则列表中，其中有两个替换符是大家需要注意的
*可以代替一个单词
#可以替代零个或多个单词

一个附带特殊的选择键将会被转发到绑定键与之匹配的队列中。
可以简单理解为模糊匹配

消费者1：

import com.cn.mq.utils.ConnectionMq;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;

/**
 * @Description
 * @ClassName ReceiveLogsTopic01
 * @Author yangff
 * @date 2021.09.28 22:36
 */
public class ReceiveLogsTopic01 {
    private static final String EXCHANGE_NAME = "topic_logs";

    public static void main(String[] argv) throws Exception {
        Channel channel = ConnectionMq.getChannel();
        channel.exchangeDeclare(EXCHANGE_NAME, "topic");
        //声明 Q1 队列与绑定关系
        String queueName = "Q1";
        //queueName，持久化，共享，自动删除，参数
        channel.queueDeclare(queueName, false, false, false, null);
        channel.queueBind(queueName, EXCHANGE_NAME, "*.orange.*");
        System.out.println("等待接收消息.....");
        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" 接收队列 :" + queueName + " 绑 定 键:"+delivery.getEnvelope().getRoutingKey()+", 消息:"+message);
        };
        channel.basicConsume(queueName, true, deliverCallback, consumerTag -> {
        });
    }

}

消费者2：

import com.cn.mq.utils.ConnectionMq;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;

/**
 * @Description
 * @ClassName ReceiveLogsTopic02
 * @Author yangff
 * @date 2021.09.28 22:37
 */
public class ReceiveLogsTopic02 {
    private static final String EXCHANGE_NAME = "topic_logs";

    public static void main(String[] argv) throws Exception {
        Channel channel = ConnectionMq.getChannel();
        channel.exchangeDeclare(EXCHANGE_NAME, "topic");
        //声明 Q2 队列与绑定关系
        String queueName = "Q2";
        channel.queueDeclare(queueName, false, false, false, null);
        channel.queueBind(queueName, EXCHANGE_NAME, "*.*.rabbit");
        channel.queueBind(queueName, EXCHANGE_NAME, "lazy.#");
        System.out.println("等待接收消息.....");
        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" 接收队列 :" + queueName + " 绑 定 键:"+delivery.getEnvelope().getRoutingKey()+", 消息:"+message);
        };
        channel.basicConsume(queueName, true, deliverCallback, consumerTag -> {
        });
    }
}

生产者：

import com.cn.mq.utils.ConnectionMq;
import com.rabbitmq.client.Channel;

import java.util.HashMap;
import java.util.Map;

/**
 * @Description
 * @ClassName EmitLogTopic
 * @Author yangff
 * @date 2021.09.28 22:36
 */
public class EmitLogTopic {
    private static final String EXCHANGE_NAME = "topic_logs";

    public static void main(String[] argv) throws Exception {
        try (Channel channel = ConnectionMq.getChannel()) {
            channel.exchangeDeclare(EXCHANGE_NAME, "topic");
            /**
             * Q1-->绑定的是
             * 中间带 orange 带 3 个单词的字符串(*.orange.*)
             * Q2-->绑定的是
             * 最后一个单词是 rabbit 的 3 个单词(*.*.rabbit)
             * 第一个单词是 lazy 的多个单词(lazy.#)
             *  *(星号)可以代替一个单词
             *  #(井号)可以替代零个或多个单词
             */
            Map<String, String> bindingKeyMap = new HashMap<>();
            bindingKeyMap.put("quick.orange.rabbit", "被队列 Q1Q2 接收到");
            bindingKeyMap.put("lazy.orange.elephant", "被队列 Q1Q2 接收到");
            bindingKeyMap.put("quick.orange.fox", "被队列 Q1 接收到");
            bindingKeyMap.put("lazy.brown.fox", "被队列 Q2 接收到");
            bindingKeyMap.put("lazy.pink.rabbit", "虽然满足两个绑定但只被队列 Q2 接收一次");
            bindingKeyMap.put("quick.brown.fox", "不匹配任何绑定不会被任何队列接收到会被丢弃");
            bindingKeyMap.put("quick.orange.male.rabbit", "是四个单词不匹配任何绑定会被丢弃");
            bindingKeyMap.put("lazy.orange.male.rabbit", "是四个单词但匹配 Q2");
            for (Map.Entry<String, String> bindingKeyEntry : bindingKeyMap.entrySet()) {
                String bindingKey = bindingKeyEntry.getKey();
                String message = bindingKeyEntry.getValue();
                channel.basicPublish(EXCHANGE_NAME, bindingKey, null,
                        message.getBytes("UTF-8"));
                System.out.println("生产者发出消息" + message);
            }
        }
    }
}

当mq报错时登录mq页面删除对应queue