mysql中單個(gè)庫(kù)數(shù)據(jù)該怎么樣同步到redis數(shù)據(jù)庫(kù)中

本文主要給大家介紹mysql中單個(gè)庫(kù)數(shù)據(jù)該怎么樣同步到redis數(shù)據(jù)庫(kù)中，文章內(nèi)容都是筆者用心摘選和編輯的，具有一定的針對(duì)性，對(duì)大家的參考意義還是比較大的，下面跟筆者一起了解下mysql中單個(gè)庫(kù)數(shù)據(jù)該怎么樣同步到redis數(shù)據(jù)庫(kù)中吧。

實(shí)際代碼只有一點(diǎn)，其他的為備忘

# -*- coding:utf-8 -*-
import MySQLdb
import redis

class Config:
    def __init__(self):
        self.mysql_host = '192.168.44.60'
        self.mysql_user = 'root'
        self.mysql_port = 3306
        self.mysql_password = '123456'
        self.mysql_db = 'bamboo'
        self.mysql_charset = 'utf8'
        self.mysql_show_tables = "show tables"
        self.mysql_desc_table = "desc %s"
        self.mysql_query_info = "select * from  %s"

        self.redis_host = "192.168.44.60"
        self.redis_port = 6379
        self.redis_passwd = 123456
        self.redis_db = 0

config = Config()

class MySQLHelper:
    myVersion = 0.1

    def __init__(self):
        self.host = config.mysql_host
        self.user = config.mysql_user
        self.password = config.mysql_password
        self.charset = config.mysql_charset
        self.db = config.mysql_db
        try:
            self.conn = MySQLdb.connect(host=self.host, user=self.user, passwd=self.password,db=self.db,charset=self.charset)
            self.cursor = self.conn.cursor()
        except MySQLdb.Error as e:
            print ('MySql Error : %d %s' % (e.args[0], e.args[1]))

    def query(self, sql):
        try:

            cursor = self.cursor
            cursor.execute(sql)
            return cursor
        except MySQLdb.Error as e:
            print('MySql Error: %s SQL: %s' % (e, sql))

    def queryOnlyRow(self, sql):
        try:
            cursor = self.query(sql)
            result = cursor.fetchall()
            desc = cursor.description

            row = {}
            for i in range(0, len(result)):
                row[desc[i][0]] = result[i]
            return row
        except MySQLdb.Error as e:
            print('MySql Error: %s SQL: %s' % (e, sql))

    def queryAll(self, sql):
        try:

            cursor = self.query(sql)
            result = cursor.fetchall()

            desc = cursor.description
            rows = []
            for cloumn in result:
                row = {}
                for i in range(0, len(cloumn)):
                    row[desc[i][0]] = cloumn[i]
                rows.append(row)
            return rows

        except MySQLdb.Error as e:
            print('MySql Error: %s SQL: %s' % (e, sql))

    def queryTableNums(self,sql):
        try:
            cursor = self.query(sql)
            result = cursor.fetchall()
            row = []
            for cloumn in result:
                row.append(cloumn[0])
            return row

        except MySQLdb.Error as e:
            print('Mysql Error: %s SQL: %s' %(e,sql))

    def insert(self, tableName, pData):
        try:
            newData = {}
            for key in pData:
                newData[key] = "'" + str(pData[key]) + "'"
            key = ','.join(newData.keys())
            value = ','.join(map(str,newData.values()))
            sql = "insert into " + tableName + "(" + key + ") values(" + value + ")"
            self.query("set names 'utf8'")
            self.query(sql)
            self.commit()
        except MySQLdb.Error as e:
            self.conn.rollback()
            print('MySql Error: %s %s' % (e.args[0], e.args[1]))

    def update(self, tableName, pData, whereData):
        try:
            newData = []
            keys = pData.keys()
            for i in keys:
                item = "%s=%s" % (i, "'" + pData[i] + "'")
                newData.append(item)
            items = ','.join(newData)
            newData2 = []
            keys = whereData.keys()
            for i in keys:
                item = "%s=%s" % (i, "'" + whereData[i] + "'")
                newData2.append(item)
            whereItems = " AND ".join(newData2)
            sql = "update " + tableName + " set " + items + " where " + whereItems
            self.query("set names 'utf8'")
            self.query(sql)
            self.commit()
        except MySQLdb.Error as e:
            self.conn.rollback()
            print('MySql Error: %s %s' % (e.args[0], e.args[1]))

    def getLastInsertRowId(self):
        return self.cursor.lastrowid

    def getRowCount(self):
        return self.cursor.rowcount

    def commit(self):
        self.conn.commit()

    def close(self):
        self.cursor.close()
        self.conn.close()

