Python與Redis的連接教程

 r=redis.StrictRedis(host=xxxx, port=xxxx, db=xxxx)
 r.xxxx()

pool = redis.ConnectionPool(host=xxx, port=xxx, db=xxxx)
r = redis.Redis(connection_pool=pool)

class StrictRedis(object):
........
 def __init__(self, host='localhost', port=6379,
 db=0, password=None, socket_timeout=None,
 socket_connect_timeout=None,
 socket_keepalive=None, socket_keepalive_options=None,
 connection_pool=None, unix_socket_path=None,
 encoding='utf-8', encoding_errors='strict',
 charset=None, errors=None,
 decode_responses=False, retry_on_timeout=False,
 ssl=False, ssl_keyfile=None, ssl_certfile=None,
 ssl_cert_reqs=None, ssl_ca_certs=None):
 if not connection_pool:
 ..........
 connection_pool = ConnectionPool(**kwargs)
 self.connection_pool = connection_pool

 # COMMAND EXECUTION AND PROTOCOL PARSING
 def execute_command(self, *args, **options):
 "Execute a command and return a parsed response"
 pool = self.connection_pool
 command_name = args[0]
 connection = pool.get_connection(command_name, **options) #調用ConnectionPool.get_connection方法獲取一個連接
 try:
 connection.send_command(*args) #命令執行，這里為Connection.send_command
 return self.parse_response(connection, command_name, **options)
 except (ConnectionError, TimeoutError) as e:
 connection.disconnect()
 if not connection.retry_on_timeout and isinstance(e, TimeoutError):
 raise
 connection.send_command(*args) 
 return self.parse_response(connection, command_name, **options)
 finally:
 pool.release(connection) #調用ConnectionPool.release釋放連接

class ConnectionPool(object): 
 ...........
 def __init__(self, connection_class=Connection, max_connections=None,
 **connection_kwargs): #類初始化時調用構造函數
 max_connections = max_connections or 2 ** 31
 if not isinstance(max_connections, (int, long)) or max_connections < 0: #判斷輸入的max_connections是否合法
 raise ValueError('"max_connections" must be a positive integer')
 self.connection_class = connection_class #設置對應的參數
 self.connection_kwargs = connection_kwargs
 self.max_connections = max_connections
 self.reset() #初始化ConnectionPool 時的reset操作
 def reset(self):
 self.pid = os.getpid()
 self._created_connections = 0 #已經創建的連接的計數器
 self._available_connections = [] #聲明一個空的數組，用來存放可用的連接
 self._in_use_connections = set() #聲明一個空的集合，用來存放已經在用的連接
 self._check_lock = threading.Lock()
.......
 def get_connection(self, command_name, *keys, **options): #在連接池中獲取連接的方法
 "Get a connection from the pool"
 self._checkpid()
 try:
 connection = self._available_connections.pop() #獲取并刪除代表連接的元素，在第一次獲取connectiong時，因為_available_connections是一個空的數組，
 會直接調用make_connection方法
 except IndexError:
 connection = self.make_connection()
 self._in_use_connections.add(connection) #向代表正在使用的連接的集合中添加元素
 return connection 
 def make_connection(self): #在_available_connections數組為空時獲取連接調用的方法
 "Create a new connection"
 if self._created_connections >= self.max_connections: #判斷創建的連接是否已經達到最大限制，max_connections可以通過參數初始化
 raise ConnectionError("Too many connections")
 self._created_connections += 1 #把代表已經創建的連接的數值+1
 return self.connection_class(**self.connection_kwargs) #返回有效的連接，默認為Connection(**self.connection_kwargs)
 def release(self, connection): #釋放連接，鏈接并沒有斷開，只是存在鏈接池中
 "Releases the connection back to the pool"
 self._checkpid()
 if connection.pid != self.pid:
 return
 self._in_use_connections.remove(connection) #從集合中刪除元素
 self._available_connections.append(connection) #并添加到_available_connections 的數組中
 def disconnect(self): #斷開所有連接池中的鏈接
 "Disconnects all connections in the pool"
 all_conns = chain(self._available_connections,
 self._in_use_connections)
 for connection in all_conns:
 connection.disconnect()

class Connection(object):
 "Manages TCP communication to and from a Redis server"
 def __del__(self): #對象刪除時的操作，調用disconnect釋放連接
 try:
 self.disconnect()
 except Exception:
 pass

 def _connect(self):
 err = None
 for res in socket.getaddrinfo(self.host, self.port, 0,
 socket.SOCK_STREAM):
 family, socktype, proto, canonname, socket_address = res
 sock = None
 try:
 sock = socket.socket(family, socktype, proto)
 # TCP_NODELAY
 sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
 # TCP_KEEPALIVE
 if self.socket_keepalive: #構造函數中默認 socket_keepalive=False，因此這里默認為短連接
 sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
 for k, v in iteritems(self.socket_keepalive_options):
 sock.setsockopt(socket.SOL_TCP, k, v)
 # set the socket_connect_timeout before we connect
 sock.settimeout(self.socket_connect_timeout) #構造函數中默認socket_connect_timeout=None，即連接為blocking的模式
 # connect
 sock.connect(socket_address)
 # set the socket_timeout now that we're connected
 sock.settimeout(self.socket_timeout) #構造函數中默認socket_timeout=None
 return sock
 except socket.error as _:
 err = _
 if sock is not None:
 sock.close()
.....

 def disconnect(self):
 "Disconnects from the Redis server"
 self._parser.on_disconnect()
 if self._sock is None:
 return
 try:
 self._sock.shutdown(socket.SHUT_RDWR) #先shutdown再close
 self._sock.close()
 except socket.error:
 pass
 self._sock = None