介绍：

　　RabbitMQ是开源的消息中间件，它是轻量级的，支持多种消息传递协议，可以部署在分布式和联合配置中，以满足高级别、高可用性需求。并且可在许多操作系统和云环境上运行，并为大多数流行语言提供了广泛的开发工具。（这里只介绍JAVA下的RabbitMQ的使用，感兴趣的可以查看官方文档：http://www.rabbitmq.com/getstarted.html）；

安装：

　　参考：http://www.cnblogs.com/lfalex0831/p/8951955.html（windows安装）

应用场景：

　　1、异步处理，主要为了较少请求的响应时间和解耦。即将比较耗时又不需要同步的操作放入消息队列中进行传递请求，只要保证消息格式（可以理解为接头的暗号）不变，这样消息的发送方和接收方互不干扰交互，即为解耦；

　　2、广播，顾名思义，广播的好处就是一次发送，大家共享，大大的减少了冗余的操作，也降低了新增消费者的成本；

　　3、流量削峰，比如秒杀活动，因为流量过大，导致应用挂掉,为了避免这个问题，会在应用前端加入消息队列。 
　　作用: 
　　　　1.可以控制进入后台的服务，超过阀值的订单直接丢弃；
　　　　2.可以缓解瞬时的高流量压垮应用；

　　ps：秒杀系统优化思路可以从将请求尽量拦截在系统上游和充分利用缓存；

　　（如果还有别的应用场景，请大家多多指教。。。）

使用场景（本文使用的RabbitMQ的版本为5.20版本）：

  1. This tutorial assumes RabbitMQ is installed and running on localhost on standard port (). In case you use a different host, port or credentials, connections settings would require adjusting.

注意：根据官方文档说明，RabbitMQ的默认访问端口为5672，而管理端口为15672，希望不要搞混了（我刚接触时就没注意，果断乱了。。-_-||）。

　　基本概念：

  • Broker：简单来说就是消息队列服务器实体
  • Exchange：消息交换机，它指定消息按什么规则，路由到哪个队列
  • Queue：消息队列载体，每个消息都会被投入到一个或多个队列
  • Binding：绑定，它的作用就是把exchange和queue按照路由规则绑定起来
  • Routing Key：路由关键字，exchange根据这个关键字进行消息投递
  • vhost：虚拟主机，一个broker里可以开设多个vhost，用作不同用户的权限分离
  • producer：消息生产者，就是投递消息的程序
  • consumer：消息消费者，就是接受消息的程序
  • channel：消息通道，在客户端的每个连接里，可建立多个channel，每个channel代表一个会话任务

　　1、简单使用（HelloWorld）

　　在下图中，P是我们的生产者，C是我们的消费者。中间的框是一个队列——RabbitMQ代表消费者保存的消息缓冲区。

　　　

　　创建RabbitMQ的工厂类：

  1.  import com.rabbitmq.client.Connection;
  2.  import com.rabbitmq.client.ConnectionFactory;
  3.  import java.io.IOException;
  4.  import java.util.concurrent.TimeoutException;
  5.  
  6.  public class ConnectionUtil {
  7.  
  8.      private static final String RABBIT_HOST = "localhost";
  9.  
  10.      private static final String RABBIT_USERNAME = "guest";
  11.  
  12.      private static final String RABBIT_PASSWORD = "guest";
  13.  
  14.      private static Connection connection = null;
  15.  
  16.      public static Connection getConnection() {
  17.          if(connection == null) {
  18.              ConnectionFactory connectionFactory = new ConnectionFactory();
  19.              connectionFactory.setHost(RABBIT_HOST);
  20.              connectionFactory.setUsername(RABBIT_USERNAME);
  21.              connectionFactory.setPassword(RABBIT_PASSWORD);
  22.              try {
  23.                  connection = connectionFactory.newConnection();
  24.              } catch (IOException e) {
  25.                  e.printStackTrace();
  26.              } catch (TimeoutException e) {
  27.                  e.printStackTrace();
  28.              }
  29.          }
  30.          return connection;
  31.      }
  32.  
  33.  }

ConnectionUtil.java

　　创建生产者Producer：

  1.  import com.cn.ConnectionUtil;
  2.  import com.rabbitmq.client.Channel;
  3.  import com.rabbitmq.client.Connection;
  4.  import java.io.IOException;
  5.  import java.util.concurrent.TimeoutException;
  6.  
  7.  public class Producer {
  8.  
  9.      private static final String QUEUE_NAME="test_queue";
  10.  
  11.      public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
  12.          //获取连接
  13.          Connection connection = ConnectionUtil.getConnection();
  14.          System.out.println(connection);
  15.          //创建通道
  16.          Channel channel = connection.createChannel(1);
  17.          /*
  18.           * 声明（创建）队列
  19.           * 参数1：队列名称
  20.           * 参数2：为true时server重启队列不会消失
  21.           * 参数3：队列是否是独占的，如果为true只能被一个connection使用，其他连接建立时会抛出异常
  22.           * 参数4：队列不再使用时是否自动删除（没有连接，并且没有未处理的消息)
  23.           * 参数5：建立队列时的其他参数
  24.           */
  25.          channel.queueDeclare(QUEUE_NAME,false,false,false,null);
  26.          String message = "Hello World!";
  27.          for (int i = 0; i < 20; i++) {
  28.              message = message + i;
  29.              channel.basicPublish("",QUEUE_NAME,null,message.getBytes());
  30.              Thread.sleep(1000);
  31.          }
  32.          System.out.println("生产者 send ："+message);
  33.          channel.close();
  34.          connection.close();
  35.      }
  36.  
  37.  }

