版本说明

使用当前版本：3.5.4

安装与启动

在官网上下载其Server二进制安装包，在Windows上的安装时简单的，与一般软件没什么区别。

安装前会提示你，还需要安装Erlang，并打开下载页面。把他们都下载安装就ok了。（当然也可先行下载安装）

安装完，服务默认是启动的。

Erlang，应该是一个在并发编程方面很厉害的语言吧。

后期可通过开始菜单启动。

简单的Java客户端连接

编码中有些配置需要特别注意配置，比如：

  • 选择什么交换器，各种交换器的分发策略不一样。
  • 是否自动确认消息。如果RabbitMQ服务器收到该消息的确认消息，会认为该消息已经处理OK了，会把它从队列中删除。
  • 队列是否持久、消息是否持久，就是队列和消息在RabbitMQ服务器重启时是否恢复。
  • 队列是否自动删除，就是队列在无监听的情况下是否自动删除。

引入的客户端包：

<dependency>

    <groupId>com.rabbitmq</groupId>

	<artifactId>amqp-client</artifactId>

	<version>3.5.6</version>

</dependency>

消费者：

package com.nicchagil.rabbit.No001MyFirstDemo;

import java.io.IOException;

import java.util.concurrent.TimeoutException;

import com.rabbitmq.client.AMQP;

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 Customer {

    private final static String QUEUE_NAME = "hello world";

    public static void main(String[] argv) throws java.io.IOException,

            java.lang.InterruptedException, TimeoutException {

        /* 创建连接工厂 */

        ConnectionFactory factory = new ConnectionFactory();

        factory.setHost("localhost");

        /* 创建连接 */

        Connection connection = factory.newConnection();

        /* 创建信道 */

        Channel channel = connection.createChannel();

        // 声明一个队列：名称、持久性的（重启仍存在此队列）、非私有的、非自动删除的

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

        System.out.println("Waiting for messages.");

        /* 定义消费者 */

        Consumer consumer = new DefaultConsumer(channel) {

            @Override

            public void handleDelivery(String consumerTag, Envelope envelope,

                    AMQP.BasicProperties properties, byte[] body)

                    throws IOException {

                String message = new String(body, "UTF-8");

                System.out.println("Received the message -> " + message);

            }

        };

        // 将消费者绑定到队列，并设置自动确认消息（即无需显示确认，如何设置请慎重考虑）

        channel.basicConsume(QUEUE_NAME, true, consumer);

    }

}

生产者：

package com.nicchagil.rabbit.No001MyFirstDemo;

import java.util.concurrent.TimeoutException;

import com.rabbitmq.client.Channel;

import com.rabbitmq.client.Connection;

import com.rabbitmq.client.ConnectionFactory;

public class Producer {

    private final static String QUEUE_NAME = "hello world";

    public static void main(String[] argv) throws java.io.IOException, TimeoutException {

        Connection connection = null;

        Channel channel = null;

        try {

        	/* 创建连接工厂 */

            ConnectionFactory factory = new ConnectionFactory();

            factory.setHost("localhost");

            /* 创建连接 */

            connection = factory.newConnection();

            /* 创建信道 */

            channel = connection.createChannel();

            // 声明一个队列：名称、持久性的（重启仍存在此队列）、非私有的、非自动删除的

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

            String message = "hello world..."; // 需发送的信息

            /* 发送消息，使用默认的direct交换器 */

            channel.basicPublish("", QUEUE_NAME, null, message.getBytes());

            System.out.println("Send message -> " + message);

        } finally {

            /* 关闭连接、通道 */

            channel.close();

            connection.close();

            System.out.println("Closed the channel and conn.");

        }

    }

}

如无意外，每运行一次生产者（发送一次消息），消费者都会执行一次业务（接收到一次消息）。

执行了两次生产者后，日志如下：

Waiting for messages.

Received the message -> hello world...

Received the message -> hello world...

注：

  • MQ服务器收到确认（ack）信息后，会在队列中删除该消息。如果未收到确认消息，则会继续等待（不存在超时的概念），它直到执行该消息的消费者挂了，才把此遗留的消息重新分发给其它的消费者。

