一、Memcache
Memcache是一套分布式的高速缓存系统，由LiveJournal的Brad Fitzpatrick开发，但目前被许多网站使用以提升网站的访问速度，尤其对于一些大型的、需要频繁访问数据库的网站访问速度提升效果十分显著。

MemCache的工作流程如下：
先检查客户端请求数据是否在memcached中，如有，直接把请求数据返回，不再对数据库进行任何操作；如果请求的数据不在memcached中，就去查数据库，把从数据库中获取的数据返回给客户端，同时把数据缓存一份到memcached中（memcached客户端不负责，需要程序明确实现）；每次更新数据库的同时更新memcached中的数据，保证一致性；当分配给memcached内存空间用完之后，会使用LRU（Least Recently Used，最近最少使用）策略加上到期失效策略，失效数据首先被替换，然后再替换掉最近未使用的数据。

Memcache是一个高性能的分布式的内存对象缓存系统，通过在内存里维护一个统一的巨大的hash表，它能够用来存储各种格式的数据，包括图像、视频、文件以及数据库检索的结果等。简单的说就是将数据调用到内存中，然后从内存中读取，从而大大提高读取速度。

Memcached是以守护程序(监听)方式运行于一个或多个服务器中，随时会接收客户端的连接和操作，特性如下：
-  在Memcached中可以保存的item数据量是没有限制的，只要内存足够 。
-  Memcached单进程在32位系统中最大使用内存为2G，若在64位系统则没有限制,这是由于32位系统限制单进程最多可使用2G内存,要使用更多内存，可以分多个端口开启多个  Memcached进程 ,
-  最大30天的数据过期时间,设置为永久的也会在这个时间过期，常量REALTIME_MAXDELTA
-  60*60*24*30控制
-  最大键长为250字节，大于该长度无法存储，常量KEY_MAX_LENGTH 250控制
-  单个item最大数据是1MB，超过1MB数据不予存储，常量POWER_BLOCK 1048576进行控制，
-  它是默认的slab大小
-  最大同时连接数是200，通过 conn_init()中的freetotal进行控制，最大软连接数是1024，通过 settings.maxconns=1024 进行控制
-  跟空间占用相关的参数：settings.factor=1.25, settings.chunk_size=48, 影响slab的数据占用和步进方式

memcached是一种无阻塞的socket通信方式服务，基于libevent库，由于无阻塞通信，对内存读写速度非常之快。
memcached分服务器端和客户端，可以配置多个服务器端和客户端，应用于分布式的服务非常广泛。
memcached作为小规模的数据分布式平台是十分有效果的。
memcached是键值一一对应，key默认最大不能超过128个字 节，value默认大小是1M，也就是一个slabs，如果要存2M的值（连续的），不能用两个slabs，因为两个slabs不是连续的，无法在内存中 存储，故需要修改slabs的大小，多个key和value进行存储时，即使这个slabs没有利用完，那么也不会存放别的数据。
memcached已经可以支持C/C++、Perl、PHP、Python、Ruby、Java、C#、Postgres、Chicken Scheme、Lua、MySQL和Protocol等语言客户端。

Memcache的安装

[root@linux-node1 ~]#  yum install libevent-devel -y

[root@linux-node1 ~]#  yum install memcached -y

Memcache的 启动

[root@linux-node1 ~]# memcached -d -m 10 -u root -l 192.168.56.11 -p 11211 -c 256 -P /tmp/memcached.pid

[root@linux-node1 ~]# netstat -antlp|grep 11211

tcp        0      0 192.168.56.11:11211     0.0.0.0:*               LISTEN      2251/memcached 

参数说明

-d 是启动一个守护进程

-m 是分配给Memcache使用的内存数量，单位是MB

-u 是运行Memcache的用户

-l 是监听的服务器IP地址

-p 是设置Memcache监听的端口,最好是1024以上的端口

-c 选项是最大运行的并发连接数，默认是1024，按照你服务器的负载量来设定

-P 是设置保存Memcache的pid文件

使用python操作Memcached
安装API

[root@linux-node1 ~]#  yum install -y python-memcached

[root@linux-node1 ~]# python

Python 2.7.5 (default, Jun 24 2015, 00:41:19)

[GCC 4.8.3 20140911 (Red Hat 4.8.3-9)] on linux2

