企业官网建设流程全解析

如果你正在寻找一个能快速构建高性能API的Python框架，但又厌倦了Flask的“自由”带来的混乱和Django的“重量”带来的束缚，那么FastAPI很可能就是你一直在等的那个答案。它不是一个简单的“又一个Web框架”，而是一个基于现代Python特性（类型提示、异步）和开放标准（OpenAPI、JSON Schema）构建的、旨在显著提升开发体验和运行效率的解决方案。

很多人第一次接触FastAPI，会被它“极简”的入门示例所吸引，几行代码就能跑起一个API。但这恰恰是最大的误解：FastAPI的核心价值不在于“简单”，而在于它通过一套严谨的体系，将开发速度、代码可维护性和运行时性能这三个通常难以兼得的目标，巧妙地统一了起来。它用类型注解来驱动一切——自动请求验证、自动序列化、自动生成交互式文档——这让开发者从繁琐的样板代码和文档维护中解放出来，能将精力真正聚焦在业务逻辑上。

本文将带你超越“Hello World”，深入FastAPI的核心机制。你会理解它如何利用Python的类型提示（Type Hints）和Pydantic模型来实现“声明即验证”，掌握其异步（async/await）处理高并发的精髓，并学会如何组织一个结构清晰、易于测试和维护的中大型FastAPI项目。我们还会直面那些搜索热词背后的真实问题：如何部署到Windows服务器？为什么Spring Boot调用会报422错误？Admin后台为什么不显示菜单？通过解决这些具体问题，你将真正“拿捏”FastAPI，让它成为你高效开发后端API的得力工具。

1. 为什么是FastAPI？解决什么真实痛点？

在FastAPI出现之前，Python的Web框架生态大致分为两类：以Flask为代表的“微框架”和以Django为代表的“全栈框架”。Flask灵活轻量，但缺乏内置的API验证、序列化和文档生成，这些都需要开发者自行组合第三方库（如Marshmallow, apispec），容易导致项目结构不一致和依赖冲突。Django功能强大、开箱即用，但其设计哲学围绕“全能型网站”构建，对于纯API服务而言显得有些臃肿，且其同步模型在处理大量I/O操作时可能成为性能瓶颈。

FastAPI精准地切入了一个细分但日益增长的市场：需要快速开发、高性能、且拥有清晰API契约（如OpenAPI）的现代Web API服务。它主要解决了以下痛点：

1. 开发效率与代码质量的矛盾：手工编写请求参数验证、数据序列化和API文档极其耗时且易出错。FastAPI通过Pydantic模型和类型提示自动完成这些工作，代码即文档，且保证了类型安全。
2. 性能需求：基于Starlette（一个轻量级ASGI框架）构建，原生支持异步编程。这意味着它可以轻松处理成千上万的并发连接，非常适合需要处理大量I/O操作（如数据库查询、外部API调用）的微服务。
3. 开发者体验：自动生成的交互式API文档（Swagger UI和ReDoc）允许前端开发者或测试人员直接在浏览器中查看和测试API，极大减少了沟通成本。
4. 学习与维护成本：它基于Python标准（类型提示）和行业标准（OpenAPI, JSON Schema），减少了框架特有的“魔法”和概念。新成员上手快，代码也更容易被静态分析工具检查。

如果你正在构建或维护一个微服务架构的后端、一个需要提供清晰API给移动端或前端的数据服务、或是一个对响应时间有要求的实时应用，那么深入理解FastAPI将带来直接的收益。

2. 核心概念：类型提示、Pydantic与ASGI

要真正理解FastAPI，必须搞懂它依赖的三个关键技术。

2.1 Python类型提示（Type Hints）

这不是FastAPI的发明，但它是FastAPI的基石。类型提示让你在函数参数和返回值后声明期望的数据类型。

# 传统方式，类型不明确 def greet(name): return f"Hello, {name}" # 使用类型提示 def greet(name: str) -> str: return f"Hello, {name}"

在FastAPI中，这些类型声明会被框架读取，并用于：

• 数据验证：确保传入的name是字符串，如果不是，自动返回422错误。
• 数据转换：将请求中的JSON数据自动转换为对应的Python类型（如将字符串"123"转换为整数123）。
• 生成API Schema：用于创建OpenAPI文档，明确描述接口的输入输出。