Producer.java

　　创建消费者Consumer：

  1.  import com.cn.ConnectionUtil;
  2.  import com.rabbitmq.client.AMQP.BasicProperties;
  3.  import com.rabbitmq.client.Channel;
  4.  import com.rabbitmq.client.Connection;
  5.  import com.rabbitmq.client.DefaultConsumer;
  6.  import com.rabbitmq.client.Envelope;
  7.  import java.io.IOException;
  8.  
  9.  public class Consumer {
  10.  
  11.      private static final String QUEUE_NAME = "test_queue";
  12.  
  13.      public static void main(String[] args) throws IOException {
  14.          Connection connection = ConnectionUtil.getConnection();
  15.          Channel channel = connection.createChannel(1);
  16.          channel.queueDeclare(QUEUE_NAME,false,false,false,null);
  17.          StringBuffer message = new StringBuffer();
  18.          //自4.0+ 版本后无法再使用QueueingConsumer，而官方推荐使用DefaultConsumer
  19.          com.rabbitmq.client.Consumer consumer = new DefaultConsumer(channel) {
  20.              @Override
  21.              public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties, byte[] body)
  22.                  throws IOException {
  23.                  try {
  24.                      Thread.sleep(2000);
  25.                  } catch (InterruptedException e) {
  26.                      e.printStackTrace();
  27.                  }
  28.                  super.handleDelivery(consumerTag, envelope, properties, body);
  29.                  message.append(new String(body,"UTF-8"));
  30.                  System.out.println(new String(body,"UTF-8"));
  31.              }
  32.          };
  33.          //监听队列，当b为true时，为自动提交（只要消息从队列中获取，无论消费者获取到消息后是否成功消息，都认为是消息已经成功消费），
  34.          // 当b为false时，为手动提交（消费者从队列中获取消息后，服务器会将该消息标记为不可用状态，等待消费者的反馈，
  35.          // 如果消费者一直没有反馈，那么该消息将一直处于不可用状态。
  36.          //如果选用自动确认,在消费者拿走消息执行过程中出现宕机时,消息可能就会丢失！！）
  37.          //使用channel.basicAck(envelope.getDeliveryTag(),false);进行消息确认
  38.          channel.basicConsume(QUEUE_NAME,true,consumer);
  39.          System.out.println(message.toString());
  40.      }
  41.  }

Consumer.java

　　测试结果，Consumer收到Producer的消息。

　　2、Work Queue

　　上一个例子是一对一发送接收形式，而工作队列为一对多发送接收形式。工作队列(即任务队列)背后的主要思想是避免立即执行资源密集型任务，并且必须等待它完成。相反，我们把任务安排在以后做。我们将任务封装为消息并将其发送到队列。在后台运行的工作进程会弹出任务并最终执行任务。当你运行许多Consumer时，任务将在他们之间共享，如下图：

　　　

　　由于工厂类已经创建，直接使用即可。

　　创建生产者Producer：

  1. package com.cn.work;
  2.  
  3. import com.cn.ConnectionUtil;
  4. import com.rabbitmq.client.Channel;
  5. import com.rabbitmq.client.Connection;
  6.  
  7. /**
  8.  * @program: rabbit-learn
  9.  * @description: 生产者
  10.  * @create: 2018-04-26 16:18
  11.  **/
  12. public class Producer {
  13.  
  14.     private final static String QUEUE_NAME = "test_queue_work";
  15.  
  16.     public static void main(String[] args) throws Exception {
  17.         Connection connection = ConnectionUtil.getConnection();
  18.         Channel channel = connection.createChannel();
  19.         channel.queueDeclare(QUEUE_NAME,false,false,false,null);
  20.         for (int i = 0; i < 50; i++) {
  21.             String message = "" + i;
  22.             channel.basicPublish("",QUEUE_NAME,null,message.getBytes());
  23.             Thread.sleep(100 * i);
  24.         }
  25.         channel.close();
  26.         connection.close();
  27.     }
  28.  
  29. }

Producer.java

