Flask 框架开发 RESTful API 时，遵循 SOLID 原则示例

最新推荐文章于 2026-01-07 14:26:31 发布

原创最新推荐文章于 2026-01-07 14:26:31 发布 · 992 阅读

CC 4.0 BY-SA版权

文章标签：

在使用 Flask 框架开发 RESTful API 时，遵循 SOLID 原则能够编写更灵活、可维护的代码。尽管 Flask 本身是一个轻量级框架，它并不强制开发者遵循复杂的设计模式或原则，但在大型项目中引入 SOLID 原则是非常有益的。

示例背景：

假设我们要开发一个简单的用户管理 API，其中包含用户的创建、查询和删除功能。我们将引入 SOLID 原则，确保代码设计具有良好的可扩展性和可维护性。

1. 单一职责原则（SRP）

原则：每个模块、类或函数应该只负责一个职责，避免多个职责耦合在一起。

在 Flask 中，通常开发者会将业务逻辑、数据库操作、请求处理全部写在一起。这违反了 SRP。我们可以将这些职责分离，具体分为：请求处理、业务逻辑和数据访问。

# routes.py
from flask import Flask, request, jsonify
from services.user_service import UserService

app = Flask(__name__)
user_service = UserService()

@app.route('/users', methods=['POST'])
def create_user():
    data = request.json
    user = user_service.create_user(data['name'], data['email'])
    return jsonify(user), 201

@app.route('/users/<int:user_id>', methods=['GET'])
def get_user(user_id):
    user = user_service.get_user(user_id)
    if user:
        return jsonify(user)
    return jsonify({'error': 'User not found'}), 404

这里，routes.py 负责处理请求和响应，但并没有涉及业务逻辑。

2. 开放封闭原则（OCP）

原则：类应该对扩展开放，对修改封闭。我们可以通过依赖接口或抽象类，使得系统可扩展而不需要修改已有的代码。

我们可以将用户的业务逻辑（如用户创建、查询等）封装在服务层，并通过定义接口的方式支持未来的扩展，比如添加更多的用户相关操作。

# services/user_service.py
from repositories.user_repository import UserRepository

class UserService:
    def __init__(self):
        self.user_repo = UserRepository()

    def create_user(self, name, email):
        user = {"name": name, "email": email}
        return self.user_repo.save(user)

    def get_user(self, user_id):
        return self.user_repo.get(user_id)

这里，UserService 提供了高层的业务逻辑，通过依赖 UserRepository 实现了具体的数据库操作。未来我们可以轻松扩展 UserService 而不需要修改已有的代码。

3. 里氏替换原则（LSP）

原则：子类应该能够替代父类并确保程序的行为一致。要保证任何地方使用父类的地方都能用子类替代。

为了让代码更具扩展性，我们可以通过抽象或接口的方式实现不同的存储机制，比如从内存存储切换到数据库存储时，不修改业务逻辑，只需要替换存储类即可。

# repositories/base_repository.py
from abc import ABC, abstractmethod

class BaseRepository(ABC):
    @abstractmethod
    def save(self, data):
        pass

    @abstractmethod
    def get(self, id):
        pass

# repositories/user_repository.py
class UserRepository(BaseRepository):
    def __init__(self):
        self.users = {}
        self.current_id = 1

    def save(self, data):
        data['id'] = self.current_id
        self.users[self.current_id] = data
        self.current_id += 1
        return data

    def get(self, user_id):
        return self.users.get(user_id)

这里 UserRepository 实现了 BaseRepository 抽象类，未来你可以很轻松地替换为数据库或其他存储系统，而不需要修改依赖它的服务层代码。

4. 接口隔离原则（ISP）

原则：不应该强迫一个类实现它不需要的接口，应该将接口划分为多个特定的接口。

在实际应用中，我们可能会有不同的存储需求。例如，用户的存储需求和日志的存储需求是不同的，因此应该为它们定义不同的接口，避免让某个类去实现它不需要的功能。

# repositories/user_repository.py
class UserRepository(BaseRepository):
    # 只负责用户的存储相关操作
    def save(self, data):
        # 实现用户保存逻辑

    def get(self, user_id):
        # 实现用户查询逻辑

# repositories/log_repository.py
class LogRepository(BaseRepository):
    # 只负责日志的存储相关操作
    def save(self, data):
        # 实现日志保存逻辑

    def get(self, log_id):
        # 实现日志查询逻辑

这里我们将用户存储和日志存储分开，避免让同一个类实现过多的职责。通过细化接口，保持接口的职责单一和明确。

5. 依赖倒置原则（DIP）

原则：高层模块不应该依赖低层模块，二者都应该依赖于抽象。

在 Flask 开发中，依赖倒置原则可以通过依赖注入实现，特别是当涉及到数据库或其他外部资源时，高层业务逻辑不应该直接依赖于具体的存储实现，而应该依赖抽象（接口或抽象类）。

# services/user_service.py
class UserService:
    def __init__(self, user_repository: BaseRepository):
        self.user_repo = user_repository

    def create_user(self, name, email):
        user = {"name": name, "email": email}
        return self.user_repo.save(user)

    def get_user(self, user_id):
        return self.user_repo.get(user_id)

在 UserService 中，我们依赖的是 BaseRepository 抽象类，而不是具体的 UserRepository。这样做的好处是，未来我们可以很容易地替换 UserRepository，比如将用户数据存储到数据库中，而不需要修改 UserService 的代码。

实现依赖注入：

在实际开发中，依赖注入可以通过构造函数注入或者 Flask 的应用上下文来实现。这里我们简单模拟依赖注入：

# routes.py
from flask import Flask, request, jsonify
from services.user_service import UserService
from repositories.user_repository import UserRepository

app = Flask(__name__)

# 手动进行依赖注入
user_repo = UserRepository()
user_service = UserService(user_repo)

@app.route('/users', methods=['POST'])
def create_user():
    data = request.json
    user = user_service.create_user(data['name'], data['email'])
    return jsonify(user), 201

@app.route('/users/<int:user_id>', methods=['GET'])
def get_user(user_id):
    user = user_service.get_user(user_id)
    if user:
        return jsonify(user)
    return jsonify({'error': 'User not found'}), 404