2.2 Pydantic模型

Pydantic是一个利用类型提示进行数据验证和设置管理的库。在FastAPI中，我们主要用它来定义请求体和响应模型。

from pydantic import BaseModel from typing import Optional # 定义一个用户创建请求的数据模型 class UserCreate(BaseModel): username: str email: str full_name: Optional[str] = None # 可选字段，默认值为None age: int = Field(gt=0, le=150, description="年龄必须在0到150之间") # 使用Field添加额外约束 # 可以添加自定义验证器 @validator('username') def username_alphanumeric(cls, v): if not v.isalnum(): raise ValueError('用户名必须为字母数字组合') return v

当这个模型被用作路径操作函数的参数时，FastAPI会自动：

1. 读取请求体（JSON）。
2. 验证数据是否符合UserCreate模型的字段类型和约束（如age > 0）。
3. 如果验证失败，自动返回包含错误详情的422响应。
4. 如果验证成功，将验证后的数据转换为UserCreate类的实例，并注入到函数中。

2.3 ASGI与异步支持

ASGI（异步服务器网关接口）是WSGI的继任者，专为支持异步Python Web应用而设计。FastAPI基于ASGI框架Starlette构建，因此原生支持async/await语法。

from fastapi import FastAPI import asyncio app = FastAPI() @app.get("/") async def read_root(): # 这里可以安全地使用await调用其他异步函数 return {"message": "Hello World"} @app.get("/items/{item_id}") async def read_item(item_id: int, q: Optional[str] = None): # 模拟一个异步I/O操作，比如数据库查询 await asyncio.sleep(0.1) return {"item_id": item_id, "q": q}

使用异步路径操作函数（用async def定义）允许服务器在等待I/O操作（如数据库查询、文件读写、调用其他API）时去处理其他请求，从而显著提升在高并发I/O密集型场景下的吞吐量。注意：如果你的操作是CPU密集型（如图像处理、复杂计算），使用异步并不会带来性能提升，反而可能因为事件循环的调度产生额外开销。

3. 环境准备与项目初始化

在开始编码前，确保你的环境准备妥当。

3.1 Python版本

FastAPI需要Python 3.7+。推荐使用Python 3.8或更高版本以获得最佳特性支持。可以使用python --version检查。

3.2 创建虚拟环境

强烈建议为每个项目创建独立的虚拟环境，以隔离依赖。

# 使用venv（Python内置） python -m venv venv # 激活虚拟环境 # Windows venv\Scripts\activate # Linux/macOS source venv/bin/activate

3.3 安装依赖

核心依赖就两个：fastapi和uvicorn（一个ASGI服务器）。

pip install fastapi uvicorn

对于生产环境，你可能还需要：

• pydantic[email]：如果使用Pydantic的电子邮件验证。
• python-multipart：如果需要处理表单数据（文件上传）。
• httpx：用于在测试中异步调用自己的API。
• sqlalchemy和databases：用于数据库操作（异步推荐databases）。
• alembic：用于数据库迁移。

一个典型的项目依赖文件requirements.txt可能如下：

fastapi==0.104.1 uvicorn[standard]==0.24.0 pydantic[email]==2.5.0 sqlalchemy==2.0.23 databases[postgresql]==0.8.0 # 根据数据库选择 alembic==1.12.1 python-jose[cryptography]==3.3.0 # JWT令牌 passlib[bcrypt]==1.7.4 # 密码哈希

使用pip install -r requirements.txt安装所有依赖。

4. 第一个FastAPI应用：从Hello World到CRUD

让我们从一个最简单的应用开始，逐步构建一个具有完整CRUD功能的API。

4.1 最小应用

创建文件main.py：

from fastapi import FastAPI app = FastAPI() @app.get("/") async def root(): return {"message": "Hello World"} @app.get("/items/{item_id}") async def read_item(item_id: int, q: str = None): return {"item_id": item_id, "q": q}

运行应用：

uvicorn main:app --reload

• main：模块名（即main.py）。
• app：在main.py中创建的FastAPI实例变量名。
• --reload：代码修改后自动重启服务器，仅用于开发。

访问http://127.0.0.1:8000看到JSON响应。访问http://127.0.0.1:8000/docs即可看到自动生成的Swagger UI交互文档。

