rabbitmq+学习手册
Rabbitmq基本API使用
Rabbitmq基本API使⽤⼀、⽣产者1. 创建ConnectionFactory⼯⼚（地址、⽤户名、密码、vhost）2. 创建Connection3. 创建信道（Channel）4. 创建 exchange（指定名称、类型-DIRECT("direct"), FANOUT("fanout"), TOPIC("topic"), HEADERS("headers");、是否持久化）5. 发送消息（指定：exchange、发送的routingKey ，发送到的消息）基础的⽣产者：public class TestProducer {public final static String EXCHANGE_NAME = "direct_logs";public static void main(String[] args)throws IOException, TimeoutException {/* 创建连接,连接到RabbitMQ*/ConnectionFactory connectionFactory = new ConnectionFactory();connectionFactory.setHost("192.168.112.131");connectionFactory.setVirtualHost("my_vhost");connectionFactory.setUsername("admin");connectionFactory.setPassword("admin");Connection connection = connectionFactory.newConnection();/*创建信道*/Channel channel = connection.createChannel();/*创建交换器*/channel.exchangeDeclare(EXCHANGE_NAME,"direct");//channel.exchangeDeclare(EXCHANGE_NAME,BuiltinExchangeType.DIRECT);/*⽇志消息级别，作为路由键使⽤*/String[] routekeys = {"king","queue","prince"};for(int i=0;i<3;i++){String routekey = routekeys[i%3];String msg = "Hellol,RabbitMq"+(i+1);/*发布消息，需要参数：交换器，路由键，其中以⽇志消息级别为路由键*/channel.basicPublish(EXCHANGE_NAME,routekey,null,msg.getBytes());System.out.println("Sent "+routekey+":"+msg);}channel.close();connection.close();}}View Code⼆、消费者1. 创建ConnectionFactory⼯⼚（地址、⽤户名、密码、vhost）2. 创建Connection3. 创建信道（Channel）4. 声明⼀个 exchange（指定名称、类型、是否持久化）5. 创建⼀个队列（指定：名称，是否持久化，是否独占，是否⾃动删除，其他参数）6. 队列、exchange通过routeKey进⾏绑定7. 消费者接收消息（队列名称，是否⾃动ACK）基本的消费者：public class TestConsumer {public static void main(String[] argv)throws IOException, TimeoutException {ConnectionFactory factory = new ConnectionFactory();factory.setHost("192.168.112.131");factory.setVirtualHost("my_vhost");factory.setUsername("admin");factory.setPassword("admin");// 打开连接和创建频道，与发送端⼀样Connection connection = factory.newConnection();final Channel channel = connection.createChannel();channel.exchangeDeclare(TestProducer.EXCHANGE_NAME,"direct");/*声明⼀个队列*/String queueName = "focuserror";channel.queueDeclare(queueName,false,false,false,null);/*绑定，将队列和交换器通过路由键进⾏绑定*/String routekey = "king";/*表⽰只关注error级别的⽇志消息*/channel.queueBind(queueName,TestProducer.EXCHANGE_NAME,routekey);System.out.println("waiting for message........");/*声明了⼀个消费者*/final Consumer consumer = new DefaultConsumer(channel){@Overridepublic void handleDelivery(String consumerTag,Envelope envelope,AMQP.BasicProperties properties,byte[] body) throws IOException {String message = new String(body, "UTF-8");System.out.println("Received["+envelope.getRoutingKey()+"]"+message);}};/*消费者正式开始在指定队列上消费消息*/channel.basicConsume(queueName,true,consumer);}}View Code三、消息持久化1. exchange 需要持久化2. 发送消息设置参数为 MessageProperties.PERSISTENT_TEXT_PLAIN3. 队列需要设置参数为持久化1、//TODO 创建持久化交换器 durable=truechannel.exchangeDeclare(EXCHANGE_NAME,"direct",true);2、//TODO 发布持久化的消息(delivery-mode=2)channel.basicPublish(EXCHANGE_NAME,routekey,MessageProperties.PERSISTENT_TEXT_PLAIN,msg.getBytes());3、//TODO 声明⼀个持久化队列(durable=true)// autoDelete=true 消费者停⽌了，则队列会⾃动删除//exclusive=true独占队列，只能有⼀个消费者消费String queueName = "msgdurable";channel.queueDeclare(queueName,true,false,false,null);四、如何⽀持事务（防⽌投递消息的时候消息丢失-效率特别低，不建议使⽤，可以使⽤⽣产者ACK机制）1. 启动事务2. 成功提交3. 失败则回滚//TODO//加⼊事务channel.txSelect();try {for(int i=0;i<3;i++){String routekey = routekeys[i%3];// 发送的消息String message = "Hello World_"+(i+1)+("_"+System.currentTimeMillis());channel.basicPublish(EXCHANGE_NAME, routekey, true,null, message.getBytes());System.out.println("----------------------------------");System.out.println(" Sent Message: [" + routekey +"]:'"+ message + "'");Thread.sleep(200);}//TODO//事务提交channel.txCommit();} catch (IOException e) {e.printStackTrace();//TODO//事务回滚channel.txRollback();} catch (InterruptedException e) {e.printStackTrace();}View Code五、消费消息⼿动ACK，如果异常则使⽤拒绝的⽅式，然后异常消息推送到-死信队列批量ack的时候如果其中有⼀个消息出现异常，则会导致消息丢失（⽇志处理的时候可以使⽤批量）1 /*消费者正式开始在指定队列上消费消息，第⼆个参数false为⼿动应答*/channel.basicConsume(queueName,false,consumer);2 收到消息以后，⼿动应答数据接收成功channel.basicAck(envelope.getDeliveryTag(),false);3 收到消息，如果处理失败则拒绝消息：DeliveryTag是消息在队列中的标识channel.basicReject(envelope.getDeliveryTag(),false);4 决绝的参数说明//TODO Reject⽅式拒绝(这⾥第2个参数决定是否重新投递),不要重复投递，因为消息重复投递后处理可能依然异常//channel.basicReject(envelope.getDeliveryTag(),false);//TODO Nack⽅式的拒绝（第2个参数决定是否批量,第3个参数是否重新投递）channel.basicNack(envelope.getDeliveryTag(), false, true);View Code六、创建队列的参数解析：场景，延迟队列，保存带有时效性的订单，⼀旦订单过期，则信息会转移到死信队列//TODO /*⾃动过期队列--参数需要Map传递*/String queueName = "setQueue";Map<String, Object> arguments = new HashMap<String, Object>();arguments.put("x-expires",10*1000);//消息在队列中保存10秒后被删除//TODO 队列的各种参数/*加⼊队列的各种参数*/// autoDelete=true 消费者停⽌了，则队列会⾃动删除//exclusive=true独占队列，只能有⼀个消费者消费channel.queueDeclare(queueName,true,true, false,arguments);七、发送消息以后带有应答的队列1. 声明⼀个回应队列2. 声明⼀个回应消息的消费者3. 声明⼀个属性对象（指定队列，会唯⼀的id）4. ⽣产者发送消息给消费者（带着回应队列）5. 消费者接收到消息以后根据对应的信息，给予回应⽣产者端：1、//TODO 响应QueueName ，消费者将会把要返回的信息发送到该QueueString responseQueue = channel.queueDeclare().getQueue();//TODO 消息的唯⼀idString msgId = UUID.randomUUID().toString();2、/*声明了⼀个消费者*/final Consumer consumer = new DefaultConsumer(channel){@Overridepublic void handleDelivery(String consumerTag,Envelope envelope,AMQP.BasicProperties properties,byte[] body) throws IOException {String message = new String(body, "UTF-8");System.out.println("Received["+envelope.getRoutingKey()+"]"+message);}};//TODO 消费者应答队列上的消息channel.basicConsume(responseQueue,true,consumer);3、//TODO 设置消息中的应答属性AMQP.BasicProperties properties = new AMQP.BasicProperties.Builder().replyTo(responseQueue).messageId(msgId).build();4、String msg = "Hello,RabbitMq";//TODO 发送消息时，把响应相关属性设置进去channel.basicPublish(EXCHANGE_NAME,"error",properties,msg.getBytes());View Code消费者端：String message = new String(body, "UTF-8");System.out.println("Received["+envelope.getRoutingKey()+"]"+message);//TODO 从消息中拿到相关属性（确定要应答的消息ID,）AMQP.BasicProperties respProp= new AMQP.BasicProperties.Builder().replyTo(properties.getReplyTo()).correlationId(properties.getMessageId()).build();//TODO 消息消费时，同时需要⽣作为⽣产者⽣产消息（以OK为标识）channel.basicPublish("", respProp.getReplyTo() ,respProp ,("OK,"+message).getBytes("UTF-8"));⼋、死信队列 - 下列消息会放到死信队列1. 消息被否定确认，使⽤ channel.basicNack 或 channel.basicReject ，并且此时requeue 属性被设置为false。
RabbitMQ-常用消息队列之：Worker模式（一对多模式）
RabbitMQ-常⽤消息队列之：Worker模式（⼀对多模式）Producer：消息的⽣产者（发送消息的程序）。
Queue：消息队列，理解为⼀个容器，⽣产者向它发送消息，它把消息存储，等待消费者消费。
Consumer：消息的消费者（接收消息的程序）。
此处我们假设 Consumer1、Consumer2、Consumer3 分别为完成任务速度不⼀样快的消费者，这会引出此模式的⼀个重点问题。
如何理解： ⼯作模式由图可以看出，就是在简单队列模式的基础上，增加了多个消费者，也就是让多个消费者绑定同⼀个队列，共同去消费，这样能解决简单队列模式中，如果⽣产速速远⼤于消费速度，⽽导致的消息堆积现象。
因为消息被消费后就会消失，所以不必担⼼任务会重复执⾏。
代码实现： 注：⼯作队列模式有两种1. 轮询模式：每个消费者均分消息2. 公平分发模式（能者多劳）：按能⼒分发，处理速度快的分发的多，处理速度慢的分发的少Worker模式 Worker模式其实就是⼀对多模式，我们定义两个消费者来看看效果： 默认情况下，RabbitMQ会顺序的将message发给下⼀个消费者。
每个消费者会得到平均数量的message。
这种⽅式称之为round-robin（轮询)。
但是很多情况下并不希望消息平均分配,⽽是要消费快的多消费,消费少的少消费.还有很多情况下⼀旦其中⼀个宕机,那么另外接收者的⽆法接收原本这个接收者所要接收的数据。
我们修改其中⼀个消费者代码,让其等待5秒。
在等待中停⽌运⾏看看效果。
consumer.Received += (ch, ea) =>{string message = Encoding.Default.GetString(ea.Body.ToArray());Console.WriteLine($"接受到消息：{message}");Thread.Sleep(5000);}; 当消费者宕机后消费者1并没有接受宕机后的数据。
rabbitmq的使用方法
rabbitmq的使用方法RabbitMQ是一个开源的消息代理软件，用于实现异步消息传递。
以下是使用RabbitMQ的一些基本方法：1. 安装和配置：首先，你需要从RabbitMQ的官网下载并安装RabbitMQ 服务器。
安装完成后，你可以通过浏览器访问RabbitMQ的管理界面，进行基本的配置。
2. 创建队列：在RabbitMQ中，消息被存储在队列中。
你可以使用RabbitMQ的管理界面或者通过编程的方式创建队列。
例如，使用Python 的pika库，你可以这样创建一个队列：```pythonimport pikaconnection = (('localhost'))channel = ()_declare(queue='hello')()```3. 发送消息：一旦你创建了队列，你就可以开始发送消息到这个队列。
同样使用pika库，你可以这样发送消息：```pythonimport pikaconnection = (('localhost'))channel = ()_publish(exchange='', routing_key='hello', body='Hello World!') ()```4. 接收消息：要接收消息，你需要创建一个消费者来从队列中获取消息。
消费者可以是任何能够处理RabbitMQ消息的应用程序。
例如，你可以创建一个Python消费者来接收消息：```pythonimport pikaconnection = (('localhost'))channel = ()_declare(queue='hello')def callback(ch, method, properties, body):print(f" [x] Received {body}")_consume(queue='hello', on_message_callback=callback,auto_ack=True)print(' [] Waiting for messages. To exit press CTRL+C')_consuming()```5. 确认消息处理：在RabbitMQ中，你可以选择自动确认（auto_ack）或手动确认（manual_ack）消息处理。
RabbitMQ学习步骤
RabbitMQ主要学习步骤1.了解 RabbitMQ的基本概念：学习 RabbitMQ的基本语法、消息类型、监听事件等。
2.学习 RabbitMQ的实现原理：了解 RabbitMQ的体系结构，包括队列、消息循环、线程池等。
3.学习 RabbitMQ的使用：通过阅读相关书籍、教程和实践项目，了解RabbitMQ的具体应用。
4.练习编写实际的项目：通过编写实际的项目，掌握 RabbitMQ的应用场景和实现技巧。
5.了解 RabbitMQ与其他 Java平台集成：通过阅读相关书籍、教程和实践项目，了解 RabbitMQ与其他 Java平台集成的方式和方法。
RabbitMQ详细学习步骤RabbitMQ是一款分布式消息队列，用于实时传输文件和数据。
下面是一个详细的学习步骤，以帮助您学会 abbitMQ：1、选择一款合适的分布式系统开发工具：选择一款适合进行分布式数据处理和传输的工具，如 Git、 ExtJS等。
2、安装 abbitMQ：通过安装 abbitMQ来初始化系统，并确保它们支持各种分布式系统。
3、配置 abbitMQ以支持各种分布式系统，如 JVM、 ElasticSearch等。
4、创建一个或多个进程来运行 abbitMQ，并配置其相关参数以支持分布式数据处理和传输。
5、编写代码：使用 abbitMQ编写各种类型的数据传输代码，并练习根据不同的用途灵活使用 abbitMQ。
6、测试和运行项目：通过测试和运行项目来验证 abbitMQ的功能和性能，并逐渐提高您的技能水平。
7、了解 abbitMQ与其他 Java平台集成：通过了解 abbitMQ与其他 Java 平台集成，如 ElasticSearch、 ExtJS等，以提高您的开发效率。
8、建议先学习一下 Java语言和分布式系统知识，这对学习 abbitMQ非常有帮助。
RabbitMQ笔记-Demo（C#）
private void btnTopicPublish_Click(object sender, EventArgs e) {
string exchangeName = "myTopicExchange1"; string queueName1 = "topic_queue1"; string queueName2 = "topic_queue2";
using (var channel = connection.CreateModel())
{ channel.ExchangeDeclare("myTopicExchange1", ExchangeType.Topic, true, false, null); channel.QueueDeclare(queueName1, true, false, false, null); channel.QueueDeclare(queueName2, true, false, false, null); channel.QueueBind(queueName1, exchangeName, "#.cn", null); channel.QueueBind(queueName2, exchangeName, "*.cn", null);
//发布info消息(消息会发送到两个队列，因为都匹配) for (int i = 0; i < 100; i++) {
var msg = Encoding.UTF8.GetBytes($"{i}:haha"); channel.BasicPublish(exchangeName, "", null, msg); } } }
rabbitmq basicconsume方法的arguments参数
rabbitmq basicconsume方法的arguments参数RabbitMQ是一款广泛使用的消息队列系统，它提供了许多功能强大的特性，如消息传递、可靠性保证、消息持久化等。
在RabbitMQ中，使用BasicConsume方法可以开始消费队列中的消息。
这个方法接受一些重要的参数，以下是关于这些参数的详细解释和用法指南。
一、参数详解1. consumer_tag：一个唯一标识符，用于标记消费者实例。
每当消费者从队列中消费完一条消息后，它的标识符都需要被重置为空字符串。
2. queue：要消费的队列名称。
这是必须的参数，因为RabbitMQ只会向指定的队列发送消息。
3. autoack：一个布尔值，用于决定是否在收到消息后自动确认并回传给服务器。
如果设置为true，那么消费者在处理完消息后需要调用BasicDeliver方法的第二个参数中的ack方法进行确认。
4. exclusive：一个布尔值，用于决定是否创建一个排他性（Exclusive）的消费者。
如果设置为true，那么这个消费者将只能消费这个队列的消息，而不会影响到其他消费者。
5. no_local：一个布尔值，用于决定是否阻止从本地队列发送消息到这个消费者。
通常这个参数是关闭的（false）。
6. wait：一个布尔值，决定是否等待消费者订阅的队列是否有新消息产生。
当设置为true时，程序将一直等待直到队列中有新消息可用为止。
7. auto_detect：这是一个指示器，当设置为true时，RabbitMQ将自动检测队列的变化并重新订阅。
二、使用示例以下是一个使用BasicConsume方法的简单示例：```pythonimport pikaconnection =pika.BlockingConnection(pika.ConnectionParameters('localhost' ))channel = connection.channel()channel.queue_declare(queue='my_queue')consumer_tag = channel.basic_consume(queue='my_queue', auto_ack=True)while True:# 获取并处理消息...connection.process_data_events()# 当处理完一条消息后，需要调用ack方法确认消息已被处理if consumer_tag:channel.basic_ack(consumer_tag,delivery_tag='<delivery-tag>')else:breakconnection.close()```在这个示例中，我们首先创建了一个到本地RabbitMQ服务器的连接，然后声明了一个名为'my_queue'的队列。
rabbitmq使用手册
rabbitmq使用手册RabbitMQ是一种开源的消息队列中间件，采用AMQP协议，被广泛应用于构建可靠、高效的分布式系统。
本手册将详细介绍RabbitMQ 的安装、配置、使用和常见问题解决方案，帮助读者快速上手使用RabbitMQ。
第一章安装与配置1.1 环境准备在开始安装RabbitMQ之前，需要确保系统满足以下要求：操作系统（例如Linux、Windows）、Erlang运行时环境以及RabbitMQ软件包。
1.2 安装RabbitMQ按照文档提供的方式，在所选的操作系统上安装RabbitMQ。
安装过程中需注意版本兼容性和安全配置。
1.3 配置RabbitMQ在安装完成后，需要对RabbitMQ进行适当的配置。
主要包括网络配置、认证与授权、虚拟主机、交换机和队列的创建等。
第二章消息发布与订阅2.1 消息生产者通过使用RabbitMQ的API，开发者可以编写生产者代码将消息发布到RabbitMQ的交换机上。
这里需要注意消息的序列化和指定交换机名称。
2.2 消息消费者RabbitMQ的消费者通过订阅交换机的队列来接收消息，可以使用RabbitMQ的API编写消费者代码，并实现消息的处理逻辑。
2.3 消息确认机制RabbitMQ提供了消息的确认机制，确保消息在传输过程中的可靠性。
开发者可以选择隐式确认或显式确认来保证消息的消费状态。
第三章消息路由与过滤3.1 路由模式RabbitMQ支持多种路由模式，如直接路由、主题路由和广播路由。
开发者可以根据实际需求选择最适合的路由模式。
3.2 消息过滤通过使用RabbitMQ的消息过滤功能，可以根据消息的属性进行过滤，只有满足条件的消息才会被消费者接收。
第四章高级特性与扩展4.1 持久化使用RabbitMQ的持久化机制，可以确保消息在服务器重启后依然存在，防止消息丢失。
4.2 集群与高可用通过搭建RabbitMQ集群，可以提高系统的可用性和扩展性。
在集群中，消息将自动在节点之间进行复制。
C#教程之C#教程之RabbitMQ基础入门篇
C#教程之C#教程之RabbitMQ基础⼊门篇作者：warren来源：/声明：原创博客请在转载时保留原⽂链接或者在⽂章开头加上本⼈博客地址，如发现错误，欢迎批评指正。
凡是转载于本⼈的⽂章，不能设置打赏功能，如有特殊需求请与本⼈联系！下载安装ErlangRabbitMQ启动RabbitMQ管理平台插件DOS下进⼊到安装⽬录\sbin,执⾏以下命令rabbitmq-plugins enable rabbitmq_management当出现以下结果时，重启RabbitMQ服务set 3 plugins.Offline change; changes will take effect at broker restart.注意：以下为C#代码，请引⽤NuGet包：RabbitMQ.Client回到顶部参考⽂章RabbitMQ快速⼊门回到顶部名词解析P（Publisher）：⽣产者C（Consumer）：消费者Channel：信道Queue：队列Exchange：信息交换机回到顶部简单演⽰信息发送端static void Send(){//1. 实例化连接⼯⼚var factory = new ConnectionFactory() { HostName = "localhost" };//2. 建⽴连接using (var connection = factory.CreateConnection()){//3. 创建信道using (var channel = connection.CreateModel()){//4. 声明队列channel.QueueDeclare(queue: "rabbitmq",durable: false,exclusive: false,autoDelete: false,arguments: null);//5. 构建字节数据包var message = "Hello RabbitMQ!";var body = Encoding.UTF8.GetBytes(message);//6. 发送数据包channel.BasicPublish(exchange: "",routingKey: "rabbitmq",basicProperties: null,body: body);Console.WriteLine(" [x] Sent {0}", message);}}}信息接收端static void Receive(){//1. 实例化连接⼯⼚var factory = new ConnectionFactory() { HostName = "localhost" };//2. 建⽴连接using (var connection = factory.CreateConnection()){//3. 创建信道using (var channel = connection.CreateModel()){//4. 声明队列channel.QueueDeclare(queue: "rabbitmq",durable: false,exclusive: false,autoDelete: false,arguments: null);//5. 构造消费者实例var consumer = new EventingBasicConsumer(channel);//6. 绑定消息接收后的事件委托consumer.Received += (model, ea) =>{var message = Encoding.UTF8.GetString(ea.Body);Console.WriteLine(" [x] Received {0}", message);};//7. 启动消费者channel.BasicConsume(queue: "rabbitmq",autoAck: true,consumer: consumer);Console.WriteLine(" Press [enter] to exit.");Console.ReadLine();}}}回到顶部轮询调度P⽣产的多个任务进⼊到队列中，多个C间可以并⾏处理任务。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
远。 与JMS不同，AMQP是一个Wire级的协议，它描述了在网络上传输的数据的格式，以字节为流。因此任何
private static Connection connection; static { ConnectionParameters params = new ConnectionParameters(); ConnectionFactory factory = new ConnectionFactory(params); try { connection = factory.newConnection("localhost", AMQP.PROTOCOL.PORT); } catch (IOException e) { e.printStackTrace(); } } public void testReceive() { try { Channel channel = connection.createChannel(); System.out.println(channel.toString()); Assert.assertNotNull(channel); channel.exchangeDeclare("exchangeName", "direct"); channel.queueDeclare("queueName"); channel.queueBind("queueName", "exchangeName", "routingKey"); boolean noAck = false; GetResponse response = channel.basicGet("queueName", true); if (response == null) { System.out.println("No message retrieved."); } else { AMQP.BasicProperties props = response.getProps(); byte[] body = response.getBody(); System.out.println(new String(body)); } } catch (IOException e) { e.printStackTrace(); } } } 先执行下发送端，再执行下接收端，输出：hello world ok
Redhat、iMatix 等联合制定了 AMQP 的公开标准。 Introduction: RabbitMQ is a complete and highly reliable enterprise messaging system based on the emerging AMQP
standard. It is licensed under the open source Mozilla Public License and has a platform-neutral distribution, plus platform-specific packages and bundles for easy installation.
Web控制台，还有许多企业级特征，客户端支持C++、Ruby、Java、JMS、Python和.NET。 4）RabbitMQ 一 个独立的开源实现，服务器端用Erlang语言编写，支持多种客户端，如：Python、Ruby、.NET、
Java、JMS、C、PHP、 ActionScript、XMPP、STOMP等，支持AJAX。RabbitMQ发布在 Ubuntu、FreeBSD平台。 5）AMQP Infrastructure Linux下，包括Broker、管理工具、Agent和客户端。 6）?MQ 一个高性能的消息平台，在分布式消息网络可作为兼容AMQP的Broker节点，绑定了多种语言，包括
若下载的是rabbitmq-server-generic-unix-1.7.2.tar.gz，可以直接解压，像windows上一样启动，然后使用 即可
rabbitmq 学习-3-初试1
本例是一个简单的异步发送消息实例 1，发送端 @Test(groups = { "sunjun" }) public class RabbitmqTest {
Python、C、C++、Lisp、Ruby等。
7）Zyre
是一个Broker，实现了RestMS协议和AMQP协议，提供了RESTful HTTP访问网络AMQP的能力。
RabbitMQ 是一个由 Erlang 写成的 Advanced Message Queuing Protocol (AMQP) 实现，AMQP 的出现
private static Connection connection; static { ConnectionParameters params = new ConnectionParameters(); ConnectionFactory factory = new ConnectionFactory(params); try { connection = factory.newConnection("192.168.18.21",
rabbitmq 学习-2-安装
Windows 1，下载 下载erlang： 下载rabbitmq：/download.html 2，安装 先安装erlang，C:\Program Files\erl5.7.5 设置环境变量：ERLANG_HOME=C:\Program Files\erl5.7.5 解压rabbitmq，进入dos下， >cd C:\rabbitmq_server-1.7.2\sbin >rabbitmq-service install 3，启动 >cd C:\rabbitmq_server-1.7.2\sbin >rabbitmq-service start 或都直接双击C:\rabbitmq_server-1.7.2\sbin\rabbitmq-service.bat Linux 1，下载erlang for linux版本，安装
遵守此数据格式的工具，其创建和解释消息，都能与其他兼容工具进行互操作。 AMQP规范的版本： 0-8 是2006年6月发布 0-9 于2006年12月发布 0-9-1 于2008年11月发布 0-10 于2009年下半年发布 1.0 draft （文档还是草案） AMQP的实现有： 1）OpenAMQ AMQP的开源实现，用C语言编写，运行于Linux、AIX、Solaris、Windows、OpenVMS。 2）Apache Qpid Apache的开源项目，支持C++、Ruby、Java、JMS、Python和.NET。 3）Redhat Enterprise MRG 实现了AMQP的最新版本0-10，提供了丰富的特征集，比如完全管理、联合、Active-Active集群，有
rabbitmq 学习-1-AMQP介绍
本文档来自网上.[ 看否网正使用rabbitmq做爬虫队列,欢迎大家交流q
AMQP，即Advanced Message Queuing Protocol，高级消息队列协议，是应用层协议的一个开放标准， 为面向消息的中间件设计。
tar -xzf otp_src_R12B-5.tar.gz cd otp_src_R12B-5 ./configure --prefix=/usr make && make install 或者先make再make install
2，下载rabbitmq for linux，最好直接下载：rabbitmq-server-generic-unix-1.7.2.tar.gz，如果下载其它 的，还要装simplejson（装simplejson得装python，还要能使用yum命令，比较复杂）
AMQP.PROTOCOL.PORT); } catch (IOException e) { e.printStackTrace(); } } public void testSend() { try { Channel channel = connection.createChannel(); System.out.println(channel.toString()); Assert.assertNotNull(channel); byte[] messageBodyBytes = "hello world".getBytes(); channel.basicPublish("exchangeName", "routingKey",
其实也是应了广大人民群众的需求，虽然在同步消息通讯的世界里有很多公开标准（如 COBAR
的 IIOP ，或者是 SOAP 等），但是在异步消息处理中却不是这样，只有大企业有一些商业实
现（如微软的 MSMQ ，IBM 的 Websphere MQ 等），因此，在 2006 年的 6 月，Cisco 、
rabbitmq 学习-4-初试2
RpcClient，RpcServer同步发送接收消息
Channel.basicPublish，Channel.basicGet异步发送接收消息
本例是一个简单的同步发送消息实例
1，发送端 public class Publish {
private static Connection connection; static { ConnectionParameters params = new ConnectionParameters(); ConnectionFactory factory = new ConnectionFactory(params); try { connection = factory.newConnection("localhost", AMQP.PROTOCOL.PORT); } catch (IOException e) { e.printStackTrace(); } } public static void main(String[] args) { try { Channel channel = connection.createChannel(); RpcClient rpc = new RpcClient(channel, "exchangeName", "routingKey"); byte[] primitiveCall = rpc.primitiveCall("hello world".getBytes()); System.out.println(new String(primitiveCall)); primitiveCall = rpc.primitiveCall("hello world2".getBytes()); System.out.println(new String(primitiveCall)); rpc = new RpcClient(channel, "exchangeName", "routingKey2"); primitiveCall = rpc.primitiveCall("hello world2".getBytes()); System.out.println(new String(primitiveCall)); System.out.println("publish success."); } catch (Exception e) { e.printStackTrace(); } } }