　　创建消费者1，2：

  1. import com.cn.ConnectionUtil;
  2. import com.rabbitmq.client.AMQP.BasicProperties;
  3. import com.rabbitmq.client.Channel;
  4. import com.rabbitmq.client.Connection;
  5. import com.rabbitmq.client.Consumer;
  6. import com.rabbitmq.client.DefaultConsumer;
  7. import com.rabbitmq.client.Envelope;
  8. import java.io.IOException;
  9.  
  10. public class Consumer1 {
  11.  
  12.     private final static String QUEUE_NAME = "test_queue_work";
  13.  
  14.     public static void main(String[] args) throws IOException {
  15.         Connection connection = ConnectionUtil.getConnection();
  16.         Channel channel = connection.createChannel();
  17.         channel.basicQos(1);//能者多劳模式
  18.         //声明队列
  19.         channel.queueDeclare(QUEUE_NAME,false,false,false,null);
  20.  
  21.         //自4.0+ 版本后无法再使用QueueingConsumer，而官方推荐使用DefaultConsumer
  22.         Consumer consumer = new DefaultConsumer(channel) {
  23.             @Override
  24.             public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties, byte[] body)
  25.                 throws IOException {
  26.                 super.handleDelivery(consumerTag, envelope, properties, body);
  27.                 String message = new String(body,"UTF-8");
  28.                 System.out.println(message);
  29.                 try {
  30.                     Thread.sleep(10);
  31.                 } catch (InterruptedException e) {
  32.                     e.printStackTrace();
  33.                 }
  34.                 try {
  35.                     doWork(message);
  36.                 }finally {
  37.                     channel.basicAck(envelope.getDeliveryTag(),false);
  38.                 }
  39.             }
  40.         };
  41.         //监听队列，当b为true时，为自动提交（只要消息从队列中获取，无论消费者获取到消息后是否成功消息，都认为是消息已经成功消费），
  42.         // 当b为false时，为手动提交（消费者从队列中获取消息后，服务器会将该消息标记为不可用状态，等待消费者的反馈，
  43.         // 如果消费者一直没有反馈，那么该消息将一直处于不可用状态。
  44.         //如果选用自动确认,在消费者拿走消息执行过程中出现宕机时,消息可能就会丢失！！）
  45.         //使用channel.basicAck(envelope.getDeliveryTag(),false);进行消息确认
  46.         channel.basicConsume(QUEUE_NAME,false,consumer);
  47.     }
  48.  
  49.     private static void doWork(String task) {
  50.         for (char ch : task.toCharArray()) {
  51.             if (ch == '.') {
  52.                 try {
  53.                     Thread.sleep(1000);
  54.                 } catch (InterruptedException _ignored) {
  55.                     Thread.currentThread().interrupt();
  56.                 }
  57.             }
  58.         }
  59.     }
  60.  
  61. }

Consumer1.java

  1.  import com.cn.ConnectionUtil;
  2.  import com.rabbitmq.client.AMQP.BasicProperties;
  3.  import com.rabbitmq.client.Channel;
  4.  import com.rabbitmq.client.Connection;
  5.  import com.rabbitmq.client.Consumer;
  6.  import com.rabbitmq.client.DefaultConsumer;
  7.  import com.rabbitmq.client.Envelope;
  8.  import java.io.IOException;
  9.  
  10.  public class Consumer2 {
  11.  
  12.      private final static String QUEUE_NAME = "test_queue_work";
  13.  
  14.      public static void main(String[] args) throws IOException {
  15.          Connection connection = ConnectionUtil.getConnection();
  16.          Channel channel = connection.createChannel();
  17.          channel.basicQos(1);//能者多劳模式
  18.          //声明队列
  19.          channel.queueDeclare(QUEUE_NAME,false,false,false,null);
  20.          //自4.0+ 版本后无法再使用QueueingConsumer，而官方推荐使用DefaultConsumer
  21.          Consumer consumer = new DefaultConsumer(channel) {
  22.              @Override
  23.              public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties, byte[] body)
  24.                  throws IOException {
  25.                  super.handleDelivery(consumerTag, envelope, properties, body);
  26.                  String message = new String(body,"UTF-8");
  27.                  System.out.println(message);
  28.                  try {
  29.                      Thread.sleep(1000);
  30.                  } catch (InterruptedException e) {
  31.                      e.printStackTrace();
  32.                  }
  33.                  try {
  34.                      doWork(message);
  35.                  }finally {
  36.                      channel.basicAck(envelope.getDeliveryTag(), false);
  37.                  }
  38.              }
  39.          };
  40.          //监听队列，当b为true时，为自动提交（只要消息从队列中获取，无论消费者获取到消息后是否成功消息，都认为是消息已经成功消费），
  41.          // 当b为false时，为手动提交（消费者从队列中获取消息后，服务器会将该消息标记为不可用状态，等待消费者的反馈，
  42.          // 如果消费者一直没有反馈，那么该消息将一直处于不可用状态。
  43.          //如果选用自动确认,在消费者拿走消息执行过程中出现宕机时,消息可能就会丢失！！）
  44.          //使用channel.basicAck(envelope.getDeliveryTag(),false);进行消息确认
  45.          channel.basicConsume(QUEUE_NAME,false,consumer);
  46.      }
  47.  
  48.      /**
  49.       * @Description: 业务代码
  50.       * @Param:
  51.       * @return:
  52.       * @Author: 535504
  53.       * @Date: 2018/4/26
  54.       */
  55.      private static void doWork(String task) {
  56.          for (char ch : task.toCharArray()) {
  57.              if (ch == '.') {
  58.                  try {
  59.                      Thread.sleep(1000);
  60.                  } catch (InterruptedException _ignored) {
  61.                      Thread.currentThread().interrupt();
  62.                  }
  63.              }
  64.          }
  65.      }
  66.  
  67.  }

Consumer2.java

　　测试结果，当消费者中的channel.basicQos(1);这行代码的注释打开时,执行会发现,休眠时间短的消费者执行的任务多，而注释后，再次执行会发现消费者1和消费者2获取到的消息内容是不同的，同一个消息只能被一个消费者获取，消费者1和消费者2获取到的消息的数量是相同的，一个是奇数一个是偶数。

　　3、Publish/Subscribe（严格来说下面介绍的路由和通配符模式也是发布订阅）

