4.RabbitMQ Publish/Subscribe

注意 消费者需要先启动，不然会有消息黑洞，即消失丢失现象。

Publish/Subscribe模式 交换器会把消息投递给所有附加在此交换器上的队列。

 

package com.study.soufang.rabbit.a001.topicAndPublish;

public class ConstantOfTopic {

    public static final String QUEUE_NAME_A = "log_queue_a";
    
    public static final String QUEUE_NAME_B = "log_queue_b";
    
    public static final String EXCHANGE_NAME="logs";
    
    public static final String EXCHANGE_TYPE_FANOUT="fanout";
}
 

 

package com.study.soufang.rabbit.a001.topicAndPublish;

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

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;
import com.rabbitmq.client.AMQP.BasicProperties;
import com.study.soufang.rabbit.a001.RabbitChannelUtil;

import lombok.Data;
import lombok.experimental.Accessors;
@Data
@Accessors(chain = true)
public class MyConsumer extends DefaultConsumer {

    
    public MyConsumer(Channel channel) {
        super(channel);
    }

    @Override
    public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties, byte[] body)
            throws IOException {
        try {
            String message = new String(body, "UTF-8");
            System.out.println(consumerTag+"--"+Thread.currentThread().getName()+" [x] Received '" + message + "'");
        } finally {
            /**
             * deliveryTag:该消息的index
                multiple：是否批量.true:将一次性ack所有小于deliveryTag的消息。
             */
            getChannel().basicAck(envelope.getDeliveryTag(), false);
            /*try {
                RabbitChannelUtil.closeChannel(getChannel());
            } catch (TimeoutException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }*/
        }
    }

}

package com.study.soufang.rabbit.a001.topicAndPublish;

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

import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Consumer;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;
import com.study.soufang.rabbit.a001.RabbitChannelUtil;

public class Recv {

    public static void doRecv(String queue) throws IOException, TimeoutException{
        Channel channel = null;
        try {
            channel = RabbitChannelUtil.createChannel();
            //声明交换机
            channel.exchangeDeclare(ConstantOfTopic.EXCHANGE_NAME, ConstantOfTopic.EXCHANGE_TYPE_FANOUT);
            //声明队列
            channel.queueDeclare(queue, false, false, false, null);
            //绑定队列到交换机
            channel.queueBind(queue, ConstantOfTopic.EXCHANGE_NAME, "");
            Consumer consumer = new MyConsumer(channel);
            boolean autoAck = false;
            channel.basicConsume(queue, autoAck, consumer);
            channel.basicQos(1);
        } catch (IOException | TimeoutException e) {
            e.printStackTrace();
        }
    }
    
    public static void main(String[] args) throws IOException, TimeoutException {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    doRecv(ConstantOfTopic.QUEUE_NAME_A);
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (TimeoutException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    doRecv(ConstantOfTopic.QUEUE_NAME_B);
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (TimeoutException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }).start();
    }
    
}
 

package com.study.soufang.rabbit.a001.topicAndPublish;

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

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.study.soufang.rabbit.a001.RabbitChannelUtil;

public class Send {

    public static void main(String[] args) throws IOException, TimeoutException {
        Channel channel = null;
        try {
            channel = RabbitChannelUtil.createChannel();
            //声明交换机
            channel.exchangeDeclare(ConstantOfTopic.EXCHANGE_NAME, ConstantOfTopic.EXCHANGE_TYPE_FANOUT);
            //发送消息，注意：需要消费者先启动并声明队列及绑定到此交换机，不然消息会丢失
            for(int i=0;i<100;i++){
                String message = "log---"+i;
                channel.basicPublish(ConstantOfTopic.EXCHANGE_NAME, "", null, message.getBytes());;
                Thread.sleep(100);
            }
        } catch (IOException | TimeoutException | InterruptedException e) {
            e.printStackTrace();
        }finally{
            RabbitChannelUtil.closeChannel(channel);
        }
        
    }
}
 

package com.study.soufang.rabbit.a001;

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

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

public class RabbitChannelUtil {

    private final static String RABBIT_HOST= "192.168.10.22";
    private final static int RABBIT_PORT=5672;
    
    public static Channel createChannel() throws IOException, TimeoutException{
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost(RABBIT_HOST);
        factory.setPort(RABBIT_PORT);
        factory.setUsername("admin");
        factory.setPassword("admin");
        factory.setVirtualHost("helloworld");
        Connection connection = null;
        Channel channel = null;
        connection = factory.newConnection();
        channel = connection.createChannel();
        return channel;
    }
    /**
     * 关闭连接后不会再监听
     * @param channel
     * @throws IOException
     * @throws TimeoutException
     */
    public static void closeChannel(Channel channel) throws IOException, TimeoutException{
        Connection connection = channel.getConnection();
        if(null != channel){
            channel.close();
        }
        if(null != connection){
            connection.close();
        }
    }
    
}