简单队列类似于我们的生产者,消费者,




一个生产者,对应一个消费者.




直接上代码:



package com.j1.rabbitmq.simple;

import com.j1.rabbitmq.util.ConnectionUtil;

import com.rabbitmq.client.Channel;

import com.rabbitmq.client.Connection;

import com.rabbitmq.client.QueueingConsumer;

public class Recv {

    private final static String QUEUE_NAME = "test_queue";

    public static void main(String[] argv) throws Exception {

        // 获取到连接以及mq通道

        Connection connection = ConnectionUtil.getConnection();

        Channel channel = connection.createChannel();

        // 声明队列

        /**

         * 如果队列存在,则返回,如果不存在,则创建

         */

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

        // 定义队列的消费者

        QueueingConsumer consumer = new QueueingConsumer(channel);

        // 监听队列

        channel.basicConsume(QUEUE_NAME, true, consumer);

        // 获取消息

        while (true) {

            QueueingConsumer.Delivery delivery = consumer.nextDelivery();

            String message = new String(delivery.getBody());

            System.out.println(" [x] Received '" + message + "'");

        }

    }

}






package com.j1.rabbitmq.simple;

import com.j1.rabbitmq.util.ConnectionUtil;

import com.rabbitmq.client.Channel;

import com.rabbitmq.client.Connection;

public class Send {

    private final static String QUEUE_NAME = "test_queue";

    public static void main(String[] argv) throws Exception {

        // 获取到连接以及mq通道

        Connection connection = ConnectionUtil.getConnection();

        // 从连接中创建通道

        Channel channel = connection.createChannel();

        // 声明（创建）队列

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

        // 消息内容

        String message = "Hello World! 1111";

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

        System.out.println(" [x] Sent '" + message + "'");

        //关闭通道和连接

        channel.close();

        connection.close();

    }

}






生产者生产一条信息,会被消费者进行消费,


但是上面有一个问题,只能是一对一的关系,在应用中很少用的到,


下面我们来讨论一下,一个生产者,多个消费者的情况




package com.j1.rabbitmq.work;

import com.j1.rabbitmq.util.ConnectionUtil;

import com.rabbitmq.client.Channel;

import com.rabbitmq.client.Connection;

public class Send {

    private final static String QUEUE_NAME = "test_queue_work";

    public static void main(String[] argv) throws Exception {

        // 获取到连接以及mq通道

        Connection connection = ConnectionUtil.getConnection();

        Channel channel = connection.createChannel();

        // 声明队列

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

        for (int i = 0; i < 100; i++) {

            // 消息内容

            String message = "" + i;

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

            System.out.println(" [x] Sent '" + message + "'");

            Thread.sleep(i * 10);

        }

        channel.close();

        connection.close();

    }

}






package com.j1.rabbitmq.work;

import com.j1.rabbitmq.util.ConnectionUtil;

import com.rabbitmq.client.Channel;

import com.rabbitmq.client.Connection;

import com.rabbitmq.client.QueueingConsumer;

public class Recv {

    private final static String QUEUE_NAME = "test_queue_work";

    public static void main(String[] argv) throws Exception {

        // 获取到连接以及mq通道

        Connection connection = ConnectionUtil.getConnection();

        Channel channel = connection.createChannel();

        // 声明队列

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

        // 同一时刻服务器只会发一条消息给消费者，每一次服务器只会向客户端发送一条

        //channel.basicQos(1);

        // 定义队列的消费者

        QueueingConsumer consumer = new QueueingConsumer(channel);

        // 监听队列，手动返回完成

        channel.basicConsume(QUEUE_NAME, false, consumer);

        // 获取消息

        while (true) {

            QueueingConsumer.Delivery delivery = consumer.nextDelivery();

            String message = new String(delivery.getBody());

            System.out.println(" [x] Received '" + message + "'");

            //休眠

            Thread.sleep(10);

            // 返回确认状态

            channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);

        }

    }

}






package com.j1.rabbitmq.work;

import com.j1.rabbitmq.util.ConnectionUtil;

import com.rabbitmq.client.Channel;

import com.rabbitmq.client.Connection;

import com.rabbitmq.client.QueueingConsumer;

public class Recv2 {

    private final static String QUEUE_NAME = "test_queue_work";

    public static void main(String[] argv) throws Exception {

        // 获取到连接以及mq通道

        Connection connection = ConnectionUtil.getConnection();

        Channel channel = connection.createChannel();

        // 声明队列

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

        // 同一时刻服务器只会发一条消息给消费者，每一次服务器只会向客户端发送一条

      //  channel.basicQos(1);

        // 定义队列的消费者

        QueueingConsumer consumer = new QueueingConsumer(channel);

        // 监听队列，手动返回完成状态

        channel.basicConsume(QUEUE_NAME, false, consumer);

        // 获取消息

        while (true) {

            QueueingConsumer.Delivery delivery = consumer.nextDelivery();

            String message = new String(delivery.getBody());

            System.out.println(" [x] Received '" + message + "'");

            // 休眠1秒

            Thread.sleep(1000);

            channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);

        }

    }

}




