Cookie与Session会话管理

网络爬虫专题 · 掌握爬虫会话管理技术

专题：Python网络爬虫系统学习

关键词：Python, 网络爬虫, Cookie, Session, JWT, 登录模拟, Token, 会话管理, requests.Session

一、Cookie与Session基础

1.1 HTTP无状态协议的问题

HTTP协议本身是无状态的，这意味着每次请求都是独立的，服务器无法识别两个请求是否来自同一个用户。对于需要保持登录状态或跟踪用户行为的场景（如购物车、个性化推荐），无状态特性带来了极大挑战。为了解决这个问题，业界发展出了Cookie、Session和Token三种主流方案。

1.2 Cookie机制

Cookie是存储在客户端浏览器中的一小段文本数据，由服务器通过Set-Cookie响应头设置，浏览器在后续请求中自动通过Cookie请求头携带回服务器。Cookie的核心属性包括：name（名称）、value（值）、domain（生效域名）、path（生效路径）、expires/max-age（过期时间）、Secure（仅HTTPS）、HttpOnly（禁止JavaScript访问）、SameSite（跨站策略）。

关键理解：Cookie相当于用户的"身份凭证"，爬虫模拟登录的本质就是获取并维持有效的Cookie。服务器通过读取请求中的Cookie来识别用户身份和状态。

1.3 Session机制

Session数据存储在服务端，客户端只保存一个Session ID（通常存放在Cookie中）。当用户登录成功后，服务器创建Session对象并生成唯一的Session ID返回给客户端。后续请求携带Session ID，服务器根据ID查找对应的Session数据。这种模式的优点是敏感数据存储在服务端更安全，缺点是服务器需要维护大量Session状态，分布式环境下需要Session共享方案（如Redis集中存储）。

1.4 Token机制（JWT无状态认证）

JWT（JSON Web Token）是一种无状态的认证方案，将用户信息加密编码到Token字符串中，服务器无需存储Session。客户端登录后获得Token，后续请求在Authorization请求头中携带Token即可。JWT自包含用户信息和签名，服务器通过验证签名来确认Token的真实性。这种模式天然适合分布式系统和移动端API，也是现代爬虫经常遇到的认证方式。

对比总结：Cookie+Session是"有状态"认证，服务端需要存储会话数据；JWT是"无状态"认证，所有信息都编码在Token中。爬虫需要根据目标网站采用的认证方式选择相应的处理策略。

二、爬虫中的Cookie处理

2.1 从浏览器获取Cookie

开发爬虫时，最直接的方式是从浏览器手动复制Cookie。打开浏览器开发者工具（F12），切换到Network标签页，访问目标网站后，从任意请求的Request Headers中找到Cookie字段即可复制。这种方式适合快速开发和简单爬虫，但Cookie过期后需要手动更新。

2.2 requests中设置Cookie

Python requests库提供了多种设置Cookie的方式。最灵活的方式是使用cookies参数传入一个dict：

import requests # 方式一：cookies参数（推荐） cookies = {"sessionid": "abc123", "token": "xyz789"} resp = requests.get("https://example.com/profile", cookies=cookies) # 方式二：headers中直接设置 headers = {"Cookie": "sessionid=abc123; token=xyz789"} resp = requests.get("https://example.com/profile", headers=headers) # 方式三：使用RequestsCookieJar from requests.cookies import RequestsCookieJar jar = RequestsCookieJar() jar.set("sessionid", "abc123", domain="example.com", path="/") resp = requests.get("https://example.com/profile", cookies=jar)

推荐使用cookies参数而非headers方式，因为requests库会对cookies参数进行编码处理，确保Cookie格式正确。此外，使用RequestsCookieJar可以更精细地控制Cookie的domain和path属性。

2.3 requests.Session自动管理Cookie

requests.Session对象会自动保存和发送Cookie，相当于在爬虫中维护了一个浏览器级别的Cookie容器。这是爬虫开发中最常用的方式：

import requests session = requests.Session() # 第一次请求，服务器返回Cookie session.get("https://example.com/login") # 后续请求自动携带Cookie resp = session.get("https://example.com/dashboard") # 此时无需手动处理Cookie，Session会自动管理

