rabbitmq rabitmq qiuickstart:
1.rabitmq 安装不在赘述：
2.rabitmq 相关源码：
生产者：
public class RabbitmqProducter {
public static void main(String[] args) throws IOException, TimeoutException {
//1:创建连接工厂
ConnectionFactory connectionFactory = new ConnectionFactory();
//2设置连接工厂的属性
connectionFactory.setHost("192.168.159.8");
connectionFactory.setPort(5672);
connectionFactory.setVirtualHost("tuling");
connectionFactory.setUsername("smlz");
connectionFactory.setPassword("smlz");
//3:通过连接工厂创建连接对象
Connection connection = connectionFactory.newConnection();
//4:通过连接创建channel
Channel channel = connection.createChannel();
//5:通过channel发送消息
for(int i=0;i<5;i++) {
String message = "hello--"+i;
/**
* 老师以前讲过说我们的消息会发送的exchange上，
* 但是在这里我们没有指定交换机?那我们的消息发送到哪里了？？？？
* The default exchange is implicitly bound to every queue, with a routing key equal to the queue name.
* It is not possible to explicitly bind to, or unbind from the default exchange. It also cannot be deleted.
* 说明:加入我们消息发送的时候没有指定具体的交换机的话，那么就会发送到rabbimtq指定默认的交换机上，
* 那么该交换机就会去根据routing_key 查找对应的queueName 然后发送的该队列上.
*
*/
channel.basicPublish("","tuling-queue-01",null,message.getBytes());
}
//6:关闭连接
channel.close();
connection.close();
}
消费者：
public class RabbitmqConsumer {
public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
//创建连接工厂
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("192.168.159.8");
connectionFactory.setPort(5672);
connectionFactory.setVirtualHost("tuling");
connectionFactory.setUsername("smlz");
connectionFactory.setPassword("smlz");
//创建连接
Connection connection = connectionFactory.newConnection();
//创建一个channel
Channel channel = connection.createChannel();
//声明队列
String queueName = "tuling-queue-01";
/**
* queue:队列的名称
* durable:是否持久化, 队列的声明默认是存放到内存中的，如果rabbitmq重启会丢失，如果想重启之后还存在就要使队列持久化，
* 保存到Erlang自带的Mnesia数据库中，当rabbitmq重启之后会读取该数据库
* exclusive:当连接关闭时connection.close()该队列是否会自动删除；
* 二：该队列是否是私有的private，如果不是排外的，可以使用两个消费者都访问同一个队列，
* 没有任何问题，如果是排外的，会对当前队列加锁，其他通道channel是不能访问的，如果强制访问会报异常
* com.rabbitmq.client.ShutdownSignalException: channel error; protocol method: #method(reply-code=405, reply-text=RESOURCE_LOCKED - cannot obtain exclusive access to locked queue 'queue_name' in vhost '/', class-id=50, method-id=20)
* 一般等于true的话用于一个队列只能有一个消费者来消费的场景
* autodelete:是否自动删除，当最后一个消费者断开连接之后队列是否自动被删除，可以通过RabbitMQ Management，
* 查看某个队列的消费者数量，当consumers = 0时队列就会自动删除
*/
channel.queueDeclare(queueName,true,false,true,null);
//创建消费者
QueueingConsumer queueingConsumer = new QueueingConsumer(channel);
channel.basicConsume(queueName,true,queueingConsumer);
while (true) {
QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
String reserveMsg = new String(delivery.getBody());
System.out.println("消费消息:"+reserveMsg);
}
}
}
二: quickstarton class
public class RabbitmqConsumer {
public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
//创建连接工厂
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("192.168.159.8");
connectionFactory.setPort(5672);
connectionFactory.setVirtualHost("tuling");
connectionFactory.setUsername("smlz");
connectionFactory.setPassword("smlz");
//创建连接
Connection connection = connectionFactory.newConnection();
//创建一个channel
Channel channel = connection.createChannel();
//声明队列
String queueName = "tuling-queue-01";
/**
* queue:队列的名称
* durable:是否持久化, 队列的声明默认是存放到内存中的，如果rabbitmq重启会丢失，如果想重启之后还存在就要使队列持久化，
* 保存到Erlang自带的Mnesia数据库中，当rabbitmq重启之后会读取该数据库
* exclusive:当连接关闭时connection.close()该队列是否会自动删除；
* 二：该队列是否是私有的private，如果不是排外的，可以使用两个消费者都访问同一个队列，
* 没有任何问题，如果是排外的，会对当前队列加锁，其他通道channel是不能访问的，如果强制访问会报异常
* com.rabbitmq.client.ShutdownSignalException: channel error; protocol method: #method(reply-code=405, reply-text=RESOURCE_LOCKED - cannot obtain exclusive access to locked queue 'queue_name' in vhost '/', class-id=50, method-id=20)
* 一般等于true的话用于一个队列只能有一个消费者来消费的场景
* autodelete:是否自动删除，当最后一个消费者断开连接之后队列是否自动被删除，可以通过RabbitMQ Management，
* 查看某个队列的消费者数量，当consumers = 0时队列就会自动删除
*/
channel.queueDeclare(queueName,true,false,true,null);
//创建消费者
QueueingConsumer queueingConsumer = new QueueingConsumer(channel);
channel.basicConsume(queueName,true,queueingConsumer);
while (true) {
QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
String reserveMsg = new String(delivery.getBody());
System.out.println("消费消息:"+reserveMsg);
}
}
三。消息分类：
public class RabbitmqMessageProducter {
public static void main(String[] args) throws IOException, TimeoutException {
//1:创建连接工厂
ConnectionFactory connectionFactory = new ConnectionFactory();
//2设置连接工厂的属性
connectionFactory.setHost("192.168.159.8");
connectionFactory.setPort(5672);
connectionFactory.setVirtualHost("tuling");
connectionFactory.setUsername("smlz");
connectionFactory.setPassword("smlz");
//3:通过连接工厂创建连接对象
Connection connection = connectionFactory.newConnection();
//4:通过连接创建channel
Channel channel = connection.createChannel();
Map headsMap = new HashMap<>();
headsMap.put("company","tuling");
headsMap.put("name","smlz");
AMQP.BasicProperties basicProperties = new AMQP.BasicProperties().builder()
.deliveryMode(2)//2标识持久化消息 1标识 服务重启后 消息不会被持久化
.expiration("10000")//消息过期 10s
.contentEncoding("utf-8")
.correlationId(UUID.randomUUID().toString())
.headers(headsMap)
.build();
//5:通过channel发送消息
for(int i=0;i<5;i++) {
String message = "hello--"+i;
/**
* 老师以前讲过说我们的消息会发送的exchange上，
* 但是在这里我们没有指定交换机?那我们的消息发送到哪里了？？？？
* The default exchange is implicitly bound to every queue, with a routing key equal to the queue name.
* It is not possible to explicitly bind to, or unbind from the default exchange. It also cannot be deleted.
* 说明:加入我们消息发送的时候没有指定具体的交换机的话，那么就会发送到rabbimtq指定默认的交换机上，
* 那么该交换机就会去根据routing_key 查找对应的queueName 然后发送的该队列上.
*
*/
channel.basicPublish("tuling.directchange","tuling.directchange.key",basicProperties,message.getBytes());
}
//6:关闭连接
channel.close();
connection.close();
}
}
消费断：
public class RabbitmqMessageProducter {
public static void main(String[] args) throws IOException, TimeoutException {
//1:创建连接工厂
ConnectionFactory connectionFactory = new ConnectionFactory();
//2设置连接工厂的属性
connectionFactory.setHost("192.168.159.8");
connectionFactory.setPort(5672);
connectionFactory.setVirtualHost("tuling");
connectionFactory.setUsername("smlz");
connectionFactory.setPassword("smlz");
//3:通过连接工厂创建连接对象
Connection connection = connectionFactory.newConnection();
//4:通过连接创建channel
Channel channel = connection.createChannel();
Map headsMap = new HashMap<>();
headsMap.put("company","tuling");
headsMap.put("name","smlz");
AMQP.BasicProperties basicProperties = new AMQP.BasicProperties().builder()
.deliveryMode(2)//2标识持久化消息 1标识 服务重启后 消息不会被持久化
.expiration("10000")//消息过期 10s
.contentEncoding("utf-8")
.correlationId(UUID.randomUUID().toString())
.headers(headsMap)
.build();
//5:通过channel发送消息
for(int i=0;i<5;i++) {
String message = "hello--"+i;
/**
* 老师以前讲过说我们的消息会发送的exchange上，
* 但是在这里我们没有指定交换机?那我们的消息发送到哪里了？？？？
* The default exchange is implicitly bound to every queue, with a routing key equal to the queue name.
* It is not possible to explicitly bind to, or unbind from the default exchange. It also cannot be deleted.
* 说明:加入我们消息发送的时候没有指定具体的交换机的话，那么就会发送到rabbimtq指定默认的交换机上，
* 那么该交换机就会去根据routing_key 查找对应的queueName 然后发送的该队列上.
*
*/
channel.basicPublish("tuling.directchange","tuling.directchange.key",basicProperties,message.getBytes());
}
//6:关闭连接
channel.close();
connection.close();
}
}
三种exchange:
package com.tuling.direct_exchange;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.QueueingConsumer;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* Created by smlz on 2019/9/28.
*/
public class DirectExchangeConsumer {
public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
//创建连接工厂
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("192.168.159.8");
connectionFactory.setPort(5672);
connectionFactory.setVirtualHost("tuling");
connectionFactory.setUsername("smlz");
connectionFactory.setPassword("smlz");
//创建连接
Connection connection = connectionFactory.newConnection();
//创建channel
Channel channel = connection.createChannel();
String exchangeName = "tuling.directchange";
String exchangeType = "direct";
String queueName = "tuling.directqueue";
String routingKey = "tuling.directchange.key";
/**
* 声明一个交换机
* exchange:交换机的名称
* type:交换机的类型 常见的有direct,fanout,topic等
* durable:设置是否持久化。durable设置为true时表示持久化，反之非持久化.持久化可以将交换器存入磁盘，在服务器重启的时候不会丢失相关信息
* autodelete:设置是否自动删除。autoDelete设置为true时，则表示自动删除。自动删除的前提是至少有一个队列或者交换器与这个交换器绑定，之后，所有与这个交换器绑定的队列或者交换器都与此解绑。
* 不能错误的理解—当与此交换器连接的客户端都断开连接时，RabbitMq会自动删除本交换器
* arguments:其它一些结构化的参数，比如：alternate-exchange
*/
channel.exchangeDeclare(exchangeName,exchangeType,true,false,null);
/**
* 声明一个队列
* durable:表示rabbitmq关闭删除队列
* autodelete:表示没有程序和队列建立连接 那么就会自动删除队列
*
*/
channel.queueDeclare(queueName,true,false,false,null);
/**
* 队里和交换机绑定
*/
channel.queueBind(queueName,exchangeName,routingKey);
/**
* 创建一个消费者
*/
QueueingConsumer queueingConsumer = new QueueingConsumer(channel);
/**
* 开始消费
*/
channel.basicConsume(queueName,true,queueingConsumer);
while (true) {
QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
String reciverMessage = new String(delivery.getBody());
System.out.println("消费消息:-----"+reciverMessage);
}
}
}:
2种方法：
package com.tuling.direct_exchange;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.QueueingConsumer;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* Created by smlz on 2019/9/28.
*/
public class DirectExchangeConsumer2 {
public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
//创建连接工厂
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("192.168.159.8");
connectionFactory.setPort(5672);
connectionFactory.setVirtualHost("tuling");
connectionFactory.setUsername("smlz");
connectionFactory.setPassword("smlz");
//创建连接
Connection connection = connectionFactory.newConnection();
//创建channel
Channel channel = connection.createChannel();
String exchangeName = "tuling.directchange";
String exchangeType = "direct";
String queueName = "tuling.directqueue";
String routingKey = "tuling.directchange.key";
/**
* 声明一个交换机
* exchange:交换机的名称
* type:交换机的类型 常见的有direct,fanout,topic等
* durable:设置是否持久化。durable设置为true时表示持久化，反之非持久化.持久化可以将交换器存入磁盘，在服务器重启的时候不会丢失相关信息
* autodelete:设置是否自动删除。autoDelete设置为true时，则表示自动删除。自动删除的前提是至少有一个队列或者交换器与这个交换器绑定，之后，所有与这个交换器绑定的队列或者交换器都与此解绑。
* 不能错误的理解—当与此交换器连接的客户端都断开连接时，RabbitMq会自动删除本交换器
* arguments:其它一些结构化的参数，比如：alternate-exchange
*/
channel.exchangeDeclare(exchangeName,exchangeType,true,false,null);
/**
* 声明一个队列
* durable:表示rabbitmq关闭删除队列
* autodelete:表示没有程序和队列建立连接 那么就会自动删除队列
* exclusive:有且只有一个消费者监听,服务停止的时候删除该队列
*
*/
channel.queueDeclare(queueName,true,false,false,null);
/**
* 队里和交换机绑定
*/
channel.queueBind(queueName,exchangeName,routingKey);
/**
* 创建一个消费者
*/
QueueingConsumer queueingConsumer = new QueueingConsumer(channel);
/**
* 开始消费
*/
channel.basicConsume(queueName,true,queueingConsumer);
while (true) {
QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
String reciverMessage = new String(delivery.getBody());
System.out.println("消费消息:-----"+reciverMessage);
}
}
}
3。DirrectExchangeProducter2
public static void main(String[] args) throws IOException, TimeoutException {
//创建连接工厂
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("192.168.159.8");
connectionFactory.setPort(5672);
connectionFactory.setVirtualHost("tuling");
connectionFactory.setUsername("smlz");
connectionFactory.setPassword("smlz");
//创建连接
Connection connection = connectionFactory.newConnection();
//创建channel
Channel channel = connection.createChannel();
//定义交换机名称
String exchangeName = "tuling.directchange";
//定义routingKey
String routingKey = "tuling.directchange.key11111111";
//消息体内容
String messageBody = "hello tuling ";
channel.basicPublish(exchangeName,routingKey,null,messageBody.getBytes());
}
}
二。fanout_change:
public class FanoutExchangeConsumer {
public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
//创建连接工厂
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("192.168.159.8");
connectionFactory.setPort(5672);
connectionFactory.setVirtualHost("tuling");
connectionFactory.setUsername("smlz");
connectionFactory.setPassword("smlz");
//创建连接
Connection connection = connectionFactory.newConnection();
//创建channel
Channel channel = connection.createChannel();
//声明交换机
String exchangeName = "tuling.fanoutexchange";
String exchangeType = "fanout";
channel.exchangeDeclare(exchangeName,exchangeType,true,true,null);
//声明队列
String quequName = "tuling.fanout.queue";
channel.queueDeclare(quequName,true,false,false,null);
//声明绑定关系
String bingdingStr = "jjsadf";
channel.queueBind(quequName,exchangeName,bingdingStr);
//声明一个消费者
QueueingConsumer queueingConsumer = new QueueingConsumer(channel);
//开始消费
/**
* 开始消费
*/
channel.basicConsume(quequName,true,queueingConsumer);
while (true) {
QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
System.out.println("接受到消息:"+new String(delivery.getBody()));
}
}
三，fanoutchange_productor:
public class FanoutExchangeProductor {
public static void main(String[] args) throws IOException, TimeoutException {
//创建连接工厂
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("192.168.159.8");
connectionFactory.setPort(5672);
connectionFactory.setVirtualHost("tuling");
connectionFactory.setUsername("smlz");
connectionFactory.setPassword("smlz");
//创建连接
Connection connection = connectionFactory.newConnection();
//创建channel
Channel channel = connection.createChannel();
//定义交换机名称
String exchangeName = "tuling.fanoutexchange";
//定义routingKey
String routingKey = "";
//消息体内容
String messageBody = "hello tuling ";
for(int i=0;i<1000;i++) {
channel.basicPublish(exchangeName,"123",null,(messageBody+i).getBytes());
}
/*channel.basicPublish(exchangeName,"456",null,"我是第二条消息".getBytes());
channel.basicPublish(exchangeName,"789",null,"我是第三条消息".getBytes());*/
}
}
Ⅲ.topic_change:
public static void main(String[] args) throws IOException, TimeoutException {
//创建连接工厂
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("192.168.159.8");
connectionFactory.setPort(5672);
connectionFactory.setVirtualHost("/");
connectionFactory.setUsername("smlz");
connectionFactory.setPassword("smlz");
//创建连接
Connection connection = connectionFactory.newConnection();
//创建channel
Channel channel = connection.createChannel();
//发送消息
String exchangeName = "policymaker.exchange";
String routingKey1 = "policymaker.key1";
String routingKey2 = "policymaker.key2";
String routingKey3 = "policymaker.key.key3";
channel.basicPublish(exchangeName,routingKey1,null,"我是第一条消息".getBytes());
channel.basicPublish(exchangeName,routingKey2,null,"我是第二条消息".getBytes());
channel.basicPublish(exchangeName,routingKey3,null,"我是第三条消息".getBytes());
}
}
public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
//创建连接工厂
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("192.168.159.8");
connectionFactory.setPort(5672);
connectionFactory.setVirtualHost("/");
connectionFactory.setUsername("smlz");
connectionFactory.setPassword("smlz");
//创建连接
Connection connection = connectionFactory.newConnection();
//创建channel
Channel channel = connection.createChannel();
//声明交换机
String exchangeName = "policymaker.exchange";
String exchangeType = "topic";
channel.exchangeDeclare(exchangeName,exchangeType,true,true,null);
//声明队列
String quequName = "policymaker.queue";
channel.queueDeclare(quequName,true,false,false,null);
//声明绑定关系
String bingdingStr = "policymaker.#";
channel.queueBind(quequName,exchangeName,bingdingStr);
//声明一个消费者
QueueingConsumer queueingConsumer = new QueueingConsumer(channel);
//开始消费
/**
* 开始消费
*/
channel.basicConsume(quequName,true,queueingConsumer);
while (true) {
QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
System.out.println("接受到消息:"+new String(delivery.getBody()));
}
}
}