上面标红的地方要特别注意一下,


生产者在生产消息时,消费者的拿到的数据是一样的,这样就很不合理,因为能者多劳嘛,为了解决这一个问题,引入一行代码:




channel.basicQos(1);


上面的生产者生产了100条信息,A消费者拿到48条信息,B拿到52条数据,说明A,B拿的信息不是同一条,


就上面的问题我们有一种解决方案:




package com.j1.rabbitmq.ps;

import com.j1.rabbitmq.util.ConnectionUtil;

import com.rabbitmq.client.Channel;

import com.rabbitmq.client.Connection;

public class Send {

    private final static String EXCHANGE_NAME = "test_exchange_fanout";

    public static void main(String[] argv) throws Exception {

        // 获取到连接以及mq通道

        Connection connection = ConnectionUtil.getConnection();

        Channel channel = connection.createChannel();

        // 声明exchange交换机

        channel.exchangeDeclare(EXCHANGE_NAME, "fanout");

        // 消息内容

        String message = "Hello World!";

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

        System.out.println(" [x] Sent '" + message + "'");

        channel.close();

        connection.close();

    }

}






package com.j1.rabbitmq.ps;

import com.j1.rabbitmq.util.ConnectionUtil;

import com.rabbitmq.client.Channel;

import com.rabbitmq.client.Connection;

import com.rabbitmq.client.QueueingConsumer;

public class Recv {

    private final static String QUEUE_NAME = "test_queue_exchange";

    private final static String EXCHANGE_NAME = "test_exchange_fanout";

    public static void main(String[] argv) throws Exception {

        // 获取到连接以及mq通道

        Connection connection = ConnectionUtil.getConnection();

        Channel channel = connection.createChannel();

        // 声明队列

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

        // 绑定队列到交换机

        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "");

        // 同一时刻服务器只会发一条消息给消费者

        channel.basicQos(1);

        // 定义队列的消费者

        QueueingConsumer consumer = new QueueingConsumer(channel);

        // 监听队列，手动返回完成

        channel.basicConsume(QUEUE_NAME, false, consumer);

        // 获取消息

        while (true) {

            QueueingConsumer.Delivery delivery = consumer.nextDelivery();

            String message = new String(delivery.getBody());

            System.out.println(" [x] Received '" + message + "'");

            Thread.sleep(10);

            // 返回消息消费状态

            channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);

        }

    }

}






package com.j1.rabbitmq.ps;

import com.j1.rabbitmq.util.ConnectionUtil;

import com.rabbitmq.client.Channel;

import com.rabbitmq.client.Connection;

import com.rabbitmq.client.QueueingConsumer;

public class Recv2 {

    private final static String QUEUE_NAME = "test_queue_exchange2";

    private final static String EXCHANGE_NAME = "test_exchange_fanout";

    public static void main(String[] argv) throws Exception {

        // 获取到连接以及mq通道

        Connection connection = ConnectionUtil.getConnection();

        Channel channel = connection.createChannel();

        // 声明队列

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

        // 绑定队列到交换机

        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "");

        // 同一时刻服务器只会发一条消息给消费者

        channel.basicQos(1);

        // 定义队列的消费者

        QueueingConsumer consumer = new QueueingConsumer(channel);

        // 监听队列，手动返回完成

        channel.basicConsume(QUEUE_NAME, false, consumer);

        // 获取消息

        while (true) {

            QueueingConsumer.Delivery delivery = consumer.nextDelivery();

            String message = new String(delivery.getBody());

            System.out.println(" [x] Received '" + message + "'");

            Thread.sleep(10);

            channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);

        }

    }

}




其实总结一下:




一个生产者，多个消费者，每个消费者获取到的消息是一样的。


1、生产者发送消息到交换机。（生产者可以向队列或者交换机发送消息）


2、消费者监听消息队列，消费者永远只能从队列中获取消息。


3、队列绑定到交换机，获取消息。


就是将队列绑定在交换机上,监听队列,获取生产者者信息.


一个交换机可以对应好几个队列,