　　在发布订阅模式中，消息需要发送到MQ的交换机exchange上，exchange根据配置的路由方式发到相应的Queue上，Queue又将消息发送给consumer，消息从queue到consumer， 消息队列的使用过程大概如下：
　　1.客户端连接到消息队列服务器，打开一个channel。
　　2.客户端声明一个exchange，并设置相关属性。
　　3.客户端声明一个queue，并设置相关属性。
　　4.客户端在exchange和queue之间建立好绑定关系。
　　5.客户端投递消息到exchange。

　　

　　创建生产者Producer：　

  1.  import com.cn.ConnectionUtil;
  2.  import com.rabbitmq.client.Channel;
  3.  import com.rabbitmq.client.Connection;
  4.  import java.io.IOException;
  5.  import java.util.concurrent.TimeoutException;
  6.  
  7.  /**
  8.   * @program: rabbit-learn
  9.   * @description: 生产者，订阅模式
  10.   * @author:
  11.   * @create:
  12.   * 消息发送到没有队列绑定的交换机时，消息将丢失，因为，交换机没有存储消息的能力，消息只能存在在队列中。
  13.   **/
  14.  public class Producer {
  15.  
  16.      //交换机名称
  17.      private static final String EXCHANGE_NAME = "test_exchange_fanout";
  18.  
  19.      public static void main(String[] args) throws IOException, TimeoutException {
  20.          Connection connection = ConnectionUtil.getConnection();
  21.          Channel channel = connection.createChannel();
  22.          /*
  23.              声明exchange交换机
  24.              参数1：交换机名称
  25.              参数2：交换机类型
  26.              参数3：交换机持久性，如果为true则服务器重启时不会丢失
  27.              参数4：交换机在不被使用时是否删除
  28.              参数5：交换机的其他属性
  29.           */
  30.          channel.exchangeDeclare(EXCHANGE_NAME,"fanout", true,true,null);
  31.  
  32.          String message = "订阅消息";
  33.          channel.basicPublish(EXCHANGE_NAME,"",null,message.getBytes());
  34.          System.out.println("生产者 send ："+message);
  35.          channel.close();
  36.          connection.close();
  37.      }
  38.  
  39.  }

Producer.java

　　创建消费者Consumer1、2：

  1.  import com.cn.ConnectionUtil;
  2.  import com.rabbitmq.client.AMQP.BasicProperties;
  3.  import com.rabbitmq.client.Channel;
  4.  import com.rabbitmq.client.Connection;
  5.  import com.rabbitmq.client.Consumer;
  6.  import com.rabbitmq.client.DefaultConsumer;
  7.  import com.rabbitmq.client.Envelope;
  8.  import java.io.IOException;
  9.  
  10.  public class Consumer1 {
  11.  
  12.      private static final String QUEUE_NAME = "test_queue_exchange_1";
  13.  
  14.      private static final String EXCHANGE_NAME = "test_exchange_fanout";
  15.  
  16.      public static void main(String[] args) throws IOException {
  17.          Connection connection = ConnectionUtil.getConnection();
  18.          Channel channel = connection.createChannel();
  19.  
  20.          //声明队列
  21.          channel.queueDeclare(QUEUE_NAME,false,false,false,null);
  22.  
  23.          /*
  24.              绑定队列到交换机（这个交换机名称一定要和生产者的交换机名相同）
  25.              参数1：队列名
  26.              参数2：交换机名
  27.              参数3：Routing key 路由键
  28.           */
  29.          channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"");
  30.  
  31.          //同一时刻服务器只会发一条数据给消费者
  32.          channel.basicQos(1);
  33.  
  34.          Consumer consumer = new DefaultConsumer(channel) {
  35.              @Override
  36.              public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties, byte[] body)
  37.                  throws IOException {
  38.                  super.handleDelivery(consumerTag, envelope, properties, body);
  39.                  String message = new String(body,"UTF-8");
  40.                  System.out.println("收到消息："+message);
  41.                  channel.basicAck(envelope.getDeliveryTag(),false);
  42.              }
  43.          };
  44.          channel.basicConsume(QUEUE_NAME,false,consumer);
  45.      }
  46.  
  47.  }

Consumer1.java

  1.  import com.cn.ConnectionUtil;
  2.  import com.rabbitmq.client.AMQP.BasicProperties;
  3.  import com.rabbitmq.client.Channel;
  4.  import com.rabbitmq.client.Connection;
  5.  import com.rabbitmq.client.Consumer;
  6.  import com.rabbitmq.client.DefaultConsumer;
  7.  import com.rabbitmq.client.Envelope;
  8.  import java.io.IOException;
  9.  
  10.  public class Consumer2 {
  11.  
  12.      private static final String QUEUE_NAME = "test_queue_exchange_2";
  13.  
  14.      private static final String EXCHANGE_NAME = "test_exchange_fanout";
  15.  
  16.      public static void main(String[] args) throws IOException {
  17.          Connection connection = ConnectionUtil.getConnection();
  18.          Channel channel = connection.createChannel();
  19.  
  20.          //声明队列
  21.          channel.queueDeclare(QUEUE_NAME,false,false,false,null);
  22.  
  23.          /*
  24.              绑定队列到交换机（这个交换机名称一定要和生产者的交换机名相同）
  25.              参数1：队列名
  26.              参数2：交换机名
  27.              参数3：Routing key 路由键
  28.           */
  29.          channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"");
  30.  
  31.          //同一时刻服务器只会发一条数据给消费者
  32.          channel.basicQos(1);
  33.  
  34.          Consumer consumer = new DefaultConsumer(channel) {
  35.              @Override
  36.              public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties, byte[] body)
  37.                  throws IOException {
  38.                  super.handleDelivery(consumerTag, envelope, properties, body);
  39.                  String message = new String(body,"UTF-8");
  40.                  System.out.println("收到消息："+message);
  41.                  channel.basicAck(envelope.getDeliveryTag(),false);
  42.              }
  43.          };
  44.          channel.basicConsume(QUEUE_NAME,false,consumer);
  45.      }
  46.  
  47.  }