4.2 定义数据模型与CRUD操作

我们构建一个简单的“待办事项”API。

步骤1：定义Pydantic模型在models.py中：

from pydantic import BaseModel from typing import Optional from datetime import datetime class TodoBase(BaseModel): title: str description: Optional[str] = None completed: bool = False class TodoCreate(TodoBase): pass # 创建时可能不需要额外字段 class TodoUpdate(BaseModel): title: Optional[str] = None description: Optional[str] = None completed: Optional[bool] = None class TodoInDB(TodoBase): id: int created_at: datetime updated_at: datetime class Config: from_attributes = True # 允许从ORM对象（如SQLAlchemy模型）创建Pydantic模型

步骤2：创建“数据库”层（模拟）在database.py中，我们用一个内存字典模拟数据库：

from typing import Dict, List from models import TodoInDB # 模拟数据库表 fake_todos_db: Dict[int, TodoInDB] = {} current_id = 0 def get_next_id() -> int: global current_id current_id += 1 return current_id def create_todo(todo_create) -> TodoInDB: todo_id = get_next_id() db_todo = TodoInDB( id=todo_id, **todo_create.dict(), created_at=datetime.now(), updated_at=datetime.now() ) fake_todos_db[todo_id] = db_todo return db_todo def get_todo(todo_id: int) -> Optional[TodoInDB]: return fake_todos_db.get(todo_id) def get_all_todos() -> List[TodoInDB]: return list(fake_todos_db.values()) def update_todo(todo_id: int, todo_update) -> Optional[TodoInDB]: todo = fake_todos_db.get(todo_id) if not todo: return None update_data = todo_update.dict(exclude_unset=True) # 只更新提供的字段 updated_todo = todo.copy(update=update_data) updated_todo.updated_at = datetime.now() fake_todos_db[todo_id] = updated_todo return updated_todo def delete_todo(todo_id: int) -> bool: if todo_id in fake_todos_db: del fake_todos_db[todo_id] return True return False

步骤3：创建路由和路径操作函数在routers/todos.py中：

from fastapi import APIRouter, HTTPException, status from typing import List from models import TodoCreate, TodoUpdate, TodoInDB import database router = APIRouter(prefix="/todos", tags=["todos"]) @router.post("/", response_model=TodoInDB, status_code=status.HTTP_201_CREATED) async def create_todo(todo: TodoCreate): """创建新的待办事项""" return database.create_todo(todo) @router.get("/", response_model=List[TodoInDB]) async def read_todos(skip: int = 0, limit: int = 100): """获取待办事项列表，支持分页""" todos = database.get_all_todos() return todos[skip : skip + limit] @router.get("/{todo_id}", response_model=TodoInDB) async def read_todo(todo_id: int): """根据ID获取单个待办事项""" todo = database.get_todo(todo_id) if todo is None: raise HTTPException(status_code=404, detail="Todo not found") return todo @router.put("/{todo_id}", response_model=TodoInDB) async def update_todo(todo_id: int, todo_update: TodoUpdate): """更新待办事项""" updated_todo = database.update_todo(todo_id, todo_update) if updated_todo is None: raise HTTPException(status_code=404, detail="Todo not found") return updated_todo @router.delete("/{todo_id}", status_code=status.HTTP_204_NO_CONTENT) async def delete_todo(todo_id: int): """删除待办事项""" if not database.delete_todo(todo_id): raise HTTPException(status_code=404, detail="Todo not found") # 返回204 No Content，没有响应体

步骤4：集成路由到主应用更新main.py：

from fastapi import FastAPI from routers import todos app = FastAPI(title="Todo API", version="1.0.0") app.include_router(todos.router) @app.get("/") async def root(): return {"message": "Welcome to the Todo API"}

现在，一个具备完整CRUD、数据验证、分页和标准HTTP状态码的API就完成了。访问/docs，你可以看到所有接口并直接测试。

5. 深入特性：依赖注入、中间件与后台任务

5.1 依赖注入系统

依赖注入是FastAPI一个极其强大的特性，用于处理共享逻辑，如数据库会话、认证、权限检查等。

示例：获取当前用户

