RabbitMQ初使用

最新推荐文章于 2022-08-18 17:11:22 发布
最新推荐文章于 2022-08-18 17:11:22 发布
阅读量3.3k 收藏 1
点赞数
分类专栏： JAVA RabbitMQ 文章标签： rabbitmq java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Myueye/article/details/123483646
版权

RabbitMQ

地址

官方地址:https://www.rabbitmq.com
官方代码demo地址:https://www.rabbitmq.com/getstarted.html

使用Docker安装

docker安装RabbitMQ
docker pull rabbitmq:3.7.7-management
docker run  -itd --name rabbitmq    -p 5672:5672 -p 15672:15672   rabbitmq:3.7.7-management
#5672：应用访问端口；15672：控制台Web端口号

个人简单总结

hello word :方式–简单方式
使用默认转发
声明一个队列即可
一个生产者对应一个消费者,也可以多个消费者

work queue
一个生产者对应多个消费者
使用非自动确认&basicQos 限制每个通道的消费数量，达到视消费能力来分配资源

Publish/Subscribe(发布订阅模式–一般一个消费者一个队列)
创建一个路由器exchange ,生产者将消息全部发送到这个路由器
消费者创建随机队列(独占、自动删除、不持久化):当创建的时候就在监听

Direct：完全根据key进行投递的，例如，绑定时设置了routing key为”abc”，那么客户端提交的消息，只有设置了key为”abc”的才会投递到队列。
Topic：对key进行模式匹配后进行投递，符号”#”匹配一个或多个词，符号””匹配正好一个词。例如”abc.#”匹配”abc.def.ghi”，”abc.”只匹配”abc.def”。
这个* # 的匹配是以.号分隔为单词的的 22.22.22 这里是三个词 22.* 匹配的是22.22 不会匹配222

Fanout：不需要key，它采取广播模式，一个消息进来时，投递到与该交换机绑定的所有队列。
Headers:我们可以不考虑它。

Routing–在发布订阅模式中加入rout_key
Direct Exchange:直接路由

Topics-在Routing模式中加入模式匹配(类似*这种符号)

java代码使用

hello word

流程

在这里插入图片描述

生产者

import java.io.IOException;
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeoutException;

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

public class RabbitMQProducter {
	
	public static void main(String[] args) {
		ExecutorService executorService = Executors.newFixedThreadPool(3);
		
		executorService.submit(()->{
			//连接基本信息
			ConnectionFactory connectionFactory =new ConnectionFactory();
			connectionFactory.setUsername("guest");
			connectionFactory.setPassword("guest");
			connectionFactory.setHost("192.168.81.132");
			connectionFactory.setConnectionTimeout(10000);
			Random random = new Random();
			
			try {
				Connection connection = connectionFactory.newConnection();
				Channel channel = connection.createChannel();
				String message = String.valueOf(random.nextInt(1000));
				
				//创建空队列
				channel.queueDeclare("hello", true, false, false, null);
				long start = System.currentTimeMillis();
				int i = 0;
				while(true) {
					message = String.valueOf(i++);
					//发送消息
					channel.basicPublish("", "hello", null, message.getBytes("UTF-8"));
					System.out.println("send:\t"+message);
					
					Thread.sleep(500);
					if( (System.currentTimeMillis() - start)> 10*1000 ) {
						break;
					}
					
					
				}
				
				
				channel.close();
				
				connection.close();
				
			} catch (IOException | TimeoutException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			
		});
		
		executorService.shutdown();
	}
}

消费者

import java.io.IOException;
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeoutException;

import com.rabbitmq.client.AMQP.BasicProperties;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Consumer;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;

public class RabbitMQCustomer {
	public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(3);
		
		executorService.submit(()->{
			//连接
			ConnectionFactory connectionFactory =new ConnectionFactory();
			connectionFactory.setUsername("guest");
			connectionFactory.setPassword("guest");
			connectionFactory.setHost("192.168.81.132");
			Random random = new Random();
			
			try {
				Connection connection = connectionFactory.newConnection();
				Channel channel = connection.createChannel();
				
				channel.queueDeclare("hello", true, false, false, null);
				long start = System.currentTimeMillis();
				
				//消费者处理消息
				Consumer consumer = new DefaultConsumer(channel) {
					
					@Override
					public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties,
							byte[] body) throws IOException {
						String message = new String(body);
						System.out.println("get\t" + message);
					}
				};
				
				channel.basicConsume("hello", true, consumer);
				
			} catch (IOException | TimeoutException e) {
				e.printStackTrace();
			}
			
		});
		
