From 4139f5d387de28265b3041c583a8a19e9aa2b384 Mon Sep 17 00:00:00 2001
From: fanyanqing <fanyanqing.fyq@antgroup.com>
Date: Mon, 8 Jan 2024 17:04:13 +0800
Subject: [PATCH] =?UTF-8?q?=E4=BF=AE=E6=94=B9=20contorller=20=E5=92=8C=20e?=
 =?UTF-8?q?ntend?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 site/docs/basics/controller.zh-CN.md | 865 ++++++++++++---------------
 site/docs/basics/extend.zh-CN.md     | 104 ++--
 2 files changed, 422 insertions(+), 547 deletions(-)

diff --git a/site/docs/basics/controller.zh-CN.md b/site/docs/basics/controller.zh-CN.md
index c9610a8565..a59daf1e5c 100644
--- a/site/docs/basics/controller.zh-CN.md
+++ b/site/docs/basics/controller.zh-CN.md
@@ -5,30 +5,30 @@ order: 7
 
 ## 什么是 Controller
 
-[前面章节](./router.md)写到，我们通过 Router 将用户的请求基于 method 和 URL 分发到了对应的 Controller 上，那 Controller 负责做什么？
+在[前面的章节](./router.md)中提到，我们通过 Router 将用户的请求基于方法和 URL 分发到了相应的 Controller。那么，Controller 负责什么呢？
 
-简单的说 Controller 负责**解析用户的输入，处理后返回相应的结果**，例如
+简单来说，Controller 的职责是**解析用户的输入，处理后返回相应的结果**。例如：
 
