diff --git a/.idea/GOHCache.xml b/.idea/GOHCache.xml
index facb2de..2bdc17b 100644
--- a/.idea/GOHCache.xml
+++ b/.idea/GOHCache.xml
@@ -3,6 +3,20 @@
   <component name="GoORMHelperCache">
     <option name="schemaMapping">
       <map>
+        <entry key="Api">
+          <value>
+            <set>
+              <option value="file://$PROJECT_DIR$/response/code.go" />
+            </set>
+          </value>
+        </entry>
+        <entry key="ApiFile">
+          <value>
+            <set>
+              <option value="file://$PROJECT_DIR$/response/code.go" />
+            </set>
+          </value>
+        </entry>
         <entry key="BaseConfig">
           <value>
             <set>
@@ -143,6 +157,20 @@
             </set>
           </value>
         </entry>
+        <entry key="apiFile">
+          <value>
+            <set>
+              <option value="file://$PROJECT_DIR$/response/code.go" />
+            </set>
+          </value>
+        </entry>
+        <entry key="resFile">
+          <value>
+            <set>
+              <option value="file://$PROJECT_DIR$/response/code.go" />
+            </set>
+          </value>
+        </entry>
         <entry key="response">
           <value>
             <set>
@@ -157,7 +185,7 @@
         <entry key="file://$PROJECT_DIR$/config/fun.go">
           <value>
             <ScannedPath>
-              <option name="lastModified" value="1770427966184" />
+              <option name="lastModified" value="1772004328410" />
             </ScannedPath>
           </value>
         </entry>
@@ -260,11 +288,13 @@
         <entry key="file://$PROJECT_DIR$/response/code.go">
           <value>
             <ScannedPath>
-              <option name="lastModified" value="1770444657704" />
+              <option name="lastModified" value="1772068030461" />
               <option name="schema">
                 <list>
                   <option value="response" />
-                  <option value="api" />
+                  <option value="Api" />
+                  <option value="resFile" />
+                  <option value="ApiFile" />
                 </list>
               </option>
             </ScannedPath>
@@ -425,7 +455,8 @@
     </option>
     <option name="tableStructMapping">
       <map>
-        <entry key="api" value="api" />
+        <entry key="api" value="Api" />
+        <entry key="api_file" value="ApiFile" />
         <entry key="base_config" value="BaseConfig" />
         <entry key="client" value="Client" />
         <entry key="config" value="Config" />
@@ -440,6 +471,7 @@
         <entry key="news_one" value="NewsOne" />
         <entry key="news_save" value="NewsSave" />
         <entry key="paginate" value="Paginate" />
+        <entry key="res_file" value="resFile" />
         <entry key="response" value="response" />
         <entry key="server_config" value="ServerConfig" />
         <entry key="tcp_connection" value="TcpConnection" />
diff --git a/response/code.go b/response/code.go
index bc403ae..315f85e 100644
--- a/response/code.go
+++ b/response/code.go
@@ -6,78 +6,158 @@ import (
 	"github.com/gin-gonic/gin"
 )
 
+// response 是 API 响应的数据结构体
 type response struct {
-	Code      int    `json:"code"`
-	Msg       string `json:"msg"`
-	Data      any    `json:"data"`
-	Timestamp int64  `json:"timestamp"`
+	Code      int    `json:"code"`      // 状态码
+	Msg       string `json:"msg"`       // 响应消息
+	Data      any    `json:"data"`      // 响应数据
+	Timestamp int64  `json:"timestamp"` // 响应时间戳
 }
 