Session对象的优势在于：自动跟踪Cookie的添加和更新、保持连接池复用（提升性能）、统一配置headers和超时时间。建议在需要登录状态的爬虫中始终使用Session对象。

2.4 Cookie的结构

理解Cookie的内部结构对爬虫调试至关重要。一个典型的Cookie包含以下属性：name（名称，如sessionid）、value（值，如加密的会话ID）、domain（生效域名，如.example.com表示所有子域名都生效）、path（生效路径，默认为/）、expires/max-age（过期时间，决定Cookie是会话级还是持久级）、Secure标记（仅HTTPS传输）、HttpOnly标记（禁止JavaScript读取，防止XSS攻击）。爬虫在模拟Cookie时需要确保domain和path的正确性，否则服务器可能拒绝接受。

2.5 Session Cookie vs Persistent Cookie

Session Cookie（会话Cookie）不设置Expires或Max-Age属性，浏览器关闭后自动删除。Persistent Cookie（持久Cookie）设置了过期时间，会保存在磁盘中，即使关闭浏览器下次打开仍然有效。在爬虫中，Session Cookie通常需要每次会话重新获取，而持久Cookie可以保存到文件重复使用，这就是Cookie持久化的基础。

实战要点：大部分网站的登录态Cookie是Session Cookie，意味着浏览器关闭就会失效。但有些网站会同时发放一个持久化的"刷新Token"用于自动续期。爬虫设计中需要考虑这两种Cookie的有效期差异。

三、登录模拟

3.1 分析登录请求

模拟登录的第一步是分析登录请求的结构。打开浏览器开发者工具的Network面板，勾选"Preserve log"（保留日志），执行登录操作，找到提交登录信息的请求（通常为POST方法，URL包含login、signin等关键词）。关注以下关键信息：请求URL、请求方法、请求头（特别是Content-Type）、请求体参数格式（表单还是JSON）、响应中的认证信息（Cookie或Token）。

3.2 表单登录模拟

大多数传统网站使用表单登录（Content-Type: application/x-www-form-urlencoded），爬虫模拟代码如下：

import requests session = requests.Session() login_url = "https://example.com/login" # 模拟表单登录 login_data = { "username": "your_account", "password": "your_password", "csrf_token": "获取的CSRF令牌" # 部分网站需要 } resp = session.post(login_url, data=login_data) # 检查登录是否成功 if "登录成功" in resp.text or resp.status_code == 200: print("登录成功！") # 此时session已保存登录Cookie profile = session.get("https://example.com/profile") else: print("登录失败，请检查参数")

3.3 JSON登录模拟

现代API接口通常使用JSON格式（Content-Type: application/json）传递登录参数。注意使用json参数而非data参数：

import requests session = requests.Session() login_url = "https://api.example.com/auth/login" login_payload = { "email": "user@example.com", "password": "encrypted_password", "device": "web" } resp = session.post(login_url, json=login_payload) # JSON接口通常返回Token而非设置Cookie data = resp.json() if "token" in data: token = data["token"] # 后续请求手动设置Authorization头 session.headers.update({"Authorization": f"Bearer {token}"}) print(f"登录成功，Token: {token[:20]}...")

3.4 验证码处理概述

验证码是模拟登录的最大障碍之一。常见的处理方案包括：手动输入（开发调试时，下载验证码图片人工识别后输入）、OCR识别（使用Tesseract等库识别简单文本验证码）、第三方打码平台（如超级鹰、打码兔，适合滑块、点选等复杂验证码）、机器学习（使用CNN训练自定义识别模型）。对于滑块验证码，可以使用Selenium模拟拖拽操作。企业级爬虫通常会搭建验证码识别服务来统一处理各种验证码。

3.5 保存登录状态

Session对象默认只在程序运行时保持登录状态，程序重启后Cookie会丢失。通过持久化Session对象可以实现登录状态的复用：