Consumer2.java

　　4、Routing（路由）

　　根据指定的路由键发送到对应的消息队列中，如下图，在这个设置中，我们可以看到与它绑定的两个队列的直接交换X。第一个队列绑定了绑定键橙色，第二个队列有两个绑定，一个绑定键为黑色，另一个为绿色。在这样的设置中，将发送到与路由键橙色的交换的消息将被路由到队列Q1。带有黑色或绿色的路由键的消息将会进入Q2。所有其他消息将被丢弃。

　　　　

　　创建生产者Producer：

  1.  import com.cn.ConnectionUtil;
  2.  import com.rabbitmq.client.Channel;
  3.  import com.rabbitmq.client.Connection;
  4.  
  5.  public class Producer {
  6.  
  7.      private static final String EXCHANGE_NAME = "test_exchange_direct";
  8.  
  9.      public static void main(String[] argv) throws Exception {
  10.          // 获取到连接以及mq通道
  11.          Connection connection = ConnectionUtil.getConnection();
  12.          Channel channel = connection.createChannel();
  13.  
  14.          // 声明exchange,路由模式声明direct
  15.          channel.exchangeDeclare(EXCHANGE_NAME, "direct");
  16.  
  17.          // 消息内容
  18.          String message = "这是消息B";
  19.          channel.basicPublish(EXCHANGE_NAME, "B", null, message.getBytes());
  20.          String messageA = "这是消息A";
  21.          channel.basicPublish(EXCHANGE_NAME, "A", null, messageA.getBytes());
  22.          System.out.println(" [生产者] Sent '" + message + "'");
  23.  
  24.          channel.close();
  25.          connection.close();
  26.      }
  27.  
  28.  }

Producer.java

　　创建消费者Consumer1、2：

  1.  package com.cn.routing;
  2.  
  3.  import com.cn.ConnectionUtil;
  4.  import com.rabbitmq.client.AMQP.BasicProperties;
  5.  import com.rabbitmq.client.Channel;
  6.  import com.rabbitmq.client.Connection;
  7.  import com.rabbitmq.client.Consumer;
  8.  import com.rabbitmq.client.DefaultConsumer;
  9.  import com.rabbitmq.client.Envelope;
  10.  import java.io.IOException;
  11.  
  12.  /**
  13.   * @program: rabbit-learn
  14.   * @description: 消费者1
  15.   * @author: 535504
  16.   * @create: 2018-04-26 17:52
  17.   **/
  18.  public class Consumer1 {
  19.      private final static String QUEUE_NAME = "test_queue_direct_A";
  20.  
  21.      private final static String EXCHANGE_NAME = "test_exchange_direct";
  22.  
  23.      public static void main(String[] argv) throws Exception {
  24.  
  25.          // 获取到连接以及mq通道
  26.          Connection connection = ConnectionUtil.getConnection();
  27.          Channel channel = connection.createChannel();
  28.  
  29.          // 声明队列
  30.          //channel.queueDeclare(QUEUE_NAME, false, false, false, null);
  31.          channel.exchangeDeclare(EXCHANGE_NAME,"direct");
  32.          /*
  33.           * 绑定队列到交换机
  34.           * 参数1：队列的名称
  35.           * 参数2：交换机的名称
  36.           * 参数3：routingKey
  37.           */
  38.          channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "A");
  39.  
  40.          // 同一时刻服务器只会发一条消息给消费者
  41.          channel.basicQos(1);
  42.  
  43.          // 定义队列的消费者
  44.          Consumer consumer = new DefaultConsumer(channel) {
  45.              @Override
  46.              public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties, byte[] body)
  47.                  throws IOException {
  48.                  super.handleDelivery(consumerTag, envelope, properties, body);
  49.                  System.out.println(new String(body,"UTF-8"));
  50.              }
  51.          };
  52.          channel.basicConsume(QUEUE_NAME,true,consumer);
  53.      }
  54.  }