发布与订阅（fanout交换器）

发布与订阅，类似于广播。

下面代码演示：两个消费者创建临时队列后绑定一个fanout类型的交换器，然后生产者往该交换器发送消息，消息被广播到两个绑定的队列中，队列将消息发送给各自的消费者，两个消费者接收到消息完成任务。

消费者A：

package com.nicchagil.rabbit.No003Fadout;

import java.io.IOException;

import java.util.concurrent.TimeoutException;

import com.rabbitmq.client.AMQP;

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 FanoutCustomerA {

    public static void main(String[] argv) throws java.io.IOException,

            java.lang.InterruptedException, TimeoutException {

        /* 创建连接工厂 */

        ConnectionFactory factory = new ConnectionFactory();

        factory.setHost("localhost");

        /* 创建连接 */

        Connection connection = factory.newConnection();

        /* 创建信道 */

        Channel channel = connection.createChannel();

        // 创建一个临时的、私有的、自动删除、随机名称的临时队列

        String queueName = channel.queueDeclare().getQueue();

        System.out.println("queue : " + queueName);

        channel.queueBind(queueName, "amq.fanout", "");

        System.out.println(FanoutCustomerA.class.getName() + ", waiting for messages.");

        /* 定义消费者 */

        Consumer consumer = new DefaultConsumer(channel) {

            @Override

            public void handleDelivery(String consumerTag, Envelope envelope,

                    AMQP.BasicProperties properties, byte[] body)

                    throws IOException {

                String message = new String(body, "UTF-8");

                System.out.println("Received the message -> " + message);

            }

        };

        // 开始消费（设置自动确认消息）

        channel.basicConsume("", true, consumer);

    }

}

消费者B：

package com.nicchagil.rabbit.No003Fadout;

import java.io.IOException;

import java.util.concurrent.TimeoutException;

import com.rabbitmq.client.AMQP;

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 FanoutCustomerB {

    public static void main(String[] argv) throws java.io.IOException,

            java.lang.InterruptedException, TimeoutException {

        /* 创建连接工厂 */

        ConnectionFactory factory = new ConnectionFactory();

        factory.setHost("localhost");

        /* 创建连接 */

        Connection connection = factory.newConnection();

        /* 创建信道 */

        Channel channel = connection.createChannel();

        // 创建一个临时的、私有的、自动删除、随机名称的临时队列

        String queueName = channel.queueDeclare().getQueue();

        System.out.println("queue : " + queueName);

        channel.queueBind(queueName, "amq.fanout", "");

        System.out.println(FanoutCustomerB.class.getName() + ", waiting for messages.");

        /* 定义消费者 */

        Consumer consumer = new DefaultConsumer(channel) {

            @Override

            public void handleDelivery(String consumerTag, Envelope envelope,

                    AMQP.BasicProperties properties, byte[] body)

                    throws IOException {

                String message = new String(body, "UTF-8");

                System.out.println("Received the message -> " + message);

            }

        };

        // 开始消费（设置自动确认消息）

        channel.basicConsume("", true, consumer);

    }

}

生产者：

package com.nicchagil.rabbit.No003Fadout;

import java.util.concurrent.TimeoutException;

import com.rabbitmq.client.Channel;

import com.rabbitmq.client.Connection;

import com.rabbitmq.client.ConnectionFactory;

public class FanoutProducer {

    public static void main(String[] argv) throws java.io.IOException, TimeoutException {

        Connection connection = null;

        Channel channel = null;

        try {

        	/* 创建连接工厂 */

            ConnectionFactory factory = new ConnectionFactory();

            factory.setHost("localhost");

            /* 创建连接 */

            connection = factory.newConnection();

            /* 创建信道 */

            channel = connection.createChannel();

            String message = "hello world..."; // 需发送的信息

            /* 发送消息，使用默认的fanout交换器 */

            channel.basicPublish("amq.fanout", "", null, message.getBytes());

            System.out.println("Send message -> " + message);

        } finally {

            /* 关闭连接、通道 */

            channel.close();

            connection.close();

            System.out.println("Closed the channel and conn.");

        }

    }

}

