Python高级技术之：`SQLAlchemy`的`Session`管理：如何正确使用`Session`来管理事务。 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

各位观众老爷，早上好/中午好/晚上好！今天咱们聊聊 SQLAlchemy 里让人又爱又恨的 Session，这玩意儿用好了，数据库操作行云流水，一不小心，就给你来个 "锁死"，让你欲哭无泪。所以，掌握 Session 的正确使用姿势，那是相当滴重要！

第一部分：Session 是个啥？它为啥这么重要？

简单来说，Session 就是 SQLAlchemy 用来和数据库交互的 "对话窗口"。它负责以下这些关键任务：

管理数据库连接： Session 内部维护着一个数据库连接池，帮你省去了手动建立和关闭连接的麻烦。
管理事务： Session 可以开启、提交或回滚事务，保证数据的一致性。
跟踪对象状态： Session 会跟踪你从数据库加载的对象，以及你新创建的对象，方便你进行增删改查操作。
缓存： Session 内部有一个缓存，可以避免重复查询相同的数据。

为啥 Session 这么重要？你想啊，如果没有 Session，你每次操作数据库都要手动建立连接，手动管理事务，那得多麻烦！而且，如果没有 Session 的缓存和对象状态跟踪，你可能会遇到各种奇奇怪怪的问题，比如数据不一致，性能低下等等。

第二部分：Session 的基本用法：CRUD 操作

先来个简单的例子，假设我们有一个 User 类，对应数据库里的 users 表：

from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.declarative import declarative_base

# 定义数据库连接
engine = create_engine('sqlite:///:memory:')  # 使用内存数据库方便测试

# 定义 ORM 基类
Base = declarative_base()

# 定义 User 类
class User(Base):
    __tablename__ = 'users'

    id = Column(Integer, primary_key=True)
    name = Column(String)
    age = Column(Integer)

    def __repr__(self):
       return f"<User(name='{self.name}', age={self.age})>"

# 创建表
Base.metadata.create_all(engine)

# 创建 Session 类
Session = sessionmaker(bind=engine)

# 创建 Session 实例
session = Session()

1. 创建（Create）

# 创建新用户
new_user = User(name='张三', age=30)

# 添加到 Session
session.add(new_user)

# 提交事务，保存到数据库
session.commit()

print(f"新用户 ID: {new_user.id}") # 输出新用户的 ID

2. 读取（Read）

# 根据 ID 查询用户
user = session.query(User).filter_by(id=1).first()

if user:
    print(f"查询到的用户: {user}")
else:
    print("用户不存在")

# 查询所有用户
users = session.query(User).all()

for user in users:
    print(user)

# 使用 filter 进行更复杂的查询
adult_users = session.query(User).filter(User.age >= 18).all()
print("成年用户:",adult_users)

3. 更新（Update）

# 查询要更新的用户
user = session.query(User).filter_by(id=1).first()

if user:
    # 修改用户信息
    user.age = 35

    # 提交事务
    session.commit()

    print(f"用户更新成功: {user}")
else:
    print("用户不存在")

4. 删除（Delete）

# 查询要删除的用户
user = session.query(User).filter_by(id=1).first()

if user:
    # 从 Session 中删除用户
    session.delete(user)

    # 提交事务
    session.commit()

    print("用户删除成功")
else:
    print("用户不存在")

第三部分：Session 的生命周期管理：try...except...finally 的重要性

Session 的生命周期管理是使用 SQLAlchemy 的关键。简单来说，就是Session的开启和关闭。一定要确保 Session 在使用完毕后被正确关闭，否则可能会导致连接泄漏，资源浪费，甚至数据库锁死。

最佳实践是使用 try...except...finally 结构来管理 Session：

session = Session()
try:
    # 执行数据库操作
    new_user = User(name='李四', age=25)
    session.add(new_user)
    session.commit()  # 提交事务

except Exception as e:
    # 发生异常，回滚事务
    session.rollback()
    print(f"发生异常: {e}")
finally:
    # 无论是否发生异常，都关闭 Session
    session.close()
    print("session closed!")

解释：

try 块： 包含可能抛出异常的数据库操作代码。
except 块： 捕获 try 块中抛出的异常，并执行相应的处理，比如回滚事务。
finally 块： 无论 try 块是否抛出异常，都会执行这里的代码。在这里关闭 Session，释放资源。

为啥要这么做？

保证事务完整性： 如果在 try 块中发生异常，session.rollback() 可以回滚事务，保证数据的一致性。
防止资源泄漏： session.close() 可以关闭 Session，释放数据库连接，防止连接泄漏。
代码健壮性： 使用 try...except...finally 可以让你的代码更加健壮，能够处理各种异常情况。

一个反例：

session = Session()
try:
    # 数据库操作
    new_user = User(name='王五', age=40)
    session.add(new_user)
    session.commit()
except Exception as e:
    print(f"发生异常: {e}") #没有回滚，也没有关闭session，可能导致连接泄漏，事务不一致。