import requests import pickle session = requests.Session() # 尝试从文件加载Cookie try: with open("session_cookies.pkl", "rb") as f: session.cookies.update(pickle.load(f)) print("从文件加载Cookie成功") except FileNotFoundError: print("未找到保存的Cookie，需要登录") # 执行登录流程 login_data = {"username": "xxx", "password": "xxx"} session.post("https://example.com/login", data=login_data) # 保存Cookie到文件 with open("session_cookies.pkl", "wb") as f: pickle.dump(session.cookies, f) print("Cookie已保存到文件") # 使用登录后的session发送请求 resp = session.get("https://example.com/dashboard")

3.6 Cookie持久化（保存到文件、下次加载）

除了pickle序列化，也可以将Cookie保存为文本格式便于查看和编辑：

import json # 将Cookie保存为JSON格式 def save_cookies(session, filepath="cookies.json"): cookies_dict = {} for cookie in session.cookies: cookies_dict[cookie.name] = cookie.value with open(filepath, "w", encoding="utf-8") as f: json.dump(cookies_dict, f, ensure_ascii=False, indent=2) # 从JSON文件加载Cookie def load_cookies(session, filepath="cookies.json"): with open(filepath, "r", encoding="utf-8") as f: cookies_dict = json.load(f) session.cookies.update(cookies_dict) return session

最佳实践：Cookie持久化时建议同时保存获取时间，在加载时判断Cookie是否过期。对于敏感Cookie，可以考虑加密存储。生产环境中，推荐使用Redis等缓存数据库存储Cookie，便于分布式爬虫共享登录状态。

四、Session池管理

4.1 多账号Session轮换

当爬虫需要高频抓取时，单一账号可能触发频率限制或被封禁。多账号Session轮换是常用的反反爬策略。核心思路是维护一个Session对象池，每个Session对应一个账号的登录状态，请求时按策略从池中选取Session：

import requests import random from dataclasses import dataclass from typing import List @dataclass class Account: username: str password: str class SessionPool: def __init__(self, accounts: List[Account]): self.sessions = {} for acc in accounts: session = requests.Session() session.post("https://example.com/login", data={"user": acc.username, "pass": acc.password}) self.sessions[acc.username] = session def get_random_session(self) -> requests.Session: return random.choice(list(self.sessions.values())) def get_round_robin_session(self): # 轮询获取 if not hasattr(self, '_rr_index'): self._rr_index = 0 keys = list(self.sessions.keys()) session = self.sessions[keys[self._rr_index]] self._rr_index = (self._rr_index + 1) % len(keys) return session

4.2 Session有效性检测

Session可能因为Cookie过期、账号异常、被踢下线等原因失效，需要定期检测有效性。通常的检测方法是访问一个需要登录才能看到的页面，检查响应中是否包含特定的用户信息标记：

def is_session_valid(session, check_url="https://example.com/user/info"): """检测Session是否有效""" try: resp = session.get(check_url, timeout=10) # 检查是否被重定向到登录页 if resp.url.endswith("login") or resp.status_code == 401: return False # 检查响应中是否包含用户标识 if "请登录" in resp.text or resp.status_code == 302: return False return True except Exception as e: print(f"检测Session时出错: {e}") return False

4.3 Session过期自动重登录

完善的Session池需要具备自动重登录能力。当Session被检测为无效时，使用对应的账号信息重新登录并更新Session：

class AutoReloginSessionPool(SessionPool): def __init__(self, accounts: List[Account]): super().__init__(accounts) self.account_map = {} for acc in accounts: self.account_map[acc.username] = acc def get_valid_session(self, username: str) -> requests.Session: session = self.sessions[username] if not is_session_valid(session): print(f"账号 {username} Session已过期，重新登录") acc = self.account_map[username] new_session = requests.Session() new_session.post("https://example.com/login", data={"user": acc.username, "pass": acc.password}) self.sessions[username] = new_session return new_session return session def validate_all(self): """批量检测所有Session，自动重登录失效的""" for username in list(self.sessions.keys()): self.get_valid_session(username)

4.4 Cookie更新机制

服务器可能在任何响应中通过Set-Cookie头更新Cookie，requests.Session会自动处理这种情况。但在某些场景下（如分布式爬虫），需要手动同步Cookie更新：