先将两个消费者跑起来，然后运行生产者发送一条消息。

正常来说，消费者A、消费者B都收到消息并执行。

消费者A的日志：

queue : amq.gen-F3EYfr68AHvfZTIJUcN_Ug

com.nicchagil.rabbit.No003Fadout.FanoutCustomerA, waiting for messages.

Received the message -> hello world...

消费者B的日志：

queue : amq.gen-AV_XDQtB-LFPK8bDy31PTw

com.nicchagil.rabbit.No003Fadout.FanoutCustomerB, waiting for messages.

Received the message -> hello world...

管理控制台

我们可以通过以下命令启用管理控制台：

rabbitmq-plugins enable rabbitmq_management

然后由此地址（http://localhost:15672）进入，默认端口是15672，默认账户是guest/guest。

进入后，可以看到Overview、Connections、Channels、Exchanges、Queues、Admin几个页签，此控制台的功能各种强大，不仅可以查看信息，还可以增、删信息，非常棒。

消费者的异常处理器

如果消费者方法体中发生异常没被捕捉并处理，如果使用默认的异常处理器，消费者的信道会关闭，不继续执行任务。

比如以下例子，遇到空字符串则抛出运行时异常：

package com.nicchagil.rabbit.No002消费者出现异常发生堵塞怎么办;

import java.io.IOException;

import java.util.concurrent.TimeoutException;

import com.rabbitmq.client.AMQP;

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 Customer {

    private final static String QUEUE_NAME = "hello world";

    public static void main(String[] argv) throws java.io.IOException,

            java.lang.InterruptedException, TimeoutException {

        /* 创建连接工厂、连接、通道 */

        ConnectionFactory factory = new ConnectionFactory();

        factory.setHost("localhost");

        Connection connection = factory.newConnection();

        Channel channel = connection.createChannel();

        // 声明消息队列

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

        System.out.println("Waiting for messages.");

        /* 定义消费者 */

        Consumer consumer = new DefaultConsumer(channel) {

            @Override

            public void handleDelivery(String consumerTag, Envelope envelope,

                    AMQP.BasicProperties properties, byte[] body)

                    throws IOException {

                String message = new String(body, "UTF-8");

                if (message == null || message.length() == 0) {

                    throw new RuntimeException("The input str is null or empty...");

                }

                System.out.println("Received the message -> " + message);

            }

        };

        // 将消费者绑定到队列

        channel.basicConsume(QUEUE_NAME, true, consumer);

    }

}

然后，我们用这个消费者监听一个队列，且此队列只有这个消费者，用于测试队列是否堵塞，也就是这个消费者是否不继续消费。

先用生产者发送“hello world...”（正常参数），再发送“”（异常参数），最后发送“hello world...”（正常参数）。

可见如下日志，消费者发生异常后，没有响应第三个“hello world...”的消息，也可进入控制台，会发现此消息为Ready状态，等待消费。

原因在于，默认的异常处理器为DefaultExceptionHandler，其继承StrictExceptionHandler，从源码看，遇到异常它会关闭信道。

日志如下：

Waiting for messages.

Received the message -> hello world...

com.rabbitmq.client.impl.DefaultExceptionHandler: Consumer com.nicchagil.rabbit.No002消费者出现异常发生堵塞怎么办.Customer$1@630bd3f1 (amq.ctag-QzWI1jxh4h23rOFJM63cBA) method handleDelivery for channel AMQChannel(amqp://guest@127.0.0.1:5672/,1) threw an exception for channel AMQChannel(amqp://guest@127.0.0.1:5672/,1):

java.lang.RuntimeException: The input str is null or empty...

    at com.nicchagil.rabbit.No002消费者出现异常发生堵塞怎么办.Customer$1.handleDelivery(Customer.java:40)

    at com.rabbitmq.client.impl.ConsumerDispatcher$5.run(ConsumerDispatcher.java:144)

    at com.rabbitmq.client.impl.ConsumerWorkService$WorkPoolRunnable.run(ConsumerWorkService.java:99)

    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1145)

    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615)

    at java.lang.Thread.run(Thread.java:745)