from fastapi import Depends, HTTPException, status from fastapi.security import OAuth2PasswordBearer from pydantic import BaseModel # 模拟用户数据库和令牌验证 fake_users_db = { "johndoe": { "username": "johndoe", "hashed_password": "fakehashedsecret", "disabled": False, } } oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token") class User(BaseModel): username: str disabled: bool = None def fake_decode_token(token): # 这里应进行真实的JWT令牌验证 user = fake_users_db.get(token) return User(**user) if user else None async def get_current_user(token: str = Depends(oauth2_scheme)): user = fake_decode_token(token) if not user: raise HTTPException( status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid authentication credentials", headers={"WWW-Authenticate": "Bearer"}, ) return user async def get_current_active_user(current_user: User = Depends(get_current_user)): if current_user.disabled: raise HTTPException(status_code=400, detail="Inactive user") return current_user # 在路径操作中使用依赖 @app.get("/users/me") async def read_users_me(current_user: User = Depends(get_current_active_user)): return current_user

Depends声明了该路径操作函数依赖于get_current_active_user函数的返回值。FastAPI会自动调用依赖函数，并将其结果注入。依赖本身也可以有依赖，形成依赖树。

5.2 中间件

中间件可以拦截请求和响应，用于添加CORS头、记录日志、处理异常等。

示例：添加CORS中间件

