引言:为什么MVC是解决代码混乱的终极方案
在软件开发领域,代码混乱和维护难题是每个团队都必须面对的挑战。随着项目规模的扩大,没有清晰架构的系统会迅速变成”意大利面条代码”,让开发和维护变得异常困难。MVC(Model-View-Controller)模式正是为了解决这些问题而诞生的经典架构模式。
MVC将应用分为三个核心组件:
Model(模型)
负责数据和业务逻辑,
View(视图)
负责用户界面展示,
Controller(控制器)
负责协调Model和View。这种分离关注点的设计让代码结构清晰、职责分明,极大提升了系统的可维护性和扩展性。
本文将从零开始,详细讲解如何用MVC设计一个高效、可维护的管理系统,包含完整的代码示例和最佳实践。
第一部分:MVC架构核心概念详解
1.1 MVC各层职责与边界
Model层:数据与业务逻辑的守护者
Model是系统的核心,它封装了所有数据处理和业务规则。Model不应该知道View和Controller的存在,它只关心数据本身和如何处理数据。
# Model示例:用户管理模型
class UserModel:
def __init__(self, db_connection):
self.db = db_connection
def create_user(self, username, email, password):
“””创建用户 – 纯业务逻辑”””
if not self._validate_email(email):
raise ValueError(“无效的邮箱格式”)
if len(password) < 8: raise ValueError("密码长度至少8位") # 数据库操作 hashed_password = self._hash_password(password) user_id = self.db.execute( "INSERT INTO users (username, email, password_hash) VALUES (?, ?, ?)", (username, email, hashed_password) ) return user_id def get_user_by_id(self, user_id): """获取用户信息""" return self.db.fetch_one("SELECT * FROM users WHERE id = ?", (user_id,)) def _validate_email(self, email): """内部验证方法""" import re pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$' return re.match(pattern, email) is not None def _hash_password(self, password): """密码加密""" import hashlib return hashlib.sha256(password.encode()).hexdigest() View层:用户界面的展示者 View只负责展示数据,不应该包含任何业务逻辑。它接收Controller传递的数据,并将其渲染成用户可见的界面。 # View示例:用户界面渲染 class UserView: def render_user_list(self, users): """渲染用户列表""" if not users: return "
”
html = “
| ID | 用户名 | 邮箱 |
|---|---|---|
| {user[‘id’]} | {user[‘username’]} | {user[’email’]} |
”
return html
def render_user_detail(self, user):
“””渲染用户详情”””
if not user:
return “
”
return f”””
{user[‘username’]}
ID: {user[‘id’]}
邮箱: {user[’email’]}
创建时间: {user[‘created_at’]}
“””
def render_error(self, message):
“””渲染错误信息”””
return f”
”
Controller层:流程的协调者
Controller接收用户输入,调用Model处理数据,然后选择合适的View来展示结果。它是Model和View之间的桥梁。
# Controller示例:用户管理控制器
class UserController:
def __init__(self, model, view):
self.model = model
self.view = view
def list_users(self):
“””处理用户列表请求”””
try:
users = self.model.get_all_users()
return self.view.render_user_list(users)
except Exception as e:
return self.view.render_error(f”获取用户列表失败: {str(e)}”)
def show_user(self, user_id):
“””处理显示单个用户请求”””
try:
user = self.model.get_user_by_id(user_id)
return self.view.render_user_detail(user)
except Exception as e:
return self.view.render_error(f”获取用户详情失败: {str(e)}”)
def create_user(self, username, email, password):
“””处理创建用户请求”””
try:
user_id = self.model.create_user(username, email, password)
return self.view.render_success(f”用户创建成功,ID: {user_id}”)
except ValueError as e:
return self.view.render_error(f”输入验证失败: {str(e)}”)
except Exception as e:
return self.view.render_error(f”创建用户失败: {str(e)}”)
1.2 MVC数据流向详解
理解MVC的数据流向是掌握其精髓的关键。以下是完整的请求-响应流程:
用户请求 → Controller → Model → 数据处理 → Controller → View → 响应用户
详细流程说明:
用户交互
:用户点击按钮或提交表单,触发HTTP请求或事件
Controller接收
:Controller的对应方法被调用,接收用户输入参数
Model处理
:Controller调用Model的方法进行数据验证、业务逻辑处理、数据库操作
数据返回
:Model将处理结果返回给Controller
View渲染
:Controller根据结果选择合适的View,传递数据进行渲染
响应用户
:View生成的HTML/界面返回给用户
第二部分:从零开始搭建MVC管理系统
2.1 项目结构设计
合理的目录结构是项目可维护性的基础。以下是推荐的生产级项目结构:
my_system/
├── app/
│ ├── __init__.py
│ ├── models/
│ │ ├── __init__.py
│ │ ├── user_model.py
│ │ ├── product_model.py
│ │ └── base_model.py
│ ├── views/
│ │ ├── __init__.py
│ │ ├── user_view.py
│ │ ├── product_view.py
│ │ └── base_view.py
│ ├── controllers/
│ │ ├── __init__.py
│ │ ├── user_controller.py
│ │ ├── product_controller.py
│ │ └── base_controller.py
│ ├── services/
│ │ ├── __init__.py
│ │ ├── auth_service.py
│ │ └── email_service.py
│ └── utils/
│ ├── __init__.py
│ ├── validators.py
│ └── helpers.py
├── config/
│ ├── __init__.py
│ ├── settings.py
│ └── database.py
├── tests/
│ ├── test_models.py
│ ├── test_controllers.py
│ └── test_views.py
├── static/
│ ├── css/
│ ├── js/
│ └── images/
├── templates/
│ ├── base.html
│ ├── user/
│ │ ├── list.html
│ │ └── detail.html
│ └── error/
│ └── 404.html
├── requirements.txt
├── run.py
└── README.md
2.2 基础架构实现
2.2.1 BaseModel:所有模型的基类
# app/models/base_model.py
from abc import ABC, abstractmethod
import sqlite3
from typing import Dict, List, Optional, Any
class BaseModel(ABC):
“””所有Model的抽象基类”””
def __init__(self, db_path: str):
self.db_path = db_path
self._connection = None
@property
def connection(self):
“””数据库连接(懒加载)”””
if self._connection is None:
self._connection = sqlite3.connect(self.db_path)
self._connection.row_factory = sqlite3.Row # 返回字典格式
return self._connection
def execute(self, sql: str, params: tuple = ()) -> int:
“””执行SQL,返回最后插入的ID”””
cursor = self.connection.cursor()
cursor.execute(sql, params)
self.connection.commit()
return cursor.lastrowid
def fetch_one(self, sql: str, params: tuple = ()) -> Optional[Dict]:
“””查询单条记录”””
cursor = self.connection.cursor()
cursor.execute(sql, params)
row = cursor.fetchone()
return dict(row) if row else None
def fetch_all(self, sql: str, params: tuple = ()) -> List[Dict]:
“””查询多条记录”””
cursor = self.connection.cursor()
cursor.execute(sql, params)
rows = cursor.fetchall()
return [dict(row) for row in rows]
def close(self):
“””关闭数据库连接”””
if self._connection:
self._connection.close()
self._connection = None
@abstractmethod
def validate(self, data: Dict) -> bool:
“””数据验证抽象方法”””
pass
def __del__(self):
“””析构函数确保连接关闭”””
self.close()
2.2.2 BaseView:所有视图的基类
# app/views/base_view.py
from abc import ABC, abstractmethod
from typing import Any
class BaseView(ABC):
“””所有View的抽象基类”””
def render_success(self, message: str) -> str:
“””渲染成功消息”””
return f”
”
def render_error(self, message: str) -> str:
“””渲染错误消息”””
return f”
”
def render_info(self, message: str) -> str:
“””渲染信息消息”””
return f”
”
@abstractmethod
def render(self, data: Any) -> str:
“””渲染主方法”””
pass
2.2.3 BaseController:所有控制器的基类
# app/controllers/base_controller.py
from abc import ABC, abstractmethod
from typing import Dict, Any
class BaseController(ABC):
“””所有Controller的抽象基类”””
def __init__(self, model, view):
self.model = model
self.view = view
def handle_request(self, action: str, **kwargs) -> str:
“””统一请求处理入口”””
try:
# 权限验证
if not self.check_permission(action, kwargs):
return self.view.render_error(“权限不足”)
# 执行对应动作
result = getattr(self, action)(**kwargs)
return result
except Exception as e:
return self.view.render_error(str(e))
def check_permission(self, action: str, params: Dict) -> bool:
“””权限验证(可被子类重写)”””
# 默认所有操作都允许,实际项目中应实现具体权限逻辑
return True
@abstractmethod
def list_items(self, **kwargs):
“””列表项抽象方法”””
pass
@abstractmethod
def show_item(self, item_id: int, **kwargs):
“””显示单项抽象方法”””
pass
@abstractmethod
def create_item(self, **kwargs):
“””创建项抽象方法”””
pass
2.3 完整用户管理模块实现
2.3.1 UserModel实现
# app/models/user_model.py
from .base_model import BaseModel
from typing import Dict, List, Optional
import re
import hashlib
import time
class UserModel(BaseModel):
“””用户模型”””
def __init__(self, db_path: str):
super().__init__(db_path)
self._init_table()
def _init_table(self):
“””初始化用户表”””
sql = “””
CREATE TABLE IF NOT EXISTS users (
id INTEGER PRIMARY KEY AUTOINCREMENT,
username TEXT UNIQUE NOT NULL,
email TEXT UNIQUE NOT NULL,
password_hash TEXT NOT NULL,
status INTEGER DEFAULT 1,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
)
“””
self.execute(sql)
def validate(self, data: Dict) -> bool:
“””验证用户数据”””
if ‘username’ in data:
if len(data[‘username’]) < 3 or len(data['username']) > 20:
raise ValueError(“用户名长度必须在3-20字符之间”)
if ’email’ in data:
pattern = r’^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$’
if not re.match(pattern, data[’email’]):
raise ValueError(“邮箱格式不正确”)
if ‘password’ in data:
if len(data[‘password’]) < 8:
raise ValueError("密码长度至少8位")
return True
def create_user(self, username: str, email: str, password: str) -> int:
“””创建用户”””
# 验证数据
self.validate({‘username’: username, ’email’: email, ‘password’: password})
# 检查用户名和邮箱是否已存在
if self.username_exists(username):
raise ValueError(f”用户名 {username} 已存在”)
if self.email_exists(email):
raise ValueError(f”邮箱 {email} 已注册”)
# 密码加密
password_hash = self._hash_password(password)
# 插入数据
sql = “””
INSERT INTO users (username, email, password_hash, created_at, updated_at)
VALUES (?, ?, ?, ?, ?)
“””
timestamp = int(time.time())
return self.execute(sql, (username, email, password_hash, timestamp, timestamp))
def get_user_by_id(self, user_id: int) -> Optional[Dict]:
“””根据ID获取用户”””
sql = “SELECT * FROM users WHERE id = ? AND status = 1”
return self.fetch_one(sql, (user_id,))
def get_user_by_username(self, username: str) -> Optional[Dict]:
“””根据用户名获取用户”””
sql = “SELECT * FROM users WHERE username = ? AND status = 1”
return self.fetch_one(sql, (username,))
def get_all_users(self, limit: int = 100, offset: int = 0) -> List[Dict]:
“””获取所有用户(分页)”””
sql = “SELECT id, username, email, created_at FROM users WHERE status = 1 LIMIT ? OFFSET ?”
return self.fetch_all(sql, (limit, offset))
def update_user(self, user_id: int, **kwargs) -> bool:
“””更新用户信息”””
if not kwargs:
return False
set_clause = “, “.join([f”{k} = ?” for k in kwargs.keys()])
values = list(kwargs.values())
values.append(user_id)
sql = f”UPDATE users SET {set_clause}, updated_at = ? WHERE id = ?”
values.append(int(time.time()))
self.execute(sql, tuple(values))
return True
def delete_user(self, user_id: int) -> bool:
“””软删除用户”””
sql = “UPDATE users SET status = 0, updated_at = ? WHERE id = ?”
self.execute(sql, (int(time.time()), user_id))
return True
def username_exists(self, username: str) -> bool:
“””检查用户名是否存在”””
sql = “SELECT COUNT(*) as count FROM users WHERE username = ?”
result = self.fetch_one(sql, (username,))
return result[‘count’] > 0
def email_exists(self, email: str) -> bool:
“””检查邮箱是否存在”””
sql = “SELECT COUNT(*) as count FROM users WHERE email = ?”
result = self.fetch_one(sql, (email,))
return result[‘count’] > 0
def _hash_password(self, password: str) -> str:
“””密码加密(实际项目应使用更安全的算法如bcrypt)”””
return hashlib.sha256(password.encode()).hexdigest()
2.3.2 UserView实现
# app/views/user_view.py
from .base_view import BaseView
from typing import Dict, List, Any
class UserView(BaseView):
“””用户视图”””
def render(self, data: Any) -> str:
“””通用渲染方法”””
if isinstance(data, list):
return self.render_user_list(data)
elif isinstance(data, dict):
return self.render_user_detail(data)
else:
return self.render_error(“不支持的数据类型”)
def render_user_list(self, users: List[Dict]) -> str:
“””渲染用户列表”””
if not users:
return “””
暂无用户
点击”创建用户”按钮添加第一个用户
“””
html = “””
用户管理
| ID | 用户名 | 邮箱 | 注册时间 | 操作 |
|---|---|---|---|---|
| {user[‘id’]} | {user[‘username’]} | {user[’email’]} | {created_at} |
查看 编辑 |
“””
return html
def render_user_detail(self, user: Dict) -> str:
“””渲染用户详情”””
if not user:
return self.render_error(“用户不存在或已被删除”)
created_at = user.get(‘created_at’, ‘N/A’)
if isinstance(created_at, int):
import time
created_at = time.strftime(‘%Y-%m-%d %H:%M:%S’, time.localtime(created_at))
return f”””
用户详情
{user[‘id’]}
{user[‘username’]}
{user[’email’]}
{created_at}
正常
“””
def render_create_form(self) -> str:
“””渲染创建用户表单”””
return “””
创建新用户
“””
def render_edit_form(self, user: Dict) -> str:
“””渲染编辑用户表单”””
return f”””
编辑用户
“””
2.3.3 UserController实现
# app/controllers/user_controller.py
from .base_controller import BaseController
from typing import Dict, Any
class UserController(BaseController):
“””用户控制器”””
def list_users(self, limit: int = 50, offset: int = 0) -> str:
“””列出所有用户”””
users = self.model.get_all_users(limit=limit, offset=offset)
return self.view.render_user_list(users)
def show_user(self, user_id: int) -> str:
“””显示单个用户详情”””
user = self.model.get_user_by_id(user_id)
return self.view.render_user_detail(user)
def create_user(self, **kwargs) -> str:
“””创建用户”””
username = kwargs.get(‘username’)
email = kwargs.get(’email’)
password = kwargs.get(‘password’)
if not all([username, email, password]):
return self.view.render_error(“缺少必要参数”)
try:
user_id = self.model.create_user(username, email, password)
return self.view.render_success(f”用户 ‘{username}’ 创建成功!用户ID: {user_id}”)
except ValueError as e:
return self.view.render_error(str(e))
except Exception as e:
return self.view.render_error(f”创建用户时发生未知错误: {str(e)}”)
def update_user(self, user_id: int, **kwargs) -> str:
“””更新用户信息”””
if not kwargs:
return self.view.render_error(“没有提供要更新的字段”)
# 验证用户是否存在
user = self.model.get_user_by_id(user_id)
if not user:
return self.view.render_error(“用户不存在”)
try:
# 验证数据
self.model.validate(kwargs)
# 检查用户名和邮箱冲突(如果修改了这些字段)
if ‘username’ in kwargs and kwargs[‘username’] != user[‘username’]:
if self.model.username_exists(kwargs[‘username’]):
return self.view.render_error(f”用户名 {kwargs[‘username’]} 已存在”)
if ’email’ in kwargs and kwargs[’email’] != user[’email’]:
if self.model.email_exists(kwargs[’email’]):
return self.view.render_error(f”邮箱 {kwargs[’email’]} 已注册”)
# 执行更新
self.model.update_user(user_id, **kwargs)
return self.view.render_success(“用户信息更新成功”)
except ValueError as e:
return self.view.render_error(str(e))
except Exception as e:
return self.view.render_error(f”更新失败: {str(e)}”)
def delete_user(self, user_id: int) -> str:
“””删除用户”””
user = self.model.get_user_by_id(user_id)
if not user:
return self.view.render_error(“用户不存在”)
try:
self.model.delete_user(user_id)
return self.view.render_success(f”用户 ‘{user[‘username’]}’ 已删除”)
except Exception as e:
return self.view.render_error(f”删除失败: {str(e)}”)
def show_create_form(self) -> str:
“””显示创建用户表单”””
return self.view.render_create_form()
def show_edit_form(self, user_id: int) -> str:
“””显示编辑用户表单”””
user = self.model.get_user_by_id(user_id)
if not user:
return self.view.render_error(“用户不存在”)
return self.view.render_edit_form(user)
def check_permission(self, action: str, params: Dict) -> bool:
“””权限验证示例”””
# 示例:删除操作需要管理员权限
if action == ‘delete_user’:
# 这里应该检查当前用户是否有管理员权限
# 实际项目中从session或token中获取当前用户信息
return params.get(‘current_user_is_admin’, False)
return True
2.4 路由与请求分发
2.4.1 简单的路由系统
# app/router.py
from typing import Dict, Callable, Any
import re
class Router:
“””简单的路由系统”””
def __init__(self):
self.routes: Dict[str, Dict[str, Any]] = {}
def add_route(self, method: str, path: str, handler: Callable):
“””添加路由”””
# 将路径转换为正则表达式模式
pattern = self._path_to_pattern(path)
self.routes[f”{method}:{path}”] = {
‘pattern’: pattern,
‘handler’: handler,
‘path’: path
}
def _path_to_pattern(self, path: str) -> re.Pattern:
“””将路径转换为正则表达式”””
# 转换 /users/{id} 为正则
pattern = re.sub(r’\{(\w+)\}’, r'(?P<\1>\\w+)’, path)
return re.compile(f”^{pattern}$”)
def match(self, method: str, path: str) -> tuple:
“””匹配路由”””
for key, route in self.routes.items():
if key.startswith(method + “:”):
match = route[‘pattern’].match(path)
if match:
return route[‘handler’], match.groupdict()
return None, {}
def get(self, path: str):
“””GET请求装饰器”””
def decorator(handler):
self.add_route(‘GET’, path, handler)
return handler
return decorator
def post(self, path: str):
“””POST请求装饰器”””
def decorator(handler):
self.add_route(‘POST’, path, handler)
return handler
return decorator
# 创建全局路由器实例
router = Router()
2.4.2 请求处理器
# app/handlers.py
from app.controllers.user_controller import UserController
from app.models.user_model import UserModel
from app.views.user_view import UserView
from app.router import router
from config.settings import DB_PATH
# 初始化依赖
def get_user_controller():
model = UserModel(DB_PATH)
view = UserView()
return UserController(model, view)
# 定义路由处理器
@router.get(r’/users’)
def handle_user_list(request):
“””用户列表页”””
controller = get_user_controller()
limit = int(request.get(‘limit’, 50))
offset = int(request.get(‘offset’, 0))
return controller.list_users(limit, offset)
@router.get(r’/users/{id}’)
def handle_user_detail(request, user_id):
“””用户详情页”””
controller = get_user_controller()
return controller.show_user(int(user_id))
@router.get(r’/users/create’)
def handle_user_create_form(request):
“””创建用户表单页”””
controller = get_user_controller()
return controller.show_create_form()
@router.post(r’/users/create’)
def handle_user_create(request):
“””创建用户提交”””
controller = get_user_controller()
return controller.create_user(**request.get(‘form_data’, {}))
@router.get(r’/users/{id}/edit’)
def handle_user_edit_form(request, user_id):
“””编辑用户表单页”””
controller = get_user_controller()
return controller.show_edit_form(int(user_id))
@router.post(r’/users/{id}/update’)
def handle_user_update(request, user_id):
“””更新用户提交”””
controller = get_user_controller()
return controller.update_user(int(user_id), **request.get(‘form_data’, {}))
@router.post(r’/users/{id}/delete’)
def handle_user_delete(request, user_id):
“””删除用户”””
controller = get_user_controller()
return controller.delete_user(int(user_id))
2.5 完整的Web应用示例
# run.py – 完整的Web应用
from http.server import BaseHTTPRequestHandler, HTTPServer
from urllib.parse import parse_qs, urlparse
import json
from app.router import router
from app.handlers import *
class MVCApplication(BaseHTTPRequestHandler):
“””MVC Web应用处理器”””
def do_GET(self):
“””处理GET请求”””
self._handle_request(‘GET’)
def do_POST(self):
“””处理POST请求”””
self._handle_request(‘POST’)
def _handle_request(self, method: str):
“””统一请求处理”””
parsed_url = urlparse(self.path)
path = parsed_url.path
# 匹配路由
handler, kwargs = router.match(method, path)
if handler:
# 准备请求数据
request = {
‘method’: method,
‘path’: path,
‘query_params’: parse_qs(parsed_url.query),
‘form_data’: {}
}
# 如果是POST请求,读取请求体
if method == ‘POST’:
content_length = int(self.headers.get(‘Content-Length’, 0))
if content_length > 0:
post_data = self.rfile.read(content_length).decode(‘utf-8’)
request[‘form_data’] = parse_qs(post_data)
# 将单值参数转换
for key in request[‘form_data’]:
if len(request[‘form_data’][key]) == 1:
request[‘form_data’][key] = request[‘form_data’][key][0]
# 合并路径参数
request.update(kwargs)
try:
# 调用处理器
response = handler(request, **kwargs)
# 发送响应
self._send_response(200, response)
except Exception as e:
self._send_response(500, f”
“)
else:
# 404处理
self._send_response(404, “
“)
def _send_response(self, code: int, body: str):
“””发送HTTP响应”””
self.send_response(code)
self.send_header(‘Content-type’, ‘text/html; charset=utf-8’)
self.end_headers()
# 包装HTML
html = f”””
{body}
“””
self.wfile.write(html.encode(‘utf-8’))
def run_server(port=8000):
“””启动服务器”””
server_address = (”, port)
httpd = HTTPServer(server_address, MVCApplication)
print(f”🚀 MVC管理系统已启动: http://localhost:{port}”)
print(f”📊 访问 http://localhost:{port}/users 查看用户列表”)
print(f”➕ 访问 http://localhost:{port}/users/create 创建用户”)
print(“按 Ctrl+C 停止服务器”)
try:
httpd.serve_forever()
except KeyboardInterrupt:
print(“\n🛑 服务器已停止”)
httpd.server_close()
if __name__ == ‘__main__’:
# 初始化数据库
from app.models.user_model import UserModel
from config.settings import DB_PATH
model = UserModel(DB_PATH)
model.close()
run_server()
2.5.1 配置文件
# config/settings.py
import os
# 项目根目录
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
# 数据库路径
DB_PATH = os.path.join(BASE_DIR, ‘data’, ‘system.db’)
# 确保数据目录存在
os.makedirs(os.path.join(BASE_DIR, ‘data’), exist_ok=True)
# 应用配置
APP_CONFIG = {
‘name’: ‘MVC管理系统’,
‘version’: ‘1.0.0’,
‘debug’: True,
‘host’: ‘0.0.0.0’,
‘port’: 8000
}
第三部分:高级MVC架构优化
3.1 依赖注入与控制反转
# app/core/container.py
from typing import Dict, Any, Type
import importlib
class Container:
“””依赖注入容器”””
def __init__(self):
self._services: Dict[str, Any] = {}
self._factories: Dict[str, callable] = {}
def register(self, name: str, service: Any):
“””注册单例服务”””
self._services[name] = service
def register_factory(self, name: str, factory: callable):
“””注册工厂方法”””
self._factories[name] = factory
def get(self, name: str) -> Any:
“””获取服务实例”””
if name in self._services:
return self._services[name]
if name in self._factories:
service = self._factories[name]()
self._services[name] = service # 缓存单例
return service
raise ValueError(f”服务 {name} 未注册”)
def clear(self):
“””清空所有服务(用于测试)”””
self._services.clear()
# 创建全局容器
container = Container()
# 注册服务
def setup_container():
from config.settings import DB_PATH
from app.models.user_model import UserModel
from app.views.user_view import UserView
from app.controllers.user_controller import UserController
# 注册数据库和模型
container.register_factory(‘db_path’, lambda: DB_PATH)
container.register_factory(‘user_model’, lambda: UserModel(container.get(‘db_path’)))
container.register_factory(‘user_view’, lambda: UserView())
container.register_factory(‘user_controller’, lambda: UserController(
container.get(‘user_model’),
container.get(‘user_view’)
))
# 使用依赖注入的处理器
def get_user_controller_di():
return container.get(‘user_controller’)
@router.get(r’/users’)
def handle_user_list_di(request):
controller = get_user_controller_di()
limit = int(request.get(‘limit’, 50))
offset = int(request.get(‘offset’, 0))
return controller.list_users(limit, offset)
3.2 中间件系统
# app/core/middleware.py
from typing import Callable, List, Any
import time
class Middleware:
“””中间件基类”””
def before_request(self, request: dict) -> dict:
“””请求前处理”””
return request
def after_request(self, response: str) -> str:
“””响应后处理”””
return response
def on_error(self, error: Exception) -> str:
“””错误处理”””
return f”
”
class LoggingMiddleware(Middleware):
“””日志中间件”””
def before_request(self, request: dict) -> dict:
request[‘start_time’] = time.time()
print(f”[{time.strftime(‘%Y-%m-%d %H:%M:%S’)}] {request[‘method’]} {request[‘path’]}”)
return request
def after_request(self, response: str) -> str:
# 可以在这里添加响应时间等信息
return response
class AuthMiddleware(Middleware):
“””认证中间件”””
def before_request(self, request: dict) -> dict:
# 模拟认证检查
if request[‘path’].startswith(‘/admin’) and not request.get(‘user_id’):
raise PermissionError(“需要登录”)
return request
class MiddlewareChain:
“””中间件链”””
def __init__(self):
self.middlewares: List[Middleware] = []
def add(self, middleware: Middleware):
“””添加中间件”””
self.middlewares.append(middleware)
def process_request(self, request: dict) -> dict:
“””处理请求”””
for middleware in self.middlewares:
request = middleware.before_request(request)
return request
def process_response(self, response: str) -> str:
“””处理响应”””
for middleware in reversed(self.middlewares):
response = middleware.after_request(response)
return response
def process_error(self, error: Exception) -> str:
“””处理错误”””
for middleware in reversed(self.middlewares):
try:
return middleware.on_error(error)
except:
continue
return f”
”
# 创建中间件链
middleware_chain = MiddlewareChain()
middleware_chain.add(LoggingMiddleware())
middleware_chain.add(AuthMiddleware())
3.3 改进的请求处理器(带中间件)
# app/handlers_advanced.py
from app.router import router
from app.core.middleware import middleware_chain
from app.core.container import container
def setup_advanced_handlers():
“””设置高级处理器”””
@router.get(r’/users’)
def handle_user_list_advanced(request):
try:
# 处理请求前中间件
request = middleware_chain.process_request(request)
# 业务逻辑
controller = container.get(‘user_controller’)
limit = int(request.get(‘limit’, 50))
offset = int(request.get(‘offset’, 0))
response = controller.list_users(limit, offset)
# 处理响应后中间件
response = middleware_chain.process_response(response)
return response
except Exception as e:
return middleware_chain.process_error(e)
@router.post(r’/users/create’)
def handle_user_create_advanced(request):
try:
request = middleware_chain.process_request(request)
controller = container.get(‘user_controller’)
form_data = request.get(‘form_data’, {})
response = controller.create_user(**form_data)
response = middleware_chain.process_response(response)
return response
except Exception as e:
return middleware_chain.process_error(e)
3.4 服务层抽象
# app/services/auth_service.py
from typing import Optional, Dict
import hashlib
import secrets
class AuthService:
“””认证服务”””
def __init__(self, user_model):
self.user_model = user_model
def authenticate(self, username: str, password: str) -> Optional[Dict]:
“””用户认证”””
user = self.user_model.get_user_by_username(username)
if not user:
return None
# 验证密码
password_hash = hashlib.sha256(password.encode()).hexdigest()
if user[‘password_hash’] == password_hash:
# 生成会话token
token = secrets.token_hex(32)
return {
‘user_id’: user[‘id’],
‘username’: user[‘username’],
‘token’: token,
‘expires_at’: int(time.time()) + 3600 # 1小时过期
}
return None
def verify_token(self, token: str) -> Optional[Dict]:
“””验证token”””
# 实际项目中应查询token缓存
# 这里简化处理
return {‘user_id’: 1, ‘username’: ‘admin’} # 模拟
# app/services/email_service.py
class EmailService:
“””邮件服务”””
def send_welcome_email(self, email: str, username: str):
“””发送欢迎邮件”””
# 实际项目中集成SMTP发送邮件
print(f”[邮件服务] 向 {email} 发送欢迎邮件,用户名: {username}”)
return True
def send_password_reset(self, email: str, reset_token: str):
“””发送密码重置邮件”””
print(f”[邮件服务] 向 {email} 发送密码重置邮件,token: {reset_token}”)
return True
3.5 完整的高级架构示例
# app/core/application.py
from app.core.container import container, setup_container
from app.core.middleware import middleware_chain, LoggingMiddleware, AuthMiddleware
from app.router import router
from config.settings import APP_CONFIG
class MVCApplication:
“””高级MVC应用框架”””
def __init__(self):
self.setup_dependencies()
self.setup_middleware()
self.setup_routes()
def setup_dependencies(self):
“””设置依赖注入”””
setup_container()
# 注册额外服务
from app.services.auth_service import AuthService
from app.services.email_service import EmailService
container.register_factory(‘auth_service’, lambda: AuthService(container.get(‘user_model’)))
container.register_factory(’email_service’, lambda: EmailService())
def setup_middleware(self):
“””设置中间件”””
middleware_chain.add(LoggingMiddleware())
middleware_chain.add(AuthMiddleware())
def setup_routes(self):
“””设置路由”””
# 这里可以动态注册所有路由
pass
def run(self, host: str = None, port: int = None):
“””运行应用”””
host = host or APP_CONFIG[‘host’]
port = port or APP_CONFIG[‘port’]
from http.server import HTTPServer
from app.server import MVCHandler
server = HTTPServer((host, port), MVCHandler)
print(f”🚀 高级MVC应用启动: http://{host}:{port}”)
try:
server.serve_forever()
except KeyboardInterrupt:
print(“\n🛑 应用已停止”)
server.server_close()
# 使用示例
if __name__ == ‘__main__’:
app = MVCApplication()
app.run()
第四部分:最佳实践与常见问题解决
4.1 代码组织最佳实践
1. 单一职责原则(SRP)
每个类只负责一件事。Model只处理数据,View只处理展示,Controller只处理协调。
2. 开闭原则(OCP)
通过抽象基类和接口实现扩展开放、修改关闭。
# 示例:可扩展的通知系统
from abc import ABC, abstractmethod
class Notification(ABC):
@abstractmethod
def send(self, message: str, recipient: str):
pass
class EmailNotification(Notification):
def send(self, message: str, recipient: str):
print(f”发送邮件到 {recipient}: {message}”)
class SMSNotification(Notification):
def send(self, message: str, recipient: str):
print(f”发送短信到 {recipient}: {message}”)
class NotificationController:
def __init__(self):
self.notifiers = []
def add_notifier(self, notifier: Notification):
self.notifiers.append(notifier)
def notify_all(self, message: str, recipient: str):
for notifier in self.notifiers:
notifier.send(message, recipient)
3. 依赖倒置原则(DIP)
高层模块不应该依赖低层模块,两者都应该依赖抽象。
4.2 性能优化策略
1. 数据库连接池
# 使用连接池而不是每次创建新连接
from sqlite3 import Connection
from threading import Lock
class ConnectionPool:
def __init__(self, db_path: str, max_connections: int = 5):
self.db_path = db_path
self.max_connections = max_connections
self.pool = []
self.lock = Lock()
def get_connection(self) -> Connection:
with self.lock:
if self.pool:
return self.pool.pop()
return sqlite3.connect(self.db_path)
def return_connection(self, conn: Connection):
with self.lock:
if len(self.pool) < self.max_connections:
self.pool.append(conn)
else:
conn.close()
2. 缓存策略
from functools import wraps
import time
def cache_with_ttl(seconds: int):
"""带TTL的缓存装饰器"""
def decorator(func):
cache = {}
@wraps(func)
def wrapper(*args, **kwargs):
key = str(args) + str(kwargs)
now = time.time()
if key in cache:
result, timestamp = cache[key]
if now - timestamp < seconds:
return result
result = func(*args, **kwargs)
cache[key] = (result, now)
return result
return wrapper
return decorator
# 使用示例
class UserModel(BaseModel):
@cache_with_ttl(60) # 缓存60秒
def get_user_by_id(self, user_id: int):
return super().get_user_by_id(user_id)
4.3 测试策略
# tests/test_user_controller.py
import unittest
from unittest.mock import Mock, patch
from app.controllers.user_controller import UserController
from app.models.user_model import UserModel
from app.views.user_view import UserView
class TestUserController(unittest.TestCase):
def setUp(self):
# 创建Mock对象
self.mock_model = Mock(spec=UserModel)
self.mock_view = Mock(spec=UserView)
self.controller = UserController(self.mock_model, self.mock_view)
def test_create_user_success(self):
# 测试成功创建用户
self.mock_model.create_user.return_value = 1
self.mock_view.render_success.return_value = "用户创建成功"
result = self.controller.create_user(
username="testuser",
email="test@example.com",
password="password123"
)
self.mock_model.create_user.assert_called_once()
self.assertIn("用户创建成功", result)
def test_create_user_validation_error(self):
# 测试验证错误
self.mock_model.create_user.side_effect = ValueError("密码太短")
self.mock_view.render_error.return_value = "错误: 密码太短"
result = self.controller.create_user(
username="testuser",
email="test@example.com",
password="123"
)
self.assertIn("错误", result)
def test_show_user_not_found(self):
# 测试用户不存在
self.mock_model.get_user_by_id.return_value = None
self.mock_view.render_error.return_value = "用户不存在"
result = self.controller.show_user(999)
self.assertIn("用户不存在", result)
# 运行测试
if __name__ == '__main__':
unittest.main()
4.4 常见问题解决方案
问题1:循环依赖
# 错误示例
# Model引用View,View引用Controller,Controller引用Model
# 解决方案:使用事件驱动或依赖注入
class EventBus:
"""事件总线解耦"""
def __init__(self):
self.listeners = {}
def subscribe(self, event: str, listener):
if event not in self.listeners:
self.listeners[event] = []
self.listeners[event].append(listener)
def emit(self, event: str, data: Any):
for listener in self.listeners.get(event, []):
listener(data)
# 在Model中触发事件
class UserModel(BaseModel):
def __init__(self, db_path: str, event_bus: EventBus):
super().__init__(db_path)
self.event_bus = event_bus
def create_user(self, username, email, password):
user_id = self._create_user_in_db(username, email, password)
# 触发事件而不是直接调用View
self.event_bus.emit('user_created', {'id': user_id, 'username': username})
return user_id
问题2:Controller变得臃肿
# 解决方案:提取业务逻辑到Service层
class UserService:
"""用户业务逻辑服务"""
def __init__(self, user_model, email_service):
self.user_model = user_model
self.email_service = email_service
def register_user(self, username, email, password):
# 验证
self.validate_registration(username, email, password)
# 创建用户
user_id = self.user_model.create_user(username, email, password)
# 发送欢迎邮件
self.email_service.send_welcome_email(email, username)
# 记录日志
self.log_registration(user_id)
return user_id
def validate_registration(self, username, email, password):
# 复杂的验证逻辑
pass
def log_registration(self, user_id):
# 日志记录
pass
# Controller变得简洁
class UserController(BaseController):
def __init__(self, model, view, user_service):
super().__init__(model, view)
self.user_service = user_service
def create_user(self, **kwargs):
try:
user_id = self.user_service.register_user(
kwargs['username'],
kwargs['email'],
kwargs['password']
)
return self.view.render_success(f"用户创建成功,ID: {user_id}")
except Exception as e:
return self.view.render_error(str(e))
第五部分:实际项目中的MVC扩展
5.1 多模块MVC架构
# app/modules/admin/__init__.py
# 管理员模块
from app.core.module import Module
class AdminModule(Module):
"""管理员模块"""
def __init__(self):
super().__init__('admin')
def register_models(self):
from .models.admin_model import AdminModel
return {'admin': AdminModel}
def register_views(self):
from .views.admin_view import AdminView
return {'admin': AdminView}
def register_controllers(self):
from .controllers.admin_controller import AdminController
return {'admin': AdminController}
def register_routes(self, router):
# 注册管理员路由
router.add_route('GET', r'/admin/dashboard', self.handlers.dashboard)
router.add_route('GET', r'/admin/users', self.handlers.user_list)
# app/modules/user/__init__.py
# 用户模块
class UserModule(Module):
"""用户模块"""
pass
5.2 API版本控制
# app/api/v1/__init__.py
class APIv1:
"""API v1 版本"""
def __init__(self, router):
self.router = router
self.setup_routes()
def setup_routes(self):
# v1 路由
self.router.add_route('GET', r'/api/v1/users', self.get_users)
self.router.add_route('POST', r'/api/v1/users', self.create_user)
def get_users(self, request):
# 返回JSON格式
return json.dumps({
'version': '1.0',
'data': []
})
# app/api/v2/__init__.py
class APIv2:
"""API v2 版本(改进版)"""
def __init__(self, router):
self.router = router
self.setup_routes()
def setup_routes(self):
# v2 路由 - 支持分页、过滤
self.router.add_route('GET', r'/api/v2/users', self.get_users)
self.router.add_route('POST', r'/api/v2/users', self.create_user)
def get_users(self, request):
# 支持查询参数
page = request.get('page', 1)
per_page = request.get('per_page', 20)
return json.dumps({
'version': '2.0',
'meta': {'page': page, 'per_page': per_page},
'data': []
})
5.3 微服务架构中的MVC
# 在微服务中,每个服务都是独立的MVC应用
# 服务间通过HTTP或消息队列通信
class MicroserviceController:
"""微服务控制器"""
def __init__(self, model, view, service_client):
super().__init__(model, view)
self.service_client = service_client # 服务间通信客户端
def create_user(self, **kwargs):
# 调用用户服务
user_response = self.service_client.post('/users', kwargs)
# 调用通知服务
self.service_client.post('/notifications', {
'type': 'welcome',
'user_id': user_response['id'],
'email': kwargs['email']
})
return self.view.render_success("用户创建成功")
总结
通过本文的详细讲解,您应该已经掌握了如何从零开始使用MVC模式构建高效、可维护的管理系统。关键要点包括:
清晰的职责分离
:Model、View、Controller各司其职,互不干扰
合理的项目结构
:按功能分层,便于维护和扩展
依赖注入
:降低耦合度,提高代码可测试性
中间件系统
:统一处理横切关注点(日志、认证等)
服务层抽象
:将业务逻辑从Controller中分离
测试驱动
:确保代码质量和稳定性
MVC不是银弹,但它提供了一个经过验证的架构模式,能够有效解决代码混乱和维护难题。在实际项目中,您可以根据具体需求进行调整和扩展,但核心原则保持不变:
关注点分离、职责单一、高内聚低耦合
。
记住,好的架构不是一蹴而就的,而是在持续演进中完善的。从简单开始,逐步优化,最终您将拥有一个既高效又易于维护的系统。