# 监听Cookie更新 def on_cookie_updated(session, request, response): """每次请求后检查Cookie是否有更新""" old_cookies = set(session.cookies.keys()) # 发送请求 resp = session.send(request) new_cookies = set(session.cookies.keys()) # 检测新增或更新的Cookie if new_cookies != old_cookies: print(f"Cookie已更新: 新增={new_cookies - old_cookies}") # 同步到共享存储（如Redis） sync_cookies_to_redis(session.cookies) return resp

五、JWT Token认证

5.1 JWT的结构

JWT由三部分组成，用点号（.）分隔：Header.Payload.Signature。Header通常包含令牌类型（typ: JWT）和签名算法（alg: HS256或RS256）。Payload包含声明（claims），如用户ID（sub）、过期时间（exp）、发布时间（iat）等。Signature是对前两部分的签名，用于验证令牌未被篡改。一个典型的JWT字符串如下：

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9. eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ. SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

三部分分别经过Base64URL编码，不含敏感信息（Base64是可解码的），因此JWT payload中不应该存放密码等敏感数据。Signature才是安全性的核心保障，需要服务端的密钥才能伪造。

5.2 爬虫中获取Token（登录接口返回）

很多现代API在登录成功后直接返回JWT Token，而非设置Cookie。爬虫需要从响应体中提取Token并保存：

import requests session = requests.Session() login_url = "https://api.example.com/v1/auth/login" payload = {"email": "user@test.com", "password": "test123"} resp = session.post(login_url, json=payload) data = resp.json() # 从响应中提取Token access_token = data.get("access_token") refresh_token = data.get("refresh_token") # 保存Token并设置到后续请求中 session.headers.update({ "Authorization": f"Bearer {access_token}" }) # 后续请求自动携带Token profile = session.get("https://api.example.com/v1/user/profile")

5.3 Token刷新机制

JWT通常有过期时间（短则15分钟，长则数小时）。访问接口返回401时，需要使用refresh_token换取新的access_token。爬虫需要实现自动刷新逻辑：

class JWTClient: def __init__(self, base_url, email, password): self.base_url = base_url self.email = email self.password = password self.session = requests.Session() self.access_token = None self.refresh_token = None self.login() def login(self): resp = self.session.post( f"{self.base_url}/auth/login", json={"email": self.email, "password": self.password} ) data = resp.json() self.access_token = data["access_token"] self.refresh_token = data.get("refresh_token") self._update_auth_header() def _update_auth_header(self): self.session.headers.update( {"Authorization": f"Bearer {self.access_token}"} ) def _refresh_token(self): if not self.refresh_token: return False resp = self.session.post( f"{self.base_url}/auth/refresh", json={"refresh_token": self.refresh_token} ) if resp.status_code == 200: data = resp.json() self.access_token = data["access_token"] self._update_auth_header() return True return False def request(self, method, endpoint, **kwargs): url = f"{self.base_url}{endpoint}" resp = self.session.request(method, url, **kwargs) # Token过期，自动刷新 if resp.status_code == 401: if self._refresh_token(): # 重试原请求 self._update_auth_header() resp = self.session.request(method, url, **kwargs) return resp

5.4 在请求头中携带Token（Authorization: Bearer xxx）

JWT认证的标准做法是在HTTP请求头中携带Token：

# 标准格式 headers = { "Authorization": "Bearer eyJhbGciOiJIUzI1NiIs..." } # 或使用session统一设置 session = requests.Session() session.headers.update({ "Authorization": "Bearer your_jwt_token_here" }) resp = session.get("https://api.example.com/protected/resource")

注意事项：Bearer后面的空格是必须的。部分旧版API可能使用"Token"替代"Bearer"前缀，需根据目标API的文档确认格式。另外，JWT Token通常有较短的过期时间（15-60分钟），建议爬虫在每次请求前检查Token是否即将过期，提前刷新。

六、常见认证机制

认证方式工作原理爬虫处理
Basic Auth 用户名密码以base64编码放在Authorization头 requests.auth.HTTPBasicAuth直接处理
Digest Auth 挑战-响应机制，传输摘要而非明文密码 requests.auth.HTTPDigestAuth自动处理
OAuth2.0 授权码/密码/客户端凭证等多种流程获取Token 模拟获取authorization_code和access_token流程
API Key 在URL参数或请求头中携带固定密钥 直接传入API Key参数即可