遇到异常，如果需使用别的处理方式，可以设置自定义的异常处理器。

以下的异常处理器，只是Demo。各方法体中只打印相关信息供查看：

package com.nicchagil.rabbit.No002消费者出现异常发生堵塞怎么办;

import com.rabbitmq.client.Channel;

import com.rabbitmq.client.Connection;

import com.rabbitmq.client.Consumer;

import com.rabbitmq.client.ExceptionHandler;

import com.rabbitmq.client.TopologyRecoveryException;

public class MyExceptionHandler implements ExceptionHandler {

    public void handleUnexpectedConnectionDriverException(Connection conn,

            Throwable exception) {

        System.out.println("MyExceptionHandler.handleUnexpectedConnectionDriverException");

    }

    public void handleReturnListenerException(Channel channel,

            Throwable exception) {

        System.out.println("MyExceptionHandler.handleReturnListenerException");

    }

    public void handleFlowListenerException(Channel channel, Throwable exception) {

        System.out.println("MyExceptionHandler.handleFlowListenerException");

    }

    public void handleConfirmListenerException(Channel channel,

            Throwable exception) {

        System.out.println("MyExceptionHandler.handleConfirmListenerException");

    }

    public void handleBlockedListenerException(Connection connection,

            Throwable exception) {

        System.out.println("MyExceptionHandler.handleBlockedListenerException");

    }

    public void handleConsumerException(Channel channel, Throwable exception,

            Consumer consumer, String consumerTag, String methodName) {

        // 正常渠道应该有专业的LOG框架打印，此处简单处理

        exception.printStackTrace();

        System.out.println("MyExceptionHandler.handleConsumerException");

    }

    public void handleConnectionRecoveryException(Connection conn,

            Throwable exception) {

        System.out.println("MyExceptionHandler.handleConnectionRecoveryException");

    }

    public void handleChannelRecoveryException(Channel ch, Throwable exception) {

        System.out.println("MyExceptionHandler.handleChannelRecoveryException");

    }

    public void handleTopologyRecoveryException(Connection conn, Channel ch,

            TopologyRecoveryException exception) {

        System.out.println("MyExceptionHandler.handleTopologyRecoveryException");

    }

}

设置自定义的异常处理器：

factory.setExceptionHandler(new MyExceptionHandler());

像上述那样，先传递“hello world...”，再传递“”（空字符串），最后传递“hello world...”。观察如下日志，可见发生异常后，消费者正常响应消息。

Waiting for messages.

Received the message -> hello world...

java.lang.RuntimeException: The input str is null or empty...

    at com.nicchagil.rabbit.No002消费者出现异常发生堵塞怎么办.Customer$1.handleDelivery(Customer.java:41)

    at com.rabbitmq.client.impl.ConsumerDispatcher$5.run(ConsumerDispatcher.java:144)

    at com.rabbitmq.client.impl.ConsumerWorkService$WorkPoolRunnable.run(ConsumerWorkService.java:99)

    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1145)

MyExceptionHandler.handleConsumerException

    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615)

    at java.lang.Thread.run(Thread.java:745)

Received the message -> hello world...

具体应该根据什么策略进行异常处理，这是个是值得深思的问题，与业务的性质有关。什么情况下消费者应不继续响应请求，什么情况下消费者应继续相应，这个在于业务的性质而定。

参考的优秀文章