class RedisHelper():

    __redis_instance = None

    def __init__(self):
        self.host = config.redis_host
        self.port = config.redis_port
        self.passwd = config.redis_passwd
        self.db = config.redis_db
        try:
            self.connPoor = redis.ConnectionPool(host=self.host,port=self.port,db=self.db,password=self.passwd)
            self.rd = redis.Redis(connection_pool=self.connPoor)
        except redis.DataError as e:
            print('Redis Error : %d %s' % (e.args[0], e.args[1]))

    @staticmethod
    def getObj():
        if RedisHelper.__redis_instance:
            return RedisHelper.__redis_instance
        else:
            RedisHelper.__redis_instance = RedisHelper().rd
            return RedisHelper.__redis_instance

    # string 操作

    def setkey(self,key,value,**kwargs):
        """
        set(name, value, ex=None, px=None, nx=False, xx=False)
        :param key: 鍵
        :param value: 值
        :param kwargs:
            在Redis中設(shè)置值，默認(rèn)，不存在則創(chuàng)建，存在則修改
            參數(shù)：
            ex，過(guò)期時(shí)間（秒）
            px，過(guò)期時(shí)間（毫秒）
            nx，如果設(shè)置為True，則只有name不存在時(shí)，當(dāng)前set操作才執(zhí)行
            xx，如果設(shè)置為True，則只有name存在時(shí)，當(dāng)前set操作才執(zhí)行
        :return: True or False
        """
        res = self.rd.set(key,value,**kwargs)

        return res

    def getkey(self,key):
        return self.rd.get(key)

    def setnxkey(self,key,value):
        """
        :param key:
        :param value:
        :return: True or False
        設(shè)置值，只有key不存在時(shí)，執(zhí)行設(shè)置操作（添加）
        """
        return self.rd.setnx(key,value)

    def setexkey(self,key,value,time=5):
        """
        :param key:
        :param value:
        :param time: 過(guò)期時(shí)間 (秒 或 timedelta對(duì)象)
        :return: True or False
        """
        return self.rd.setex(key,time,value)

    def psetexkey(self,key,value,time):
        """
        :param key:
        :param value:
        :param time: time_ms，過(guò)期時(shí)間（數(shù)字毫秒 或 timedelta對(duì)象）
        :return:
        """
        return self.rd.psetex(key,time,value)

    def msetkey(self,mapping):
        """
        批量設(shè)置多個(gè)值
        :param mapping: {'k1':'v1','k2':'v2'} or k1='v1',k2='v2'
        :return:
        """
        return self.rd.mset(mapping)

    def mgetkey(self,keys,*args):
        """
        批量獲取多個(gè)值
        'k1','k2' or ['k1','k2']
        :param keys:
        :param args:
        :return:
        """
        return self.rd.mget(keys,args)

    def getsetkey(self,key,value):
        """
        獲取值并設(shè)置新值
        :param key:
        :param value:
        :return:
        """
        return self.rd.getset(key,value)

    def getrangekey(self,key,start,end):
        """
        獲取子序列（根據(jù)字節(jié)獲取，非字符） 一個(gè)漢字，是占3個(gè)字節(jié)
        :param key:
        :param start: bytes 起始位置(包含)
        :param end: bytes  結(jié)束位置（包含）
        :return:
        set 'name' 'helloworld'
        OK
        GETRANGE 'name' 0 2
        "hel"
        getrange 'name' 0 -1
        "helloworld"
        """
        return self.rd.getrange(key,start,end)

    def setrange(self,key,index,value):
        """
        修改字符串內(nèi)容，從指定字符串索引開(kāi)始向后替換（新值太長(zhǎng)時(shí)，則向后添加）
        參數(shù)：

        :param key:
        :param index: 字符串的索引，字節(jié)（一個(gè)漢字三個(gè)字節(jié)）
        :param value: 要設(shè)置的值
        :return:
        """
        return self.rd.setrange(key,index,value)

    def strlenkey(self,key):
        """
        返回name對(duì)應(yīng)值的字節(jié)長(zhǎng)度（一個(gè)漢字3個(gè)字節(jié)）
        :param key:
        :return:
        """
        return self.rd.strlen(key)

    def incrkey(self,key):
        """
        自增 name對(duì)應(yīng)的值，當(dāng)name不存在時(shí)，則創(chuàng)建name＝amount，否則，則自增。
        :param key:
        :param amount: 自增數(shù) 必須是整數(shù) 一次只能自增一個(gè)
        :return:
        """

        return self.rd.incr(key,1)

    def incrbykey(self,key,amount=1):
        """
        自增 key對(duì)應(yīng)的值，當(dāng)key不存在時(shí)，則創(chuàng)建key＝amount，否則，則自增。
        :param key:
        :param amount: 自增數(shù) 必須是整數(shù)
        :return:
        """
        try:
            if not isinstance(amount,int):
                raise TypeError('amount 必須是整數(shù)')
            return self.rd.incrby(key,amount)
        except Exception as e:
            return "Func incrbykey Error : %d %s" % (e.args[0], e.args[1])

    def incrbyfloatkey(self,key,amount=1.0):
        """
        自增 key對(duì)應(yīng)的值，當(dāng)key不存在時(shí)，則創(chuàng)建key＝amount，否則，則自增。
        :param key:
        :param amount: 自增數(shù)(浮點(diǎn)型)
        :return:
        """
        try:
            if not isinstance(amount,float):
                raise TypeError('amount 必須是浮點(diǎn)數(shù)')
            return self.rd.incrbyfloat(key,amount)
        except Exception as e:
            return "Func incrbyfloatkey Error : %d %s" % (e.args[0], e.args[1])

    def decrkey(self,key):
        """
        自減 name對(duì)應(yīng)的值，當(dāng)name不存在時(shí)，則創(chuàng)建name＝amount，否則，則自減
        :param name:
        :return:
        """
        self.rd.decr(key,1)

    def decrbykey(self,key,amount=1):
        """
        自減 key對(duì)應(yīng)的值，當(dāng)key不存在時(shí)，則創(chuàng)建key＝amount，否則，則自減。
        :param key:
        :param amount: 自減數(shù) 必須是整數(shù)
        :return:
        """
        try:
            if not isinstance(amount, int):
                raise TypeError('amount 必須是整數(shù)')
            return self.rd.decrby(key, amount)
        except Exception as e:
            return "Func decrbykey Error : %d %s" % (e.args[0], e.args[1])

    def appendkey(self,key,value):
        """
        在redis key對(duì)應(yīng)的值后面追加內(nèi)容
        :param key:
        :param value: 要追加的字符串
        :return:
        """
        return self.rd.append(key,value)

    def setbitkey(self,key,index,value):
        """
        注：如果在Redis中有一個(gè)對(duì)應(yīng)： n1 = "foo"，
        那么字符串foo的二進(jìn)制表示為：01100110 01101111 01101111
        所以，如果執(zhí)行 setbit('n1', 7, 1)，則就會(huì)將第7位設(shè)置為1，
        那么最終二進(jìn)制則變成 01100111 01101111 01101111，即："goo"

        擴(kuò)展，轉(zhuǎn)換二進(jìn)制表示：
        source = "陳思維"
        source = "foo"
        for i in source:
        num = ord(i)
        print bin(num).replace('b','')
        特別的，如果source是漢字 "陳思維"怎么辦？
        答：對(duì)于utf-8，每一個(gè)漢字占 3 個(gè)字節(jié)，那么 "陳思維" 則有 9個(gè)字節(jié)
        對(duì)于漢字，for循環(huán)時(shí)候會(huì)按照 字節(jié) 迭代，那么在迭代時(shí)，將每一個(gè)字節(jié)轉(zhuǎn)換 十進(jìn)制數(shù)，然后再將十進(jìn)制數(shù)轉(zhuǎn)換成二進(jìn)制
        11100110 10101101 10100110 11100110 10110010 10011011 11101001 10111101 10010000

        對(duì)name對(duì)應(yīng)值的二進(jìn)制表示的位進(jìn)行操作
        :param key:
        :param index: 位的索引（將值變換成二進(jìn)制后再進(jìn)行索引）
        :param value: 值只能是 1 或 0
        :return:
        """
        try:
            if not isinstance(index,int):
                raise TypeError('index 只能是數(shù)字')
            if  value not in [0,1]:
                raise ValueError('value 只能是0或1' )

            return self.rd.setbit(key,index,value)

        except Exception as e:
            return "Redis Error : %d %s" % (e.args[0], e.args[1])

    def getbitkey(self,key,index):
        """
        獲取name對(duì)應(yīng)的值的二進(jìn)制表示中的某位的值 （0或1）
        :param key:
        :param index: 0 or 1
        :return:
        """
        try:
            if index not in [0,1]:
                raise ValueError("index 值只能是0或1")
            return self.rd.getbit(key,index)
        except Exception as e:
            return "Redis Error : %d %s" % (e.args[0], e.args[1])

    def bitcountkey(self,key,start=None,end=None):
        """
        獲取name對(duì)應(yīng)的值的二進(jìn)制表示中 1 的個(gè)數(shù)
        :param key:
        :param start:
        :param end:
        :return:
        """
        return self.rd.bitcount(key,start,end)

    def bitopkey(self,operation,new_key,*keys):
        """
        bitop("AND", 'new_name', 'n1', 'n2', 'n3')
        獲取Redis中n1,n2,n3對(duì)應(yīng)的值，然后講所有的值做位運(yùn)算（求并集），然后將結(jié)果保存 new_name 對(duì)應(yīng)的值中
        r.set("foo","1")  # 0110001
        r.set("foo1","2")  # 0110010
        print(r.mget("foo","foo1"))  # ['goo1', 'baaanew']
        print(r.bitop("AND","new","foo","foo1"))  # "new" 0 0110000
        print(r.mget("foo","foo1","new"))

        source = "12"
        for i in source:
        num = ord(i)
        print(num)  # 打印每個(gè)字母字符或者漢字字符對(duì)應(yīng)的ascii碼值 f-102-0b100111-01100111
        print(bin(num))  # 打印每個(gè)10進(jìn)制ascii碼值轉(zhuǎn)換成二進(jìn)制的值 0b1100110（0b表示二進(jìn)制）
        print bin(num).replace('b','')  # 將二進(jìn)制0b1100110替換成01100110

        獲取多個(gè)值，并將值做位運(yùn)算，將最后的結(jié)果保存至新的name對(duì)應(yīng)的值
        :param operation: AND（并） 、 OR（或） 、 NOT（非） 、 XOR（異或）
        :param new_key: new key
        :param keys: 要查找的Redis的name
        :return:
        """
        return self.rd.bitop(operation,new_key,keys)

    # hash 操作

    def hsetkey(self,name,key,value):
        """
        name對(duì)應(yīng)的hash中設(shè)置一個(gè)鍵值對(duì)（不存在，則創(chuàng)建；否則，修改）

        :param name: redis的name
        :param key: name對(duì)應(yīng)的hash中的key
        :param value: name對(duì)應(yīng)的hash中的value
        :return:
        """
        return self.rd.hset(name,key,value)

    def hmsetkey(self,name,mapping):
        """
        在name對(duì)應(yīng)的hash中批量設(shè)置鍵值對(duì)
        :param name:
        :param mapping: {'k1':'v1','k2':'v2'}
        :return:
        """
        return self.rd.hmset(name,mapping)

    def hgetkey(self,name,key):
        """
        在name對(duì)應(yīng)的hash中獲取根據(jù)key獲取value
        :param name:
        :param key:
        :return:
        """
        return self.rd.hget(name,key)

    def hgetallkey(self,name):
        """
        獲取hash中對(duì)應(yīng)name的所有值
        :param name:
        :return:
        """
        return self.rd.hgetall(name)

    def hmgetkey(self,name,keys,*args):
        """
        在name對(duì)應(yīng)的hash中獲取多個(gè)key的值
        :param name:
        :param keys: ['k1','k2','k3']
        :param args: 'k1','k2','k3'
        :return:
        """
        return self.rd.hmget(name,keys,args)

    def hlenkey(self,name):
        """
        獲取name對(duì)應(yīng)的hash中的鍵值對(duì)的個(gè)數(shù)
        :param name:
        :return:
        """
        return self.rd.hlen(name)

    def hallkeys(self,name):
        """
        獲取name對(duì)應(yīng)的hash中所有的key的值
        :param name:
        :return:
        """
        return self.rd.hkeys(name)

    def hvalskeys(self, name):
        """
        獲取name對(duì)應(yīng)的hash中所有的value的值
        :param name:
        :return:
        """
        return self.rd.hvals(name)

    def hexistskeys(self,name,key):
        """
        檢查name對(duì)應(yīng)的hash是否存在當(dāng)前傳入的key 類似字典的in
        :param name:
        :param key:
        :return:
        """
        return self.rd.hexists(name,key)

    def hdelkeys(self,name,*keys):
        """
        將name值對(duì)應(yīng)的hash中指定key的鍵值對(duì)刪除
        :param name:
        :param keys: 'k1' or 'k1','k2'
        :return:
        """
        return self.rd.hdel(name,keys)

    def hincrby(self,name,key,amount=1):
        """
        將key對(duì)應(yīng)的value--整數(shù) 自增1或者2，或者別的整數(shù) 負(fù)數(shù)就是自減(自增name對(duì)應(yīng)的hash中的指定key的值，不存在則創(chuàng)建key=amount)
        :param name:
        :param key:
        :param amount:
        :return:
        """
        try:
            if not isinstance(amount,int):
                raise TypeError('amount 只能是整數(shù)')
            return self.rd.hincrby(name,key,amount)
        except Exception as e:
            return "Func hincrby Error : %d %s" % (e.args[0], e.args[1])

    def hincrbyfloatkeys(self,name,key,amount=1.0):
        """
        將key對(duì)應(yīng)的value--浮點(diǎn)數(shù) 自增1.0或者2.0，或者別的浮點(diǎn)數(shù) 負(fù)數(shù)就是自減 (自增name對(duì)應(yīng)的hash中的指定key的值，不存在則創(chuàng)建key=amount)
        :param name:
        :param key:
        :param amount: 自增數(shù)（浮點(diǎn)數(shù)）
        :return:
        """
        try:
            if not isinstance(amount,float):
                raise TypeError('amount 只能是浮點(diǎn)數(shù)')
            return self.rd.hincrbyfloat(name, key, amount)
        except Exception as e:
            return "Func hincrby Error : %d %s" % (e.args[0], e.args[1])

    def hscankeys(self,name,cursor=0,match=None,count=None):
        """
        增量式迭代獲取，對(duì)于數(shù)據(jù)大的數(shù)據(jù)非常有用，hscan可以實(shí)現(xiàn)分片的獲取數(shù)據(jù)，并非一次性將數(shù)據(jù)全部獲取完，從而放置內(nèi)存被撐爆
        :param name:
        :param curosr: 游標(biāo)（基于游標(biāo)分批取獲取數(shù)據(jù)）
        :param match: 匹配指定key，默認(rèn)None 表示所有的key
        :param count: 每次分片最少獲取個(gè)數(shù)，默認(rèn)None表示采用Redis的默認(rèn)分片個(gè)數(shù)
        :return:
        """
        return self.rd.hscan(name,cursor,match,count)

    def hscaniterkeys(self,name,match=None,count=None):
        """
        利用yield 封裝hscan創(chuàng)建生成器，實(shí)現(xiàn)分批器redis中獲取數(shù)據(jù)
        :param name:
        :param match: 匹配指定key，默認(rèn)表示所有key
        :param count: 每次分片最少獲取個(gè)數(shù)，默認(rèn)None表示采用Redis的默認(rèn)分片個(gè)數(shù)
        :return:
        """
        return self.rd.hscan_iter(name,match,count)

    # list 操作

    def lpushkeys(self,key,values):
        """
        增加（類似于list的append，只是這里是從左邊新增加）--沒(méi)有就新建
        在name對(duì)應(yīng)的list中添加元素，每個(gè)新的元素都添加到列表的最左邊
        lpush('xx',11,12,13)
        :param key:
        :param values:
        :return:
        """
        return self.rd.lpush(key,values)

    def  rpushkeys(self,key,values):
        """
        增加（類似于list的append，只是這里是從右邊新增加）--沒(méi)有就新建
        在name對(duì)應(yīng)的list中添加元素，每個(gè)新的元素都添加到列表的最右邊
        rpush('xx',11,12,13)
        :param key:
        :param values:
        :return:
        """
        return self.rd.rpush(key,values)

    def lpushxkeys(self,key,value):
        """
        在key對(duì)應(yīng)的list中添加一個(gè)元素，只有key存在時(shí)，值添加到列表的最左邊，key不存在則不能創(chuàng)建，但是不報(bào)錯(cuò)
        :param key:
        :param values:
        :return:
        """
        return self.rd.lpushx(key,value)

    def rpushxkeys(self,key,value):
        """
        在key對(duì)應(yīng)的list中添加一個(gè)元素，只有key存在時(shí)，值添加到列表的最右邊，key不存在則不能創(chuàng)建,但是不報(bào)錯(cuò)
        :param key:
        :param value:
        :return:
        """
        return self.rd.rpushx(key,value)

    def linsertkeys(self,key,where,refvalue,value):
        """
        在key對(duì)應(yīng)的列表的某一個(gè)值前或后插入一個(gè)新值

        r.linsert("list2", "before", "11", "00")   # 往列表中左邊第一個(gè)出現(xiàn)的元素"11"前插入元素"00"

        :param key:
        :param where: before or after
        :param refvalue: 標(biāo)桿值，即：在它前后插入數(shù)據(jù)
        :param value:  要插入的數(shù)據(jù)
        :return:
        """
        try:
            if str(where).lower() not in ['before','after']:
                raise ValueError('where 值只能是 before 或 after')
            return self.rd.linsert(key,where,refvalue,value)
        except Exception as e:
            return "Func linsertkeys Error: %d %s"%(e.args[0],e.args[1])

    def lsetkeys(self,key,index,value):
        """
        對(duì)key對(duì)應(yīng)的list中的某一個(gè)索引位置重新賦值
        :param key:
        :param index: 索引值，從0 開(kāi)始
        :param value:
        :return:
        """
        try:
            if not isinstance(index,int):
                raise TypeError('index 只能是整數(shù)')
            return self.rd.lset(key,index,value)
        except Exception as e:
            return "Func lsetkeys: %d %s"%(e.args[0],e.args[1])

    def lremkeys(self,key,num,value):
        """
        在key對(duì)應(yīng)的list中刪除指定的值
        :param key:
        :param value:
        :param num: num=0,刪除列表中所有指定值，num=2，從前到后，刪除2個(gè)，num=1，從前到后，刪除左邊第一個(gè)，num=-2，從后到前，刪除兩個(gè)
        :return:
        """
        return self.rd.lrem(key,num,value)

    def lpopkeys(self,key):
        """
        在key 對(duì)應(yīng)的列表的左側(cè)獲取第一個(gè)元素并在列表中移除，返回值則是第一個(gè)元素
        :param key:
        :return:
        """
        return self.rd.lpop(key)

    def rpopkeys(self,key):
        """
        在key 對(duì)應(yīng)的列表的右側(cè)獲取第一個(gè)元素并在列表中移除，返回值則是第一個(gè)元素
        :param key:
        :return:
        """
        return self.rd.rpop(key)

    def ltrimkeys(self,key,start,end):
        """
        在key對(duì)應(yīng)的list中移除沒(méi)有在start - end 索引之間的值
        :param key:
        :param start: 索引的開(kāi)始位置
        :param end: 索引的結(jié)束位置
        :return:
        """
        return self.rd.ltrim(key,start,end)

    def lindexkeys(self,key,index):
        """
        在name對(duì)應(yīng)的list中根據(jù)索引獲取列表元素
        :param key:
        :param index:
        :return:
        """
        return self.rd.lindex(key,index)

    def rpoplpushkeys(self,srckey,dstkey):
        """
        將元素從一個(gè)表移動(dòng)到另一個(gè)表中(從一個(gè)列表取出最右邊的元素，同時(shí)將其添加至另一個(gè)列表的最左邊)
        :param srckey:
        :param detkey:
        :return:
        """
        return self.rd.rpoplpush(srckey,dstkey)

    def brpoplpushkeys(self,srckey,dstkey,timeout=0):
        """
        從一個(gè)列表的右側(cè)移除一個(gè)元素并將其添加到另一個(gè)列表的左側(cè)，可以設(shè)置超時(shí)
        :param srckey:
        :param dstkey:
        :param timeout: 當(dāng)seckey對(duì)應(yīng)的list中沒(méi)有數(shù)據(jù)時(shí)，阻塞等待其有數(shù)據(jù)的超時(shí)時(shí)間 單位為秒,0表示永遠(yuǎn)阻塞
        :return:
        """
        return self.rd.brpoplpush(srckey,dstkey,timeout)

    def blpopkeys(self,keys,timeout):
        """
        將多個(gè)列表排序，按照從左到右去pop對(duì)應(yīng)的list元素
        :param keys:
        :param timeout: 超時(shí)時(shí)間，當(dāng)元素所有列表的元素獲取完之后，阻塞等待列表內(nèi)有數(shù)據(jù)的時(shí)間（秒）, 0 表示永遠(yuǎn)阻塞
        :return:
        """
        return self.rd.blpop(keys,timeout)

    def brpopkeys(self,keys,timeout):
        """
        將多個(gè)列表排序，按照從右到左去pop對(duì)應(yīng)的list元素
        :param keys:
        :param timeout: 超時(shí)時(shí)間，當(dāng)元素所有列表的元素獲取完之后，阻塞等待列表內(nèi)有數(shù)據(jù)的時(shí)間（秒）, 0 表示永遠(yuǎn)阻塞
        :return:
        """
        return self.rd.brpop(keys,timeout)

    def llenkeys(self,key):
        """
        返回key的數(shù)據(jù)長(zhǎng)度
        :param key:
        :return:
        """
        return self.rd.llen(key)

    def lrangekeys(self,key,start=0,end=-1):
        """
        獲取key的全部數(shù)據(jù)值 通常與llen聯(lián)用
        :param key:
        :param start: 起始位置(包括)
        :param end: 結(jié)束位置(包括)
        :return:
        """
        return self.rd.lrange(key,start,end)

    def listiterkeys(self,key):
        """
        list增量迭代
        :param key:
        :return: 返回yield 生成器
        """
        list_count = self.rd.llen(key)
        for index in range(list_count):
            yield self.rd.lindex(key,index)

    # set 操作

    def saddkeys(self,key,values):
        """
        :key對(duì)應(yīng)的集合中添加元素,重復(fù)的元素將忽略
        saddkeys('xxx',1,2,3,4,5)
        :param key:
        :param values:
        :return:
        """
        return self.rd.sadd(key,values)

    def scardkeys(self,key):
        """
        獲取元素個(gè)數(shù)，類似于len
        :param key:
        :return:
        """
        return self.rd.scard(key)

    def smemnerkeys(self,key):
        """
        獲取key對(duì)應(yīng)的集合的所有成員
        :param key:
        :return:
        """
        return self.rd.smembers(key)

    def sscankeys(self, key, cursor=0, match=None, count=None):
        """
        獲取集合中所有的成員 -- 元組形式
        :param key:
        :param cursor:
        :param match:
        :param count:
        :return:
        """
        return self.rd.sscan(key,cursor,match,count)

    def sscaniterkeys(self,key,match=0,count=None):
        """
        獲取集合中所有的成員 --迭代器方式
        :param key:
        :param match:
        :param count:
        :return:
        """
        return self.rd.sscan_iter(key,match,count)

    def sdiffkeys(self,keys,*args):
        """
        在第一個(gè)key對(duì)應(yīng)的集合中且不在其他key對(duì)應(yīng)的集合的元素集合
        sdiffkeys('a','b) 在集合a中并且不再集合b中
        :param keys:
        :param args:
        :return:
        """
        return self.rd.sdiff(keys,args)

    def sdiffstorekeys(self,dstkey,keys,*args):
        """
        獲取第一個(gè)key對(duì)應(yīng)的集合中且不在其他name對(duì)應(yīng)的結(jié)合，在將其加入到dstkey對(duì)應(yīng)的集合中
        :param dstkey:
        :param keys:
        :param args:
        :return:
        """
        res = self.rd.sdiffstore(dstkey,keys,args)
        return res

    def sinterkeys(self,keys,*args):
        """
        獲取多個(gè)keys對(duì)應(yīng)集合的交集
        :param keys:
        :param args:
        :return:
        """
        return self.rd.sinter(keys,args)

    def sinterstorekeys(self,dstkey,keys,*args):
        """
        獲取多個(gè)keys對(duì)應(yīng)集合的交集，再將其加入到dstkey對(duì)應(yīng)的集合中
        :param dstkey:
        :param keys:
        :param args:
        :return:
        """
        res = self.rd.sinterstore(dstkey,keys,args)
        return res

    def sunionkeys(self,keys,*args):
        """
        獲取多個(gè)key對(duì)應(yīng)的集合的并集
        :param keys:
        :param args:
        :return:
        """
        return self.rd.sunion(keys,args)

    def sunionstorekeys(self,dstkey,keys,*args):
        """
        獲取多個(gè)key對(duì)應(yīng)集合的并集，并將其結(jié)果保存到dstkey對(duì)應(yīng)的集合中
        :param dstkey:
        :param keys:
        :param args:
        :return:
        """
        return self.rd.sunionstore(dstkey,keys,args)

    def sismemberkeys(self,key,value):
        """
        檢查value是否是key對(duì)應(yīng)的結(jié)合的成員，結(jié)果返回True or False
        :param key:
        :param value:
        :return: True or False
        """
        return self.rd.sismember(key,value)

    def smovekeys(self,srckey,dstkey,value):
        """
        將某個(gè)成員從一個(gè)集合中移動(dòng)到另一個(gè)集合
        :param srckey:
        :param dstkey:
        :param value:
        :return:
        """
        return self.rd.smove(srckey,dstkey,value)

    def spopkeys(self,key):
        """
        從集合移除一個(gè)成員，并將其返回，說(shuō)明一下，集合是無(wú)序的，所有都是隨機(jī)刪除的
        :param key:
        :return:
        """
        return self.rd.spop(key)

    def sremkeys(self,key,values):
        """
        在key對(duì)應(yīng)的集合中刪除某些值
        sremkeys('xx','a','b')
        :param key:
        :param values:
        :return:
        """
        return self.rd.srem(key,values)

    #  有序集合  zset 操作

    def zaddkeys(self,key,mapping):
        """
        在key對(duì)應(yīng)的有序集合中添加元素
        zaddkeys('xx',{'k1':1,'k2':2})

        :param key:
        :param args:
        :param kwargs:
        :return:
        """
        return self.rd.zadd(key,mapping)

    def zcardkeys(self,key):
        """
        獲取有序集合元素的個(gè)數(shù)
        :param key:
        :return:
        """
        return self.rd.zcard(key)

    def zrangekeys(self,key,start,stop,desc=False,withscores=False,score_cast_func=float):
        """
        獲取有序集合索引范圍內(nèi)的元素
        :param key:
        :param start: 索引起始位置
        :param stop: 索引結(jié)束位置
        :param desc: 排序規(guī)則，默認(rèn)按照分?jǐn)?shù)從小到大排序
        :param withscores: 是否獲取元素的分?jǐn)?shù)，默認(rèn)之火去元素的值
        :param score_cast_func: 對(duì)分?jǐn)?shù)進(jìn)行數(shù)據(jù)轉(zhuǎn)換的函數(shù)
        :return:
        """
        return self.rd.zrange(key,start,stop,desc,withscores,score_cast_func)

    def zrevrangekeys(self,key,start,end,withscores=False,score_cast_func=float):
        """
        從大到小排序
        :param key:
        :param start:
        :param end:
        :param withscores:
        :param score_cast_func:
        :return:
        """
        return self.rd.zrevrange(key,start,end,withscores,score_cast_func)

    def zrangebyscorekeys(self,key,min,max,start=None,num=None,withscores=False,score_cast_func=float):
        """
        按照分?jǐn)?shù)返回獲取key對(duì)應(yīng)的有序集合的元素
        zrangebyscore("zset3", 15, 25)) # # 在分?jǐn)?shù)是15-25之間，取出符合條件的元素
        zrangebyscore("zset3", 12, 22, withscores=True)   # 在分?jǐn)?shù)是12-22之間，取出符合條件的元素（帶分?jǐn)?shù)）

        :param key:
        :param min:
        :param max:
        :param start:
        :param num:
        :param withscores:
        :param score_cast_func:
        :return:
        """
        return self.rd.zrangebyscore(key,min,max,start,num,withscores,score_cast_func)

    def zrevrangebyscorekeys(self,key,max,min,start=None,num=None,withscores=False,score_cast_func=float):
        """
        按照分?jǐn)?shù)范圍獲取有序集合的元素并排序（默認(rèn)按照從大到小排序）
        :param key:
        :param max:
        :param min:
        :param start:
        :param num:
        :param withscores:
        :param score_cast_func:
        :return:
        """
        return self.rd.zrevrangebyscore(key,max,min,start,num,withscores,score_cast_func)

    def zscankeys(self,key,cursor=0,match=None,count=None,score_cast_func=float):
        """
        獲取所有元素 -- 默認(rèn)按照分?jǐn)?shù)順序排序
        :param key:
        :param cursor:
        :param match:
        :param count:
        :param score_cast_func:
        :return:
        """
        return self.rd.zscan(key,cursor,match,count,score_cast_func)

    def zscaniterkeys(self,key,match=None,count=None,score_cast_func=float):
        """
        獲取所有元素的迭代器
        :param key:
        :param match:
        :param count:
        :param score_cast_func:
        :return:
        """
        return self.rd.zscan_iter(key,match,count,score_cast_func)

    def zcountkeys(self,key,min,max):
        """
        獲取key對(duì)應(yīng)的有序集合中分?jǐn)?shù)在[min,max] 之間的個(gè)數(shù)
        :param key:
        :param min:
        :param max:
        :return:
        """
        return self.rd.zcount(key,min,max)

    def zincrbykey(self,key,value,amount=1):
        """
        自增key對(duì)應(yīng)的有序集合key對(duì)應(yīng)的分?jǐn)?shù)
        :param key:
        :param value:
        :param amount:
        :return:
        """
        return self.rd.zincrby(key,amount,value)

    def zrankeys(self,key,value):
        """
        獲取某個(gè)值在key對(duì)應(yīng)的有序集合中的索引(從0開(kāi)始),默認(rèn)是從小到大順序
        :param key:
        :param value:
        :return:
        """
        return self.rd.zrank(key,value)

    def zrevrankey(self,key,value):
        """
        獲取某個(gè)值在key對(duì)應(yīng)的有序集合中的索引,默認(rèn)是從大到小順序
        :param key:
        :param value:
        :return:
        """
        return self.rd.zrevrank(key,value)

    def zremkeys(self,key,values):
        """
        刪除key對(duì)應(yīng)的有序集合中值是value的成員
        :param key:
        :param value:
        :return:
        """
        return self.rd.zrem(key,values)

    def zremrangebyrankeys(self,key,min,max):
        """
        刪除根據(jù)排行范圍刪除，按照索引刪除
        :param key:
        :param min:
        :param max:
        :return:
        """
        return self.rd.zremrangebyrank(key,min,max)

    def zremrangebyscoreskeys(self,key,min,max):
        """
        刪除根據(jù)分?jǐn)?shù)范圍刪除，按照分?jǐn)?shù)范圍刪除
        :param key:
        :param min:
        :param max:
        :return:
        """
        return self.rd.zremrangebyscore(key,min,max)

    def zscoreskeys(self,key,value):
        """
        獲取key對(duì)應(yīng)有序集合中value對(duì)應(yīng)的分?jǐn)?shù)
        :param key:
        :param value:
        :return:
        """
        return self.rd.zscore(key,value)

    # 其他常用操作

    def deletekeys(self,*keys):
        """
        根據(jù)刪除redis中的任意數(shù)據(jù)類型
        deletekeys('gender','cname') 可以刪除多個(gè)key
        :param keys:
        :return:
        """
        return self.rd.delete(*keys)

    def existskeys(self,key):
        """
        檢測(cè)redis的key 是否存在，存在就返回True,False則不存在
        :param key:
        :return:
        """
        return  self.rd.exists(key)

    def getkeys(self,pattern=""):
        """
        根據(jù)模型獲取redis的key

        getkeys * 匹配數(shù)據(jù)庫(kù)中所有 key 。
        getkeys h?llo 匹配 hello ， hallo 和 hxllo 等。
        getkeys hllo 匹配 hllo 和 heeeeello 等。
        getkeys h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo

        :param pattern:
        :return:
        """
        return self.rd.keys(pattern)

    def expirekeys(self,key,time):
        """
        設(shè)置超時(shí)時(shí)間，為某個(gè)key設(shè)置超時(shí)時(shí)間
        :param key:
        :param time: 秒
        :return:
        """
        return self.rd.expire(key,time)

    def renamekeys(self,srckey,dstkey):
        """
        對(duì)key進(jìn)行重命名
        :param srckey:
        :param dstkey:
        :return:
        """
        return self.rd.rename(srckey,dstkey)

    def randomkeys(self):
        """
        隨即獲取一個(gè)key(不刪除)
        :return:
        """
        return self.rd.randomkey()

    def getkeytypes(self,key):
        """
        獲取key的類型
        :param key:
        :return:
        """
        return self.rd.type(key)

    def scankeys(self,cursor=0,match=None,count=None):
        """
        查看所有key，終極大招
        :param cursor:
        :param match:
        :param count:
        :return:
        """
        return self.rd.scan(cursor,match,count)

    def scaniterkeys(self,match=None,count=None):
        """
        查看所有key的迭代器，防止內(nèi)存被撐爆
        :param match:
        :param count:
        :return:
        """
        return self.rd.scan_iter(match,count)

    def dbsizekeys(self):
        """
        當(dāng)前redis包含多少條數(shù)據(jù)
        :return:
        """
        return self.rd.dbsize()

    def savekeys(self):
        """
        將數(shù)據(jù)刷入磁盤(pán)中，保存時(shí)阻塞
        :return:
        """
        return self.rd.save()

    def flushdbkeys(self,asynchronous=False):
        """
        清空當(dāng)前數(shù)據(jù)庫(kù)的所有數(shù)據(jù),請(qǐng)謹(jǐn)慎使用
        :param asynchronous：異步
        :return:
        """
        return self.rd.flushdb(asynchronous)

    def flushallkeys(self,asynchronous=False):
        """
        清空redis所有庫(kù)中的數(shù)據(jù)，不到最后時(shí)刻 請(qǐng)不要使用
        :param asynchronous: 異步
        :return:
        """

        return self.rd.flushall(asynchronous)

    # 創(chuàng)建管道

    """
    redis默認(rèn)在執(zhí)行每次請(qǐng)求都會(huì)創(chuàng)建（連接池申請(qǐng)連接）和斷開(kāi)（歸還連接池）一次連接操作，
    如果想要在一次請(qǐng)求中指定多個(gè)命令，則可以使用pipline實(shí)現(xiàn)一次請(qǐng)求指定多個(gè)命令，
    并且默認(rèn)情況下一次pipline 是原子性操作。
    管道（pipeline）是redis在提供單個(gè)請(qǐng)求中緩沖多條云服務(wù)器命令的基類的子類。
    它通過(guò)減少云服務(wù)器-客戶端之間反復(fù)的TCP數(shù)據(jù)庫(kù)包，從而大大提高了執(zhí)行批量命令的功能。

    """
    def createpipe(self):
        """
        pipeline(transaction=False)    # 默認(rèn)的情況下，管道里執(zhí)行的命令可以保證執(zhí)行的原子性，執(zhí)行pipe = r.pipeline(transaction=False)可以禁用這一特性。
        pipe = r.pipeline() # 創(chuàng)建一個(gè)管道

        pipe.set('name', 'jack')
        pipe.set('role', 'sb')
        pipe.sadd('faz', 'baz')
        pipe.incr('num')    # 如果num不存在則vaule為1，如果存在，則value自增1
        pipe.execute()

        pipe.set('hello', 'redis').sadd('faz', 'baz').incr('num').execute()

        :return:
        """
        return  self.rd.pipeline()

    def disconectkeys(self):
        return self.connPoor.disconnect()