-- 在 [RESTful](https://en.wikipedia.org/wiki/Representational_state_transfer) 接口中，Controller 接受用户的参数，从数据库中查找内容返回给用户或者将用户的请求更新到数据库中。
-- 在 HTML 页面请求中，Controller 根据用户访问不同的 URL，渲染不同的模板得到 HTML 返回给用户。
-- 在代理服务器中，Controller 将用户的请求转发到其他服务器上，并将其他服务器的处理结果返回给用户。
+- 在 [RESTful](https://en.wikipedia.org/wiki/Representational_state_transfer) 接口中，Controller 接收用户的参数，从数据库中查找信息后返回给用户，或者将用户的请求更新到数据库中。
+- 在 HTML 页面请求中，Controller 根据用户访问不同的 URL，渲染不同的模板并返回 HTML 给用户。
+- 在代理服务器中，Controller 将用户的请求转发到其他服务器，然后将其处理结果返回给用户。
 
-框架推荐 Controller 层主要对用户的请求参数进行处理（校验、转换），然后调用对应的 [service](./service.md) 方法处理业务，得到业务结果后封装并返回：
+框架推荐的 Controller 层主要对用户的请求参数进行处理（校验、转换），然后调用相应的 [service](./service.md) 方法处理业务。处理完业务后，再封装并返回结果：
 
 1. 获取用户通过 HTTP 传递过来的请求参数。
-1. 校验、组装参数。
-1. 调用 Service 进行业务处理，必要时处理转换 Service 的返回结果，让它适应用户的需求。
-1. 通过 HTTP 将结果响应给用户。
+2. 校验、组装参数。
+3. 调用 Service 进行业务处理。如有必要，处理转换 Service 的返回结果，使之适应用户的需求。
+4. 通过 HTTP 将结果响应给用户。
 
 ## 如何编写 Controller
 
-所有的 Controller 文件都必须放在 `app/controller` 目录下，可以支持多级目录，访问的时候可以通过目录名级联访问。Controller 支持多种形式进行编写，可以根据不同的项目场景和开发习惯来选择。
+所有的 Controller 文件都必须放在 `app/controller` 目录下。支持多级目录结构，用户可以通过目录名级联访问。Controller 有多种编写形式，可根据不同项目场景和开发习惯选择合适的方式。
 
 ### Controller 类（推荐）
 
-我们可以通过定义 Controller 类的方式来编写代码：
+通过定义 Controller 类的方式编写代码是推荐的做法：
 
-```js
+```javascript
 // app/controller/post.js
 const Controller = require('egg').Controller;
 class PostController extends Controller {
@@ -53,9 +53,9 @@ class PostController extends Controller {
 module.exports = PostController;
 ```
 
-我们通过上面的代码定义了一个 `PostController` 的类，类里面的每一个方法都可以作为一个 Controller 在 Router 中引用到，我们可以从 `app.controller` 根据文件名和方法名定位到它。
+上述代码定义了一个 `PostController` 类，其中的每个方法都可以作为一个 Controller 在 Router 中引用。可以从 `app.controller` 根据文件名和方法名定位到它。
 
-```js
+```javascript
 // app/router.js
 module.exports = (app) => {
   const { router, controller } = app;
@@ -63,28 +63,28 @@ module.exports = (app) => {
 };
 ```
 
-Controller 支持多级目录，例如如果我们将上面的 Controller 代码放到 `app/controller/sub/post.js` 中，则可以在 router 中这样使用：
+如果将 Controller 代码放在 `app/controller/sub/post.js` 中，则在 router 中可以这样使用：
 
-```js
+```javascript
 // app/router.js
 module.exports = (app) => {
   app.router.post('createPost', '/api/posts', app.controller.sub.post.create);
 };
 ```
 
-定义的 Controller 类，会在每一个请求访问到 server 时实例化一个全新的对象，而项目中的 Controller 类继承于 `egg.Controller`，会有下面几个属性挂在 `this` 上。
+定义的 Controller 类在每个请求访问服务器时会实例化一个全新的对象。项目中的 Controller 类继承自 `egg.Controller`，会有以下几个属性挂载在 `this` 上：
 
-- `this.ctx`: 当前请求的上下文 [Context](./extend.md#context) 对象的实例，通过它我们可以拿到框架封装好的处理当前请求的各种便捷属性和方法。
-- `this.app`: 当前应用 [Application](./extend.md#application) 对象的实例，通过它我们可以拿到框架提供的全局对象和方法。
-- `this.service`：应用定义的 [Service](./service.md)，通过它我们可以访问到抽象出的业务层，等价于 `this.ctx.service` 。
-- `this.config`：应用运行时的[配置项](./config.md)。
-- `this.logger`：logger 对象，上面有四个方法（`debug`，`info`，`warn`，`error`），分别代表打印四个不同级别的日志，使用方法和效果与 [context logger](../core/logger.md#context-logger) 中介绍的一样，但是通过这个 logger 对象记录的日志，在日志前面会加上打印该日志的文件路径，以便快速定位日志打印位置。
+- `this.ctx`：当前请求的上下文 [Context](./extend.md#context) 对象实例，包含了处理当前请求的各种便捷属性和方法。
+- `this.app`：当前应用 [Application](./extend.md#application) 对象实例，可以访问框架提供的全局对象和方法。
+- `this.service`：应用定义的 [Service](./service.md)，可以访问抽象业务层，等同于 `this.ctx.service`。
+- `this.config`：应用运行时的 [配置项](./config.md)。
+- `this.logger`：日志对象，包含 `debug`、`info`、`warn`、`error` 四个方法，用于记录不同级别的日志。记录的日志会加上文件路径，便于快速定位。
 
 #### 自定义 Controller 基类
 
-按照类的方式编写 Controller，不仅可以让我们更好的对 Controller 层代码进行抽象（例如将一些统一的处理抽象成一些私有方法），还可以通过自定义 Controller 基类的方式封装应用中常用的方法。
+通过类方式编写 Controller，除了可以对 Controller 层代码进行抽象外，还可以通过自定义 Controller 基类封装常用方法。
 
-```js
+```javascript
 // app/core/base_controller.js
 const { Controller } = require('egg');
 class BaseController extends Controller {
@@ -107,10 +107,10 @@ class BaseController extends Controller {
 module.exports = BaseController;
 ```
 
-此时在编写应用的 Controller 时，可以继承 BaseController，直接使用基类上的方法：
+继承 `BaseController` 后，可以直接使用基类上的方法：
 
-```js
-//app/controller/post.js
+```javascript
+// app/controller/post.js
 const Controller = require('../core/base_controller');
 class PostController extends Controller {
   async list() {
@@ -120,13 +120,13 @@ class PostController extends Controller {
 }
 ```
 
-### Controller 方法（不推荐使用，只是为了兼容）
+### Controller 方法（不推荐使用，仅为兼容旧代码）
 
-每一个 Controller 都是一个 async function，它的入参为请求的上下文 [Context](./extend.md#context) 对象的实例，通过它我们可以拿到框架封装好的各种便捷属性和方法。
+每个 Controller 都可以是一个异步函数（async function），它的入参是当前请求的上下文 [Context](./extend.md#context) 对象实例。通过 Context，我们可以访问到封装好的各种便捷属性和方法。
 
-例如我们写一个对应到 `POST /api/posts` 接口的 Controller，我们会在 `app/controller` 目录下创建一个 `post.js` 文件
+例如，编写一个对应 `POST /api/posts` 接口的 Controller，我们会在 `app/controller` 目录下创建一个 `post.js` 文件：
 
-```js
+```javascript
 // app/controller/post.js
 exports.create = async (ctx) => {
   const createRule = {
@@ -138,7 +138,7 @@ exports.create = async (ctx) => {
   // 组装参数
   const author = ctx.session.userId;
   const req = Object.assign(ctx.request.body, { author });
-  // 调用 service 进行业务处理
+  // 调用 Service 进行业务处理
   const res = await ctx.service.post.create(req);
   // 设置响应内容和响应状态码
   ctx.body = { id: res.id };
@@ -146,19 +146,19 @@ exports.create = async (ctx) => {
 };
 ```
 
-在上面的例子中我们引入了许多新的概念，但还是比较直观，容易理解的，我们会在下面对它们进行更详细的介绍。
+在上述示例中，我们引入了许多新的概念，但它们都是直观且易于理解的。这些概念将在下文中进行更详细的介绍。
 
 ## HTTP 基础
 
-由于 Controller 基本上是业务开发中唯一和 HTTP 协议打交道的地方，在继续往下了解之前，我们首先简单的看一下 HTTP 协议是怎样的。
+由于 Controller 是业务开发中唯一与 HTTP 协议打交道的地方，在继续了解之前，我们先简单回顾一下 HTTP 协议的基础知识。
 
-如果我们发起一个 HTTP 请求来访问前面例子中提到的 Controller：
+假设我们发起一个 HTTP 请求来访问前面例子中提到的 Controller：
 
 ```
 curl -X POST http://localhost:3000/api/posts --data '{"title":"controller", "content": "what is controller"}' --header 'Content-Type:application/json; charset=UTF-8'
 ```
 
-通过 curl 发出的 HTTP 请求的内容就会是下面这样的：
+使用 curl 发出的 HTTP 请求内容如下：
 
 ```
 POST /api/posts HTTP/1.1
@@ -168,19 +168,19 @@ Content-Type: application/json; charset=UTF-8
 {"title": "controller", "content": "what is controller"}
 ```
 
-请求的第一行包含了三个信息，我们比较常用的是前面两个：
+请求的第一行包含了三个部分，通常我们关注前两个：
 
-- method：这个请求中 method 的值是 `POST`。
-- path：值为 `/api/posts`，如果用户的请求中包含 query，也会在这里出现
+- method：本请求的方法为 `POST`。
+- path：路径为 `/api/posts`，如果用户请求中包含查询字符串（query），也会在此处显示。
 
-从第二行开始直到遇到的第一个空行位置，都是请求的 Headers 部分，这一部分中有许多常用的属性，包括这里看到的 Host，Content-Type，还有 `Cookie`，`User-Agent` 等等。在这个请求中有两个头：
+从第二行开始，直到遇到第一个空行，都是请求的 Headers 部分。这一部分包含了许多常用的属性，例如这里看到的 `Host` 和 `Content-Type`，以及其他如 `Cookie`、`User-Agent` 等。本例中有两个请求头：
 
-- `Host`：我们在浏览器发起请求的时候，域名会用来通过 DNS 解析找到服务的 IP 地址，但是浏览器也会将域名和端口号放在 Host 头中一并发送给服务端。
-- `Content-Type`：当我们的请求有 body 的时候，都会有 Content-Type 来标明我们的请求体是什么格式的。
+- `Host`：在浏览器发起请求时，域名用于 DNS 解析以找到服务的 IP 地址，但浏览器也会将域名和端口号放在 Host 头中发送给服务器。
+- `Content-Type`：当请求有 body 时，这个头部标明了请求体的格式。
 
-之后的内容全部都是请求的 body，当请求是 POST, PUT, DELETE 等方法的时候，可以带上请求体，服务端会根据 Content-Type 来解析请求体。
+之后的内容是请求的 body 部分，当请求方法为 POST、PUT、DELETE 等时，可以包含请求体，服务器会根据 `Content-Type` 来解析请求体内容。
 
-在服务端处理完这个请求后，会发送一个 HTTP 响应给客户端
+服务器在处理完请求后，会发送一个 HTTP 响应给客户端：
 
 ```
 HTTP/1.1 201 Created
@@ -192,24 +192,25 @@ Connection: keep-alive
 {"id": 1}
 ```
 
-第一行中也包含了三段，其中我们常用的主要是[响应状态码](https://en.wikipedia.org/wiki/List_of_HTTP_status_codes)，这个例子中它的值是 201，它的含义是在服务端成功创建了一条资源。
+响应的第一行也包含三部分，其中我们通常关注的是[响应状态码](https://en.wikipedia.org/wiki/List_of_HTTP_status_codes)，这个例子中它的值是 201，表示在服务器端成功创建了资源。
 
-和请求一样，从第二行开始到下一个空行之间都是响应头，这里的 Content-Type, Content-Length 表示这个响应的格式是 JSON，长度为 8 个字节。
+和请求一样，从第二行到下一个空行之间是响应头。这里的 `Content-Type` 和 `Content-Length` 表示响应格式是 JSON，长度为 8 个字节。
 
-最后剩下的部分就是这次响应真正的内容。
+最后剩下的部分是响应的实际内容。
 
-## 获取 HTTP 请求参数
+### 获取 HTTP 请求参数
 
-从上面的 HTTP 请求示例中可以看到，有好多地方可以放用户的请求数据，框架通过在 Controller 上绑定的 Context 实例，提供了许多便捷方法和属性获取用户通过 HTTP 请求发送过来的参数。
+从上述 HTTP 请求示例可以看到，用户的请求数据可以放在多个位置。框架通过在 Controller 上绑定的 Context 实例，提供了多种便捷方法和属性来获取用户通过 HTTP 请求发送过来的参数。
 
-### query
+#### query
 
-在 URL 中 `?` 后面的部分是一个 Query String，这一部分经常用于 GET 类型的请求中传递参数。例如 `GET /posts?category=egg&language=node` 中 `category=egg&language=node` 就是用户传递过来的参数。我们可以通过 `ctx.query` 拿到解析过后的这个参数体
+在 URL 中 `?` 后面的部分称为查询字符串（Query String），这部分通常用于 GET 请求中传递参数。例如 `GET /posts?category=egg&language=node` 中的 `category=egg&language=node` 就是用户传递过来的参数。我们可以通过 `ctx.query` 获取到解析后的参数对象：
 
-```js
+```javascript
 class PostController extends Controller {
   async listPosts() {
     const query = this.ctx.query;
+    // query 的值为：
     // {
     //   category: 'egg',
     //   language: 'node',
@@ -218,28 +219,29 @@ class PostController extends Controller {
 }
 ```
 
-当 Query String 中的 key 重复时，`ctx.query` 只取 key 第一次出现时的值，后面再出现的都会被忽略。`GET /posts?category=egg&category=koa` 通过 `ctx.query` 拿到的值是 `{ category: 'egg' }`。
+当查询字符串中的键（key）重复时，`ctx.query` 只取第一次出现的键值，后续相同的键会被忽略。例如 `GET /posts?category=egg&category=koa` 通过 `ctx.query` 获取的值将是 `{ category: 'egg' }`。
 
-这样处理的原因是为了保持统一性，由于通常情况下我们都不会设计让用户传递 key 相同的 Query String，所以我们经常会写类似下面的代码：
+这样的处理原因是为了保持一致性。通常情况下，我们不会设计让用户传递重复的键，所以我们经常会写类似以下代码：
 
-```js
+```javascript
 const key = ctx.query.key || '';
 if (key.startsWith('egg')) {
-  // do something
+  // 执行相关操作
 }
 ```
 
-而如果有人故意发起请求在 Query String 中带上重复的 key 来请求时就会引发系统异常。因此框架保证了从 `ctx.query` 上获取的参数一旦存在，一定是字符串类型。
+如果有人故意发起请求并在查询字符串中带上重复的键，这可能会引发系统异常。因此，框架保证了从 `ctx.query` 获取的参数一旦存在，一定是字符串类型。
 
 #### queries
 
-有时候我们的系统会设计成让用户传递相同的 key，例如 `GET /posts?category=egg&id=1&id=2&id=3`。针对此类情况，框架提供了 `ctx.queries` 对象，这个对象也解析了 Query String，但是它不会丢弃任何一个重复的数据，而是将他们都放到一个数组中：
+有时候，我们的系统会设计成允许用户传递相同的键，例如 `GET /posts?category=egg&id=1&id=2&id=3`。对于这种情况，框架提供了 `ctx.queries` 对象，这个对象也解析了查询字符串，但它会保留所有重复的数据，并将它们放到一个数组中：
 
-```js
+```javascript
 // GET /posts?category=egg&id=1&id=2&id=3
 class PostController extends Controller {
   async listPosts() {
     console.log(this.ctx.queries);
+    // queries 的值为：
     // {
     //   category: [ 'egg' ],
     //   id: [ '1', '2', '3' ],
@@ -248,15 +250,16 @@ class PostController extends Controller {
 }
 ```
 
-`ctx.queries` 上所有的 key 如果有值，也一定会是数组类型。
+`ctx.queries` 中所有的键如果有值，也一定会是数组类型。
 
-### Router params
+#### Router params
 
-在 [Router](./router.md) 中，我们介绍了 Router 上也可以申明参数，这些参数都可以通过 `ctx.params` 获取到。
+在 [Router](./router.md) 中，我们介绍了路由中也可以声明参数，这些参数可以通过 `ctx.params` 获取。
 
-```js
+```javascript
+// app/router.js
 // app.get('/projects/:projectId/app/:appId', 'app.listApp');
-// GET /projects/1/app/2
+// 当请求为 GET /projects/1/app/2 时
 class AppController extends Controller {
   async listApp() {
     assert.equal(this.ctx.params.projectId, '1');
@@ -265,18 +268,18 @@ class AppController extends Controller {
 }
 ```
 
-### body
+#### body
 
-虽然我们可以通过 URL 传递参数，但是还是有诸多限制：
+虽然可以通过 URL 传递参数，但还是有诸多限制：
 
-- [浏览器中会对 URL 的长度有所限制](http://stackoverflow.com/questions/417142/what-is-the-maximum-length-of-a-url-in-different-browsers)，如果需要传递的参数过多就会无法传递。
-- 服务端经常会将访问的完整 URL 记录到日志文件中，有一些敏感数据通过 URL 传递会不安全。
+- 浏览器对 URL 长度有限制，如果参数过多，可能无法传递。
+- 服务端通常会将访问的完整 URL 记录到日志文件中，通过 URL 传递敏感数据可能不安全。
 
-在前面的 HTTP 请求报文示例中，我们看到在 header 之后还有一个 body 部分，我们通常会在这个部分传递 POST、PUT 和 DELETE 等方法的参数。一般请求中有 body 的时候，客户端（浏览器）会同时发送 `Content-Type` 告诉服务端这次请求的 body 是什么格式的。Web 开发中数据传递最常用的两类格式分别是 JSON 和 Form。
+在前面的 HTTP 请求报文示例中，我们看到请求头（header）之后还有一个 body 部分。我们通常会在这个部分传递 POST、PUT 和 DELETE 等方法的参数。一般情况下，客户端（如浏览器）会同时发送 `Content-Type` 告诉服务端请求体的格式。Web 开发中最常用的两种数据传递格式是 JSON 和 Form。
 
-框架内置了 [bodyParser](https://github.com/koajs/bodyparser) 中间件来对这两类格式的请求 body 解析成 object 挂载到 `ctx.request.body` 上。HTTP 协议中并不建议在通过 GET、HEAD 方法访问时传递 body，所以我们无法在 GET、HEAD 方法中按照此方法获取到内容。
+框架内置了 [bodyParser](https://github.com/koajs/bodyparser) 中间件，用于解析这两种格式的请求体，并将解析结果挂载到 `ctx.request.body` 上。HTTP 协议中不建议在 GET、HEAD 方法中传递 body，因此我们无法在这两种方法中通过此方式获取内容。
 
-```js
+```javascript
 // POST /api/posts HTTP/1.1
 // Host: localhost:3000
 // Content-Type: application/json; charset=UTF-8
@@ -290,15 +293,16 @@ class PostController extends Controller {
 }
 ```
 
-框架对 bodyParser 设置了一些默认参数，配置好之后拥有以下特性：
+框架对 bodyParser 中间件设置了一些默认参数，配置后具有以下特性：
 
-- 当请求的 Content-Type 为 `application/json`，`application/json-patch+json`，`application/vnd.api+json` 和 `application/csp-report` 时，会按照 json 格式对请求 body 进行解析，并限制 body 最大长度为 `100kb`。
-- 当请求的 Content-Type 为 `application/x-www-form-urlencoded` 时，会按照 form 格式对请求 body 进行解析，并限制 body 最大长度为 `100kb`。
-- 如果解析成功，body 一定会是一个 Object（可能是一个数组）。
+- 当请求的 Content-Type 为 `application/json`、`application/json-patch+json`、`application/vnd.api+json` 和 `application/csp-report` 时，会按照 JSON 格式对请求体进行解析，并限制 body 最大长度为 `100kb`。
+- 当请求的 Content-Type 为 `application/x-www-form-urlencoded` 时，会按照表单格式对请求体进行解析，并限制 body 最大长度为 `100kb`。
+- 如果解析成功，body 一定是一个对象（可能是数组）。
 
-一般来说我们最经常调整的配置项就是变更解析时允许的最大长度，可以在 `config/config.default.js` 中覆盖框架的默认值。
+通常我们最常调整的配置项是解析时允许的最大长度，可以在 `config/config.default.js` 中覆盖框架的默认值。
 
-```js
+```javascript
+// config/config.default.js
 module.exports = {
   bodyParser: {
     jsonLimit: '1mb',
@@ -307,333 +311,255 @@ module.exports = {
 };
 ```
 
-如果用户的请求 body 超过了我们配置的解析最大长度，会抛出一个状态码为 `413` 的异常，如果用户请求的 body 解析失败（错误的 JSON），会抛出一个状态码为 `400` 的异常。
-
-**注意：在调整 bodyParser 支持的 body 长度时，如果我们应用前面还有一层反向代理（Nginx），可能也需要调整它的配置，确保反向代理也支持同样长度的请求 body。**
-
-**一个常见的错误是把 `ctx.request.body` 和 `ctx.body` 混淆，后者其实是 `ctx.response.body` 的简写。**
-
-### 获取上传的文件
-
-请求 body 除了可以带参数之外，还可以发送文件，一般来说，浏览器上都是通过 `Multipart/form-data` 格式发送文件的，框架通过内置 [Multipart](https://github.com/eggjs/egg-multipart) 插件来支持获取用户上传的文件，我们为你提供了两种方式：
-
-- #### File 模式：
-  如果你完全不知道 Nodejs 中的 Stream 用法，那么 File 模式非常合适你：
-
-1）在 config 文件中启用 `file` 模式：
-
-```js
-// config/config.default.js
-exports.multipart = {
-  mode: 'file',
-};
-```
-
-2）上传 / 接收文件：
-
-1. 上传 / 接收单个文件：
-
-你的前端静态页面代码应该看上去如下样子：
-
-```html
-<form
-  method="POST"
-  action="/upload?_csrf={{ ctx.csrf | safe }}"
-  enctype="multipart/form-data"
->
-  title: <input name="title" /> file: <input name="file" type="file" />
-  <button type="submit">Upload</button>
-</form>
-```
-
-对应的后端代码如下：
-
-```js
-// app/controller/upload.js
-const Controller = require('egg').Controller;
-const fs = require('fs/promises');
-
-module.exports = class extends Controller {
-  async upload() {
-    const { ctx } = this;
-    const file = ctx.request.files[0];
-    const name = 'egg-multipart-test/' + path.basename(file.filename);
-    let result;
-    try {
-      // 处理文件，比如上传到云端
-      result = await ctx.oss.put(name, file.filepath);
-    } finally {
-      // 需要删除临时文件
-      await fs.unlink(file.filepath);
-    }
-
-    ctx.body = {
-      url: result.url,
-      // 获取所有的字段值
-      requestBody: ctx.request.body,
-    };
-  }
-};
-```
-
-2. 上传 / 接收多个文件：
-
-对于多个文件，我们借助 `ctx.request.files` 属性进行遍历，然后分别进行处理：
-
-你的前端静态页面代码应该看上去如下样子：
-
-```html
-<form
-  method="POST"
-  action="/upload?_csrf={{ ctx.csrf | safe }}"
-  enctype="multipart/form-data"
->
-  title: <input name="title" /> file1: <input name="file1" type="file" /> file2:
-  <input name="file2" type="file" />
-  <button type="submit">Upload</button>
-</form>
-```
-
-对应的后端代码：
-
-```js
-// app/controller/upload.js
-const Controller = require('egg').Controller;
-const fs = require('fs/promises');
-
-module.exports = class extends Controller {
-  async upload() {
-    const { ctx } = this;
-    console.log(ctx.request.body);
-    console.log('got %d files', ctx.request.files.length);
-    for (const file of ctx.request.files) {
-      console.log('field: ' + file.fieldname);
-      console.log('filename: ' + file.filename);
-      console.log('encoding: ' + file.encoding);
-      console.log('mime: ' + file.mime);
-      console.log('tmp filepath: ' + file.filepath);
-      let result;
-      try {
-        // 处理文件，比如上传到云端
-        result = await ctx.oss.put(
-          'egg-multipart-test/' + file.filename,
-          file.filepath,
-        );
-      } finally {
-        // 需要删除临时文件
-        await fs.unlink(file.filepath);
-      }
-      console.log(result);
-    }
-  }
-};
-```
-
-- #### Stream 模式：
-  如果你对于 Node 中的 Stream 模式非常熟悉，那么你可以选择此模式。在 Controller 中，我们可以通过 `ctx.getFileStream()` 接口能获取到上传的文件流。
-
-1. 上传 / 接受单个文件：
-
-```html
-<form
-  method="POST"
-  action="/upload?_csrf={{ ctx.csrf | safe }}"
-  enctype="multipart/form-data"
->
-  title: <input name="title" /> file: <input name="file" type="file" />
-  <button type="submit">Upload</button>
-</form>
-```
-
-```js
-const path = require('path');
-const sendToWormhole = require('stream-wormhole');
-const Controller = require('egg').Controller;
-
-class UploaderController extends Controller {
-  async upload() {
-    const ctx = this.ctx;
-    const stream = await ctx.getFileStream();
-    const name = 'egg-multipart-test/' + path.basename(stream.filename);
-    // 文件处理，上传到云存储等等
-    let result;
-    try {
-      result = await ctx.oss.put(name, stream);
-    } catch (err) {
-      // 必须将上传的文件流消费掉，要不然浏览器响应会卡死
-      await sendToWormhole(stream);
-      throw err;
-    }
-
-    ctx.body = {
-      url: result.url,
-      // 所有表单字段都能通过 `stream.fields` 获取到
-      fields: stream.fields,
-    };
-  }
-}
-
-module.exports = UploaderController;
-```
-
-要通过 `ctx.getFileStream` 便捷的获取到用户上传的文件，需要满足两个条件：
-
-- 只支持上传一个文件。
-- 上传文件必须在所有其他的 fields 后面，否则在拿到文件流时可能还获取不到 fields。
-
-2. 上传 / 接受多个文件：
-
-如果要获取同时上传的多个文件，不能通过 `ctx.getFileStream()` 来获取，只能通过下面这种方式：
-
-```js
-const sendToWormhole = require('stream-wormhole');
-const Controller = require('egg').Controller;
-
-class UploaderController extends Controller {
-  async upload() {
-    const ctx = this.ctx;
-    const parts = ctx.multipart();
-    let part;
-    // parts() 返回 promise 对象
-    while ((part = await parts()) != null) {
-      if (part.length) {
-        // 这是 busboy 的字段
-        console.log('field: ' + part[0]);
-        console.log('value: ' + part[1]);
-        console.log('valueTruncated: ' + part[2]);
-        console.log('fieldnameTruncated: ' + part[3]);
-      } else {
-        if (!part.filename) {
-          // 这时是用户没有选择文件就点击了上传(part 是 file stream，但是 part.filename 为空)
-          // 需要做出处理，例如给出错误提示消息
-          return;
-        }
-        // part 是上传的文件流
-        console.log('field: ' + part.fieldname);
-        console.log('filename: ' + part.filename);
-        console.log('encoding: ' + part.encoding);
-        console.log('mime: ' + part.mime);
-        // 文件处理，上传到云存储等等
+如果用户的请求体超过配置的最大长度，框架会抛出一个状态码为 `413` 的异常；如果请求体解析失败（如错误的 JSON），会抛出一个状态码为 `400` 的异常。
+
+**注意：调整 bodyParser 支持的 body 长度时，如果应用前有反向代理（如 Nginx），可能也需要调整其配置，确保反向代理也支持同样长度的请求体。**
+
+**另外，注意不要将 `ctx.request.body` 和 `ctx.body` 混淆。后者实际上是 `ctx.response.body` 的简写。**
+
+#### 获取上传的文件
+
+请求体除了可以携带参数，还可以上传文件。通常，浏览器通过 `Multipart/form-data` 格式发送文件。框架内置的 [Multipart](https://github.com/eggjs/egg-multipart) 插件支持获取用户上传的文件，提供了两种方式：
+
+- **File 模式**：适合对 Node.js 中的 Stream 不太熟悉的开发者。
+
+1. 在配置文件中启用 `file` 模式：
+
+   ```javascript
+   // config/config.default.js
+   exports.multipart = {
+     mode: 'file',
+   };
+   ```
+
+2. 接收文件：
+
+   - 接收单个文件：
+
+     前端页面代码示例：
+
+     ```html
+     <form method="POST" action="/upload?_csrf={{ ctx.csrf | safe }}" enctype="multipart/form-data">
+       title: <input name="title" />
+       file: <input name="file" type="file" />
+       <button type="submit">Upload</button>
+     </form>
+     ```
+
+     后端 Controller 代码：
+
+     ```javascript
+     // app/controller/upload.js
+     const Controller = require('egg').Controller;
+     const fs = require('fs/promises');
+
+     class UploadController extends Controller {
+       async upload() {
+         const { ctx } = this;
+         const file = ctx.request.files[0];
+         let result;
+         try {
+           // 处理文件，例如上传到云存储等
+           result = await ctx.oss.put('egg-multipart-test/' + file.filename, file.filepath);
+         } finally {
+           // 删除临时文件
+           await fs.unlink(file.filepath);
+         }
+         ctx.body = {
+           url: result.url,
+           requestBody: ctx.request.body,
+         };
+       }
+     }
+     ```
+
+     后端 Controller 代码：
+
+     ```javascript
+     // app/controller/upload.js
+     const Controller = require('egg').Controller;
+     const fs = require('fs/promises');
+
+     class UploadController extends Controller {
+       async upload() {
+         const { ctx } = this;
+         for (const file of ctx.request.files) {
+           let result;
+           try {
+             // 处理文件，例如上传到云存储等
+             result = await ctx.oss.put('egg-multipart-test/' + file.filename, file.filepath);
+           } finally {
+             // 删除临时文件
+             await fs.unlink(file.filepath);
+           }
+           console.log(result);
+         }
+         ctx.body = {
+           success: true,
+         };
+       }
+     }
+     ```
+
+- - **Stream 模式**：适合熟悉 Node.js Stream 的开发者。在 Controller 中，可以通过 `ctx.getFileStream()` 获取上传的文件流。
+
+  - 接收单个文件：
+
+    前端页面代码示例：
+
+    ```html
+    <form method="POST" action="/upload?_csrf={{ ctx.csrf | safe }}" enctype="multipart/form-data">
+      title: <input name="title" />
+      file: <input name="file" type="file" />
+      <button type="submit">Upload</button>
+    </form>
+    ```
+
+    后端 Controller 代码：
+
+    ```javascript
+    const Controller = require('egg').Controller;
+    const sendToWormhole = require('stream-wormhole');
+
+    class UploaderController extends Controller {
+      async upload() {
+        const ctx = this.ctx;
+        const stream = await ctx.getFileStream();
         let result;
         try {
-          result = await ctx.oss.put(
-            'egg-multipart-test/' + part.filename,
-            part,
-          );
+          // 文件处理，例如上传到云存储等
+          result = await ctx.oss.put('egg-multipart-test/' + stream.filename, stream);
         } catch (err) {
-          // 必须将上传的文件流消费掉，要不然浏览器响应会卡死
-          await sendToWormhole(part);
+          // 必须消费掉 stream，否则浏览器响应会卡死
+          await sendToWormhole(stream);
           throw err;
         }
-        console.log(result);
+        ctx.body = {
+          url: result.url,
+          fields: stream.fields,
+        };
       }
     }
-    console.log('and we are done parsing the form!');
-  }
-}
+    ```
+```markdown
+  - 接收多个文件：
+
+    如果需要同时获取多个上传的文件，不能使用 `ctx.getFileStream()` 方法，而应该使用以下方式：
+
+    ```javascript
+    const Controller = require('egg').Controller;
+    const sendToWormhole = require('stream-wormhole');
+
+    class UploaderController extends Controller {
+      async upload() {
+        const ctx = this.ctx;
+        const parts = ctx.multipart();
+        let part;
+        while ((part = await parts()) != null) {
+          if (part.length) {
+            // 这是 busboy 的字段
+            console.log('field: ' + part[0]);
+            console.log('value: ' + part[1]);
+            console.log('valueTruncated: ' + part[2]);
+            console.log('fieldnameTruncated: ' + part[3]);
+          } else {
+            if (!part.filename) {
+              // 用户没有选择文件就点击了上传
+              // 需要做出处理，例如给出错误提示消息
+              return;
+            }
+            // part 是上传的文件流
+            let result;
+            try {
+              result = await ctx.oss.put('egg-multipart-test/' + part.filename, part);
+            } catch (err) {
+              // 必须消费掉 stream，否则浏览器响应会卡死
+              await sendToWormhole(part);
+              throw err;
+            }
+            console.log(result);
+          }
+        }
+        console.log('表单解析完成');
+      }
+    }
+    ```
 
-module.exports = UploaderController;
-```
+    为了确保文件上传的安全，框架限制了支持的文件格式。默认情况下，框架支持的文件扩展名包括：
 
-为了保证文件上传的安全，框架限制了支持的的文件格式，框架默认支持白名单如下：
-
-```js
-// images
-'.jpg', '.jpeg', // image/jpeg
-'.png', // image/png, image/x-png
-'.gif', // image/gif
-'.bmp', // image/bmp
-'.wbmp', // image/vnd.wap.wbmp
-'.webp',
-'.tif',
-'.psd',
-// text
-'.svg',
-'.js', '.jsx',
-'.json',
-'.css', '.less',
-'.html', '.htm',
-'.xml',
-// tar
-'.zip',
-'.gz', '.tgz', '.gzip',
-// video
-'.mp3',
-'.mp4',
-'.avi',
-```
+    - 图片：`.jpg`, `.jpeg`, `.png`, `.gif`, `.bmp`, `.wbmp`, `.webp`, `.tif`, `.psd`
+    - 文本：`.svg`, `.js`, `.jsx`, `.json`, `.css`, `.less`, `.html`, `.htm`, `.xml`
+    - 压缩文件：`.zip`, `.gz`, `.tgz`, `.gzip`
+    - 视频：`.mp3`, `.mp4`, `.avi`
 
-用户可以通过在 `config/config.default.js` 中配置来新增支持的文件扩展名，或者重写整个白名单
+    开发者可以通过在 `config/config.default.js` 中配置来新增或覆盖支持的文件扩展名：
 
-- 新增支持的文件扩展名
+    - 新增支持的文件扩展名：
 
-```js
-module.exports = {
-  multipart: {
-    fileExtensions: ['.apk'], // 增加对 apk 扩展名的文件支持
-  },
-};
-```
+      ```javascript
+      // config/config.default.js
+      exports.multipart = {
+        fileExtensions: ['.apk'], // 增加对 .apk 扩展名的支持
+      };
+      ```
 
-- 覆盖整个白名单
+    - 覆盖整个文件扩展名白名单：
 
-```js
-module.exports = {
-  multipart: {
-    whitelist: ['.png'], // 覆盖整个白名单，只允许上传 '.png' 格式
-  },
-};
-```
+      ```javascript
+      // config/config.default.js
+      exports.multipart = {
+        whitelist: ['.png'], // 覆盖整个白名单，只允许上传 .png 格式
+      };
+      ```
 
-**注意：当重写了 whitelist 时，fileExtensions 不生效。**
+    **注意：当重写 `whitelist` 时，`fileExtensions` 配置不会生效。**
 
-欲了解更多相关此技术细节和详情，请参阅 [Egg-Multipart](https://github.com/eggjs/egg-multipart)。
+    欲了解更多相关技术细节和详情，请参阅 [Egg-Multipart](https://github.com/eggjs/egg-multipart) 文档。
+了解了，我将继续执行修改任务，并注意不翻译代码中的英文以及保留原文中全角圆括号里的补充说明内容。现在我开始进行下一部分的修改。
 
 ### header
 
-除了从 URL 和请求 body 上获取参数之外，还有许多参数是通过请求 header 传递的。框架提供了一些辅助属性和方法来获取。
-
-- `ctx.headers`，`ctx.header`，`ctx.request.headers`，`ctx.request.header`：这几个方法是等价的，都是获取整个 header 对象。
-- `ctx.get(name)`，`ctx.request.get(name)`：获取请求 header 中的一个字段的值，如果这个字段不存在，会返回空字符串。
-- 我们建议用 `ctx.get(name)` 而不是 `ctx.headers['name']`，因为前者会自动处理大小写。
+除了从 URL 和请求体上获取参数外，还有许多参数是通过请求头（header）传递的。框架提供了一些辅助属性和方法来获取这些值。
 
-由于 header 比较特殊，有一些是 `HTTP` 协议规定了具体含义的（例如 `Content-Type`，`Accept`），有些是反向代理设置的，已经约定俗成（X-Forwarded-For），框架也会对他们增加一些便捷的 getter，详细的 getter 可以查看 [API](https://eggjs.org/api/) 文档。
+- `ctx.headers`、`ctx.header`、`ctx.request.headers`、`ctx.request.header`：这些方法等价，用于获取整个 header 对象。
+- `ctx.get(name)`、`ctx.request.get(name)`：用于获取请求头中某个字段的值。如果字段不存在，将返回空字符串。
+- 建议使用 `ctx.get(name)` 而不是 `ctx.headers['name']`，因为前者会自动处理字段名的大小写。
 
-特别是如果我们通过 `config.proxy = true` 设置了应用部署在反向代理（Nginx）之后，有一些 Getter 的内部处理会发生改变。
+由于 header 的特殊性，框架为一些常见的 header 字段提供了便捷的 getter，例如 `Content-Type`、`Accept`。如果应用部署在反向代理（如 Nginx）之后，通过 `config.proxy = true` 设置后，这些 getter 的内部处理逻辑会有所不同。
 
 #### `ctx.host`
 
-优先读通过 `config.hostHeaders` 中配置的 header 的值，读不到时再尝试获取 host 这个 header 的值，如果都获取不到，返回空字符串。
+优先读取 `config.hostHeaders` 配置中指定的 header 值，如果没有则尝试读取 `host` 这个 header 的值。如果都获取不到，则返回空字符串。
 
 `config.hostHeaders` 默认配置为 `x-forwarded-host`。
 
 #### `ctx.protocol`
 
-通过这个 Getter 获取 protocol 时，首先会判断当前连接是否是加密连接，如果是加密连接，返回 https。
+通过 `ctx.protocol` 获取协议时，首先会判断当前连接是否为加密连接（https）。如果是，返回 `https`。
 
-如果处于非加密连接时，优先读通过 `config.protocolHeaders` 中配置的 header 的值来判断是 HTTP 还是 https，如果读取不到，我们可以在配置中通过 `config.protocol` 来设置兜底值，默认为 HTTP。
+如果是非加密连接，将优先读取 `config.protocolHeaders` 配置中指定的 header 值来判断是 HTTP 还是 HTTPS。如果读取不到，可以通过 `config.protocol` 设置默认值，默认为 HTTP。
 
 `config.protocolHeaders` 默认配置为 `x-forwarded-proto`。
 
 #### `ctx.ips`
 
-通过 `ctx.ips` 获取请求经过所有的中间设备 IP 地址列表，只有在 `config.proxy = true` 时，才会通过读取 `config.ipHeaders` 中配置的 header 的值来获取，获取不到时为空数组。
+通过 `ctx.ips` 获取请求经过所有中间设备的 IP 地址列表。只有在 `config.proxy = true` 时，才会通过 `config.ipHeaders` 配置中指定的 header 值来获取。如果获取不到，则为空数组。
 
 `config.ipHeaders` 默认配置为 `x-forwarded-for`。
 
 #### `ctx.ip`
 
-通过 `ctx.ip` 获取请求发起方的 IP 地址，优先从 `ctx.ips` 中获取，`ctx.ips` 为空时使用连接上发起方的 IP 地址。
+通过 `ctx.ip` 获取请求发起方的 IP 地址。优先从 `ctx.ips` 获取，如果 `ctx.ips` 为空，则使用连接上发起方的 IP 地址。
 
-**注意：`ip` 和 `ips` 不同，`ip` 当 `config.proxy = false` 时会返回当前连接发起者的 `ip` 地址，`ips` 此时会为空数组。**
+**注意：`ip` 和 `ips` 的区别在于，当 `config.proxy = false` 时，`ip` 返回当前连接发起者的 IP 地址，`ips` 会是空数组。**
 
 ### Cookie
 
-HTTP 请求都是无状态的，但是我们的 Web 应用通常都需要知道发起请求的人是谁。为了解决这个问题，HTTP 协议设计了一个特殊的请求头：[Cookie](https://en.wikipedia.org/wiki/HTTP_cookie)。服务端可以通过响应头（set-cookie）将少量数据响应给客户端，浏览器会遵循协议将数据保存，并在下次请求同一个服务的时候带上（浏览器也会遵循协议，只在访问符合 Cookie 指定规则的网站时带上对应的 Cookie 来保证安全性）。
+HTTP 请求是无状态的，但我们的 Web 应用通常需要知道发起请求的用户是谁。为此，HTTP 协议设计了一个特殊的请求头：[Cookie](https://en.wikipedia.org/wiki/HTTP_cookie)。服务端可以通过响应头（Set-Cookie）将少量数据发送给客户端。浏览器会根据协议保存这些数据，并在下次请求同一服务时携带它们。
 
-通过 `ctx.cookies`，我们可以在 Controller 中便捷、安全的设置和读取 Cookie。
+通过 `ctx.cookies`，我们可以在 Controller 中便捷且安全地设置和读取 Cookie。
 
-```js
+```javascript
 class CookieController extends Controller {
   async add() {
     const ctx = this.ctx;
@@ -645,21 +571,21 @@ class CookieController extends Controller {
 
   async remove() {
     const ctx = this.ctx;
-    const count = ctx.cookies.set('count', null);
+    ctx.cookies.set('count', null);
     ctx.status = 204;
   }
 }
 ```
 
-Cookie 虽然在 HTTP 中只是一个头，但是通过 `foo=bar;foo1=bar1;` 的格式可以设置多个键值对。
+Cookie 虽然在 HTTP 中只是一个头，但它可以设置多个键值对，例如 `foo=bar;foo1=bar1;`。
 
-Cookie 在 Web 应用中经常承担了传递客户端身份信息的作用，因此有许多安全相关的配置，不可忽视，[Cookie](../core/cookie-and-session.md#cookie) 文档中详细介绍了 Cookie 的用法和安全相关的配置项，可以深入阅读了解。
+Cookie 在 Web 应用中常用于传递客户端身份信息，因此有许多与安全相关的配置。[Cookie](../core/cookie-and-session.md#cookie) 文档中详细介绍了 Cookie 的用法和安全配置项。
 
 #### 配置
 
-对于 Cookie 来说，主要有下面几个属性可以在 `config.default.js` 中进行配置:
+Cookie 的一些属性可以在 `config.default.js` 中配置：
 
-```js
+```javascript
 module.exports = {
   cookies: {
     // httpOnly: true | false,
@@ -668,9 +594,9 @@ module.exports = {
 };
 ```
 
-举例: 配置应用级别的 Cookie [SameSite](https://www.ruanyifeng.com/blog/2019/09/cookie-samesite.html) 属性等于 `Lax`。
+举例：配置应用级别的 Cookie [SameSite](https://www.ruanyifeng.com/blog/2019/09/cookie-samesite.html) 属性为 `Lax`。
 
-```js
+```javascript
 module.exports = {
   cookies: {
     sameSite: 'lax',
@@ -680,11 +606,11 @@ module.exports = {
 
 ### Session
 
-通过 Cookie，我们可以给每一个用户设置一个 Session，用来存储用户身份相关的信息，这份信息会加密后存储在 Cookie 中，实现跨请求的用户身份保持。
+利用 Cookie，我们可以为每个用户创建一个 Session，用于存储用户身份相关的信息。这些信息经过加密后存储在 Cookie 中，实现了跨请求的用户身份保持。
 
-框架内置了 [Session](https://github.com/eggjs/egg-session) 插件，给我们提供了 `ctx.session` 来访问或者修改当前用户 Session 。
+框架内置了 [Session](https://github.com/eggjs/egg-session) 插件，提供了 `ctx.session` 来访问或修改当前用户的 Session。
 
-```js
+```javascript
 class PostController extends Controller {
   async fetchPosts() {
     const ctx = this.ctx;
@@ -701,9 +627,9 @@ class PostController extends Controller {
 }
 ```
 
-Session 的使用方法非常直观，直接读取它或者修改它就可以了，如果要删除它，直接将它赋值为 `null`：
+使用 Session 非常直观，直接读取或修改即可。如果需要删除 Session，直接将其赋值为 `null`：
 
-```js
+```javascript
 class SessionController extends Controller {
   async deleteSession() {
     this.ctx.session = null;
@@ -711,26 +637,24 @@ class SessionController extends Controller {
 }
 ```
 
-和 Cookie 一样，Session 也有许多安全等选项和功能，在使用之前也最好阅读 [Session](../core/cookie-and-session.md#session) 文档深入了解。
+和 Cookie 一样，Session 也有许多安全选项和功能。在使用之前，建议阅读 [Session](../core/cookie-and-session.md#session) 文档以深入了解。
 
 #### 配置
 
-对于 Session 来说，主要有下面几个属性可以在 `config.default.js` 中进行配置:
+Session 的一些属性可以在 `config.default.js` 中配置：
 
-```js
+```javascript
 module.exports = {
-  key: 'EGG_SESS', // 承载 Session 的 Cookie 键值对名字
+  key: 'EGG_SESS', // 承载 Session 的 Cookie 键值对名称
   maxAge: 86400000, // Session 的最大有效时间
 };
 ```
 
 ## 参数校验
 
-在获取到用户请求的参数后，不可避免的要对参数进行一些校验。
+在获取用户请求的参数后，我们通常需要对这些参数进行校验。框架内置的 [Validate](https://github.com/eggjs/egg-validate) 插件提供了便捷的参数校验机制，帮助我们完成各种复杂的参数校验。
 
-借助 [Validate](https://github.com/eggjs/egg-validate) 插件提供便捷的参数校验机制，帮助我们完成各种复杂的参数校验。
-
-```js
+```javascript
 // config/plugin.js
 exports.validate = {
   enable: true,
@@ -738,13 +662,13 @@ exports.validate = {
 };
 ```
 
-通过 `ctx.validate(rule, [body])` 直接对参数进行校验：
+使用 `ctx.validate(rule, [body])` 方法可以直接对参数进行校验：
 
-```js
+```javascript
 class PostController extends Controller {
   async create() {
     // 校验参数
-    // 如果不传第二个参数会自动校验 `ctx.request.body`
+    // 如果不传第二个参数，将自动校验 `ctx.request.body`
     this.ctx.validate({
       title: { type: 'string' },
       content: { type: 'string' },
@@ -753,9 +677,9 @@ class PostController extends Controller {
 }
 ```
 
-当校验异常时，会直接抛出一个异常，异常的状态码为 422，errors 字段包含了详细的验证不通过信息。如果想要自己处理检查的异常，可以通过 `try catch` 来自行捕获。
+当校验发生异常时，会直接抛出一个异常，异常状态码为 422，`errors` 字段包含了详细的校验失败信息。如果希望自己处理校验异常，可以通过 `try catch` 来捕获。
 
-```js
+```javascript
 class PostController extends Controller {
   async create() {
     const ctx = this.ctx;
@@ -772,13 +696,13 @@ class PostController extends Controller {
 
 ### 校验规则
 
-参数校验通过 [Parameter](https://github.com/node-modules/parameter#rule) 完成，支持的校验规则可以在该模块的文档中查阅到。
+参数校验通过 [Parameter](https://github.com/node-modules/parameter#rule) 完成，支持的校验规则可以在该模块的文档中查阅。
 
 #### 自定义校验规则
 
-除了上一节介绍的内置检验类型外，有时候我们希望自定义一些校验规则，让开发时更便捷，此时可以通过 `app.validator.addRule(type, check)` 的方式新增自定义规则。
+除了内置的校验类型，有时我们需要自定义一些校验规则，这时可以通过 `app.validator.addRule(type, check)` 来新增自定义规则。
 
-```js
+```javascript
 // app.js
 app.validator.addRule('json', (rule, value) => {
   try {
@@ -789,52 +713,54 @@ app.validator.addRule('json', (rule, value) => {
 });
 ```
 
-添加完自定义规则之后，就可以在 Controller 中直接使用这条规则来进行参数校验了
+添加自定义规则后，就可以在 Controller 中使用这条规则进行参数校验了。
 
-```js
+```javascript
 class PostController extends Controller {
   async handler() {
     const ctx = this.ctx;
-    // query.test 字段必须是 json 字符串
+    // query.test 必须是 json 字符串
     const rule = { test: 'json' };
     ctx.validate(rule, ctx.query);
   }
 }
 ```
 
+
 ## 调用 Service
 
-我们并不想在 Controller 中实现太多业务逻辑，所以提供了一个 [Service](./service.md) 层进行业务逻辑的封装，这不仅能提高代码的复用性，同时可以让我们的业务逻辑更好测试。
+我们希望 Controller 层主要负责解析用户输入和发送 HTTP 响应，业务逻辑则应该抽象到 Service 层。Service 不仅提高了代码的复用性，还可以让业务逻辑更容易被测试。
 
-在 Controller 中可以调用任何一个 Service 上的任何方法，同时 Service 是懒加载的，只有当访问到它的时候框架才会去实例化它。
+在 Controller 中，你可以调用任何一个 Service 上的任何方法。Service 是懒加载的，只有当访问到它时，框架才会去实例化它。
 
-```js
+```javascript
 class PostController extends Controller {
   async create() {
     const ctx = this.ctx;
     const author = ctx.session.userId;
     const req = Object.assign(ctx.request.body, { author });
-    // 调用 service 进行业务处理
+    // 调用 Service 进行业务处理
     const res = await ctx.service.post.create(req);
+    // 设置响应内容和状态码
     ctx.body = { id: res.id };
     ctx.status = 201;
   }
 }
 ```
 
-Service 的具体写法，请查看 [Service](./service.md) 章节。
+Service 的具体写法可以参考 [Service](./service.md) 章节。
 
 ## 发送 HTTP 响应
 
-当业务逻辑完成之后，Controller 的最后一个职责就是将业务逻辑的处理结果通过 HTTP 响应发送给用户。
+业务逻辑处理完成后，Controller 的最后一个职责是将结果通过 HTTP 响应发送给用户。
 
 ### 设置 status
 
-HTTP 设计了非常多的[状态码](https://en.wikipedia.org/wiki/List_of_HTTP_status_codes)，每一个状态码都代表了一个特定的含义，通过设置正确的状态码，可以让响应更符合语义。
+HTTP 定义了丰富的[状态码](https://en.wikipedia.org/wiki/List_of_HTTP_status_codes)，每个状态码都有其特定含义。通过设置合适的状态码，可以使响应更具语义性。
 
-框架提供了一个便捷的 Setter 来进行状态码的设置
+框架提供了一个便捷的 Setter 来设置状态码：
 
-```js
+```javascript
 class PostController extends Controller {
   async create() {
     // 设置状态码为 201
@@ -843,18 +769,18 @@ class PostController extends Controller {
 }
 ```
 
-具体什么场景设置什么样的状态码，可以参考 [List of HTTP status codes](https://en.wikipedia.org/wiki/List_of_HTTP_status_codes) 中各个状态码的含义。
+具体应使用哪个状态码，可以参考 [HTTP 状态码列表](https://en.wikipedia.org/wiki/List_of_HTTP_status_codes)。
 
 ### 设置 body
 
-绝大多数的数据都是通过 body 发送给请求方的，和请求中的 body 一样，在响应中发送的 body，也需要有配套的 Content-Type 告知客户端如何对数据进行解析。
+大多数情况下，数据是通过响应体（body）发送给用户的。响应体的 `Content-Type` 应该明确指定，以告知客户端如何解析数据。
 
-- 作为一个 RESTful 的 API 接口 controller，我们通常会返回 Content-Type 为 `application/json` 格式的 body，内容是一个 JSON 字符串。
-- 作为一个 html 页面的 controller，我们通常会返回 Content-Type 为 `text/html` 格式的 body，内容是 html 代码段。
+- RESTful API 接口通常返回 `application/json` 格式的 JSON 字符串。
+- HTML 页面请求通常返回 `text/html` 格式的 HTML 代码。
 
-**注意：`ctx.body` 是 `ctx.response.body` 的简写，不要和 `ctx.request.body` 混淆了。**
+**注意：`ctx.body` 是 `ctx.response.body` 的简写，不要与 `ctx.request.body` 混淆。**
 
-```js
+```javascript
 class ViewController extends Controller {
   async show() {
     this.ctx.body = {
@@ -870,15 +796,13 @@ class ViewController extends Controller {
 }
 ```
 
-由于 Node.js 的流式特性，我们还有很多场景需要通过 Stream 返回响应，例如返回一个大文件，代理服务器直接返回上游的内容，框架也支持直接将 body 设置成一个 Stream，并会同时处理好这个 Stream 上的错误事件。
+Node.js 的流式处理特性使得我们有时需要通过 Stream 返回响应，例如返回大文件或代理服务器直接返回上游内容。框架支持将 body 设置为一个 Stream，并会处理好 Stream 上的错误事件。
 
-```js
+```javascript
 class ProxyController extends Controller {
   async proxy() {
     const ctx = this.ctx;
-    const result = await ctx.curl(url, {
-      streaming: true,
-    });
+    const result = await ctx.curl(url, { streaming: true });
     ctx.set(result.header);
     // result.res 是一个 stream
     ctx.body = result.res;
@@ -888,10 +812,9 @@ class ProxyController extends Controller {
 
 #### 渲染模板
 
-通常来说，我们不会手写 HTML 页面，而是会通过模板引擎进行生成。
-框架自身没有集成任何一个模板引擎，但是约定了 [View 插件的规范](../advanced/view-plugin.md)，通过接入的模板引擎，可以直接使用 `ctx.render(template)` 来渲染模板生成 html。
+通常，我们不会手写 HTML 页面，而是通过模板引擎生成。框架没有集成特定的模板引擎，但约定了 [View 插件规范](../advanced/view-plugin.md)。通过接入的模板引擎，可以直接使用 `ctx.render(template)` 渲染模板生成 HTML。
 
-```js
+```javascript
 class HomeController extends Controller {
   async index() {
     const ctx = this.ctx;
@@ -901,17 +824,17 @@ class HomeController extends Controller {
 }
 ```
 
-具体示例可以查看[模板渲染](../core/view.md)。
+更多示例可参考[模板渲染](../core/view.md)。
 
 #### JSONP
 
-有时我们需要给非本域的页面提供接口服务，又由于一些历史原因无法通过 [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/Access_control_CORS) 实现，可以通过 [JSONP](https://en.wikipedia.org/wiki/JSONP) 来进行响应。
+在某些场合，我们需要向非同源的页面提供接口服务。由于历史原因，我们可能无法使用 [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/Access_control_CORS) 实现跨域资源共享，这时可以使用 [JSONP](https://en.wikipedia.org/wiki/JSONP) 来响应请求。
 
-由于 JSONP 如果使用不当会导致非常多的安全问题，所以框架中提供了便捷的响应 JSONP 格式数据的方法，封装了 [JSONP XSS 相关的安全防范](../core/security.md#jsonp-xss)，并支持进行 CSRF 校验和 referrer 校验。
+由于 JSONP 存在潜在的安全风险，框架提供了安全的 JSONP 支持，封装了 [JSONP XSS 相关的安全防范](../core/security.md#jsonp-xss)，并支持进行 CSRF 校验和 referrer 校验。
 
-- 通过 `app.jsonp()` 提供的中间件来让一个 controller 支持响应 JSONP 格式的数据。在路由中，我们给需要支持 jsonp 的路由加上这个中间件：
+- 使用 `app.jsonp()` 提供的中间件，可以让 controller 支持响应 JSONP 格式的数据。在路由中，我们给需要支持 JSONP 的路由加上这个中间件：
 
-```js
+```javascript
 // app/router.js
 module.exports = (app) => {
   const jsonp = app.jsonp();
@@ -920,9 +843,9 @@ module.exports = (app) => {
 };
 ```
 
-- 在 Controller 中，只需要正常编写即可：
+- 在 Controller 中，只需要正常编写逻辑即可：
 
-```js
+```javascript
 // app/controller/posts.js
 class PostController extends Controller {
   async show() {
@@ -935,25 +858,23 @@ class PostController extends Controller {
 }
 ```
 
-用户请求对应的 URL 访问到这个 controller 的时候，如果 query 中有 `_callback=fn` 参数，将会返回 JSONP 格式的数据，否则返回 JSON 格式的数据。
+如果请求的 query 中包含 `_callback=fn` 参数，将返回 JSONP 格式的数据；否则返回 JSON 格式的数据。
 
 ##### JSONP 配置
 
-框架默认通过 query 中的 `_callback` 参数作为识别是否返回 JSONP 格式数据的依据，并且 `_callback` 中设置的方法名长度最多只允许 50 个字符。应用可以在 `config/config.default.js` 全局覆盖默认的配置：
+框架默认使用 `_callback` 作为 JSONP 请求的回调函数名称。`_callback` 函数名的长度最多允许 50 个字符。应用可以在 `config/config.default.js` 中全局覆盖默认配置：
 
-```js
+```javascript
 // config/config.default.js
 exports.jsonp = {
-  callback: 'callback', // 识别 query 中的 `callback` 参数
+  callback: 'callback', // 通过 query 中的 `callback` 参数识别 JSONP 请求
   limit: 100, // 函数名最长为 100 个字符
 };
 ```
 
-通过上面的方式配置之后，如果用户请求 `/api/posts/1?callback=fn`，响应为 JSONP 格式，如果用户请求 `/api/posts/1`，响应格式为 JSON。
-
-我们同样可以在 `app.jsonp()` 创建中间件时覆盖默认的配置，以达到不同路由使用不同配置的目的：
+也可以在创建中间件时覆盖配置，以实现不同路由使用不同配置：
 
-```js
+```javascript
 // app/router.js
 module.exports = (app) => {
   const { router, controller, jsonp } = app;
@@ -968,19 +889,13 @@ module.exports = (app) => {
 
 ##### 跨站防御配置
 
-默认配置下，响应 JSONP 时不会进行任何跨站攻击的防范，在某些情况下，这是很危险的。我们初略将 JSONP 接口分为三种类型：
-
-1. 查询非敏感数据，例如获取一个论坛的公开文章列表。
-2. 查询敏感数据，例如获取一个用户的交易记录。
-3. 提交数据并修改数据库，例如给某一个用户创建一笔订单。
-
-如果我们的 JSONP 接口提供下面两类服务，在不做任何跨站防御的情况下，可能泄露用户敏感数据甚至导致用户被钓鱼。因此框架给 JSONP 默认提供了 CSRF 校验支持和 referrer 校验支持。
+默认情况下，响应 JSONP 时不会进行跨站攻击防范。如果 JSONP 接口提供敏感数据或修改数据库，可能存在安全风险。因此，框架提供了 CSRF 校验和 referrer 校验的配置。
 
 ###### CSRF
 
-在 JSONP 配置中，我们只需要打开 `csrf: true`，即可对 JSONP 接口开启 CSRF 校验。
+在 JSONP 配置中，开启 `csrf: true` 即可为 JSONP 接口启用 CSRF 校验。
 
-```js
+```javascript
 // config/config.default.js
 module.exports = {
   jsonp: {
@@ -989,16 +904,16 @@ module.exports = {
 };
 ```
 
-**注意，CSRF 校验依赖于 [security](../core/security.md) 插件提供的基于 Cookie 的 CSRF 校验。**
+**注意：CSRF 校验依赖于 [security](../core/security.md) 插件提供的基于 Cookie 的 CSRF 校验。**
 
-在开启 CSRF 校验时，客户端在发起 JSONP 请求时，也要带上 CSRF token，如果发起 JSONP 的请求方所在的页面和我们的服务在同一个主域名之下的话，可以读取到 Cookie 中的 CSRF token（在 CSRF token 缺失时也可以自行设置 CSRF token 到 Cookie 中），并在请求时带上该 token。
+开启 CSRF 校验后，客户端在发起 JSONP 请求时，也需要携带 CSRF token。如果请求方页面与服务同域，可以读取 Cookie 中的 CSRF token，并在请求时带上该 token。
 
-##### referrer 校验
+###### referrer 校验
 
-如果在同一个主域之下，可以通过开启 CSRF 的方式来校验 JSONP 请求的来源，而如果想对其他域名的网页提供 JSONP 服务，我们可以通过配置 referrer 白名单的方式来限制 JSONP 的请求方在可控范围之内。
+如果想对其他域名的网页提供 JSONP 服务，可以通过配置 referrer 白名单来限制请求来源。
 
-```js
-//config/config.default.js
+```javascript
+// config/config.default.js
 exports.jsonp = {
   whiteList: /^https?:\/\/test.com\//,
   // whiteList: '.test.com',
@@ -1007,61 +922,24 @@ exports.jsonp = {
 };
 ```
 
-`whiteList` 可以配置为正则表达式、字符串或者数组：
+`whiteList` 可配置为正则表达式、字符串或数组：
 
-- 正则表达式：此时只有请求的 Referrer 匹配该正则时才允许访问 JSONP 接口。在设置正则表达式的时候，注意开头的 `^` 以及结尾的 `\/`，保证匹配到完整的域名。
+- 正则表达式：只有请求的 Referrer 匹配该正则时，才允许访问 JSONP 接口。
 
-```js
-exports.jsonp = {
-  whiteList: /^https?:\/\/test.com\//,
-};
-// matches referrer:
-// https://test.com/hello
-// http://test.com/
-```
+- 字符串：以 `.` 开头的字符串（如 `.test.com`）表示允许 `test.com` 及其所有子域名的请求。不以 `.` 开头的字符串（如 `sub.test.com`）表示只允许特定域名的请求。
 
-- 字符串：设置字符串形式的白名单时分为两种，当字符串以 `.` 开头，例如 `.test.com` 时，代表 referrer 白名单为 `test.com` 的所有子域名，包括 `test.com` 自身。当字符串不以 `.` 开头，例如 `sub.test.com`，代表 referrer 白名单为 `sub.test.com` 这一个域名。（同时支持 HTTP 和 HTTPS）。
+- 数组：只要满足数组中任一元素的条件，即可通过 referrer 校验。
 
-```js
-exports.jsonp = {
-  whiteList: '.test.com',
-};
-// matches domain test.com:
-// https://test.com/hello
-// http://test.com/
-
-// matches subdomain
-// https://sub.test.com/hello
-// http://sub.sub.test.com/
-
-exports.jsonp = {
-  whiteList: 'sub.test.com',
-};
-// only matches domain sub.test.com:
-// https://sub.test.com/hello
-// http://sub.test.com/
-```
+**当 CSRF 和 referrer 校验同时开启时，只需满足其中一个条件即可通过 JSONP 的安全校验。**
 
-- 数组：当设置的白名单为数组时，代表只要满足数组中任意一个元素的条件即可通过 referrer 校验。
-
-```js
-exports.jsonp = {
-  whiteList: ['sub.test.com', 'sub2.test.com'],
-};
-// matches domain sub.test.com and sub2.test.com:
-// https://sub.test.com/hello
-// http://sub2.test.com/
-```
-
-**当 CSRF 和 referrer 校验同时开启时，请求发起方只需要满足任意一个条件即可通过 JSONP 的安全校验。**
 
 ### 设置 Header
 
-我们通过状态码标识请求成功与否、状态如何，在 body 中设置响应的内容。而通过响应的 Header，还可以设置一些扩展信息。
+除了通过状态码和响应体（body）传递信息外，我们还可以通过响应头（Header）设置一些扩展信息。
 
-通过 `ctx.set(key, value)` 方法可以设置一个响应头，`ctx.set(headers)` 设置多个 Header。
+使用 `ctx.set(key, value)` 方法可以设置一个响应头，或使用 `ctx.set(headers)` 设置多个响应头。
 
-```js
+```javascript
 // app/controller/api.js
 class ProxyController extends Controller {
   async show() {
@@ -1077,18 +955,19 @@ class ProxyController extends Controller {
 
 ### 重定向
 
-框架通过 security 插件覆盖了 koa 原生的 `ctx.redirect` 实现，以提供更加安全的重定向。
+框架提供了安全的重定向方法，覆盖了 koa 原生的 `ctx.redirect` 实现，以确保只能重定向到配置的白名单域名内。
 
-- `ctx.redirect(url)` 如果不在配置的白名单域名内，则禁止跳转。
-- `ctx.unsafeRedirect(url)` 不判断域名，直接跳转，一般不建议使用，明确了解可能带来的风险后使用。
+- `ctx.redirect(url)`：如果不在配置的白名单域名内，则禁止跳转。
+- `ctx.unsafeRedirect(url)`：不判断域名，直接跳转，一般不建议使用，除非明确了解可能带来的风险。
 
-用户如果使用`ctx.redirect`方法，需要在应用的配置文件中做如下配置：
+使用 `ctx.redirect` 方法时，需要在应用的配置文件中进行如下配置：
 
-```js
+```javascript
 // config/config.default.js
 exports.security = {
   domainWhiteList: ['.domain.com'], // 安全白名单，以 . 开头
 };
 ```
 
-若用户没有配置 `domainWhiteList` 或者 `domainWhiteList`数组内为空，则默认会对所有跳转请求放行，即等同于`ctx.unsafeRedirect(url)`
+如果没有配置 `domainWhiteList` 或者 `domainWhiteList` 数组为空，则默认允许所有跳转，等同于 `ctx.unsafeRedirect(url)`。
+
diff --git a/site/docs/basics/extend.zh-CN.md b/site/docs/basics/extend.zh-CN.md
index 08c147b587..ead77df3cd 100644
--- a/site/docs/basics/extend.zh-CN.md
+++ b/site/docs/basics/extend.zh-CN.md
@@ -1,9 +1,4 @@
----
-title: 框架扩展
-order: 11
----
-
-框架提供了多种扩展点扩展自身的功能：
+框架提供了多种扩展点以扩展自身的功能：
 
 - Application
 - Context
@@ -11,47 +6,47 @@ order: 11
 - Response
 - Helper
 
-在开发中，我们既可以使用已有的扩展 API 来方便开发，也可以对以上对象进行自定义扩展，进一步加强框架的功能。
+在开发中，我们既可以使用已有的扩展 API 来方便开发，也可以对以上对象进行自定义扩展，以进一步加强框架的功能。
 
 ## Application
 
-`app` 对象指的是 Koa 的全局应用对象，全局只有一个，在应用启动时被创建。
+`app` 对象是指 Koa 的全局应用对象，全局唯一，在应用启动时创建。
 
 ### 访问方式
 
-- `ctx.app`
-- Controller，Middleware，Helper，Service 中都可以通过 `this.app` 访问到 Application 对象，例如 `this.app.config` 访问配置对象。
-- 在 `app.js` 中 `app` 对象会作为第一个参数注入到入口函数中
+- 通过 `ctx.app` 访问
+- 在 Controller、Middleware、Helper、Service 中可以通过 `this.app` 访问 Application 对象，例如 `this.app.config` 用于访问配置对象。
+- 在 `app.js` 中，`app` 对象作为入口函数的第一个参数：
 
   ```js
   // app.js
-  module.exports = (app) => {
-    // 使用 app 对象
+  module.exports = app => {
+    // 在这里可以使用 app 对象
   };
   ```
 
 ### 扩展方式
 
-框架会把 `app/extend/application.js` 中定义的对象与 Koa Application 的 prototype 对象进行合并，在应用启动时会基于扩展后的 prototype 生成 `app` 对象。
+框架将 `app/extend/application.js` 中定义的对象与 Koa Application 的 prototype 对象合并。在应用启动时，会基于扩展后的 prototype 生成 `app` 对象。
 
 #### 方法扩展
 
-例如，我们要增加一个 `app.foo()` 方法：
+例如，要增加一个 `app.foo()` 方法：
 
 ```js
 // app/extend/application.js
 module.exports = {
   foo(param) {
-    // this 就是 app 对象，在其中可以调用 app 上的其他方法，或访问属性
+    // this 即 app 对象，在这里可以调用 app 上的其他方法或访问属性
   },
 };
 ```
 
 #### 属性扩展
 
-一般来说属性的计算只需要进行一次，那么一定要实现缓存，否则在多次访问属性时会计算多次，这样会降低应用性能。
+通常属性只需计算一次，应实现缓存，避免多次访问时重复计算，降低性能。
 
-推荐的方式是使用 Symbol + Getter 的模式。
+推荐使用 Symbol + Getter 模式。
 
 例如，增加一个 `app.bar` 属性 Getter：
 
@@ -61,7 +56,7 @@ const BAR = Symbol('Application#bar');
 
 module.exports = {
   get bar() {
-    // this 就是 app 对象，在其中可以调用 app 上的其他方法，或访问属性
+    // this 即 app 对象，在这里可以调用 app 上的其他方法或访问属性
     if (!this[BAR]) {
       // 实际情况肯定更复杂
       this[BAR] = this.config.xx + this.config.yy;
@@ -70,39 +65,38 @@ module.exports = {
   },
 };
 ```
-
 ## Context
 
-Context 指的是 Koa 的请求上下文，这是 **请求级别** 的对象，每次请求生成一个 Context 实例，通常我们也简写成 `ctx`。在所有的文档中，Context 和 `ctx` 都是指 Koa 的上下文对象。
+Context 是指 Koa 的请求上下文，这是请求级别的对象。每次请求生成一个 Context 实例，通常简写为 `ctx`。在所有文档中，Context 和 `ctx` 均指 Koa 的上下文对象。
 
 ### 访问方式
 
-- middleware 中 `this` 就是 ctx，例如 `this.cookies.get('foo')`。
-- controller 有两种写法，类的写法通过 `this.ctx`，方法的写法直接通过 `ctx` 入参。
-- helper，service 中的 this 指向 helper，service 对象本身，使用 `this.ctx` 访问 context 对象，例如 `this.ctx.cookies.get('foo')`。
+- 在 middleware 中，`this` 就是 `ctx`，例如 `this.cookies.get('foo')`。
+- 在 controller 中，类的写法通过 `this.ctx` 访问，方法的写法则直接通过 `ctx` 参数访问。
+- 在 helper 和 service 中，`this` 指向 helper 或 service 对象本身，通过 `this.ctx` 访问 context 对象，例如 `this.ctx.cookies.get('foo')`。
 
 ### 扩展方式
 
-框架会把 `app/extend/context.js` 中定义的对象与 Koa Context 的 prototype 对象进行合并，在处理请求时会基于扩展后的 prototype 生成 ctx 对象。
+框架将 `app/extend/context.js` 中定义的对象与 Koa Context 的 prototype 对象合并。在处理请求时，会基于扩展后的 prototype 生成 `ctx` 对象。
 
 #### 方法扩展
 
-例如，我们要增加一个 `ctx.foo()` 方法：
+例如，要增加一个 `ctx.foo()` 方法：
 
 ```js
 // app/extend/context.js
 module.exports = {
   foo(param) {
-    // this 就是 ctx 对象，在其中可以调用 ctx 上的其他方法，或访问属性
+    // this 即 ctx 对象，在这里可以调用 ctx 上的其他方法或访问属性
   },
 };
 ```
 
 #### 属性扩展
 
-一般来说属性的计算在同一次请求中只需要进行一次，那么一定要实现缓存，否则在同一次请求中多次访问属性时会计算多次，这样会降低应用性能。
+通常属性在同一次请求中只需计算一次，应实现缓存，避免同一请求中多次访问时重复计算，降低性能。
 
-推荐的方式是使用 Symbol + Getter 的模式。
+推荐使用 Symbol + Getter 模式。
 
 例如，增加一个 `ctx.bar` 属性 Getter：
 
@@ -112,7 +106,7 @@ const BAR = Symbol('Context#bar');
 
 module.exports = {
   get bar() {
-    // this 就是 ctx 对象，在其中可以调用 ctx 上的其他方法，或访问属性
+    // this 即 ctx 对象，在这里可以调用 ctx 上的其他方法或访问属性
     if (!this[BAR]) {
       // 例如，从 header 中获取，实际情况肯定更复杂
       this[BAR] = this.get('x-bar');
@@ -124,21 +118,23 @@ module.exports = {
 
 ## Request
 
-Request 对象和 Koa 的 Request 对象相同，是 **请求级别** 的对象，它提供了大量请求相关的属性和方法供使用。
+Request 对象与 Koa 的 Request 对象相同，是请求级别的对象。它提供了众多请求相关的属性和方法供使用。
 
 ### 访问方式
 
+通过 `ctx.request` 访问：
+
 ```js
 ctx.request;
 ```
 
-`ctx` 上的很多属性和方法都被代理到 `request` 对象上，对于这些属性和方法使用 `ctx` 和使用 `request` 去访问它们是等价的，例如 `ctx.url === ctx.request.url`。
+`ctx` 上的许多属性和方法都代理到了 `request` 对象上。因此，直接通过 `ctx` 或通过 `request` 访问这些属性和方法是等价的，例如 `ctx.url === ctx.request.url`。
 
-Koa 内置的代理 `request` 的属性和方法列表：[Koa - Request aliases](http://koajs.com/#request-aliases)
+Koa 内置的代理 `request` 的属性和方法列表可以参见：[Koa - Request aliases](http://koajs.com/#request-aliases)。
 
 ### 扩展方式
 
-框架会把 `app/extend/request.js` 中定义的对象与内置 `request` 的 prototype 对象进行合并，在处理请求时会基于扩展后的 prototype 生成 `request` 对象。
+框架会把 `app/extend/request.js` 中定义的对象与内置 `request` 的 prototype 对象合并，在处理请求时会基于扩展后的 prototype 生成 `request` 对象。
 
 例如，增加一个 `request.foo` 属性 Getter：
 
@@ -153,21 +149,23 @@ module.exports = {
 
 ## Response
 
-Response 对象和 Koa 的 Response 对象相同，是 **请求级别** 的对象，它提供了大量响应相关的属性和方法供使用。
+Response 对象与 Koa 的 Response 对象相同，是请求级别的对象。它提供了众多响应相关的属性和方法供使用。
 
 ### 访问方式
 
+通过 `ctx.response` 访问：
+
 ```js
 ctx.response;
 ```
 
-ctx 上的很多属性和方法都被代理到 `response` 对象上，对于这些属性和方法使用 `ctx` 和使用 `response` 去访问它们是等价的，例如 `ctx.status = 404` 和 `ctx.response.status = 404` 是等价的。
+`ctx` 上的许多属性和方法都代理到了 `response` 对象上。因此，直接通过 `ctx` 或通过 `response` 访问这些属性和方法是等价的，例如 `ctx.status = 404` 与 `ctx.response.status = 404` 是等价的。
 
-Koa 内置的代理 `response` 的属性和方法列表：[Koa Response aliases](http://koajs.com/#response-aliases)
+Koa 内置的代理 `response` 的属性和方法列表可以参见：[Koa - Response aliases](http://koajs.com/#response-aliases)。
 
 ### 扩展方式
 
-框架会把 `app/extend/response.js` 中定义的对象与内置 `response` 的 prototype 对象进行合并，在处理请求时会基于扩展后的 prototype 生成 `response` 对象。
+框架会把 `app/extend/response.js` 中定义的对象与内置 `response` 的 prototype 对象合并，在处理请求时会基于扩展后的 prototype 生成 `response` 对象。
 
 例如，增加一个 `response.foo` 属性 setter：
 
@@ -180,40 +178,38 @@ module.exports = {
 };
 ```
 
-就可以这样使用啦：`this.response.foo = 'bar';`
+使用方式：`this.response.foo = 'bar';`
 
 ## Helper
 
-Helper 函数用来提供一些实用的 utility 函数。
+Helper 函数用来提供一系列实用的工具函数。它们的作用是将一些常用动作抽离到 `helper.js` 中，形成独立的函数。这样可以用 JavaScript 编写复杂逻辑，避免逻辑分散。此外，Helper 函数便于编写测试用例。
 
-它的作用在于我们可以将一些常用的动作抽离在 helper.js 里面成为一个独立的函数，这样可以用 JavaScript 来写复杂的逻辑，避免逻辑分散各处。另外还有一个好处是 Helper 这样一个简单的函数，可以让我们更容易编写测试用例。
-
-框架内置了一些常用的 Helper 函数。我们也可以编写自定义的 Helper 函数。
+框架内置了一些常用的 Helper 函数，同时也支持自定义 Helper 函数。
 
 ### 访问方式
 
-通过 `ctx.helper` 访问到 helper 对象，例如：
+可以通过 `ctx.helper` 访问 helper 对象，例如：
 
 ```js
-// 假设在 app/router.js 中定义了 home router
+// 假设在 app/router.js 中定义了 home 路由
 app.get('home', '/', 'home.index');
 
-// 使用 helper 计算指定 url path
+// 使用 helper 计算指定的 url 路径
 ctx.helper.pathFor('home', { by: 'recent', limit: 20 });
 // => /?by=recent&limit=20
 ```
 
 ### 扩展方式
 
-框架会把 `app/extend/helper.js` 中定义的对象与内置 `helper` 的 prototype 对象进行合并，在处理请求时会基于扩展后的 prototype 生成 `helper` 对象。
+框架会把 `app/extend/helper.js` 中定义的对象与内置 `helper` 的 prototype 对象合并，在处理请求时会基于扩展后的 prototype 生成 `helper` 对象。
 
-例如，增加一个 `helper.foo()` 方法：
+例如，要增加一个 `helper.foo()` 方法：
 
 ```js
 // app/extend/helper.js
 module.exports = {
   foo(param) {
-    // this 是 helper 对象，在其中可以调用其他 helper 方法
+    // this 是 helper 对象，在这里可以调用其他 helper 方法
     // this.ctx => context 对象
     // this.app => application 对象
   },
@@ -222,15 +218,15 @@ module.exports = {
 
 ## 按照环境进行扩展
 
-另外，还可以根据环境进行有选择的扩展，例如，只在 unittest 环境中提供 `mockXX()` 方法以便进行 mock 方便测试。
+可以根据不同的环境选择性地进行扩展。例如，仅在 `unittest` 环境中提供 `mockXX()` 方法，以便于进行 mock 测试。
 
 ```js
 // app/extend/application.unittest.js
 module.exports = {
-  mockXX(k, v) {},
+  mockXX(k, v) {
+    // mock 方法实现
+  },
 };
 ```
 
-这个文件只会在 unittest 环境加载。
-
-同理，对于 Application，Context，Request，Response，Helper 都可以使用这种方式针对某个环境进行扩展，更多参见[运行环境](./env.md)。
+这个文件只会在 `unittest` 环境下加载。类似地，Application、Context、Request、Response 和 Helper 都可以采用这种方式根据特定环境进行扩展。更多信息请参见[运行环境](./env.md)。