这个例子中，如果 session.commit() 抛出异常，事务不会被回滚，Session 也不会被关闭，这可能会导致数据不一致和资源泄漏。切记切记！

第四部分：Session 的高级用法：scoped_session 和上下文管理器

1. scoped_session：线程安全，方便管理

在多线程或多进程环境中，直接使用 Session 对象可能会导致线程安全问题。 scoped_session 可以解决这个问题。简单来说，scoped_session 会为每个线程维护一个独立的 Session 实例。

from sqlalchemy.orm import scoped_session

# 创建 Session 类
Session = sessionmaker(bind=engine)

# 创建 scoped_session
session_factory = Session
Session = scoped_session(session_factory)

# 在线程中使用 Session
def worker():
    session = Session() # 注意这里直接调用Session()得到session
    try:
        # 数据库操作
        new_user = User(name='赵六', age=28)
        session.add(new_user)
        session.commit()
        print(f"Thread {threading.current_thread().name}: User created with id {new_user.id}")
    except Exception as e:
        session.rollback()
        print(f"Thread {threading.current_thread().name}: Error: {e}")
    finally:
        Session.remove() #关键！保证线程结束时，session被移除。
        print(f"Thread {threading.current_thread().name}: Session removed")

import threading

threads = []
for i in range(3):
    t = threading.Thread(target=worker, name=f"Thread-{i}")
    threads.append(t)
    t.start()

for t in threads:
    t.join()

解释：

scoped_session(session_factory) 创建一个 scoped_session 对象。
在每个线程中，直接调用 Session() 就可以获取当前线程的 Session 实例。
Session.remove() 非常重要！在线程结束时，一定要调用 Session.remove()，否则会导致连接泄漏。

2. 上下文管理器（with 语句）：更加优雅的 Session 管理

Python 的 with 语句可以让你更加优雅地管理 Session 的生命周期。

from contextlib import contextmanager

@contextmanager
def session_scope():
    """Provide a transactional scope around a series of operations."""
    session = Session()
    try:
        yield session
        session.commit()
    except Exception:
        session.rollback()
        raise
    finally:
        session.close()

# 使用上下文管理器
with session_scope() as session:
    # 数据库操作
    new_user = User(name='钱七', age=32)
    session.add(new_user)
    #session.commit() # 不需要手动提交，上下文管理器会自动提交或回滚

    user = session.query(User).filter_by(name='钱七').first()
    print(user)

解释：

@contextmanager 装饰器可以将一个函数变成上下文管理器。
yield session 会将 session 对象传递给 with 语句中的 as 变量。
在 with 语句块结束时，上下文管理器会自动提交或回滚事务，并关闭 Session。

使用上下文管理器可以简化代码，提高可读性，并且可以保证 Session 在使用完毕后被正确关闭。

第五部分：Session 的常见问题和解决方案

在使用 Session 的过程中，你可能会遇到各种各样的问题。这里列举一些常见的问题和解决方案：

问题	原因	解决方案
`DetachedInstanceError`	对象脱离了 Session 的管理。比如，你从 Session 中查询到一个对象，然后关闭了 Session，再尝试访问这个对象，就会抛出 `DetachedInstanceError`。	重新将对象添加到 Session 中，或者在 Session 关闭之前完成对对象的操作。
`InvalidRequestError: Session is closed`	尝试在一个已经关闭的 Session 上执行操作。	确保在 Session 关闭之前完成所有的数据库操作。
数据库连接泄漏	没有正确关闭 Session，导致数据库连接没有被释放。	使用 `try...except...finally` 结构或上下文管理器来管理 Session 的生命周期。
事务冲突	多个 Session 同时修改同一行数据，导致事务冲突。	使用悲观锁或乐观锁来解决事务冲突。
脏读	一个 Session 读取到另一个 Session 尚未提交的数据。	调整数据库的事务隔离级别，比如设置为 `READ COMMITTED` 或 `REPEATABLE READ`。
对象状态不一致	Session 内部缓存的对象状态与数据库中的数据不一致。	调用 `session.refresh(object)` 来刷新对象的状态。

第六部分：Session 的最佳实践

使用 try...except...finally 结构或上下文管理器来管理 Session 的生命周期。
尽量避免长时间持有 Session。 尽快完成数据库操作，然后关闭 Session，释放资源。
在多线程或多进程环境中使用 scoped_session。
使用 session.refresh(object) 来刷新对象的状态，确保对象状态与数据库中的数据一致。
根据实际情况选择合适的事务隔离级别。
使用日志记录 Session 的操作，方便调试和排查问题。

总结

Session 是 SQLAlchemy 中非常重要的一个概念，掌握 Session 的正确使用姿势，可以让你更加高效地进行数据库操作，并且可以避免各种潜在的问题。希望今天的讲座能够帮助大家更好地理解和使用 SQLAlchemy 的 Session。

好了，今天的讲座就到这里，谢谢大家！祝大家编程愉快！

发表回复 取消回复

发表回复取消回复