java rabbitmq 的使用

 四、java操作简单的simple简单队列

• 模型

P:消息的生产者

红色：队列

C:消费者

• 获取Mq的链接

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

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

public class ConnectionUtils {
    
    /**
     * 
     * 方法功能说明：获取MQ的链接
     * 参数说明：
     * @return
     * 作者：Administrator
     * 创建时间:2019年1月22日-下午7:51:48
     * @throws TimeoutException 
     * @throws IOException 
     * 
     *   
     */
    public static Connection getConnection() throws IOException, TimeoutException {
        //定义一个链接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //设置服务地址
        factory.setHost("192.168.0.116");
        //设定端口
        factory.setPort(8244);
        //设定vhost
        factory.setVirtualHost("vhost");
        //设定用户名
        factory.setUsername("admin");
        //设定密码
        factory.setPassword("jorudan0407");
        return factory.newConnection();
    }
}

• 生产者生产消息

package com.mmr.rabbitmq.simple;

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

import com.mmr.rabbitmq.utils.ConnectionUtils;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;

public class Send {
    private static final String QUEUE_NAME="test_simple_queue";
    
    public static void main(String[] args) throws IOException, TimeoutException {
        //获取一个链接
        Connection connection = ConnectionUtils.getConnection();
        //获取一个通道
        Channel channel = connection.createChannel();
        //创建队列声明
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        String msg = "hello simple!";
        channel.basicPublish("", QUEUE_NAME, null, msg.getBytes());
        System.out.println("-- send msg: "+msg);
        
        channel.close();
    }
}

• 消费者消费消息

package com.mmr.rabbitmq.simple;

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

import com.mmr.rabbitmq.utils.ConnectionUtils;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;
import com.rabbitmq.client.AMQP.BasicProperties;

/**
 * 
* 公司:若尔丹软件开发公司  
* 类描述:获取消息 
* 作者:lizongti
* 创建时间:2019年1月22日-下午8:09:24
* 更新时间:
 */
public class Recv {
    private static final String QUEUE_NAME="test_simple_queue";
    public static void main(String[] args) throws IOException, TimeoutException {
        //获取链接
        Connection connection = ConnectionUtils.getConnection();
        //创建链接
        Channel channel = connection.createChannel();
        //队列声明
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        //监听队列
        channel.basicConsume(QUEUE_NAME, true, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties, byte[] body)
                    throws IOException {
                // TODO Auto-generated method stub
                System.out.println("接收到消息："+new String(body, "UTF-8"));
            }
        });
    }
}

• 简单队列不足
  • 耦合性告，生产者意义对应消费者，如果我想有多个消费者，就不行了
  • 对列明变更，这时候的同时变更

五、Work queues工作队列

• 模型

为什么会出现工作队列

simple队列是意义对应的，而且实际开发，生产者生产消息是很快的，而消费者一般是同业务结合的，处理逻辑慢。可能花费时间较多，这时候队列就会积压很多消息。 

• 生产者生产消息

package com.mmr.rabbitmq.work;

import com.mmr.rabbitmq.utils.ConnectionUtils;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;

public class Send {
    private static final String QUEUE_NAME="test_work_query";
    public static void main(String[] args) throws Exception {
        Connection connection = ConnectionUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        for(int i=0;i<50;i++) {
            String msg = "hello"+i;
            channel.basicPublish("", QUEUE_NAME, null, msg.getBytes());
            Thread.sleep(i*20);
        }
        
        channel.close();
        connection.close();
    }
}

• 消费者1消费消息

package com.mmr.rabbitmq.work;

import java.io.IOException;

import com.mmr.rabbitmq.utils.ConnectionUtils;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;
import com.rabbitmq.client.AMQP.BasicProperties;

public class Recv1 {
    private static final String QUEUE_NAME="test_work_query";
    public static void main(String[] args) throws Exception {
        //获取链接
        Connection con = ConnectionUtils.getConnection();
        //获取channel
        Channel channel = con.createChannel();
        //声明队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        Boolean autoAck = true;
        channel.basicConsume(QUEUE_NAME, autoAck, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties, byte[] body)
                    throws IOException {
                System.out.println("Recv1 触发消息："+new String(body,"utf-8"));
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }finally {
                    System.out.println("Recv1 消息处理完成！");
                }
            }
        });
    }
}

• 消费者2消费消息

package com.mmr.rabbitmq.work;

import java.io.IOException;

import com.mmr.rabbitmq.utils.ConnectionUtils;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;
import com.rabbitmq.client.AMQP.BasicProperties;

public class Recv2 {
    private static final String QUEUE_NAME="test_work_query";
    public static void main(String[] args) throws Exception {
        //获取链接
        Connection con = ConnectionUtils.getConnection();
        //获取channel
        Channel channel = con.createChannel();
        //声明队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        Boolean autoAck = true;
        channel.basicConsume(QUEUE_NAME, autoAck, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties, byte[] body)
                    throws IOException {
                System.out.println("Recv2 触发消息："+new String(body,"utf-8"));
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }finally {
                    System.out.println("Recv2 消息处理完成！");
                }
            }
        });
    }
}