Consumer1.java

  1.  import com.cn.ConnectionUtil;
  2.  import com.rabbitmq.client.AMQP.BasicProperties;
  3.  import com.rabbitmq.client.Channel;
  4.  import com.rabbitmq.client.Connection;
  5.  import com.rabbitmq.client.Consumer;
  6.  import com.rabbitmq.client.DefaultConsumer;
  7.  import com.rabbitmq.client.Envelope;
  8.  import java.io.IOException;
  9.  
  10.  public class Consumer2 {
  11.      private final static String QUEUE_NAME = "test_queue_direct_B";
  12.  
  13.      private final static String EXCHANGE_NAME = "test_exchange_direct";
  14.  
  15.      public static void main(String[] argv) throws Exception {
  16.  
  17.          // 获取到连接以及mq通道
  18.          Connection connection = ConnectionUtil.getConnection();
  19.          Channel channel = connection.createChannel();
  20.  
  21.          // 声明队列
  22.          //channel.queueDeclare(QUEUE_NAME, false, false, false, null);
  23.          channel.exchangeDeclare(EXCHANGE_NAME,"direct");
  24.          /*
  25.           * 绑定队列到交换机
  26.           * 参数1：队列的名称
  27.           * 参数2：交换机的名称
  28.           * 参数3：routingKey
  29.           */
  30.          channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "B");
  31.  
  32.          // 同一时刻服务器只会发一条消息给消费者
  33.          channel.basicQos(1);
  34.  
  35.          // 定义队列的消费者
  36.          Consumer consumer = new DefaultConsumer(channel) {
  37.              @Override
  38.              public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties, byte[] body)
  39.                  throws IOException {
  40.                  super.handleDelivery(consumerTag, envelope, properties, body);
  41.                  System.out.println(new String(body,"UTF-8"));
  42.              }
  43.          };
  44.          channel.basicConsume(QUEUE_NAME,true,consumer);
  45.      }
  46.  }

Consumer2.java

　　5、Topics（主题通配符）

　　可以理解为Routing的通配符模式，如下图：

　　

　　“#”：表示匹配一个或多个词；（lazy.a.b.c）

　　“*”：表示匹配一个词；（a.orange.b）

　　创建生产者Producer：

  1.  import com.cn.ConnectionUtil;
  2.  import com.rabbitmq.client.Channel;
  3.  import com.rabbitmq.client.Connection;
  4.  
  5.  import java.io.IOException;
  6.  import java.util.concurrent.TimeoutException;
  7.  
  8.  public class Producer {
  9.  
  10.      private static final String EXCHANGE_NAME = "test_exchange_topic";
  11.  
  12.      public static void main(String[] args) throws IOException, TimeoutException {
  13.          Connection connection = ConnectionUtil.getConnection();
  14.          Channel channel = connection.createChannel();
  15.          //声明交换机
  16.          channel.exchangeDeclare(EXCHANGE_NAME,"topic");
  17.          String message = "匹配insert";
  18.          channel.basicPublish(EXCHANGE_NAME,"order.update",false,false,null,message.getBytes());
  19.  
  20.          channel.close();
  21.          connection.close();
  22.      }
  23.  }

Producer.java

　　创建消费者Consumer1、2：

  1.  import com.cn.ConnectionUtil;
  2.  import com.rabbitmq.client.AMQP.BasicProperties;
  3.  import com.rabbitmq.client.Channel;
  4.  import com.rabbitmq.client.Connection;
  5.  import com.rabbitmq.client.Consumer;
  6.  import com.rabbitmq.client.DefaultConsumer;
  7.  import com.rabbitmq.client.Envelope;
  8.  
  9.  import java.io.IOException;
  10.  
  11.  public class Consumer1 {
  12.  
  13.      private static final String EXCHANGE_NAME = "test_exchange_topic";
  14.  
  15.      private  static final String QUEUE_NAME = "test_queue_topic_1";
  16.  
  17.      public static void main(String[] args) throws IOException {
  18.          Connection connection = ConnectionUtil.getConnection();
  19.          Channel channel = connection.createChannel();
  20.          //channel.queueDeclare(QUEUE_NAME,false,false,false,null);
  21.          channel.exchangeDeclare(EXCHANGE_NAME,"topic");
  22.          //order.#
  23.          channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"order.*");
  24.  
  25.          channel.basicQos(1);
  26.  
  27.          Consumer consumer = new DefaultConsumer(channel) {
  28.              @Override
  29.              public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties, byte[] body)
  30.                  throws IOException {
  31.                  super.handleDelivery(consumerTag, envelope, properties, body);
  32.                  System.out.println(new String(body,"UTF-8"));
  33.              }
  34.          };
  35.          channel.basicConsume(QUEUE_NAME,true,consumer);
  36.  
  37.      }
  38.  }

Consumer1.java

  1.  import com.cn.ConnectionUtil;
  2.  import com.rabbitmq.client.AMQP.BasicProperties;
  3.  import com.rabbitmq.client.Channel;
  4.  import com.rabbitmq.client.Connection;
  5.  import com.rabbitmq.client.Consumer;
  6.  import com.rabbitmq.client.DefaultConsumer;
  7.  import com.rabbitmq.client.Envelope;
  8.  
  9.  import java.io.IOException;
  10.  
  11.  public class Consumer2 {
  12.  
  13.      private static final String EXCHANGE_NAME = "test_exchange_topic";
  14.  
  15.      private  static final String QUEUE_NAME = "test_queue_topic_2";
  16.  
  17.      public static void main(String[] args) throws IOException {
  18.          Connection connection = ConnectionUtil.getConnection();
  19.          Channel channel = connection.createChannel();
  20.          channel.queueDeclare(QUEUE_NAME,false,false,false,null);
  21.  
  22.          channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"order.insert");
  23.  
  24.          channel.basicQos(1);
  25.  
  26.          Consumer consumer = new DefaultConsumer(channel) {
  27.              @Override
  28.              public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties, byte[] body) throws IOException {
  29.                  super.handleDelivery(consumerTag, envelope, properties, body);
  30.                  System.out.println("接收消息：" + new String(body, "UTF-8"));
  31.              }
  32.          };
  33.          channel.basicConsume(QUEUE_NAME,true,consumer);
  34.  
  35.      }
  36.  }

