Python爬虫程序运行在服务器上，如何为不同用户区分使用Cookie？

核心思路： 为每个用户创建独立的CookieJar实例或会话对象，并将用户标识（如用户ID）与对应的会话进行映射管理。

具体实现方案：

1. 使用requests.Session为每个用户创建独立会话

   import requests
   from threading import Lock
   
   class UserSessionManager:
       def __init__(self):
           self.user_sessions = {}  # 用户ID -> Session对象
           self.lock = Lock()
       
       def get_session(self, user_id):
           """获取或创建用户的专属会话"""
           with self.lock:
               if user_id not in self.user_sessions:
                   self.user_sessions[user_id] = requests.Session()
               return self.user_sessions[user_id]
       
       def clear_session(self, user_id):
           """清理用户会话"""
           with self.lock:
               if user_id in self.user_sessions:
                   self.user_sessions.pop(user_id, None)
   
   # 使用示例
   manager = UserSessionManager()
   
   # 用户A的请求
   session_a = manager.get_session("user_001")
   response_a = session_a.get("https://example.com")
   
   # 用户B的请求（使用独立的Cookie）
   session_b = manager.get_session("user_002")
   response_b = session_b.get("https://example.com")
   

2. 数据库存储方案（持久化Cookie）

   import sqlite3
   import pickle
   from requests.cookies import RequestsCookieJar
   
   class DBCookieManager:
       def __init__(self, db_path="cookies.db"):
           self.conn = sqlite3.connect(db_path, check_same_thread=False)
           self._init_db()
       
       def _init_db(self):
           """初始化数据库表"""
           cursor = self.conn.cursor()
           cursor.execute("""
               CREATE TABLE IF NOT EXISTS user_cookies (
                   user_id TEXT PRIMARY KEY,
                   cookies BLOB,
                   updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
               )
           """)
           self.conn.commit()
       
       def save_cookies(self, user_id, cookie_jar):
           """保存用户Cookie到数据库"""
           serialized = pickle.dumps(cookie_jar)
           cursor = self.conn.cursor()
           cursor.execute("""
               INSERT OR REPLACE INTO user_cookies (user_id, cookies)
               VALUES (?, ?)
           """, (user_id, serialized))
           self.conn.commit()
       
       def load_cookies(self, user_id):
           """从数据库加载用户Cookie"""
           cursor = self.conn.cursor()
           cursor.execute("SELECT cookies FROM user_cookies WHERE user_id=?", (user_id,))
           row = cursor.fetchone()
           if row:
               return pickle.loads(row[0])
           return RequestsCookieJar()
       
       def close(self):
           self.conn.close()
   
   # 使用示例
   cookie_manager = DBCookieManager()
   
   # 为不同用户创建会话并保存Cookie
   session = requests.Session()
   session.get("https://example.com/login", params={"user": "user_001"})
   cookie_manager.save_cookies("user_001", session.cookies)
   
   # 加载特定用户的Cookie
   user_cookies = cookie_manager.load_cookies("user_001")
   session.cookies.update(user_cookies)
   

3. Redis缓存方案（高性能场景）

   import redis
   import pickle
   
   class RedisCookieManager:
       def __init__(self, host='localhost', port=6379, db=0):
           self.redis_client = redis.Redis(host=host, port=port, db=db)
       
       def save_cookies(self, user_id, cookie_jar, expire=86400):
           """保存Cookie到Redis，可设置过期时间"""
           serialized = pickle.dumps(cookie_jar)
           self.redis_client.setex(f"cookies:{user_id}", expire, serialized)
       
       def load_cookies(self, user_id):
           """从Redis加载Cookie"""
           data = self.redis_client.get(f"cookies:{user_id}")
           if data:
               return pickle.loads(data)
           return RequestsCookieJar()
   

总结建议： 根据你的并发量和持久化需求选择合适的方案。