Type "help", "copyright", "credits" or "license" for more information.

>>> import memcache

>>> quit()

1）Memcache的第一次

[root@linux-node1 ~]# python

Python 2.7.5 (default, Jun 24 2015, 00:41:19)

[GCC 4.8.3 20140911 (Red Hat 4.8.3-9)] on linux2

Type "help", "copyright", "credits" or "license" for more information.

>>> import memcache

>>> mc =memcache.Client(['192.168.56.11:11211'],debug=True)

>>> mc.set("foo","bar")

True

>>> ret = mc.get('foo')

>>> print ret

温馨提示：上面的debug=True；是表示运行出现错误的时候，显示错误信息，上线后，移除该参数。

2）Memcache和集群是一对好基友
python-memcached模块原生支持集群的操作，其原理是在内存维护一个主机列表

#!/usr/bin/env python

# coding:utf-8

import memcache

mc = memcache.Client([('192.168.56.11',1),('192.168.56.12',2)],debug=True)

# 主机列表：li = [192.168.56.11:11211,192.168.56.12:11211,192.168.56.13:11211,]

mc.set("foo","234")

# 1：将"foo"字符串转换成数字

# 2：将数字和主机列表长度求余数

# 3：li[余数]，可以得到主机和IP

# 4：连接主机ip 将foo = 234 保存到mem上

ret = mc.get('foo')

print ret

3）add
添加一条键值对，如果已经存在的key，重复执行add操作异常。

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import memcache

mc = memcache.Client(['192.168.56.11:11211'],debug=True)

mc.add('k1','v1')

多次执行会报错

[root@linux-node1 test]# python 1.py

[root@linux-node1 test]# python 1.py

MemCached: while expecting 'STORED', got unexpected response 'NOT_STORED'

4）replace
修改某个key的值，如果key值不存在，则异常

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import memcache

mc = memcache.Client(['192.168.56.11:11211'],debug=True)

# 如果存在k1，则替换成功；

mc.replace('k1','v1v1v1')

不存在则报错

[root@linux-node1 test]# cat 2.py

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import memcache

mc = memcache.Client(['192.168.56.11:11211'],debug=True)

# 如果存在k1，则替换成功；

mc.replace('k1k1','v1v1v1')

[root@linux-node1 test]# python 2.py

MemCached: while expecting 'STORED', got unexpected response 'NOT_STORED'

5）set和set_multi
set                  设置一个键值对，如果key不存在，则创建，如果key存在，则修改
set_multi        设置多个键值对，如果key不存在，则创建，如果key存在，则修改

[root@linux-node1 test]# cat 3.py

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import memcache

mc = memcache.Client(['192.168.56.11:11211'],debug=True)

mc.set('key1','ccccc')

# 一个键值对

mc.set_multi({'key2': 'ggggg','key3': 'tttt'})

[root@linux-node1 test]# python 3.py

6）delete和delete_multi
delete 在Memcached中删除指定的一个键值对
delete_multi 在Memcached中删除指定的多个键值对

[root@linux-node1 test]# cat 4.py

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import memcache

mc = memcache.Client(['192.168.56.11:11211'],debug=True)

mc.delete('key1')

# 一个键值对

mc.delete_multi(['key2','key3'])

[root@linux-node1 test]# python 4.py

7）get和get_multi
get              获取一个键值对
get_multi    取多一个键值对

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import memcache