-// api 返回结构体
-type api struct {
-	JSON *response
-	c    *gin.Context
+// Api 返回结构体
+// Api 是 Gin 上下文的响应包装器
+type Api struct {
+	JSON *response    // JSON 响应数据
+	c    *gin.Context // Gin 上下文对象
 }
 
-// Success 函数用于创建一个包含成功响应的 api 对象。
-// 参数 c 是 Gin 框架的上下文对象，用于处理请求和响应。
-// 返回值是一个指向 API 结构体的指针，其中包含 JSON 响应数据。
-func Success(c *gin.Context) *api {
-	// 创建响应结构体，包含状态码和时间戳
-	json := &response{
-		Code:      200,               // 成功的状态码
-		Timestamp: time.Now().Unix(), // 当前时间的时间戳
-	}
-	// 创建 api 结构体实例，并将响应数据和上下文对象赋值给它
-	r := &api{
-		JSON: json, // JSON 响应数据
-		c:    c,    // Gin 上下文对象
-	}
-	return r // 返回 api 对象的指针
+// resFile 是文件响应的数据结构体
+type resFile struct {
+	Code        int    `json:"code"`         // 状态码
+	ContentType string `json:"content_type"` // 内容类型
+	Data        []byte `json:"data"`         // 文件数据
 }
 
-// Error 函数用于创建一个包含错误响应的 api 对象。
-// 参数 c 是 Gin 框架的上下文对象，用于处理请求和响应。
-// 返回值是一个指向 api 结构体的指针，其中包含 JSON 响应数据。
-func Error(c *gin.Context) *api {
-	json := &response{
-		Code:      200,
-		Timestamp: time.Now().Unix(),
+// ApiFile 是 Gin 上下文的文件响应包装器
+type ApiFile struct {
+	JSON *resFile     // 文件响应数据
+	c    *gin.Context // Gin 上下文对象
+}
+
+// SuccessFile 创建一个包含成功响应的 ApiFile 对象
+// 参数 c 是 Gin 框架的上下文对象
+// 返回值是指向 ApiFile 结构体的指针
+func SuccessFile(c *gin.Context) *ApiFile {
+	json := &resFile{
+		Code: 200,
 	}
-	r := &api{
+	r := &ApiFile{
 		JSON: json,
 		c:    c,
 	}
 	return r
 }
 
-// SetMsg 方法用于设置 api 对象的 JSON 响应数据中的 Msg 字段。
-// 参数 msg 是要设置的消息字符串。
-// 返回值是指向 api 结构体的指针，用于链式调用。
-func (r *api) SetMsg(msg string) *api {
+// SetContentType 设置文件响应的内容类型
+// 参数 contentType 是要设置的 MIME 类型字符串
+// 返回值是指向 ApiFile 结构体的指针，用于链式调用
+func (af *ApiFile) SetContentType(contentType string) *ApiFile {
+	af.JSON.ContentType = contentType
+	return af
+}
+
+func (af *ApiFile) SetPng(data []byte) *ApiFile {
+	af.SetContentType("image/png")
+	af.SetData(data)
+	return af
+}
+
+func (af *ApiFile) SetJpeg(data []byte) *ApiFile {
+	af.SetContentType("image/jpeg")
+	af.SetData(data)
+	return af
+}
+
+func (af *ApiFile) SetGif(data []byte) *ApiFile {
+	af.SetContentType("image/gif")
+	af.SetData(data)
+	return af
+}
+
+func (af *ApiFile) SetPdf(data []byte) *ApiFile {
+	af.SetContentType("application/pdf")
+	af.SetData(data)
+	return af
+}
+
+func (af *ApiFile) SetXls(data []byte) *ApiFile {
+	af.SetContentType("application/vnd.ms-excel")
+	af.SetData(data)
+	return af
+}
+
+// SetData 设置文件响应的数据
+// 参数 data 是要设置的字节数据
+// 返回值是指向 ApiFile 结构体的指针，用于链式调用
+func (af *ApiFile) SetData(data []byte) *ApiFile {
+	af.JSON.Data = data
+	return af
+}
+
+// End 将文件响应数据发送给客户端
+// 使用 Gin 上下文对象的 Data 方法发送原始数据
+func (af *ApiFile) End() {
+	af.c.Data(af.JSON.Code, af.JSON.ContentType, af.JSON.Data)
+}
+
+// Success 函数用于创建一个包含成功响应的 api 对象。
+// 参数 c 是 Gin 框架的上下文对象，用于处理请求和响应。
+// 返回值是一个指向 API 结构体的指针，其中包含 JSON 响应数据。
+func Success(c *gin.Context) *Api {
+	// 创建响应结构体，包含状态码和时间戳
+	json := &response{
+		Code:      200,               // 成功的状态码
+		Timestamp: time.Now().Unix(), // 当前时间的时间戳
+	}
+	// 创建 api 结构体实例，并将响应数据和上下文对象赋值给它
+	r := &Api{
+		JSON: json, // JSON 响应数据
+		c:    c,    // Gin 上下文对象
+	}
+	return r // 返回 api 对象的指针
+}
+
+// Error 创建一个包含错误响应的 Api 对象
+// 参数 c 是 Gin 框架的上下文对象
+// 返回值是指向 Api 结构体的指针
+func Error(c *gin.Context) *Api {
+	json := &response{
+		Code:      200,
+		Timestamp: time.Now().Unix(),
+	}
+	r := &Api{
+		JSON: json,
+		c:    c,
+	}
+	return r
+}
+
+// SetMsg 设置响应的消息
+// 参数 msg 是要设置的消息字符串
+// 返回值是指向 Api 结构体的指针，用于链式调用
+func (r *Api) SetMsg(msg string) *Api {
 	r.JSON.Msg = msg
 	return r
 }
 
-// SetData 方法用于设置 api 对象的 JSON 响应数据中的 Data 字段。
-// 参数 data 是要设置的数据，类型为 any（任意类型）。
-// 返回值是指向 api 结构体的指针，用于链式调用。
-func (r *api) SetData(data any) *api {
+// SetData 设置响应的数据
+// 参数 data 是要设置的数据，类型为 any（任意类型）
+// 返回值是指向 Api 结构体的指针，用于链式调用
+func (r *Api) SetData(data any) *Api {
 	r.JSON.Data = data
 	return r
 }
 
-// SetCode 方法用于设置 api 对象的 JSON 响应数据中的 Code 字段。
-// 参数 code 是要设置的状态码，类型为 int。
-// 返回值是指向 api 结构体的指针，用于链式调用。
-func (r *api) SetCode(code int) *api {
+// SetCode 设置响应的状态码
+// 参数 code 是要设置的状态码
+// 返回值是指向 Api 结构体的指针，用于链式调用
+func (r *Api) SetCode(code int) *Api {
 	r.JSON.Code = code
 	return r
 }
 
-// End 方法用于将 api 对象的 JSON 响应数据发送给客户端。
-// 它使用 Gin 上下文对象的 JSON 方法将 JSON 响应数据发送给客户端。
-// 参数 r 是指向 api 结构体的指针，包含 JSON 响应数据和 Gin 上下文对象。
-func (r *api) End() {
+// End 将 JSON 响应数据发送给客户端
+// 使用 Gin 上下文对象的 JSON 方法发送响应
+func (r *Api) End() {
 	r.c.JSON(r.JSON.Code, r.JSON)
 }