这种模式将用于我们的搜索,缓存服务,后面会在实际应用中看到
												


											
RabbitMq 之简单队列的更多相关文章
	

    
								
  1. RabbitMQ (二) 简单队列
		
    参考:https://blog.csdn.net/vbirdbest/article/details/78583480 简单队列的模型: P : 生产者,即 Producer C : 消费者,即 Co ...
    
		
    2. 
						
  2. RabbitMq(2) 简单消息队列
		
    <dependency> <groupId>com.rabbitmq</groupId> <artifactId>amqp-client </ar ...
    
		
    3. 
						
  3. RabbitMQ学习笔记（2）----RabbitMQ简单队列（Hello World）的使用
		
    1. 简单队列结构图 2. 引入依赖 pom.xml文件 <dependency> <groupId>com.rabbitmq</groupId> <arti ...
    
		
    4. 
						
  4. RabbitMQ六种队列模式-简单队列模式
		
    前言 RabbitMQ六种队列模式-简单队列 [本文]RabbitMQ六种队列模式-工作队列RabbitMQ六种队列模式-发布订阅RabbitMQ六种队列模式-路由模式RabbitMQ六种队列模式-主 ...
    
		
    5. 
						
  5. RabbitMQ ——与Spring集成及exchange的direct、topic方式实现和简单队列实现
		
    程序整体结构 Maven依赖 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http: ...
    
		
    6. 
						
  6. RabbitMQ ——简单队列
		
    一 .概述 我们不从开始就讲述基本的概念,尤其是在Rabbitmq之中有些概念确实比较难以理解,我们首先做的就是将光放提供的消息模型 进行实现,然后再总结一下Rabbitmq之中的基本概念. 二 .基 ...
    
		
    7. 
						
  7. RabbitMQ消息队列（一）: 简单队列
		
    1. 示例选用python的pika模块进行测试,需要预先安装pika模块: https://pypi.python.org/pypi/pika/0.10.0#downloads 上述地址下载源码,加 ...
    
		
    8. 
						
  8. RabbitMQ分布式消息队列服务器（一、Windows下安装和部署）
		
    RabbitMQ消息队列服务器在Windows下的安装和部署-> 一.Erlang语言环境的搭建 RabbitMQ开源消息队列服务是使用Erlang语言开发的,因此我们要使用他就必须先进行Erl ...
    
		
    9. 
						
  9. python---RabbitMQ（1）简单队列使用,消息依次分发（一对一），消息持久化处理
		
    MQ全称为Message Queue, 消息队列(MQ)是一种应用程序对应用程序的通信方法.应用程序通过读写出入队列的消息(针对应用程序的数据)来通信,而无需专用连接来链接它们.消息传递指的是程序之间 ...
    
		
    10. 
		

	


随机推荐
	

    
									
  1. Hive之分区（Partitions）和桶（Buckets）
			
    转自:http://www.aahyhaa.com/archives/316 hive引入partition和bucket的概念,中文翻译分别为分区和桶(我觉的不是很合适,但是网上基本都是这么翻译,暂 ...
    
			
    2. 
						
  2. FPGA中的时序分析(一)
			
    谈及此部分,多多少少有一定的难度,笔者写下这篇文章,差不多是在学习FPGA一年之后的成果,尽管当时也是看过类似的文章,但是都没有引起笔者注意,笔者现在再对此知识进行梳理,也发现了有很多不少的收获.笔者 ...
    
			
    3. 
						
  3. redis、kafka、rabittMQ对比
			
    本文不对三者之间的性能进行对比,只是从三者的特性上区分他们,并指出三者的不用应用场景. 1.publish/subscribe 发布订阅模式如下图所示可以具有多个生产者和发布者,redis.kafka ...
    
			
    4. 
						
  4. SpringBoot系列十二：SpringBoot整合 Shiro
			
    声明:本文来源于MLDN培训视频的课堂笔记,写在这里只是为了方便查阅. 1.概念:SpringBoot 整合 Shiro 2.具体内容 Shiro 是现在最为流行的权限认证开发框架,与它起名的只有最初 ...
    
			
    5. 
						
  5. python环境搭建和开发工具的配置【转】
			
    因为要学习python了,第一步当然是环境搭建和开发工具的配置了,下边开始了. 我的开发环境是在window下. 一.环境搭建 先在python官网python.org下载安装文件,python2.x ...
    
			
    6. 
						
  6. Linux Shell nohup命令用法
			
    linux的nohup命令的用法.   在应用Unix/Linux时,我们一般想让某个程序在后台运行,于是我们将常会用 & 在程序结尾来让程序自动运行.比如我们要运行mysql在后台: /us ...
    
			
    7. 
						
  7. andorid ndk 各种坑啊 记录下
			
    android jni代码回调java的问题 因为多线程原因会导致找不到java类,无法call函数的问题 问题1找不到java类 在JNI_OnLoad的时候 保存下来 JNIEXPORT jint ...
    
			
    8. 
						
  8. html常用对照表
			
    常用对照表:http://tool.oschina.net/commons
    
			
    9. 
						
  9. RNA_seq GATK 最佳实践
			
    GATK处理DNA 水平的snp 经验比较成熟,而RNA 水平较少,所以可能会存在错误 目前的流程兼顾了假阳性(不是真的snp位点)和假阴性(该位点是snp,却没有检测到):后续会不断改善     G ...
    
			
    10. 
						
  10. HTML5 Canvas火焰效果 像火球发射一样
			
    Canvas是HTML5中非常重要而且有用的东西,我们可以在Canvas上绘制任意的元素,就像你制作Flash一样.今天我们就在Canvas上来制作一款火焰发射的效果.就像古代的火球炮一样,而且可以在 ...
    
			
    11.