mc = memcache.Client(['192.168.56.11:11211], debug=True)

val = mc.get('key1')

item_dict = mc.get_multi(["key2", "key3"])

8）append和prepend
append     修改指定key的值，在该值 后面 追加内容
prepend    修改指定key的值，在该值 前面 插入内容

[root@linux-node1 test]# cat 5.py

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import memcache

mc = memcache.Client(['192.168.56.11:11211'],debug=True)

# 假设k1 = v1

mc.append('k1','after')

# 在v1的后面加after

mc.prepend('k1','before')

# 在v1的前面加before

9）decr和incr
incr    自增，将Memcached中的某一个值增加 N （ N默认为1 ）
decr  自减，将Memcached中的某一个值减少 N （ N默认为1 ）

#!/usr/bin/env python

# coding:utf-8

import memcache

mc = memcache.Client(['192.168.56.11',1],debug=True)

mc.set('k1','123')

# 默认变化的值为1

mc.incr('k1',10)

# k1的值会变成133

mc.decr('k1',23)

# k1的值会变成110

10）如果用终端，同时操作一组数据的话，会出现非正常数据，使用gets和cas来解决

#!/usr/bin/env python

# coding:utf-8

import memcache

mc = memcache.Client(['192.168.56.11',1],debug=True)

# 假设k1=1111

mc.gets('k1')

# 此时A用户gets了数据。

# 进行了减法操作

# 来了B用户，也对k1进行了操作，这时候，执行下面的操作就会报错

mc.cas('product_count', "1110")

解析：
本质上每次执行gets时，会从memcache中获取一个自增的数字，通过cas去修改gets的值时，会携带之前获取的自增值和memcache中的自增值进行比较，如果相等，则可以提交，如果不想等，那表示在gets和cas执行之间，又有其他人执行了gets（获取了缓冲的指定值）， 如此一来有可能出现非正常数据，则不允许修改。

二、Redis
简介：
Redis是一个key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在此基础上，redis支持各种不同方式的排序。与memcached一样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。

Redis支持主从同步。数据可以从主服务器向任意数量的从服务器上同步，从服务器可以是关联其他从服务器的主服务器。这使得Redis可执行单层树复制。存盘可以有意无意的对数据进行写操作。由于完全实现了发布/订阅机制，使得从数据库在任何地方同步树时，可订阅一个频道并接收主服务器完整的消息发布记录。同步对读取操作的可扩展性和数据冗余很有帮助。

Redis与memcache的比较
Redis 是一个高性能的key-value数据库。 redis的出现，很大程度补偿了memcached这类key/value存储的不足，在部 分场合可以对关系数据库起到很好的补充作用。它提供了Java，C/C++，C#，PHP，JavaScript，Perl，Object-C，Python，Ruby，Erlang等客户端，使用很方便。

数据模型：
Redis的外围由一个键、值映射的字典构成。与其他非关系型数据库主要不同在于：Redis中值的类型
不仅限于字符串，还支持如下抽象数据类型：
-  字符串列表
-  无序不重复的字符串集合
-  有序不重复的字符串集合
-  键、值都为字符串的哈希表
-  值的类型决定了值本身支持的操作。Redis支持不同无序、有序的列表，无序、有序的集合间的交集、并集等高级服务器端原子操作。

数据结构：
redis提供五种数据类型：string，hash，list，set及zset(sorted set)。

存储：
-  redis使用了两种文件格式：全量数据和增量请求。
-  全量数据格式是把内存中的数据写入磁盘，便于下次读取文件进行加载；
-  增量请求文件则是把内存中的数据序列化为操作请求，用于读取文件进行replay得到数据，序列化的操作包括SET、RPUSH、SADD、ZADD。
-  redis的存储分为内存存储、磁盘存储和log文件三部分，配置文件中有三个参数对其进行配置。
-  save seconds updates，save配置，指出在多长时间内，有多少次更新操作，就将数据同步到数据文件。这个可以多个条件配合，比如默认配置文件中的设置，就设置了三个条件。
-  appendonly yes/no ，appendonly配置，指出是否在每次更新操作后进行日志记录，如果不开启，可能会在断电时导致一段时间内的数据丢失。因为redis本身同步数据文件是按上面的save条件来同步的，所以有的数据会在一段时间内只存在于内存中。
-  appendfsync no/always/everysec ，appendfsync配置，no表示等操作系统进行数据缓存同步到磁盘，always表示每次更新操作后手动调用fsync()将数据写到磁盘，everysec表示每秒同步一次。

安装启动：
直接yum安装:

[root@linux-node1 ~]#  yum -y install redis

[root@linux-node1 ~]# systemctl start redis

[root@linux-node1 ~]# ps -ef |grep redis

redis     16359      1  0 16:55 ?        00:00:00 /usr/bin/redis-server 127.0.0.1:6379

root      16363  16335  0 16:56 pts/0    00:00:00 grep --color=auto redis

启动客户端：

[root@linux-node1 ~]# redis-cli

127.0.0.1:6379> set foo bar

OK

127.0.0.1:6379> get foo

"bar"

使用python操作redis
首先安装组件：

[root@linux-node1 ~]# yum -y install python-pip

[root@linux-node1 ~]# pip install redis

常用操作
1）操作模式
redis-py提供两个类Redis和StictRedis用于实现Redis命令，StrictRedis用于实现大部分官方的功能，并使用官方的语法和命令，Redis是StricRedis的子类，用于向后兼容旧版本的redis-py。

[root@linux-node1 test]# cat 6.py

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import redis

r = redis.Redis(host='127.0.0.1',port=6379)

r.set('foo','bar')

print r.get('foo')

[root@linux-node1 test]# python 6.py

bar

2）连接池
redis-py使用connection pool来管理对一个redis server的所有连接，避免每次建立、释放连接的开销。默认，每个Redis实例都会维护一个自己的连接池。可以直接建立一个连接池，然后作为参数Redis，这样就可以实现多个Redis实例共享一个连接池。

[root@linux-node1 test]# cat 6.py

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import redis

pool = redis.ConnectionPool(host='127.0.0.1',port=6379)

r=redis.Redis(connection_pool=pool)

r.set('foo','bar')

print r.get('foo')

[root@linux-node1 test]# python 6.py

bar

3）管道
redis-py默认在执行每次请求都会创建（连接池申请连接）和断开（归还连接池）一次连接操作，如果想要在一次请求中指定多个命令，则可以使用pipline实现一次请求指定多个命令，并且默认情况下一次pipline 是原子性操作。

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import redis

pool = redis.ConnectionPool(host='127.0.0.1',port=6379)

r=redis.Redis(connection_pool=pool)

#pipe = r.pipeline(transaction=False)

pipe = r.pipeline(transaction=True)

r.set('foo','bar')

r.set('foo111','bar111')

ret = pipe.execute()

4）发布订阅

频道：

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import redis

class RedisHelper:

    def __init__(self):

        self.__conn = redis.Redis(host='10.211.55.4')

        self.chan_sub = 'fm104.5'

        self.chan_pub = 'fm104.5'

    def public(self, msg):

        self.__conn.publish(self.chan_pub, msg)

        return True

    def subscribe(self):

        pub = self.__conn.pubsub()

        pub.subscribe(self.chan_sub)

        pub.parse_response()

        return pub

订阅者

#!/usr/bin/env python

# -*- coding:utf-8 -*-

from monitor.RedisHelper import RedisHelper

obj = RedisHelper()

redis_sub = obj.subscribe()

while True:

    msg= redis_sub.parse_response()

    print msg

发布者

#!/usr/bin/env python

# -*- coding:utf-8 -*-

from monitor.RedisHelper import RedisHelpe

obj = RedisHelper()

obj.public('hello')

三、RabbitMQ
RabbitMQ是一个在AMQP基础上完整的，可复用的企业消息系统。他遵循Mozilla Public License开源协议。

MQ全称为Message Queue, 消息队列（MQ）是一种应用程序对应用程序的通信方法。应用程序通过读写出入队列的消息（针对应用程序的数据）来通信，而无需专用连接来链接它们。消 息传递指的是程序之间通过在消息中发送数据进行通信，而不是通过直接调用彼此来通信，直接调用通常是用于诸如远程过程调用的技术。排队指的是应用程序通过 队列来通信。队列的使用除去了接收和发送应用程序同时执行的要求。

RabbitMQ的安装

### 安装配置epel源，如果你是centos7，请换epel源

   $ rpm -ivh http://dl.fedoraproject.org/pub/epel/6/i386/epel-release-6-8.noarch.rpm

### 安装erlang

   $ yum -y install erlang

### 安装RabbitMQ

   $ yum -y install rabbitmq-server

### 启动

[root@linux-node1 test]# /usr/sbin/rabbitmq-server start

[root@linux-node1 test]# ps -ef |grep rabbitmq-server

root      17096  16335  0 18:36 pts/0    00:00:00 /bin/sh /usr/sbin/rabbitmq-server start

root      17105  17096  0 18:36 pts/0    00:00:00 su rabbitmq -s /bin/sh -c /usr/lib/rabbitmq/bin/rabbitmq-server  "start"

root      17181  16510  0 18:36 pts/3    00:00:00 grep --color=auto rabbitmq-server

安装API

[root@linux-node1 test]# pip install pika

使用API操作RabbitMQ
基于Queue实现生产者消费者模型

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import Queue

import threading

message = Queue.Queue(10)

def producer(i):

    while True:

        message.put(i)

def consumer(i):

    while True:

        msg = message.get()

for i in range(12):

    t = threading.Thread(target=producer, args=(i,))

    t.start()

for i in range(10):

    t = threading.Thread(target=consumer, args=(i,))

    t.start()

对于RabbitMQ来说，生产和消费不再针对内存里的一个Queue对象，而是某台服务器上的RabbitMQ Server实现的消息队列。
生产者：

#!/usr/bin/env python

# coding:utf-8

import pika

# 创建一个连接

connection = pika.BlockingConnection(pika.ConnectionParameters(host='127.0.0.1'))

# 打开一个通道

channel = connection.channel()

# 队列声明叫hello

channel.queue_declare(queue='hello')

# 向队列中插入数据，往hello对队列中插入hello world

channel.basic_publish(exchange='',

                      routing_key='hello',

                      body='Hello World!')

print(" [x] Sent 'Hello World!'")

connection.close()

消费者：

#!/usr/bin/env python

# coding:utf-8

import pika

# 创建一个连接

connection = pika.BlockingConnection(pika.ConnectionParameters(host='127.0.0.1'))

# 打开一个通道，创建频道

channel = connection.channel()

# 队列声明叫hello

channel.queue_declare(queue='hello')

def callback(ch, method, properties, body):

    print(" [x] Received %r" % body)

# 消费队列中的内容，同时执行callback函数，callback函数中的body就是拿取到的内容

channel.basic_consume(callback,

                      queue='hello',

                      no_ack=True)      # 出现断开的情况，数据就会丢失；这种方式发布者和听众是没有相互应答的

print(' [*] Waiting for messages. To exit press CTRL+C')

channel.start_consuming()

1）acknowledgment 消息不丢失（消费者失联）
no-ack ＝ False，如果生产者遇到情况(its channel is closed, connection is closed, or TCP connection is lost)挂掉了，那么，RabbitMQ会重新将该任务添加到队列中。在消费者中操作

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters(host='127.0.0.1'))

channel = connection.channel()

channel.queue_declare(queue='hello')

def callback(ch, method, properties, body):

    print(" [x] Received %r" % body)

    import time

    time.sleep(10)

    print 'ok'

    ch.basic_ack(delivery_tag = method.delivery_tag)

channel.basic_consume(callback,

                      queue='hello',

                      no_ack=False)

# 这里使用False

print(' [*] Waiting for messages. To exit press CTRL+C')

channel.start_consuming()

2）durable消息不丢失
如果是生产者挂掉了呢，你说你咋整？消息队列可以做持久化，哈哈哈
生产者

#!/usr/bin/env python

# coding:utf-8

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters(host='127.0.0.1'))