Consumer2.java

　　6、RPC（远程调用）

　　如果我们需要在远程计算机上运行一个函数并等待结果，这种模式通常称为远程过程调用或RPC；

　　　

　　创建RPC服务：

  1.  import com.cn.ConnectionUtil;
  2.  import com.rabbitmq.client.AMQP;
  3.  import com.rabbitmq.client.Channel;
  4.  import com.rabbitmq.client.Connection;
  5.  import com.rabbitmq.client.Consumer;
  6.  import com.rabbitmq.client.DefaultConsumer;
  7.  import com.rabbitmq.client.Envelope;
  8.  
  9.  import java.io.IOException;
  10.  import java.util.concurrent.TimeoutException;
  11.  
  12.  public class RPCServer {
  13.  
  14.      private static final String RPC_QUEUE_NAME = "rpc_queue";
  15.  
  16.      public static void main(String[] args) throws IOException, TimeoutException {
  17.          Connection connection = ConnectionUtil.getConnection();
  18.          final Channel channel = connection.createChannel();
  19.          channel.queueDeclare(RPC_QUEUE_NAME, false, false, false, null);
  20.          channel.basicQos(1);
  21.  
  22.          Consumer consumer = new DefaultConsumer(channel) {
  23.              @Override
  24.              public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
  25.                  super.handleDelivery(consumerTag, envelope, properties, body);
  26.                  AMQP.BasicProperties properties1 = new AMQP.BasicProperties.Builder().correlationId(properties.getCorrelationId()).build();
  27.                  String mes = new String(body, "UTF-8");
  28.                  int num = Integer.valueOf(mes);
  29.                  System.out.println("接收数据：" + num);
  30.                  num = fib(num);
  31.                  channel.basicPublish("", properties.getReplyTo(), properties1, String.valueOf(num).getBytes());
  32.                  channel.basicAck(envelope.getDeliveryTag(), false);
  33.              }
  34.          };
  35.          channel.basicConsume(RPC_QUEUE_NAME, false, consumer);
  36.          while (true) {
  37.              synchronized (consumer) {
  38.                  try {
  39.                      consumer.wait();
  40.                  } catch (InterruptedException e) {
  41.                      e.printStackTrace();
  42.                  }
  43.              }
  44.          }
  45.      }
  46.  
  47.      /*
  48.          获取斐波那契数列的第n个值得大小
  49.       */
  50.      private static int fib(int n) {
  51.          System.out.println(n);
  52.          if (n == 0)
  53.              return 0;
  54.          if (n == 1)
  55.              return 1;
  56.          return fib(n - 1) + fib(n - 2);
  57.      }
  58.  }

RPCServer.java

　　创建RPC客户端：

  1.  import com.cn.ConnectionUtil;
  2.  import com.rabbitmq.client.AMQP;
  3.  import com.rabbitmq.client.Channel;
  4.  import com.rabbitmq.client.Connection;
  5.  import com.rabbitmq.client.DefaultConsumer;
  6.  import com.rabbitmq.client.Envelope;
  7.  
  8.  import java.io.IOException;
  9.  import java.util.UUID;
  10.  import java.util.concurrent.ArrayBlockingQueue;
  11.  import java.util.concurrent.BlockingQueue;
  12.  import java.util.concurrent.TimeoutException;
  13.  
  14.  public class RPCClient {
  15.  
  16.      private Connection connection;
  17.      private Channel channel;
  18.      private String requestQueueName = "rpc_queue";
  19.      private String replyQueueName;
  20.  
  21.      public RPCClient() throws IOException, TimeoutException {
  22.          connection = ConnectionUtil.getConnection();
  23.          channel = connection.createChannel();
  24.  
  25.          replyQueueName = channel.queueDeclare().getQueue();
  26.      }
  27.  
  28.      public String call(String message) throws IOException, InterruptedException {
  29.          final String corrId = UUID.randomUUID().toString();
  30.  
  31.          AMQP.BasicProperties props = new AMQP.BasicProperties
  32.                  .Builder()
  33.                  .correlationId(corrId)
  34.                  .replyTo(replyQueueName)
  35.                  .build();
  36.  
  37.          channel.basicPublish("", requestQueueName, props, message.getBytes("UTF-8"));
  38.  
  39.          final BlockingQueue<String> response = new ArrayBlockingQueue<String>(1);
  40.  
  41.          channel.basicConsume(replyQueueName, true, new DefaultConsumer(channel) {
  42.              @Override
  43.              public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
  44.                  if (properties.getCorrelationId().equals(corrId)) {
  45.                      response.offer(new String(body, "UTF-8"));
  46.                  }
  47.              }
  48.          });
  49.  
  50.          //close();
  51.          return response.take();
  52.      }
  53.  
  54.      public void close() throws IOException {
  55.          connection.close();
  56.      }
  57.  
  58.  }

RPCClient.java

　　创建RPC测试类：

  1.  import java.io.IOException;
  2.  import java.util.concurrent.TimeoutException;
  3.  
  4.  public class RPCTest {
  5.  
  6.      public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
  7.          RPCClient rpcClient = new RPCClient();
  8.          System.out.println(rpcClient.call("2"));
  9.      }
  10.  }

RPCTest

完整示例https://gitee.com/lfalex/rabbitmq-learn

参考官方文档：http://www.rabbitmq.com/getstarted.html