6.1 Basic Auth（HTTP基本认证）

Basic Auth是最简单的HTTP认证方式，将用户名和密码用冒号拼接后做Base64编码，放在Authorization头中。requests库提供了便捷的处理方式：

from requests.auth import HTTPBasicAuth # 方式一：使用auth参数（推荐） resp = requests.get("https://api.example.com/data", auth=HTTPBasicAuth("admin", "password123")) # 简写形式 resp = requests.get("https://api.example.com/data", auth=("admin", "password123")) # 方式二：手动编码（了解原理） import base64 credentials = base64.b64encode(b"admin:password123").decode() headers = {"Authorization": f"Basic {credentials}"} resp = requests.get("https://api.example.com/data", headers=headers)

6.2 Digest Auth（摘要认证）

Digest Auth相比Basic Auth更安全，不会直接传输密码。服务器先返回一个nonce（随机数），客户端使用MD5摘要算法对密码+nonce等组合进行哈希后返回。requests库同样内置支持：

from requests.auth import HTTPDigestAuth resp = requests.get("https://api.example.com/protected", auth=HTTPDigestAuth("user", "pass")) # HTTPDigestAuth会自动处理挑战-响应流程

6.3 OAuth2.0认证流程

OAuth2.0是互联网应用最广泛的授权框架，包含四种授权模式。爬虫最常遇到的是密码模式（Resource Owner Password Credentials Grant）和客户端凭证模式（Client Credentials Grant）。密码模式需要用户名、密码、client_id、client_secret四个参数，返回access_token和refresh_token。爬虫实现时需要注意：OAuth2.0的Token也有过期时间需刷新、部分接口还需要额外的scope权限参数、某些平台限制了单个账号的并发Token数量。

6.4 API Key认证

API Key是最简单的认证方式，很多开放API采用这种模式。通常以请求头、URL查询参数或Cookie的形式传递。处理方式最为直接：

# 请求头方式（最常见） headers = {"X-API-Key": "your_api_key_here"} resp = requests.get("https://api.example.com/data", headers=headers) # URL参数方式 resp = requests.get("https://api.example.com/data", params={"api_key": "your_api_key_here"}) # Cookie方式 cookies = {"api_key": "your_api_key_here"} resp = requests.get("https://api.example.com/data", cookies=cookies)

6.5 各认证方式在爬虫中的处理

面对不同类型的认证机制，爬虫的处理策略各不相同。Basic Auth和Digest Auth有现成的库支持，处理起来最简单。API Key认证只需要在配置中管理好密钥即可。OAuth2.0和JWT Token是最复杂的，需要处理完整的认证流程、Token刷新、并发Token管理等。在实际项目中，建议将认证模块抽象为独立的类或函数，统一管理各种认证方式，便于维护和复用。

七、实战技巧

7.1 使用浏览器开发者工具查看Cookie

浏览器开发者工具（F12）的Application面板中的Cookies选项卡，可以查看当前网站的所有Cookie详细信息，包括名称、值、域名、路径、过期时间、HttpOnly、Secure等属性。这是分析目标网站Cookie结构最直观的方式。同时，在Network面板中查看任意请求的Request Headers，可以看到浏览器实际发送的Cookie字符串，有助于确认哪些Cookie是服务器真正关心的。

7.2 Cookie转换为Python字典

从浏览器复制的Cookie是字符串格式（如 "key1=value1; key2=value2"），需要转换为Python字典才能在requests中使用。手动转换字符串效率低且容易出错，建议使用辅助函数自动转换：

def parse_cookie_string(cookie_str: str) -> dict: """将Cookie字符串解析为字典""" cookies = {} for item in cookie_str.split(";"): item = item.strip() if "=" in item: key, value = item.split("=", 1) cookies[key.strip()] = value.strip() return cookies # 使用示例 cookie_str = "sessionid=abc123; csrftoken=xyz789; _ga=GA1.2.123456789" cookies = parse_cookie_string(cookie_str) print(cookies) # {'sessionid': 'abc123', 'csrftoken': 'xyz789', '_ga': 'GA1.2.123456789'}