class QueryAllData():
    def __init__(self):
        self.show_tables = config.mysql_show_tables
        self.desc_table = config.mysql_desc_table
        self.query_info = config.mysql_query_info

    def query_tables_info(self):
        mhelper = MySQLHelper()
        tables_list = mhelper.queryTableNums(self.show_tables)
        tables_attr = {}
        for table in tables_list:
            rows = mhelper.queryAll(self.query_info %table)
            tables_attr[table] = rows

        mhelper.close()
        return tables_attr

    def mysql2redis(self,redisobj):

        mysql_data = self.query_tables_info()

        for keys, values in mysql_data.items():
            # keys 為表名字
            for val in values:
                # val 為每一行的數(shù)據(jù)
                keysorted = sorted(val.keys())
                for s in keysorted:
                    #s 為數(shù)據(jù)的key
                    item = '%s:%s'%(keys,str(val['id']))
                    ischange = redisobj.hgetkey(item,s)
                    if ischange != val[s]:
                        redisobj.hsetkey(item,s,val[s])

if __name__ == "__main__":

    queryalldata = QueryAllData()
    rhelper = RedisHelper()
    while True:
        queryalldata.mysql2redis(rhelper)

看完以上關(guān)于mysql中單個(gè)庫(kù)數(shù)據(jù)該怎么樣同步到redis數(shù)據(jù)庫(kù)中，很多讀者朋友肯定多少有一定的了解，如需獲取更多的行業(yè)知識(shí)信息 ，可以持續(xù)關(guān)注我們的行業(yè)資訊欄目的。