RabbitMQ In JAVA 介绍及使用的更多相关文章

  1. RabbitMQ与java、Spring结合实例详细讲解（转）

    林炳文Evankaka原创作品.转载请注明出处http://blog.csdn.net/evankaka 摘要:本文介绍了rabbitMq,提供了如何在Ubuntu下安装RabbitMQ 服务的方法. ...

  2. RabbitMQ系列（三）RabbitMQ交换器Exchange介绍与实践

    RabbitMQ交换器Exchange介绍与实践 RabbitMQ系列文章 RabbitMQ在Ubuntu上的环境搭建 深入了解RabbitMQ工作原理及简单使用 RabbitMQ交换器Exchang ...

  3. RabbitMQ与java、Spring结合实例详细讲解

    林炳文Evankaka原创作品.转载请注明出处http://blog.csdn.net/evankaka 摘要:本文介绍了rabbitMq,提供了如何在Ubuntu下安装RabbitMQ 服务的方法. ...

  4. RabbitMQ的基础介绍

    转自:http://blog.csdn.net/whycold/article/details/41119807 一.引言 你是否遇到过两个(多个)系统间需要通过定时任务来同步某些数据?你是否在为异构 ...

  5. RabbitMQ交换器Exchange介绍与实践

    RabbitMQ交换器Exchange介绍与实践 RabbitMQ系列文章 RabbitMQ在Ubuntu上的环境搭建 深入了解RabbitMQ工作原理及简单使用 RabbitMQ交换器Exchang ...

  6. rabbitmq的简单介绍一

    该博客的主要讲解了以下几种rabbitmq的用法1.实现简单的生产者发送消息给消费者2.实现序列持久化3.实现消息持久化4.实现消息公平分发5.实现广播6.实现组播7.实现细分组播 先来看下rabbi ...

  7. RabbitMQ(3) Java客户端使用

    RabbitMQ针对不同的开发语言(java,python,c/++,Go等等),提供了丰富对客户端,方便使用.就Java而言,可供使用的客户端有RabbitMQ Java client. Rabbi ...

  8. JAVA学习（一）：Java介绍及其平台、开发环境的配置与搭建

    Java介绍及其平台.开发环境的配置与搭建 1.Java的介绍 Java是一种面向对象的编程语言,具有跨平台.可移植.分布式.简单.可扩展等诸多特性.Java能够进行桌面应用.Web应用.分布式系统及 ...

  9. RabbitMQ简单Java示例——生产者和消费者

    添加Maven依赖: 使用rabbitmq-client的最新Maven坐标: <!-- https://mvnrepository.com/artifact/com.rabbitmq/amqp ...

随机推荐

  1. 【Android 应用开发】Android 上实现非root的 Traceroute -- 非Root权限下移植可执行二进制文件 脚本文件

    作者 : 万境绝尘 转载请著名出处 : http://blog.csdn.net/shulianghan/article/details/36438365 示例代码下载 : -- CSDN : htt ...

  2. jsp自动编译机制

    总的来说,Jasper的自动检测实现的机制比较简单,依靠某后台线程不断检测JSP文件与编译后的class文件的最后修改时间是否相同,若相同则认为没有改动,但倘若不同则需要重新编译.实际上由于在Tomc ...

  3. python的exec

    exec "一条python语句" 这样会执行python 语句.用于执行储存在字符串或文件中的Python语句. 当然 也可以 用 exec(str)这种方式, 总之一句话,尽量 ...

  4. mysql进阶(七)limit的用法

    limit是mysql的语法 select * from table limit m,n 其中m是指记录开始的index,从0开始,表示第一条记录 n是指从第m+1条开始,取n条. select *  ...

  5. (转载)SQL Server2008附加数据库之后显示为只读时解决方法

    SQL Server2008附加数据库之后显示为只读时解决方法 啰嗦的话就不多说了,直入主题吧! 方案一: 碰到这中情况一般是使用的sa账户登录的,只要改为Windows身份验证,再附加数据库即可搞定 ...

  6. C/C++中关键字static的用法及作用

    本文将主要从static在C和C++共有的作用及C++特有的作用两个方面进行解析. 在C和C++中共有的作用 隐藏(对变量.函数均可) 当同时编译多个文件时,所有未加static前缀的全局变量或全局函 ...

  7. linu下C语言之BMP图片操作编程(上)

    BMP文件格式,也被称为位图图像文件或与设备无关的位图文件格式(DIB)或者只是一个位图,是 一个光栅图形 图像文件格式使用 来存储位图,数字,图片,独立的显示设备. 微软已经定义了一个特定的表示颜色 ...

  8. SharePoint 2013 新建网站集图解(绝对菜鸟篇)

    前言:接触SharePoint的人可能是越来越多,但是很多人一接触就很迷茫,在技术群里问如何新建网站集,这样一篇图解,帮助新手学习在搭建好SharePoint环境之后,如何创建一个网站集,做一个基本的 ...

  9. LeetCode(69)-Reverse String

    题目: Write a function that takes a string as input and returns the string reversed. Example: Given s ...

  10. 面试之路（3）-详解MVC，MVP，MVVM

    一:mvc mvc结构: 视图(View):用户界面. 控制器(Controller):业务逻辑 模型(Model):数据保存 mvc各部分的通信方式 mvc互动模式 通过 View 接受指令,传递给 ...