channel = connection.channel()

# 声明这个消息队列的时候就要使用durable来声明持久化

channel.queue_declare(queue='hello', durable=True)

channel.basic_publish(exchange='',

                      routing_key='hello',

                      body='Hello World!',

                      properties=pika.BasicProperties(

                          delivery_mode=2, # make message persistent

                      ))    # 指定消息的时候，也是要持久化

print(" [x] Sent 'Hello World!'")

connection.close()

消费者

#!/usr/bin/env python

# coding:utf-8

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters(host='127.0.0.1'))

channel = connection.channel()

# 这个可有可无

channel.queue_declare(queue='hello', durable=True)

def callback(ch, method, properties, body):

    print(" [x] Received %r" % body)

    import time

    time.sleep(10)

    print 'ok'

    ch.basic_ack(delivery_tag = method.delivery_tag)

channel.basic_consume(callback,

                      queue='hello',

                      no_ack=False)

print(' [*] Waiting for messages. To exit press CTRL+C')

channel.start_consuming()

已经存在的消息队列，无法进行持久化，只能重新生成队列才行。

3）消息获取顺序
默认消息队列里的数据是按照顺序被消费者拿走，例如：消费者1 去队列中获取 奇数 序列的任务，消费者1去队列中获取 偶数 序列的任务。
channel.basic_qos(prefetch_count=1) 表示谁来谁取，不再按照奇偶数排列。这个需要在消费者上来操作。