现象：

消费者1和消费者2处理的数据消息是一样多的，消费者1都是偶数，消费者2都是基数，这种方式叫做轮询分发（round-robin）结果就不管谁处理快，都不会都给一个消息，任务消息总是你一个我一个。

公平分发：

使用basicQos(perfetch=1)，使用自动分发，必需干逼ack，手动应答

生产者

package com.mmr.rabbitmq.work.workfair;

import com.mmr.rabbitmq.utils.ConnectionUtils;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;

public class Send {
    private static final String QUEUE_NAME="test_work_query";
    public static void main(String[] args) throws Exception {
        Connection connection = ConnectionUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        /**
         * 每个消费者发送确认消息之前，消息队列不发送下一个消息到消费者，一次只能处理一个消息
         * 限制发送给同一个消费者不超过一条消息
         */
        int prefetchCount=1;
        channel.basicQos(prefetchCount);
        for(int i=0;i<50;i++) {
            String msg = "hello"+i;
            channel.basicPublish("", QUEUE_NAME, null, msg.getBytes());
            Thread.sleep(i*20);
        }
        
        channel.close();
        connection.close();
    }
}

消费者1

package com.mmr.rabbitmq.work.workfair;

import java.io.IOException;

import com.mmr.rabbitmq.utils.ConnectionUtils;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;
import com.rabbitmq.client.AMQP.BasicProperties;

public class Recv1 {
    private static final String QUEUE_NAME="test_work_query";
    public static void main(String[] args) throws Exception {
        //获取链接
        Connection con = ConnectionUtils.getConnection();
        //获取channel
        Channel channel = con.createChannel();
        //声明队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        channel.basicQos(1);//保证一次只发一个
        Boolean autoAck = false;//自动应答 false
        channel.basicConsume(QUEUE_NAME, autoAck, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties, byte[] body)
                    throws IOException {
                System.out.println("Recv1 触发消息："+new String(body,"utf-8"));
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }finally {
                    System.out.println("Recv1 消息处理完成！");
                    channel.basicAck(envelope.getDeliveryTag(), false);
                }
            }
        });
    }
}

消费者2

package com.mmr.rabbitmq.work.workfair;

import java.io.IOException;

import com.mmr.rabbitmq.utils.ConnectionUtils;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;
import com.rabbitmq.client.AMQP.BasicProperties;

public class Recv2 {
    private static final String QUEUE_NAME="test_work_query";
    public static void main(String[] args) throws Exception {
        //获取链接
        Connection con = ConnectionUtils.getConnection();
        //获取channel
        Channel channel = con.createChannel();
        //声明队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        channel.basicQos(1);//保证一次只发一个
        Boolean autoAck = false;//自动应答 false
        channel.basicConsume(QUEUE_NAME, autoAck, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties, byte[] body)
                    throws IOException {
                System.out.println("Recv2 触发消息："+new String(body,"utf-8"));
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }finally {
                    System.out.println("Recv2 消息处理完成！");
                    //手动回执一个消息
                    channel.basicAck(envelope.getDeliveryTag(), false);
                }
            }
        });
    }
}

 现象：消费者2比消费者消费的多，也叫能者多劳

 

六、消息应答与消息持久化

boolean autoAck = false;

channel.basicConsume(QUEUE_NAME,autoAck,consumer);

boolean autoAck = true;(自动确认模式)，一旦rabbitmq将消息分发给消费者，就会从内存删除，这种情况，如果杀死正在执行的消费者，就会丢失正在处理的消息

boolean autoAck = false;（手动模式），如果有一个消费者挂掉，就会交付给其他的消费者，消息不会丢失，rabbitmq支持消息应答，消费者发送一个消息应答告诉rabbitmq这个消息我已经处理完成，你可以删除了，然后rabbitmq就会删除内存中的消息。

消息应答默认是打开的，即false

消息的持久化：

boolean durable = true;

channel.queueDeclare(QUEUE_NAME, durable , false, false, null);

我们将程序的dureable=false改成true，是不可以的，应为代码景观是正确的，它也不会运行成功，因为我们定义了一个test_work_queue这个queue是为持久化的，rabbitmq不允许重新定义不同参数的一个已存在的队列

解决方法：在控制台将原来的队列删除即可

七、订阅模式

• 模型

一个生产者、多个消费者

每个消费者都有自己的队列

生产者没有将消息直接发给队列，而是发给交换机（转发器 exchange）里面

每个队列都要绑定到交换机上

生产者发送的消息经过交换机到达多个队列，就能实现一个消息被多个消费者消费