@Configuration
public class TopicRabbitConfig {
    //绑定键
    private final static String MAN = "topic.man";

    private final static String WOMAN = "topic.woman";

    private final static String EXCHANGE = "topicExchange";

    @Bean(MAN)
    public Queue manQueue() {
        // name:队列名称
        // durable:是否持久化,默认是false,持久化队列：会被存储在磁盘上，当消息代理重启时仍然存在，暂存队列：当前连接有效
        // exclusive:默认也是false，代表是否独占，如果未true，只能被当前创建的连接使用，而且当连接关闭后队列即被删除。此参考优先级高于durable
        // autoDelete:是否自动删除，当没有生产者或者消费者使用此队列，该队列会自动删除。
        return new Queue(TopicRabbitConfig.MAN, true, false, false);
    }

    @Bean(WOMAN)
    public Queue womanQueue() {
        return new Queue(TopicRabbitConfig.WOMAN);
    }

    @Bean(EXCHANGE)
    TopicExchange exchange() {
        // name:交换机名称
        // durable:是否持久化,默认是false,持久化队列：会被存储在磁盘上，当消息代理重启时仍然存在，暂存队列：当前连接有效
        // autoDelete:是否自动删除，当没有生产者或者消费者使用此队列，该队列会自动删除。
        return new TopicExchange(EXCHANGE, true, false);
    }


    //#匹配零个或多个单词,*匹配单个单词
    //将firstQueue和topicExchange绑定,而且绑定的键值为topic.man
    //这样只要是消息携带的路由键是topic.man,才会分发到该队列
    @Bean
    Binding bindingExchangeMessage(@Qualifier(MAN) Queue queue, @Qualifier(EXCHANGE) TopicExchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with(MAN);
    }

    //#匹配零个或多个单词,*匹配单个单词
    //将secondQueue和topicExchange绑定,而且绑定的键值为用上通配路由键规则topic.#
    //这样只要是消息携带的路由键是以topic.开头,都会分发到该队列
    @Bean
    Binding bindingExchangeMessage2(@Qualifier(WOMAN) Queue queue, @Qualifier(EXCHANGE) TopicExchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with("topic.#");
    }

}

@RestController
public class TopicSender {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @GetMapping("/send")
    public void send(String messageStr, String routingKey){
        String messageId = String.valueOf(UUID.randomUUID());
        String messageData = "test message, hello!";
        String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        Map<String, Object> map = new HashMap<>();
        map.put("messageId", messageId);
        map.put("messageData", messageData);
        map.put("createTime", createTime);
        map.put("sex","man");
        map.put("message", messageStr);
        String message = JSON.toJSONString(map);
        //将消息携带绑定键值：TestDirectRouting 发送到交换机TestDirectExchange
        rabbitTemplate.convertAndSend("topicExchange", routingKey, message);
    }
}

@Component
public class TopicManReceiver {

    private Logger log = LoggerFactory.getLogger(TopicManReceiver.class);

    @RabbitListener(queues = "topic.man")
    public void processMan(Message message, Channel channel) {
        log.info("man message is {}", message);
        try {
            //参数一：签收消息的编号 参数二：是否批量签收，比如签收了编号为4的消息，但是前面的0，1，2，3 都没有签收，则MQ若是批量的签收，它会把0，1，2，3 都签收
            channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @RabbitListener(queues = "topic.woman")
    public void processWoman(Message message, Channel channel) {
        log.info("woman message is {}", message);
        try {
            channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

@Component
@RabbitListener(queues = "topic.woman")
public class TopicWomanReceiver {

    private Logger log = LoggerFactory.getLogger(TopicWomanReceiver.class);

    @RabbitHandler
    public String process(Message message, Channel channel) {
        log.info("woman message is {}", message);
        try {
            channel.basicAck((Long)message.getHeaders().get(AmqpHeaders.DELIVERY_TAG), false);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return "hello world,too";
    }
}