from fastapi.middleware.cors import CORSMiddleware app.add_middleware( CORSMiddleware, allow_origins=["http://localhost:3000"], # 前端开发服务器地址 allow_credentials=True, allow_methods=["*"], # 允许所有方法 allow_headers=["*"], # 允许所有头 )

自定义中间件示例（记录请求处理时间）

import time from fastapi import Request @app.middleware("http") async def add_process_time_header(request: Request, call_next): start_time = time.time() response = await call_next(request) process_time = time.time() - start_time response.headers["X-Process-Time"] = str(process_time) return response

5.3 后台任务

如果路径操作函数需要执行一个耗时操作，但不想让客户端等待（如发送邮件、处理视频），可以使用后台任务。

from fastapi import BackgroundTasks def write_notification(email: str, message=""): # 模拟一个耗时的任务，比如写数据库或发邮件 with open("log.txt", mode="a") as email_file: content = f"notification for {email}: {message}\n" email_file.write(content) @app.post("/send-notification/{email}") async def send_notification(email: str, background_tasks: BackgroundTasks): background_tasks.add_task(write_notification, email, message="some notification") return {"message": "Notification sent in the background"}

BackgroundTasks参数由FastAPI注入。使用add_task方法添加的函数会在响应返回后执行。

6. 连接真实数据库：以SQLAlchemy + PostgreSQL为例

上面的例子使用了内存数据库。在实际项目中，我们需要连接真实的数据库。这里以异步SQLAlchemy（通过databases库）和PostgreSQL为例。

6.1 配置数据库连接

创建database.py：

from sqlalchemy import create_engine, MetaData from sqlalchemy.ext.declarative import declarative_base from sqlalchemy.orm import sessionmaker from databases import Database import os # 从环境变量读取数据库URL，开发时默认 DATABASE_URL = os.getenv("DATABASE_URL", "postgresql://user:password@localhost/tododb") # SQLAlchemy核心 engine = create_engine(DATABASE_URL) metadata = MetaData() Base = declarative_base(metadata=metadata) # databases异步数据库接口 database = Database(DATABASE_URL) # SQLAlchemy会话工厂 SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine) # 依赖项，用于获取数据库会话 def get_db(): db = SessionLocal() try: yield db finally: db.close()

6.2 定义SQLAlchemy模型

创建models.py：

from sqlalchemy import Column, Integer, String, Boolean, DateTime, Text from sqlalchemy.sql import func from database import Base class TodoModel(Base): __tablename__ = "todos" id = Column(Integer, primary_key=True, index=True) title = Column(String(255), nullable=False) description = Column(Text, nullable=True) completed = Column(Boolean, default=False) created_at = Column(DateTime(timezone=True), server_default=func.now()) updated_at = Column(DateTime(timezone=True), onupdate=func.now())

6.3 创建Pydantic模型（与之前类似，但注意区分）

创建schemas.py（通常将Pydantic模型称为schemas以区分ORM模型）：

from pydantic import BaseModel from typing import Optional from datetime import datetime class TodoBase(BaseModel): title: str description: Optional[str] = None completed: bool = False class TodoCreate(TodoBase): pass class TodoUpdate(BaseModel): title: Optional[str] = None description: Optional[str] = None completed: Optional[bool] = None class Todo(TodoBase): id: int created_at: datetime updated_at: Optional[datetime] = None class Config: from_attributes = True # 允许从ORM对象创建

6.4 更新CRUD操作函数（使用异步）

更新crud.py：

from sqlalchemy.orm import Session from sqlalchemy import select from models import TodoModel from schemas import TodoCreate, TodoUpdate async def create_todo(db: Session, todo: TodoCreate): db_todo = TodoModel(**todo.dict()) db.add(db_todo) await db.commit() await db.refresh(db_todo) # 刷新以获取生成的值（如id） return db_todo async def get_todo(db: Session, todo_id: int): result = await db.execute(select(TodoModel).where(TodoModel.id == todo_id)) return result.scalar_one_or_none() async def get_todos(db: Session, skip: int = 0, limit: int = 100): result = await db.execute(select(TodoModel).offset(skip).limit(limit)) return result.scalars().all() async def update_todo(db: Session, todo_id: int, todo_update: TodoUpdate): db_todo = await get_todo(db, todo_id) if not db_todo: return None update_data = todo_update.dict(exclude_unset=True) for field, value in update_data.items(): setattr(db_todo, field, value) db.add(db_todo) await db.commit() await db.refresh(db_todo) return db_todo async def delete_todo(db: Session, todo_id: int): db_todo = await get_todo(db, todo_id) if not db_todo: return False await db.delete(db_todo) await db.commit() return True

6.5 更新路由，使用数据库依赖

更新routers/todos.py：

from fastapi import APIRouter, Depends, HTTPException, status from typing import List from sqlalchemy.ext.asyncio import AsyncSession from database import get_db import crud import schemas router = APIRouter(prefix="/todos", tags=["todos"]) @router.post("/", response_model=schemas.Todo, status_code=status.HTTP_201_CREATED) async def create_todo( todo: schemas.TodoCreate, db: AsyncSession = Depends(get_db) ): return await crud.create_todo(db, todo) # ... 其他路由函数，类似地注入db依赖

6.6 启动应用前初始化数据库

创建init_db.py（或使用Alembic进行迁移）：

from database import engine, Base from models import TodoModel async def init_models(): async with engine.begin() as conn: # 在生产环境中，请使用Alembic进行迁移，而不是直接create_all await conn.run_sync(Base.metadata.create_all) if __name__ == "__main__": import asyncio asyncio.run(init_models())

运行python init_db.py创建表。

现在，你的FastAPI应用已经连接到了真实的PostgreSQL数据库，并使用了异步操作。

7. 部署到生产环境：以Windows Server为例

搜索热词中提到了“fastapi uvicorn 部署到windows服务器”。在Windows上部署，关键在于将FastAPI应用作为一个稳定的Windows服务运行。

7.1 使用Uvicorn与Gunicorn（不推荐纯Uvicorn用于生产）

虽然Uvicorn可以直接运行（uvicorn main:app），但生产环境更推荐搭配Gunicorn（一个WSGI/ASGI服务器管理器）作为进程管理器，以提高稳定性和性能。但请注意，Gunicorn在Windows上原生支持有限。以下方案主要适用于Linux，但Windows上可以考虑替代方案。

对于Windows生产环境，推荐方案：

1. 使用Uvicorn配合多个Worker：虽然Uvicorn本身是服务器，但可以启动多个工作进程。

   uvicorn main:app --host 0.0.0.0 --port 8000 --workers 4

   --workers 4会启动4个工作进程。但Uvicorn的进程管理相对简单。

2. 使用Hypercorn：另一个兼容ASGI的服务器，设计上更注重生产环境特性，在Windows上可能有更好的支持。

   pip install hypercorn hypercorn main:app --bind 0.0.0.0:8000 --workers 4

3. 使用Windows Service包装：将应用封装为Windows服务，实现开机自启和崩溃恢复。可以使用nssm（Non-Sucking Service Manager）工具。

   • 下载nssm。
   • 以管理员身份运行命令行，执行：nssm install MyFastAPIApp
   • 在GUI中设置：
     • Path:C:\path\to\your\venv\Scripts\python.exe(或uvicorn.exe)
     • Startup directory:C:\path\to\your\project
     • Arguments:-m uvicorn main:app --host 0.0.0.0 --port 8000 --workers 2
   • 点击“Install service”。之后可以在Windows服务管理中启动/停止它。

7.2 使用反向代理（Nginx/Apache）

无论用哪种方式运行应用，都应该在前面放置一个反向代理（如Nginx或Apache），用于处理静态文件、SSL/TLS终止、负载均衡和缓冲。

Nginx配置示例 (/etc/nginx/sites-available/your_api)：

server { listen 80; server_name api.yourdomain.com; location / { proxy_pass http://127.0.0.1:8000; # 指向Uvicorn/Hypercorn运行地址 proxy_set_header Host $host; proxy_set_header X-Real-IP $remote_addr; proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; proxy_set_header X-Forwarded-Proto $scheme; } # 可选：直接由Nginx提供静态文件 location /static { alias /path/to/your/static/files; } }

7.3 环境变量与配置管理

生产环境不应将敏感信息（如数据库密码、API密钥）硬编码在代码中。使用环境变量或配置文件。

创建.env文件（开发用）：

DATABASE_URL=postgresql://user:password@localhost/proddb SECRET_KEY=your-secret-key-here DEBUG=False

使用python-dotenv在开发中加载，生产环境则在服务器上设置系统环境变量。 在main.py或配置模块中：

from pydantic_settings import BaseSettings class Settings(BaseSettings): database_url: str secret_key: str debug: bool = False class Config: env_file = ".env" settings = Settings()

然后使用settings.database_url等。

8. 常见问题与排查思路

以下是基于搜索热词和常见陷阱整理的问题排查指南。

9. 最佳实践与工程建议

1. 项目结构：不要把所有代码都堆在main.py里。采用模块化结构，例如：

   your_project/ ├── app/ │ ├── __init__.py │ ├── main.py # 创建FastAPI app并导入路由 │ ├── core/ # 核心配置、安全、依赖项 │ ├── models/ # SQLAlchemy ORM 模型 │ ├── schemas/ # Pydantic 模型 │ ├── crud/ # 数据库操作函数 │ ├── api/ # 路由端点 │ │ └── v1/ # API版本 │ │ ├── __init__.py │ │ ├── endpoints/ │ │ └── routers/ │ ├── db/ # 数据库会话、引擎 │ └── utils/ # 工具函数 ├── alembic/ # 数据库迁移 ├── tests/ # 测试 ├── requirements.txt └── .env

2. 依赖注入的滥用：依赖注入非常强大，但不要过度使用。将其用于真正的共享资源（数据库会话、认证）和可复用的业务逻辑。简单的参数验证直接用Pydantic模型。

3. 错误处理：使用FastAPI的异常处理器（@app.exception_handler）来统一处理特定异常，返回结构一致的错误响应。

4. 日志记录：配置完整的日志系统，记录请求、错误和应用事件。可以使用Python标准库的logging模块。

5. 测试：为你的API编写测试。FastAPI提供了TestClient，可以方便地模拟HTTP请求。

   from fastapi.testclient import TestClient from .main import app client = TestClient(app) def test_read_main(): response = client.get("/") assert response.status_code == 200 assert response.json() == {"message": "Hello World"}

6. 安全性：

   • 始终使用HTTPS。
   • 使用Pydantic进行严格的输入验证。
   • 对于用户密码，使用passlib等库进行哈希存储（如bcrypt）。
   • 使用FastAPI内置的OAuth2PasswordBearer等工具处理认证。
   • 设置CORS策略时，不要在生产环境中使用allow_origins=["*"]。

7. 性能监控：考虑集成像Prometheus和Grafana这样的监控工具，跟踪请求延迟、错误率和系统资源使用情况。

FastAPI的优雅在于它用一套简洁的机制（类型提示+Pydantic+依赖注入）解决了API开发中的一系列复杂问题。从快速原型到生产级服务，它都能提供出色的支持。掌握其核心思想并遵循良好的工程实践，你就能高效地构建出健壮、可维护且高性能的Web API。建议从官方文档入手，然后尝试用其重构一个小型项目，在实践中深化理解。