7.3 使用curl命令导出Cookie

curl命令提供了强大的Cookie处理能力，可以方便地导出和导入Cookie。使用curl访问目标网站后，通过-c参数将Cookie保存到文件，随后爬虫可以直接加载这个文件：

# 终端命令 curl -c cookies.txt -b cookies.txt https://example.com/login \ -d "username=admin&password=123456" # Python加载curl格式的Cookie文件 from http.cookiejar import MozillaCookieJar import requests def load_curl_cookies(filepath="cookies.txt"): jar = MozillaCookieJar(filepath) jar.load() session = requests.Session() for cookie in jar: session.cookies.set(cookie.name, cookie.value, domain=cookie.domain, path=cookie.path) return session

7.4 Cookie池构建

在大规模爬虫系统中，Cookie池是基础设施之一。一个完整的Cookie池应包括以下功能：多账号Cookie自动获取和更新、Cookie有效性自动检测、失效Cookie自动剔除和补充、Cookie按站点/账号分类存储、支持并发安全的读写操作（生产环境建议使用Redis）、提供统一的获取接口（随机获取、按权重获取等）：

import redis import json import requests from typing import Optional class RedisCookiePool: """基于Redis的Cookie池""" def __init__(self, redis_host="localhost", redis_port=6379, db=0): self.r = redis.Redis(host=redis_host, port=redis_port, db=db) self.key_prefix = "cookie_pool:" def add_cookie(self, site: str, account: str, cookies: dict): """添加或更新Cookie""" key = f"{self.key_prefix}{site}:{account}" data = { "cookies": cookies, "created_at": int(time.time()), "valid": True } self.r.set(key, json.dumps(data)) def get_random_cookie(self, site: str) -> Optional[dict]: """随机获取一个有效的Cookie""" pattern = f"{self.key_prefix}{site}:*" keys = self.r.keys(pattern) if not keys: return None import random key = random.choice(keys) data = json.loads(self.r.get(key)) return data["cookies"] def mark_invalid(self, site: str, account: str): """标记Cookie为无效""" key = f"{self.key_prefix}{site}:{account}" data = json.loads(self.r.get(key)) data["valid"] = False self.r.set(key, json.dumps(data)) def get_all_valid(self, site: str) -> list: """获取所有有效Cookie""" pattern = f"{self.key_prefix}{site}:*" keys = self.r.keys(pattern) valid_cookies = [] for key in keys: data = json.loads(self.r.get(key)) if data.get("valid", False): valid_cookies.append(data["cookies"]) return valid_cookies

架构建议：Cookie池是分布式爬虫的核心组件，推荐独立部署为微服务，提供RESTful API供各爬虫节点调用。这样可以统一管理所有Cookie的状态，避免重复登录，提高爬虫系统的稳定性和可维护性。

八、核心要点总结

1. HTTP无状态协议的特性决定了必须有会话管理机制，Cookie/Session/JWT是三种主流方案。

2. requests.Session是爬虫管理Cookie的最核心工具，务必熟练掌握其用法。

3. 登录模拟的关键在于准确分析登录请求的参数格式和认证信息的返回方式。

4. Session池管理是大规模爬虫的必备技术，包括多账号轮换、有效性检测和自动重登录。

5. JWT Token在现代API中越来越普及，爬虫需要实现自动刷新机制应对Token过期。

6. 不同的认证方式（Basic Auth / Digest Auth / OAuth2.0 / API Key）需要不同的处理策略。

7. Cookie池是爬虫工程化的重要基础设施，推荐使用Redis等中间件实现分布式共享。

8. 实战中应始终关注Cookie的有效期和安全性，设计完善的异常处理机制。

九、进一步思考

在掌握了基础的Cookie和Session管理后，可以进一步探索以下方向：使用Selenium或Playwright模拟浏览器环境，处理需要JavaScript渲染的登录流程；研究反爬虫对抗技术，如请求指纹、行为分析等；探索无头浏览器在复杂登录场景中的应用；学习异步爬虫中的会话管理（如aiohttp的Cookie处理）。会话管理是爬虫技术的核心能力之一，扎实掌握后将能应对绝大多数需要登录态的数据采集场景。