【RabbitMQ】RabbitMQ在Windows的安装和简单的使用的更多相关文章

  1. RabbitMQ学习在windows下安装配置

    RabbitMQ学习一. 在windows下安装配置 1.下载并安装erlang,http://www.erlang.org/download.html,最新版是R15B01(5.9.1).由于我机器 ...

  2. RabbitMQ介绍及windows下安装使用

    RebbitMQ介绍 RabbitMQ是一个由 Erlang (一种通用的面向并发的编程语言)开发的AMQP(Advanced Message Queue )的开源实现,Rabbit MQ 是建立在E ...

  3. Redis Windows版安装及简单使用

    1.Redis简介及优势 Redis 是完全开源免费的,遵守BSD协议,是一个高性能的key-value数据库. 特点: Redis支持数据的持久化,可以将内存中的数据保存在磁盘中,重启的时候可以再次 ...

  4. windows下安装laravel简单步骤以及碰到的问题

    1.下载并安装composerhttp://pkg.phpcomposer.com/ ========================================================= ...

  5. 在 Windows 上安装 TensorFlow（转载）

    在 Windows 上安装 TensorFlow windows下配置安装Anaconda+tensorflow Spyder——科学的Python开发环境 Windows7 安装TensorFlow ...

  6. RabbitMQ安装以及简单操作应用（针对Windows和C#）

    1.RabbitMQ安装 1.1下载并安装Erlang https://www.erlang.org/downloads 一直点next就安装好了.我直接使用了默认的安装目录.否则的话,应该需要配置一 ...

  7. RabbitMQ消息队列系列教程（二）Windows下安装和部署RabbitMQ

    摘要 本篇经验将和大家介绍Windows下安装和部署RabbitMQ消息队列服务器,希望对大家的工作和学习有所帮助! 目录 一.Erlang语言环境的搭建 二.RabbitMQ服务环境的搭建 三.Ra ...

  8. Linux RabbitMQ的安装、环境配置、远程访问 ， Windows 下安装的RabbitMQ远程访问

    Linux  RabbitMQ的安装和环境配置 1.安装 RabbitMQ是使用Erlang语言编写的,所以安装RabbitMQ之前,先要安装Erlang环境 #对原来的yum官方源做个备份 1.mv ...

  9. windows下安装rabbitmq的php扩展amqp

    最近研究rabbitmq队列,linux安装这样的软件一向都是很方便的,但是windows可能会比较麻烦,所以对windows的安装做个记录. windows上使用的php扩展为dll文件,首先去下载 ...

随机推荐

  1. HTML中id、name、class 区别

    参考:http://www.cnblogs.com/polk6/archive////.html http://blog.csdn.net/ithomer/article/details/ HTML ...

  2. IOS第15天(2,事件处理hitTest练习）

    ***hitTest 获取最合适的点 @implementation HMGreenView - (void)touchesBegan:(NSSet *)touches withEvent:(UIEv ...

  3. Jquery--防止冒泡

    e.stopPropagation();//阻止冒泡

  4. SQL server的存储过程

    1.sp_databases 列出服务器上的所有数据库信息,包括数据库名称大小. 例:exec sp_databases 2.sp_helpdb 报告有关指定数据库或所有数据库的信息. 例: exec ...

  5. JavaScript 代码 优化笔记

    1. 判断某个元素是否在数组中. setCheckNodes : function (zNodes, checkIds){ var that = this; that.setAllNodesUnche ...

  6. openfire二次开发eclipse环境搭建

    转自:http://blog.csdn.net/daigua245/article/details/7918243 1.将openfire源码项目解压到(如果是从SVN CO下来的则不用)eclips ...

  7. SSD果然劲爆！

    前两周入手了一块浦科特128G盘,不说多了,有图为证 以前把机械盘放在主硬盘位的时候,鲁大师显示是SATA II接口,现在把SSD放在主硬盘位,显示居然是SATA III接口了,看上面测试,确实是II ...

  8. 白话学习MVC(五)Controller的激活

    一.概述 在此系列开篇的时候介绍了MVC的生命周期 , 对于请求的处理,都是将相应的类的方法注册到HttpApplication事件中,通过事件的依次执行从而完成对请求的处理.对于MVC来说,请求是先 ...

  9. vim - multiple windows

    https://www.cs.oberlin.edu/~kuperman/help/vim/windows.html

  10. Python基础、文件处理

    一.概述 Python中操作文件是通过file对象来处理的,步骤: 指定文件的路径.操作的模式 对文件进行操作,读或写操作 关闭文件对象 f = open( '文件路径','访问模式') # 打开文件 ...