#!/usr/bin/env python

# coding:utf-8

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters(host='127.0.0.1'))

channel = connection.channel()

channel.queue_declare(queue='hello')

def callback(ch, method, properties, body):

    print(" [x] Received %r" % body)

    import time

    time.sleep(10)

    print 'ok'

    ch.basic_ack(delivery_tag = method.delivery_tag)

# 谁来谁取

channel.basic_qos(prefetch_count=1)

channel.basic_consume(callback,

                      queue='hello',

                      no_ack=False)

print(' [*] Waiting for messages. To exit press CTRL+C')

channel.start_consuming()

4）发布订阅
发布订阅和简单的消息队列区别在于，发布订阅会将消息发送给所有的订阅者，而消息队列中的数据被消费一次便消失。所以，RabbitMQ实现发布和订阅时，会为每一个订阅者创建一个队列，而发布者发布消息时，会将消息放置在所有相关队列中。
exchange type = fanout 表示可以给多个队列发数据，可以理解为广播
发布者

#!/usr/bin/env python

# coding:utf-8

import pika

import sys

connection = pika.BlockingConnection(pika.ConnectionParameters(

        host=((‘

127.0.0.1

'))

channel = connection.channel()

channel.exchange_declare(exchange='logs',  # logs随便起名字

                         type='fanout') # 可以给多个队列发数据

message = ' '.join(sys.argv[1:]) or "info: Hello World!"

channel.basic_publish(exchange='logs',

                      routing_key='',

                      body=message)

print(" [x] Sent %r" % message)

connection.close()

订阅者一

#!/usr/bin/env python

# coding:utf-8

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters(

        host='127.0.0.1'))

channel = connection.channel()

# 定义声明，为logs

channel.exchange_declare(exchange='logs',

                         type='fanout')

result = channel.queue_declare(exclusive=True)

queue_name = result.method.queue

# 生成了一个随机名称

# 让队列和exchange进行绑定，以后生产者发送来数据，exchange就会往queue中转发数据

channel.queue_bind(exchange='logs',

                   queue=queue_name)

print(' [*] Waiting for logs. To exit press CTRL+C')

def callback(ch, method, properties, body):

    print(" [x] %r" % body)

# 一直去取数据

channel.basic_consume(callback,

                      queue=queue_name,

                      no_ack=True)

channel.start_consuming()

订阅者二

#!/usr/bin/env python

# coding:utf-8

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters(

        host='127.0.0.1'))

channel = connection.channel()

# 定义声明，为logs

channel.exchange_declare(exchange='logs',

                         type='fanout')

result = channel.queue_declare(exclusive=True)

queue_name = result.method.queue

# 生成了一个随机名称

# 让队列和exchange进行绑定，以后生产者发送来数据，exchange就会往queue中转发数据

channel.queue_bind(exchange='logs',

                   queue=queue_name)

print(' [*] Waiting for logs. To exit press CTRL+C')

def callback(ch, method, properties, body):

    print(" [x] %r" % body)

# 一直去取数据

channel.basic_consume(callback,

                      queue=queue_name,

                      no_ack=True)

channel.start_consuming()

可以同时使用两个来测试，同时都能接收到数据

5）关键字发送
exchange type = direct
之前事例，发送消息时明确指定某个队列并向其中发送消息，RabbitMQ还支持根据关键字发送，即：队列绑定关键字，发送者将数据根据关键字发送到消息exchange，exchange根据 关键字 判定应该将数据发送至指定队列。
订阅者一：

#!/usr/bin/env python

# coding:utf-8

import pika

import sys

connection = pika.BlockingConnection(pika.ConnectionParameters(

        host='127.0.0.1'))

channel = connection.channel()

channel.exchange_declare(exchange='direct_logs',

                         type='direct')

result = channel.queue_declare(exclusive=True)

queue_name = result.method.queue

channel.queue_bind(exchange='direct_logs',

                   queue=queue_name,

                   routing_key='aaa')

channel.queue_bind(exchange='direct_logs', queue=queue_name, routing_key='bbb')

print(' [*] Waiting for logs. To exit press CTRL+C')

def callback(ch, method, properties, body):

    print(" [x] %r:%r" % (method.routing_key, body))

channel.basic_consume(callback,

                      queue=queue_name,

                      no_ack=True)

channel.start_consuming()

订阅者二

#!/usr/bin/env python

# coding:utf-8

import pika

import sys

connection = pika.BlockingConnection(pika.ConnectionParameters(

        host='127.0.0.1'))

channel = connection.channel()

channel.exchange_declare(exchange='direct_logs',

                         type='direct')

result = channel.queue_declare(exclusive=True)

queue_name = result.method.queue

channel.queue_bind(exchange='direct_logs',

                   queue=queue_name,

                   routing_key='bbb')

channel.queue_bind(exchange='direct_logs', queue=queue_name, routing_key='ccc')

print(' [*] Waiting for logs. To exit press CTRL+C')

def callback(ch, method, properties, body):

    print(" [x] %r:%r" % (method.routing_key, body))

channel.basic_consume(callback,

                      queue=queue_name,

                      no_ack=True)

channel.start_consuming()

生产者

#!/usr/bin/env python

# coding:utf-8

import pika

import sys

connection = pika.BlockingConnection(pika.ConnectionParameters(

        host='127.0.0.1'))

channel = connection.channel()

channel.exchange_declare(exchange='direct_logs',

                         type='direct')

message = 'Hello World!'

channel.basic_publish(exchange='direct_logs',

                      routing_key='ccc',    # 指定订阅者的队列关键字是ccc

                      body=message)

print(" [x] Sent %r" % (message))

此时，只有订阅者二符合，会有数据收到

6）模糊匹配
exchange type = topic
在topic类型下，可以让队列绑定几个模糊的关键字，之后发送者将数据发送到exchange，exchange将传入”路由值“和 ”关键字“进行匹配，匹配成功，则将数据发送到指定队列。
#  表示可以匹配 0 个 或 多个 单词
*  表示只能匹配 一个 单词
订阅者1

#!/usr/bin/env python

# coding:utf-8

import pika

import sys

connection = pika.BlockingConnection(pika.ConnectionParameters(

        host='127.0.0.1'))

channel = connection.channel()

channel.exchange_declare(exchange='topic_logs',

                         type='topic')

result = channel.queue_declare(exclusive=True)

queue_name = result.method.queue

channel.queue_bind(exchange='topic_logs',

                   queue=queue_name,

                   routing_key='cgt.*')

print(' [*] Waiting for logs. To exit press CTRL+C')

def callback(ch, method, properties, body):

    print(" [x] %r:%r" % (method.routing_key, body))

channel.basic_consume(callback,

                      queue=queue_name,

                      no_ack=True)

channel.start_consuming()

订阅者2

#!/usr/bin/env python

# coding:utf-8

import pika

import sys

connection = pika.BlockingConnection(pika.ConnectionParameters(

        host='127.0.0.1'))

channel = connection.channel()

channel.exchange_declare(exchange='topic_logs',

                         type='topic')

result = channel.queue_declare(exclusive=True)

queue_name = result.method.queue

channel.queue_bind(exchange='topic_logs',

                   queue=queue_name,

                   routing_key='cgt.#')

print(' [*] Waiting for logs. To exit press CTRL+C')

def callback(ch, method, properties, body):

    print(" [x] %r:%r" % (method.routing_key, body))

channel.basic_consume(callback,

                      queue=queue_name,

                      no_ack=True)

channel.start_consuming()

生产者

#!/usr/bin/env python

# coding:utf-8

import pika

import sys

connection = pika.BlockingConnection(pika.ConnectionParameters(

        host='127.0.0.1'))

channel = connection.channel()

channel.exchange_declare(exchange='topic_logs',

                         type='topic')

message = 'Hello World!'

channel.basic_publish(exchange='topic_logs',

                      routing_key='cgt.caoxiaojian.com',

                      body=message)

print(" [x] Sent %r:%r" % (message))

connection.close()

这样测试，只有订阅者2收到，因为他是#

Python下操作Memcache/Redis/RabbitMQ说明的更多相关文章

  1. 在telnet下操作memcache详解（操作命令详解）

    这篇文章主要介绍了在telnet下操作memcache详解,telnet下的memcache操作命令详解,需要的朋友可以参考下 在定位问题.测试等时候经常需要对memcache的数据进行一些操作,但是 ...

  2. python下操作mysql 之 pymsql

    python下操作mysql  之  pymsql pymsql是Python中操作MySQL的模块, 下载安装: pip3 install pymysql 使用操作 1, 执行SQL #!/usr/ ...

  3. 文成小盆友python-num11－（2） python操作Memcache Redis

    本部分主要内容: python操作memcache python操作redis 一.python 操作 memcache memcache是一套分布式的高速缓存系统,由LiveJournal的Brad ...

  4. python下操作redis

    python安装这里我只介绍如何在Windows上安装redis,以及接下来的实践都是在Windows上进行的.在Windows上安装python的依赖库,常用的方法有两种,第一种是直接通过pip i ...

  5. linux下操作memcache的操作命令

    1.连接memcache linux下一般使用telnet连接memcache服务 [root@localhost ~]# telnet 127.0.0.1 11266 Trying 127.0.0. ...

  6. python下操作ftp上传

    生产情况:tomcat下业务log备份,目录分多级,然后对应目录格式放到ftp上:所以,结构上 我就是一级一级目录进行判断(因为我没有找到在ftp一次判断其子目录是否存在),还有一个low点就是我没有 ...

  7. Python下操作sqlite3

    import sqlite3 dbpath = 'C:\\Django\\workplace\\sf\\d1.sqlite3' conn = sqlite3.connect(dbpath) cu = ...

  8. memcache/redis 缓存学习笔记

    0.redis和memcache的区别 a.redis可以存储除了string之外的对象,如list,hash等 b.服务器宕机以后,redis会把内存的数据持久化到磁盘上,而memcache则不会 ...

  9. Python操作Redis、Memcache、RabbitMQ、SQLAlchemy

    Python操作 Redis.Memcache.RabbitMQ.SQLAlchemy redis介绍:redis是一个开源的,先进的KEY-VALUE存储,它通常被称为数据结构服务器,因为键可以包含 ...

随机推荐

  1. 常用Linux 服务器命令--各种性能指标命令

    如果你想知道你的服务器正在做干什么,你就需要了解一些基本的命令,一旦你精通了这些命令,那你就是一个专业的 Linux 系统管理员. 监控命令## iostat### iostat命令用来显示存储系统的 ...

  2. windows下设置JupyterNotebook默认目录

    目录 windows下设置JupyterNotebook默认目录 生成配置文件 设置默认工作目录 设置快捷方式中的目标与起始位置 直接修改anaconda中的相关配置文件 windows下设置Jupy ...

  3. January 04th, 2018 Week 01st Thursday

    Just do what works for you, because there will always be someone who think differently. 就做你自己所能做的,因为 ...

  4. TG可能会用到的动态规划-简易自学

    最新更新 完整校订版见此 戳我阅读 以下为未核对不完整版本. 因版权原因,完整精校版不向所有公众开放. 请从您找到本博客的地址查找附带密码(比如简书分享了本网址,请您从简书分享页底部查询密码),感谢您 ...

  5. JS获取本周、本季度、本月、上月的开始日期、结束日期

    /** * 获取本周.本季度.本月.上月的开始日期.结束日期 */ var now = new Date();                    //当前日期 var nowDayOfWeek = ...

  6. luogu P3809 【模板】后缀排序

    嘟嘟嘟 今天学了一个后缀数组,还是挺好理解的. 因为我不会基数排序,所以只会\(O(n \log ^ 2 n)\)的sort版. 首先,后缀数组就是把该字符串的所有后缀按字典序排序得到的一个数组.注意 ...

  7. QT 11 鼠标键盘事件添加

    鼠标事件 void mousePressEvent(QMouseEvent *event); //单击 void mouseReleaseEvent(QMouseEvent *event); //释放 ...

  8. ethereum/EIPs-155 Simple replay attack protection 35，36

    EIP 155:重放攻击保护——防止了在一个以太坊链上的交易被重复广播到另外一条链. 在看椭圆曲线时有提到,与r.s.v中的v相关 不同的共有链定义不同的chainId, 防止同一笔交易在不同的共有链 ...

  9. day02---编程语言、python解释器以及变量

    计算机编程语言分类: 机器语言 直接用计算机能理解的二进制指令编写程序,来直接控制硬件.(用机器语言编写的程序称为目标程序) 优点:执行效率高,属于计算机最底层语言 缺点:开发效率低.跨平台性差 汇编 ...

  10. 安装Docker和配置加速器（二）

    一. 安装 docker-ce 1. 访问 https://opsx.alibaba.com/mirror 2. 打开这条URL: 二.Ubuntu 系统安装 Docker 1. 使用apt-get进 ...