		executorService.shutdown();
	}
}

Work queues

流程

在这里插入图片描述

生产者

代码使用Hello Word 的即可

消费者

消费者1
import java.io.IOException;
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeoutException;

import com.rabbitmq.client.AMQP.BasicProperties;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Consumer;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;

public class RabbitMQCustomerWork_1 {
	public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(3);
		
		executorService.submit(()->{
			ConnectionFactory connectionFactory =new ConnectionFactory();
			connectionFactory.setUsername("guest");
			connectionFactory.setPassword("guest");
			connectionFactory.setHost("192.168.81.132");
			Random random = new Random();
			
			try {
				Connection connection = connectionFactory.newConnection();
				Channel channel = connection.createChannel();
				
				channel.queueDeclare("hello", true, false, false, null);
				long start = System.currentTimeMillis();
				Consumer consumer = new DefaultConsumer(channel) {

					@Override
					public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties,
							byte[] body) throws IOException {
						String message = new String(body);
						System.out.println("work-1 get\t" + message);
						doWork();
						channel.basicAck(envelope.getDeliveryTag(), false);
					}
				};
				
				//限制每次未确认的最大消息数是2 --需要设置不自动确认才生效
				//自动确认的好处:等消息处理完后再返回确认，RabbitMQ 才会删除消息
				//依次处理消息，可以实现按需分配，做的快的就分配多一点，做得慢的就分配少一点
				channel.basicQos(2,false);
				channel.basicConsume("hello", false, consumer);
				
			} catch (IOException | TimeoutException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} 
			
		});
		
		executorService.shutdown();
	}
	
	
	public static void doWork() {
		try {
			System.out.println("work_1-----");
			//睡眠一分钟
			Thread.sleep(6000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}
消费者2
import java.io.IOException;
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeoutException;

import com.rabbitmq.client.AMQP.BasicProperties;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Consumer;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;

public class RabbitMQCustomerWork_2 {
	public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(3);
		
		executorService.submit(()->{
			ConnectionFactory connectionFactory =new ConnectionFactory();
			connectionFactory.setUsername("guest");
			connectionFactory.setPassword("guest");
			connectionFactory.setHost("192.168.81.132");
			Random random = new Random();
			
			try {
				Connection connection = connectionFactory.newConnection();
				Channel channel = connection.createChannel();
				
				channel.queueDeclare("hello", true, false, false, null);
				long start = System.currentTimeMillis();
				
				Consumer consumer = new DefaultConsumer(channel) {

					@Override
					public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties,
							byte[] body) throws IOException {
						String message = new String(body);
						System.out.println("work-2 get\t" + message);
						doWork();
						channel.basicAck(envelope.getDeliveryTag(), false);
					}
				};
				channel.basicQos(2,false);
				channel.basicConsume("hello", false, consumer);
				
			} catch (IOException | TimeoutException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			
		});
		
		executorService.shutdown();
	}
	
	public static void doWork() {
		try {
			System.out.println("work_2-----");
			//睡眠1s
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

Publish/Subscribe

流程

在这里插入图片描述

生产者

import java.io.IOException;
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeoutException;

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

public class ExchangeProducter {
	
	static final String EXCHANGE_NAME = "test_exchange";
	public static void main(String[] args) {
		ExecutorService executorService = Executors.newFixedThreadPool(3);
		
		executorService.submit(()->{
			ConnectionFactory connectionFactory =new ConnectionFactory();
			connectionFactory.setUsername("guest");
			connectionFactory.setPassword("guest");
			connectionFactory.setHost("192.168.81.132");
			connectionFactory.setConnectionTimeout(10000);
			Random random = new Random();
			
			try {
				Connection connection = connectionFactory.newConnection();
				Channel channel = connection.createChannel();
				
				channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.FANOUT);
				
				String message = String.valueOf(random.nextInt(1000));
				
				long start = System.currentTimeMillis();
				int i = 0;
				while(true) {
					message = String.valueOf(i++);
					channel.basicPublish(EXCHANGE_NAME, "", null, message.getBytes("UTF-8"));
					System.out.println("send:\t"+message);
					
					Thread.sleep(500);
					if( (System.currentTimeMillis() - start)> 10*1000 ) {
						break;
					}
				}
				
				channel.close();
				connection.close();
				
			} catch (IOException | TimeoutException e) {
				e.printStackTrace();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			
		});
		
		executorService.shutdown();
	}
}

消费者

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

import com.rabbitmq.client.AMQP.BasicProperties;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Consumer;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;

public class ExchangeConsumer_1 {
	
	public static void main(String[] args) {
		ExecutorService executorService = Executors.newFixedThreadPool(3);
				
				executorService.submit(()->{
					ConnectionFactory connectionFactory =new ConnectionFactory();
					connectionFactory.setUsername("guest");
					connectionFactory.setPassword("guest");
					connectionFactory.setHost("192.168.81.132");
					
					try {
						Connection connection = connectionFactory.newConnection();
						Channel channel = connection.createChannel();
						
						String queueName = channel.queueDeclare().getQueue();
						
						channel.queueBind(queueName, ExchangeProducter.EXCHANGE_NAME, "");
						
						long start = System.currentTimeMillis();
						Consumer consumer = new DefaultConsumer(channel) {

							@Override
							public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties,
									byte[] body) throws IOException {
								String message = new String(body);
								System.out.println("Consumer-1 get\t" + message);
								doWork();
								channel.basicAck(envelope.getDeliveryTag(), false);
							}
						};
						
						//限制每次未确认的最大消息数是2 --需要设置不自动确认才生效
						//自动确认的好处:等消息处理完后再返回确认，RabbitMQ 才会删除消息
						//依次处理消息，可以实现按需分配，做的快的就分配多一点，做得慢的就分配少一点
						channel.basicQos(2,false);
						channel.basicConsume(queueName, false, consumer);
						
					} catch (IOException | TimeoutException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					} 
					
				});
				
				executorService.shutdown();
			}
			
			
			public static void doWork() {
				try {
					System.out.println("Consumer-----");
					//睡眠一分钟
					Thread.sleep(6000);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
}

Routing

流程

在这里插入图片描述

生产者

import java.io.IOException;
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeoutException;

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

public class DirectExchangeProducter {
	
	static final String EXCHANGE_NAME = "test_direct_exchange";
	public static void main(String[] args) {
		ExecutorService executorService = Executors.newFixedThreadPool(3);
		
		executorService.submit(()->{
			ConnectionFactory connectionFactory =new ConnectionFactory();
			connectionFactory.setUsername("guest");
			connectionFactory.setPassword("guest");
			connectionFactory.setHost("192.168.81.132");
			connectionFactory.setConnectionTimeout(10000);
			Random random = new Random();
			
			try {
				Connection connection = connectionFactory.newConnection();
				Channel channel = connection.createChannel();
				
				channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
				
				String message = String.valueOf(random.nextInt(1000));
				
				long start = System.currentTimeMillis();
				String roule = null;
				int i = 0;
				while(true) {
					message = String.valueOf(i++);
					switch (i%3) {
					case 0:
						roule = "0";
						break;
					case 1:
						roule = "1";
						break;
					case 2:
						roule = "2";
						break;
					default:
						roule = "3";
						break;
					}
					
					channel.basicPublish(EXCHANGE_NAME, roule, null, message.getBytes("UTF-8"));
					System.out.println("send:\t"+message);
					
					Thread.sleep(500);
					if( (System.currentTimeMillis() - start)> 10*1000 ) {
						break;
					}
				}
				
				channel.close();
				connection.close();
				
			} catch (IOException | TimeoutException e) {
				e.printStackTrace();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			
		});
		
		executorService.shutdown();
	}
}

消费者

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

import com.rabbitmq.client.AMQP.BasicProperties;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Consumer;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;

public class DirectExchangeConsumer_1 {
	
	public static void main(String[] args) {
		ExecutorService executorService = Executors.newFixedThreadPool(3);
				
				executorService.submit(()->{
					ConnectionFactory connectionFactory =new ConnectionFactory();
					connectionFactory.setUsername("guest");
					connectionFactory.setPassword("guest");
					connectionFactory.setHost("192.168.81.132");
					
					try {
						Connection connection = connectionFactory.newConnection();
						Channel channel = connection.createChannel();
						
						String queueName = channel.queueDeclare().getQueue();
						
						String[] bindRoultKeys = {"1","2"};
						for (String key : bindRoultKeys) {
							channel.queueBind(queueName, DirectExchangeProducter.EXCHANGE_NAME, key);
						}
						
						
						long start = System.currentTimeMillis();
						Consumer consumer = new DefaultConsumer(channel) {

							@Override
							public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties,
									byte[] body) throws IOException {
								String message = new String(body);
								System.out.println("Consumer-1 get\t" + message);
								doWork();
								channel.basicAck(envelope.getDeliveryTag(), false);
							}
						};
						
						//限制每次未确认的最大消息数是2 --需要设置不自动确认才生效
						//自动确认的好处:等消息处理完后再返回确认，RabbitMQ 才会删除消息
						//依次处理消息，可以实现按需分配，做的快的就分配多一点，做得慢的就分配少一点
						channel.basicQos(2,false);
						channel.basicConsume(queueName, false, consumer);
						
					} catch (IOException | TimeoutException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					} 
					
				});
				
				executorService.shutdown();
			}
			
			
			public static void doWork() {
				try {
					System.out.println("Consumer-----");
					//睡眠一分钟
					Thread.sleep(6000);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
}

Topics

流程

在这里插入图片描述

生产者

import java.io.IOException;
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeoutException;

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

public class TopicExchangeProducter {
	
	static final String EXCHANGE_NAME = "test_topic_exchange";
	public static void main(String[] args) {
		ExecutorService executorService = Executors.newFixedThreadPool(3);
		
		executorService.submit(()->{
			ConnectionFactory connectionFactory =new ConnectionFactory();
			connectionFactory.setUsername("guest");
			connectionFactory.setPassword("guest");
			connectionFactory.setHost("192.168.81.132");
			connectionFactory.setConnectionTimeout(10000);
			Random random = new Random();
			
			try {
				Connection connection = connectionFactory.newConnection();
				Channel channel = connection.createChannel();
				
				channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC);
				
				String message = String.valueOf(random.nextInt(1000));
				
				long start = System.currentTimeMillis();
				String roule = null;
				int i = 0;
				while(true) {
					message = String.valueOf(i++);
					switch (i%3) {
					case 0:
						roule = "1.1.1";
						break;
					case 1:
						roule = "1.2";
						break;
					case 2:
						roule = "2.1";
						break;
					default:
						roule = "2.2";
						break;
					}
					channel.basicPublish(EXCHANGE_NAME, roule, null, message.getBytes("UTF-8"));
					System.out.println("send:\t"+message+"\t roult:"+roule);
					
					Thread.sleep(500);
					if( (System.currentTimeMillis() - start)> 10*1000 ) {
						break;
					}
				}
				
				channel.close();
				connection.close();
				
			} catch (IOException | TimeoutException e) {
				e.printStackTrace();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			
		});
		
		executorService.shutdown();
	}
}

消费者

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

import com.rabbitmq.client.AMQP.BasicProperties;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Consumer;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;

public class TopicExchangeConsumer_1 {
	
	public static void main(String[] args) {
		ExecutorService executorService = Executors.newFixedThreadPool(3);
				
				executorService.submit(()->{
					ConnectionFactory connectionFactory =new ConnectionFactory();
					connectionFactory.setUsername("guest");
					connectionFactory.setPassword("guest");
					connectionFactory.setHost("192.168.81.132");
					
					try {
						Connection connection = connectionFactory.newConnection();
						Channel channel = connection.createChannel();
						
						String queueName = channel.queueDeclare().getQueue();
						
						channel.queueBind(queueName, TopicExchangeProducter.EXCHANGE_NAME, "1.*");
						
						
						long start = System.currentTimeMillis();
						Consumer consumer = new DefaultConsumer(channel) {

							@Override
							public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties,
									byte[] body) throws IOException {
								String message = new String(body);
								System.out.println("Consumer-1 get\t" + message);
								doWork();
								channel.basicAck(envelope.getDeliveryTag(), false);
							}
						};
						
						//限制每次未确认的最大消息数是2 --需要设置不自动确认才生效
						//自动确认的好处:等消息处理完后再返回确认，RabbitMQ 才会删除消息
						//依次处理消息，可以实现按需分配，做的快的就分配多一点，做得慢的就分配少一点
						channel.basicQos(2,false);
						channel.basicConsume(queueName, false, consumer);
						
					} catch (IOException | TimeoutException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					} 
					
				});
				
				executorService.shutdown();
			}
			
			
			public static void doWork() {
				try {
					System.out.println("Consumer-----");
					//睡眠一分钟
					Thread.sleep(2000);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
}
Myueye
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
rabbitmq第一次使用
m0_37924505的博客
03-19 254
当类被@Scope(BeanDefination.SCOPE_PROTOTYPE)修饰时，说明每次依赖注入时，都会产生新的对象
RabbitMQ初步使用
狮子头儿的博客
06-04 430
windows安装rabbitMQ下载rabbitMQ，安装版本为3.7.5，安装rabbitMQ需要首先安装Erlang，从官网下载速度很慢。为了方便后续学习者使用，已经将两个安装包上传至百度网盘。下载链接链接：https://pan.baidu.com/s/1IR-i5EOl5jlRxaH51u8inQ 密码：i4aaotp_win64_20.3.exe、rabbitmq-server-3.7...
Java与RabbitMQ（一） 第一次使用安装RabbitMQ教程
青山师
09-21 2326
Windows环境使用rabbitmq下载rabbitmq安装文件官网下载地址： http://www.rabbitmq.com/download.html, 点击如图绿色框内容进入到下载页面：点击要下载的*.msi安装文件到计算机，如图：下载完成后点击安装，提示需要安装elang（因为rabbitmq是erlang编写的，需要erlang语言支持），按提示安装erlang后，再安装rabbitmq
RabbitMQ 的这些骚操作你知道吗？
weixin_50666791的博客
10-15 905
RabbitMQ的Java客户端统一使用com.rabbitmq.client作为顶级包名。其中，最核心的类主要有：ConnectionFactory、Connection、Channel、Consumer、DefaultConsumer、BasicProperties。需要说明的是，本文不只是教你RabbitMQ客户端的基本玩法，还有一些你可能不知道的一些骚操作。 连接RabbitMQ 使用RabbitMQ第一步当然是连接RabbitMQ，这里就不说怎么搭建RabbitMQ环境了，本文假设你.
消息队列rabbitMQ初次使用
你是我的OO皮
04-25 321
rabbitMq初次使用
一、RabbitMQ初使用（Consumer）
ZER_xy的博客
12-23 523
@[TOC]RabbieMQ使用过程中的小问题 在rabbitmq的使用过程中，记录一些自己的使用问题 因为在我当前的项目中，我只是一个独立的分析jar，各位看官按自己需求修改 首先是pom引用： <dependency> <groupId>com.rabbitmq</groupId> <artifactId>amqp-client</artifactId> <version>5.1.2</ver
task_bunny：TaskBunny是用Elixir编写的后台处理应用程序，并使用RabbitMQ作为消息传递后端
02-05
TaskBunny是一个基于Elixir构建的后台处理应用程序，它的核心设计目标是利用RabbitMQ作为...通过深入研究这些文件，我们可以更详细地了解TaskBunny的实现细节，学习如何使用Elixir和RabbitMQ构建类似的后台处理系统。
rabbitmq-server-windows-3.8.19.zip
09-06
最后，RabbitMQ提供了丰富的客户端库，支持多种编程语言，如Java、Python、Ruby、.NET等，方便开发者在不同平台上使用RabbitMQ进行异步通信。 总之，RabbitMQ是一个强大且灵活的消息中间件，适用于构建可扩展、可靠...
头歌springboot初体验
最新发布
05-27
它集成了大量常用的第三方库配置，如JDBC、MongoDB、RabbitMQ、Quartz等，使得开发者可以快速地创建一个独立的、生产级别的基于Spring的Java应用程序。 在"头歌springboot初体验"中，我们可以探讨以下几个关键知识...
node-rabbitmq-configure:根据消费者和生产者端的通用 JSON 配置文件自动配置 RabbitMQ 交换、队列、绑定和其他内容，并带有角色条件
06-17
根据消费者和生产者端的通用 JSON 配置文件，使用角色条件自动配置 RabbitMQ 交换、队列、绑定和其他内容。 我很懒。 AMQP 库的包装。 用法 待定 应用程序接口 构造函数 ..（[选项]） 方法 发布（） 连接（服务器...
2020年初最新版Rabbit MQ 和 Erlang.rar
02-20
4. 根据提供的安装教程，了解如何启动和停止RabbitMQ服务，以及如何使用管理界面进行监控和管理。 通过深入理解RabbitMQ的架构和Erlang OTP的优势，开发者可以有效地利用这些技术构建稳定、高效的分布式系统。在...
rabbitmq 初次使用
weixin_41282397的博客
12-18 417
rabbitmq 初次使用   目标： 1.使用rabbitmq UI 界面 步骤： 1. https://blog.csdn.net/zheng911209/article/details/49949303   e.g. #查询用户列表  ./rabbitmqadmin -f long list users  --username=teleinfo --password=12...
error occurred ErrorResponse(code = InvalidAccessKeyId, message = The Access Key Id you provided doe
Myueye的博客
02-25 5123
报错信息如下: error occurred ErrorResponse(code = InvalidAccessKeyId, message = The Access Key Id you provided does not exist in our records.....) .... response={code=403, headers=Accept-Ranges: bytes Content-Length: 312 Content-Security-Policy: block-all-mixed-
字符串的编码格式转换
Myueye的博客
08-18 4725
主要的思路就是先将字符串正常化,然后就可以按照指定编码进行编码解码。开发工具是STS,默认的编码格式是UTF-8。本次主要是UTF-8和GBK之间的相互转换。
java.nio.channels.UnresolvedAddressException
Myueye的博客
03-31 2872
RocketMq和Redis的netty版本冲突报错信息如下排查原因解决办法分析 报错信息如下 java.nio.channels.UnresolvedAddressException … Unable to connect to Redis; nested exception is org.springframework.data.redis.connection.PoolException: Could not get a resource from the pool; nested exception
redis插入大量key
Myueye的博客
03-17 2792
redis插入大量key工具代码顺序插入多线程&资源池插入使用pip测试结果 工具代码 import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicInteger; import redis.clients.jedis.Jedis; i
解决mybatis查询时间的时候多出一个0
Myueye的博客
07-12 2668
我数据库时间类型为Timestamp,查询后的时间多了个0；解决办法有如下: 1.将时间转换成字符串，并截取所需要的部分： String time = date.toString(); time.substring(0, time.indexOf(".")); 2:.使用SimpleDateFormat将字符串格式化: SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); String time = sdf.format(d
socket流的关闭
Myueye的博客
06-15 2650
在使用socket进行全双工通信时，原本以为输入流和输出流是分开关闭的，然而不管关闭哪个都会直接关闭socket;可以使用socket.shutdownInput()和socket.shutdownOutput() 客户端 使用InputStream 进入bebug模式，在执行到 inputStream.close()后进入SocketInputStream的close()方法，而这个方法是关闭socket流 执行reader.close()后，最后也是执行SocketInputStream的close(
rabbitmq运维
09-22
RabbitMQ的消息存储在队列中，因此在架构设计之初需要预估队列的使用情况。队列的使用情况会真正耗费服务器的性能，所以衡量RabbitMQ当前的每秒查询率时，只需关注队列即可。为了运维RabbitMQ，你可以使用命令...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值