修改dto为requestParams

convenient/entity/service.go

@@ -15,7 +15,7 @@ import (
 )
 
 func Create(tableName string, dbExecutor database.Executor, callbacks *Callbacks[string]) binding.ServiceFunc[string] {
-	return func(c *api.Context, dto request.DTO, objects []domain.Object, i *infrastructure.Infrastructure) (string, error) {
+	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (string, error) {
 		e, ok := objects[0].(domain.Entity)
 		if !ok {
 			return "", fserr.New("需要传递领域对象应该为实体")
@@ -55,7 +55,7 @@ func Create(tableName string, dbExecutor database.Executor, callbacks *Callbacks
 }
 
 func Delete(tableName string, dbExecutor database.Executor, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
-	return func(c *api.Context, dto request.DTO, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
+	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
 		e, ok := objects[0].(domain.Entity)
 		if !ok {
 			return nil, fserr.New("需要传递领域对象应该为实体")
@@ -86,7 +86,7 @@ func Delete(tableName string, dbExecutor database.Executor, callbacks *Callbacks
 }
 
 func Update(tableName string, dbExecutor database.Executor, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
-	return func(c *api.Context, dto request.DTO, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
+	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
 		e, ok := objects[0].(domain.Entity)
 		if !ok {
 			return nil, fserr.New("需要传递领域对象应该为实体")
@@ -132,10 +132,10 @@ func Update(tableName string, dbExecutor database.Executor, callbacks *Callbacks
 type ConditionFieldCallback func(conditions *sql.Conditions, fieldName string, columnName string, value any) (hasDeal bool)
 
 func Query[O any](tableName string, dbExecutor database.Executor, callbacks *Callbacks[response.InfosData[O]], conditionFieldCallback ConditionFieldCallback) binding.ServiceFunc[response.InfosData[O]] {
-	return func(c *api.Context, dto request.DTO, objects []domain.Object, i *infrastructure.Infrastructure) (response.InfosData[O], error) {
-		queryDTO, ok := dto.(request.Query)
+	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (response.InfosData[O], error) {
+		queryParams, ok := params.(request.Query)
 		if !ok {
-			return response.InfosData[O]{}, fserr.New("DTO不是Query")
+			return response.InfosData[O]{}, fserr.New("请求参数不是Query接口")
 		}
 
 		e, ok := objects[0].(domain.Entity)
@@ -172,8 +172,8 @@ func Query[O any](tableName string, dbExecutor database.Executor, callbacks *Cal
 		results, totalCount, err := database.Query(dbExecutor, &sql.QueryExecuteParams{
 			TableName:  tableName,
 			Conditions: conditions,
-			PageNo:     queryDTO.GetPageNo(),
-			PageSize:   queryDTO.GetPageSize(),
+			PageNo:     queryParams.GetPageNo(),
+			PageSize:   queryParams.GetPageSize(),
 		})
 		if err != nil {
 			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, response.InfosData[O]{})
@@ -193,7 +193,7 @@ func Query[O any](tableName string, dbExecutor database.Executor, callbacks *Cal
 		output := response.InfosData[O]{
 			Infos:      infos,
 			TotalCount: totalCount,
-			PageNo:     queryDTO.GetPageNo(),
+			PageNo:     queryParams.GetPageNo(),
 		}
 
 		return callbackOnSuccessReturn(callbacks, e, dbExecutor, output)
@@ -201,7 +201,7 @@ func Query[O any](tableName string, dbExecutor database.Executor, callbacks *Cal
 }
 
 func GetByID[O any](tableName string, dbExecutor database.Executor, callbacks *Callbacks[O]) binding.ServiceFunc[O] {
-	return func(c *api.Context, dto request.DTO, objects []domain.Object, i *infrastructure.Infrastructure) (O, error) {
+	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (O, error) {
 		var outputZero O
 		outputZeroValue := reflect.Zero(reflect.TypeOf(outputZero))
 		if outputZeroValue.Kind() == reflect.Pointer {
@@ -254,7 +254,7 @@ func GetByID[O any](tableName string, dbExecutor database.Executor, callbacks *C
 }
 
 func CreateTx(tableName string, dbExecutor database.Executor, callbacks *Callbacks[string]) binding.ServiceFunc[string] {
-	return func(c *api.Context, dto request.DTO, objects []domain.Object, i *infrastructure.Infrastructure) (string, error) {
+	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (string, error) {
 		e, ok := objects[0].(domain.Entity)
 		if !ok {
 			return "", fserr.New("需要传递领域对象应该为实体")
@@ -301,7 +301,7 @@ func CreateTx(tableName string, dbExecutor database.Executor, callbacks *Callbac
 }
 
 func DeleteTx(tableName string, dbExecutor database.Executor, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
-	return func(c *api.Context, dto request.DTO, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
+	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
 		e, ok := objects[0].(domain.Entity)
 		if !ok {
 			return nil, fserr.New("需要传递领域对象应该为实体")
@@ -339,7 +339,7 @@ func DeleteTx(tableName string, dbExecutor database.Executor, callbacks *Callbac
 }
 
 func UpdateTx(tableName string, dbExecutor database.Executor, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
-	return func(c *api.Context, dto request.DTO, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
+	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
 		e, ok := objects[0].(domain.Entity)
 		if !ok {
 			return nil, fserr.New("需要传递领域对象应该为实体")

convenient/entity/simple.go

@@ -1,6 +1,7 @@
 package entity
 
 import (
+	"git.sxidc.com/go-framework/baize/api"
 	"git.sxidc.com/go-framework/baize/binding"
 	"git.sxidc.com/go-framework/baize/binding/request"
 	"git.sxidc.com/go-framework/baize/binding/response"
@@ -16,58 +17,73 @@ type Simple[O any] struct {
 	// 使用的领域实体，注意是Entity类型
 	Entity domain.Entity
 
-	// 表名
-	TableName string
-
 	// 选择要使用的数据库Executor
 	// DBExecutorOperations operations 数据库操作
 	// DBExecutorDataService data_service 数据服务
 	DBExecutorType string
 
-	// URL领域相对路径，如/class，后面会自动补充
-	DomainPath string
+	// 创建使用的请求参数
+	CreateJsonBody request.Params
+
+	// 删除使用的请求参数，注意是WithID类型
+	DeleteQueryParams request.WithID
+
+	// 更新使用的请求参数，注意是WithID类型
+	UpdateJsonBody request.WithID
+
+	// 查询使用的请求参数，注意是Query类型
+	QueryParams request.Query
 
-	// 创建使用的DTO
-	CreateDTO request.DTO
+	// 根据ID查询使用的请求参数，注意是WithID类型
+	GetByIDQueryParams request.WithID
+
+	// 表名
+	tableName string
+
+	// URL领域相对路径，如/class，后面会自动补充
+	domainPath string
 
 	// 创建是否使用事务
-	CreateNeedTx bool
+	createNeedTx bool
 
 	// 创建回调
-	CreateCallbacks *Callbacks[string]
+	createCallbacks *Callbacks[string]
 
-	// 删除使用的DTO，注意是WithID类型
-	DeleteDTO request.WithID
+	// 创建中间件
+	createMiddlewares []api.Handler
 
 	// 删除是否使用事务
-	DeleteNeedTx bool
+	deleteNeedTx bool
 
 	// 删除回调
-	DeleteCallbacks *Callbacks[any]
+	deleteCallbacks *Callbacks[any]
 
-	// 更新使用的DTO，注意是WithID类型
-	UpdateDTO request.WithID
+	// 删除中间件
+	deleteMiddlewares []api.Handler
 
-	// 根性是否使用事务
-	UpdateNeedTx bool
+	// 更新是否使用事务
+	updateNeedTx bool
 
 	// 更新回调
-	UpdateCallbacks *Callbacks[any]
+	updateCallbacks *Callbacks[any]
 
-	// 查询使用的DTO，注意是Query类型
-	QueryDTO request.Query
+	// 更新中间件
+	updateMiddlewares []api.Handler
 
 	// 查询条件构造回调
-	QueryConditionFieldCallback ConditionFieldCallback
+	queryConditionFieldCallback ConditionFieldCallback
 
 	// 查询回调
-	QueryCallbacks *Callbacks[response.InfosData[O]]
+	queryCallbacks *Callbacks[response.InfosData[O]]
 
-	// 根据ID查询使用的DTO，注意是WithID类型
-	GetByIDDTO request.WithID
+	// 查询中间件
+	queryMiddlewares []api.Handler
 
 	// 根据ID查询回调
-	GetByIDCallbacks *Callbacks[O]
+	getByIDCallbacks *Callbacks[O]
+
+	// 根据ID查询中间件
+	getByIDMiddlewares []api.Handler
 }
 
 func (crud *Simple[O]) bind(binder *binding.Binder) {
@@ -76,75 +92,77 @@ func (crud *Simple[O]) bind(binder *binding.Binder) {
 	// 创建
 	if !crud.CreateNeedTx {
 		binding.PostBind(binder, &binding.SimpleBindItem[string]{
-			Path:         crud.DomainPath + "/create",
-			ResponseFunc: response.SendIDResponse[string],
-			DTO:          crud.CreateDTO,
-			Objects:      []domain.Object{crud.Entity},
-			ServiceFunc:  Create(crud.TableName, dbExecutor, crud.CreateCallbacks),
+			Path:          crud.DomainPath + "/create",
+			ResponseFunc:  response.SendIDResponse[string],
+			RequestParams: crud.CreateJsonBody,
+			Objects:       []domain.Object{crud.Entity},
+			ServiceFunc:   Create(crud.TableName, dbExecutor, crud.CreateCallbacks),
 		})
 	} else {
 		binding.PostBind(binder, &binding.SimpleBindItem[string]{
-			Path:         crud.DomainPath + "/create",
-			ResponseFunc: response.SendIDResponse[string],
-			DTO:          crud.CreateDTO,
-			Objects:      []domain.Object{crud.Entity},
-			ServiceFunc:  CreateTx(crud.TableName, dbExecutor, crud.CreateCallbacks),
+			Path:          crud.DomainPath + "/create",
+			ResponseFunc:  response.SendIDResponse[string],
+			RequestParams: crud.CreateJsonBody,
+			Objects:       []domain.Object{crud.Entity},
+			ServiceFunc:   CreateTx(crud.TableName, dbExecutor, crud.CreateCallbacks),
 		})
 	}
 
 	// 删除
 	if !crud.DeleteNeedTx {
 		binding.DeleteBind(binder, &binding.SimpleBindItem[any]{
-			Path:         crud.DomainPath + "/:id/delete",
-			ResponseFunc: response.SendMsgResponse,
-			DTO:          crud.DeleteDTO,
-			Objects:      []domain.Object{crud.Entity},
-			ServiceFunc:  Delete(crud.TableName, dbExecutor, crud.DeleteCallbacks),
+			Path:          crud.DomainPath + "/:id/delete",
+			ResponseFunc:  response.SendMsgResponse,
+			RequestParams: crud.DeleteQueryParams,
+			Objects:       []domain.Object{crud.Entity},
+			ServiceFunc:   Delete(crud.TableName, dbExecutor, crud.DeleteCallbacks),
 		})
 	} else {
 		binding.DeleteBind(binder, &binding.SimpleBindItem[any]{
-			Path:         crud.DomainPath + "/:id/delete",
-			ResponseFunc: response.SendMsgResponse,
-			DTO:          crud.DeleteDTO,
-			Objects:      []domain.Object{crud.Entity},
-			ServiceFunc:  DeleteTx(crud.TableName, dbExecutor, crud.DeleteCallbacks),
+			Path:          crud.DomainPath + "/:id/delete",
+			ResponseFunc:  response.SendMsgResponse,
+			RequestParams: crud.DeleteQueryParams,
+			Objects:       []domain.Object{crud.Entity},
+			ServiceFunc:   DeleteTx(crud.TableName, dbExecutor, crud.DeleteCallbacks),
 		})
 	}
 
 	// 修改
 	if !crud.UpdateNeedTx {
 		binding.PutBind(binder, &binding.SimpleBindItem[any]{
-			Path:         crud.DomainPath + "/update",
-			ResponseFunc: response.SendMsgResponse,
-			DTO:          crud.UpdateDTO,
-			Objects:      []domain.Object{crud.Entity},
-			ServiceFunc:  Update(crud.TableName, dbExecutor, crud.UpdateCallbacks),
+			Path:          crud.DomainPath + "/update",
+			ResponseFunc:  response.SendMsgResponse,
+			RequestParams: crud.UpdateJsonBody,
+			Objects:       []domain.Object{crud.Entity},
+			ServiceFunc:   Update(crud.TableName, dbExecutor, crud.UpdateCallbacks),
 		})
 	} else {
 		binding.PutBind(binder, &binding.SimpleBindItem[any]{
-			Path:         crud.DomainPath + "/update",
-			ResponseFunc: response.SendMsgResponse,
-			DTO:          crud.UpdateDTO,
-			Objects:      []domain.Object{crud.Entity},
-			ServiceFunc:  UpdateTx(crud.TableName, dbExecutor, crud.UpdateCallbacks),
+			Path:          crud.DomainPath + "/update",
+			ResponseFunc:  response.SendMsgResponse,
+			RequestParams: crud.UpdateJsonBody,
+			Objects:       []domain.Object{crud.Entity},
+			ServiceFunc:   UpdateTx(crud.TableName, dbExecutor, crud.UpdateCallbacks),
 		})
 	}
 
 	// 查询
 	binding.GetBind(binder, &binding.SimpleBindItem[response.InfosData[O]]{
-		Path:         crud.DomainPath + "/query",
-		ResponseFunc: response.SendInfosResponse[O],
-		DTO:          crud.QueryDTO,
-		Objects:      []domain.Object{crud.Entity},
-		ServiceFunc:  Query[O](crud.TableName, dbExecutor, crud.QueryCallbacks, crud.QueryConditionFieldCallback),
+		Path:          crud.DomainPath + "/query",
+		ResponseFunc:  response.SendInfosResponse[O],
+		RequestParams: crud.QueryParams,
+		Objects:       []domain.Object{crud.Entity},
+		ServiceFunc:   Query[O](crud.TableName, dbExecutor, crud.QueryCallbacks, crud.QueryConditionFieldCallback),
 	})
 
 	// 通过ID获取
 	binding.GetBind(binder, &binding.SimpleBindItem[O]{
-		Path:         crud.DomainPath + "/get",
-		ResponseFunc: response.SendInfoResponse[O],
-		DTO:          crud.GetByIDDTO,
-		Objects:      []domain.Object{crud.Entity},
-		ServiceFunc:  GetByID[O](crud.TableName, dbExecutor, crud.GetByIDCallbacks),
+		Path:          crud.DomainPath + "/get",
+		ResponseFunc:  response.SendInfoResponse[O],
+		RequestParams: crud.GetByIDQueryParams,
+		Objects:       []domain.Object{crud.Entity},
+		ServiceFunc:   GetByID[O](crud.TableName, dbExecutor, crud.GetByIDCallbacks),
 	})
 }
+
+type Option[O any] func(simple Simple[O])

convenient/value_object/service.go

@@ -15,7 +15,7 @@ import (
 )
 
 func Create(tableName string, dbExecutor database.Executor, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
-	return func(c *api.Context, dto request.DTO, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
+	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
 		valueObject, ok := objects[0].(domain.ValueObject)
 		if !ok {
 			return nil, fserr.New("需要传递领域对象应该为值对象")
@@ -45,7 +45,7 @@ func Create(tableName string, dbExecutor database.Executor, callbacks *Callbacks
 }
 
 func Delete(tableName string, dbExecutor database.Executor, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
-	return func(c *api.Context, dto request.DTO, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
+	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
 		valueObject, ok := objects[0].(domain.ValueObject)
 		if !ok {
 			return nil, fserr.New("需要传递领域对象应该为值对象")
@@ -78,10 +78,10 @@ func Delete(tableName string, dbExecutor database.Executor, callbacks *Callbacks
 type ConditionFieldCallback func(conditions *sql.Conditions, fieldName string, columnName string, value any) (hasDeal bool)
 
 func Query[O any](tableName string, dbExecutor database.Executor, callbacks *Callbacks[response.InfosData[O]], conditionFieldCallback ConditionFieldCallback) binding.ServiceFunc[response.InfosData[O]] {
-	return func(c *api.Context, dto request.DTO, objects []domain.Object, i *infrastructure.Infrastructure) (response.InfosData[O], error) {
-		queryDTO, ok := dto.(request.Query)
+	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (response.InfosData[O], error) {
+		queryParams, ok := params.(request.Query)
 		if !ok {
-			return response.InfosData[O]{}, fserr.New("DTO不是Query")
+			return response.InfosData[O]{}, fserr.New("请求参数不是Query接口")
 		}
 
 		valueObject, ok := objects[0].(domain.ValueObject)
@@ -118,8 +118,8 @@ func Query[O any](tableName string, dbExecutor database.Executor, callbacks *Cal
 		results, totalCount, err := database.Query(dbExecutor, &sql.QueryExecuteParams{
 			TableName:  tableName,
 			Conditions: conditions,
-			PageNo:     queryDTO.GetPageNo(),
-			PageSize:   queryDTO.GetPageSize(),
+			PageNo:     queryParams.GetPageNo(),
+			PageSize:   queryParams.GetPageSize(),
 		})
 		if err != nil {
 			return callbackOnErrorReturn(callbacks, valueObject, err, dbExecutor, response.InfosData[O]{})
@@ -139,7 +139,7 @@ func Query[O any](tableName string, dbExecutor database.Executor, callbacks *Cal
 		output := response.InfosData[O]{
 			Infos:      infos,
 			TotalCount: totalCount,
-			PageNo:     queryDTO.GetPageNo(),
+			PageNo:     queryParams.GetPageNo(),
 		}
 
 		return callbackOnSuccessReturn(callbacks, valueObject, dbExecutor, output)
@@ -147,7 +147,7 @@ func Query[O any](tableName string, dbExecutor database.Executor, callbacks *Cal
 }
 
 func CreateTx(tableName string, dbExecutor database.Executor, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
-	return func(c *api.Context, dto request.DTO, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
+	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
 		valueObject, ok := objects[0].(domain.ValueObject)
 		if !ok {
 			return nil, fserr.New("需要传递领域对象应该为值对象")
@@ -184,7 +184,7 @@ func CreateTx(tableName string, dbExecutor database.Executor, callbacks *Callbac
 }
 
 func DeleteTx(tableName string, dbExecutor database.Executor, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
-	return func(c *api.Context, dto request.DTO, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
+	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
 		valueObject, ok := objects[0].(domain.ValueObject)
 		if !ok {
 			return nil, fserr.New("需要传递领域对象应该为值对象")

convenient/value_object/simple.go

@@ -27,8 +27,8 @@ type Simple[O any] struct {
 	// URL领域相对路径，如/class，后面会自动补充
 	DomainPath string
 
-	// 创建使用的DTO
-	CreateDTO request.DTO
+	// 创建使用的请求参数
+	CreateJsonBody request.Params
 
 	// 创建是否使用事务
 	CreateNeedTx bool
@@ -36,8 +36,8 @@ type Simple[O any] struct {
 	// 创建回调
 	CreateCallbacks *Callbacks[any]
 
-	// 删除使用的DTO，注意是WithID类型
-	DeleteDTO request.WithID
+	// 删除使用的请求参数，注意是WithID类型
+	DeleteQueryParams request.WithID
 
 	// 删除是否使用事务
 	DeleteNeedTx bool
@@ -45,8 +45,8 @@ type Simple[O any] struct {
 	// 删除回调
 	DeleteCallbacks *Callbacks[any]
 
-	// 查询使用的DTO，注意是Query类型
-	QueryDTO request.Query
+	// 查询使用的请求参数，注意是Query类型
+	QueryParams request.Query
 
 	// 查询条件构造回调
 	QueryConditionFieldCallback ConditionFieldCallback
@@ -61,47 +61,47 @@ func (crud *Simple[O]) bind(binder *binding.Binder) {
 	// 创建
 	if !crud.CreateNeedTx {
 		binding.PostBind(binder, &binding.SimpleBindItem[any]{
-			Path:         crud.DomainPath + "/create",
-			ResponseFunc: response.SendMsgResponse,
-			DTO:          crud.CreateDTO,
-			Objects:      []domain.Object{crud.ValueObject},
-			ServiceFunc:  Create(crud.TableName, dbExecutor, crud.CreateCallbacks),
+			Path:          crud.DomainPath + "/create",
+			ResponseFunc:  response.SendMsgResponse,
+			RequestParams: crud.CreateJsonBody,
+			Objects:       []domain.Object{crud.ValueObject},
+			ServiceFunc:   Create(crud.TableName, dbExecutor, crud.CreateCallbacks),
 		})
 	} else {
 		binding.PostBind(binder, &binding.SimpleBindItem[any]{
-			Path:         crud.DomainPath + "/create",
-			ResponseFunc: response.SendMsgResponse,
-			DTO:          crud.CreateDTO,
-			Objects:      []domain.Object{crud.ValueObject},
-			ServiceFunc:  CreateTx(crud.TableName, dbExecutor, crud.CreateCallbacks),
+			Path:          crud.DomainPath + "/create",
+			ResponseFunc:  response.SendMsgResponse,
+			RequestParams: crud.CreateJsonBody,
+			Objects:       []domain.Object{crud.ValueObject},
+			ServiceFunc:   CreateTx(crud.TableName, dbExecutor, crud.CreateCallbacks),
 		})
 	}
 
 	// 删除班级
 	if !crud.DeleteNeedTx {
 		binding.DeleteBind(binder, &binding.SimpleBindItem[any]{
-			Path:         crud.DomainPath + "/:id/delete",
-			ResponseFunc: response.SendMsgResponse,
-			DTO:          crud.DeleteDTO,
-			Objects:      []domain.Object{crud.ValueObject},
-			ServiceFunc:  Delete(crud.TableName, dbExecutor, crud.DeleteCallbacks),
+			Path:          crud.DomainPath + "/:id/delete",
+			ResponseFunc:  response.SendMsgResponse,
+			RequestParams: crud.DeleteQueryParams,
+			Objects:       []domain.Object{crud.ValueObject},
+			ServiceFunc:   Delete(crud.TableName, dbExecutor, crud.DeleteCallbacks),
 		})
 	} else {
 		binding.DeleteBind(binder, &binding.SimpleBindItem[any]{
-			Path:         crud.DomainPath + "/:id/delete",
-			ResponseFunc: response.SendMsgResponse,
-			DTO:          crud.DeleteDTO,
-			Objects:      []domain.Object{crud.ValueObject},
-			ServiceFunc:  DeleteTx(crud.TableName, dbExecutor, crud.DeleteCallbacks),
+			Path:          crud.DomainPath + "/:id/delete",
+			ResponseFunc:  response.SendMsgResponse,
+			RequestParams: crud.DeleteQueryParams,
+			Objects:       []domain.Object{crud.ValueObject},
+			ServiceFunc:   DeleteTx(crud.TableName, dbExecutor, crud.DeleteCallbacks),
 		})
 	}
 
 	// 查询班级
 	binding.GetBind(binder, &binding.SimpleBindItem[response.InfosData[O]]{
-		Path:         crud.DomainPath + "/query",
-		ResponseFunc: response.SendInfosResponse[O],
-		DTO:          crud.QueryDTO,
-		Objects:      []domain.Object{crud.ValueObject},
-		ServiceFunc:  Query(crud.TableName, dbExecutor, crud.QueryCallbacks, crud.QueryConditionFieldCallback),
+		Path:          crud.DomainPath + "/query",
+		ResponseFunc:  response.SendInfosResponse[O],
+		RequestParams: crud.QueryParams,
+		Objects:       []domain.Object{crud.ValueObject},
+		ServiceFunc:   Query(crud.TableName, dbExecutor, crud.QueryCallbacks, crud.QueryConditionFieldCallback),
 	})
 }

binding/bind_item.go

@@ -41,13 +41,13 @@ func (item *BindItem[O]) bind(binder *Binder, middlewares ...api.Handler) {
 	// 给单个路由增加中间件
 	handlers := []api.Handler{
 		func(c *api.Context) {
-			itemDTO := item.DTO
+			params := item.RequestParams
 
 			// 有请求数据
-			if itemDTO != nil {
-				// 将请求数据解析到dto中
-				if item.DTOBindFunc != nil {
-					err := item.DTOBindFunc(c, itemDTO)
+			if params != nil {
+				// 将请求数据解析到请求参数中
+				if item.RequestParamsBindFunc != nil {
+					err := item.RequestParamsBindFunc(c, params)
 					if err != nil {
 						var outputZero O
 						item.ResponseFunc(c, http.StatusBadRequest, outputZero, err)
@@ -58,21 +58,21 @@ func (item *BindItem[O]) bind(binder *Binder, middlewares ...api.Handler) {
 					case http.MethodPost:
 						fallthrough
 					case http.MethodPut:
-						err := request.JsonBody(c, itemDTO)
+						err := request.JsonBody(c, params)
 						if err != nil {
 							var outputZero O
 							item.ResponseFunc(c, http.StatusBadRequest, outputZero, err)
 							return
 						}
 					case http.MethodGet:
-						err := request.QueryParams(c, itemDTO)
+						err := request.QueryParams(c, params)
 						if err != nil {
 							var outputZero O
 							item.ResponseFunc(c, http.StatusBadRequest, outputZero, err)
 							return
 						}
 					case http.MethodDelete:
-						err := request.PathParams(c, itemDTO)
+						err := request.PathParams(c, params)
 						if err != nil {
 							var outputZero O
 							item.ResponseFunc(c, http.StatusBadRequest, outputZero, err)
@@ -85,7 +85,7 @@ func (item *BindItem[O]) bind(binder *Binder, middlewares ...api.Handler) {
 			// 进行领域对象转化
 			var domainObjects []domain.Object
 			if item.FormDomainObjectsFunc != nil {
-				innerDomainObjects, err := item.FormDomainObjectsFunc(c, itemDTO)
+				innerDomainObjects, err := item.FormDomainObjectsFunc(c, params)
 				if err != nil {
 					var outputZero O
 					item.ResponseFunc(c, http.StatusOK, outputZero, err)
@@ -108,7 +108,7 @@ func (item *BindItem[O]) bind(binder *Binder, middlewares ...api.Handler) {
 						}
 
 						obj := reflect.New(reflectutils.PointerTypeElem(objectType)).Interface()
-						err := request.AssignDTOToDomainObject(itemDTO, obj)
+						err := request.AssignRequestParamsToDomainObject(params, obj)
 						if err != nil {
 							var outputZero O
 							item.ResponseFunc(c, http.StatusOK, outputZero, err)
@@ -128,7 +128,7 @@ func (item *BindItem[O]) bind(binder *Binder, middlewares ...api.Handler) {
 				i = item.Infrastructure
 			}
 
-			outputModel, err := item.ServiceFunc(c, itemDTO, domainObjects, i)
+			outputModel, err := item.ServiceFunc(c, params, domainObjects, i)
 			if err != nil {
 				statusCode = fserr.ParseCode(err).HttpCode
 			}

binding/request/common.go

@@ -57,7 +57,7 @@ func (id *IDQuery) GetTenantID() string {
 }
 
 type Query interface {
-	DTO
+	Params
 	GetPageNo() int
 	GetPageSize() int
 }

binding/request/dto.go

@@ -8,63 +8,63 @@ import (
 	"reflect"
 )
 
-type DTO interface{}
+type Params interface{}
 
-func AssignDTOToDomainObject(dto DTO, domainObject domain.Object) error {
-	return assign.DefaultUsage(dto, domainObject)
+func AssignRequestParamsToDomainObject(params Params, domainObject domain.Object) error {
+	return assign.DefaultUsage(params, domainObject)
 }
 
-func Field[T any](dto DTO, fieldName string) (T, error) {
+func Field[T any](params Params, fieldName string) (T, error) {
 	var zero T
 
-	if dto == nil {
-		return zero, fserr.New("DTO为nil")
+	if params == nil {
+		return zero, fserr.New("请求参数为nil")
 	}
 
-	fieldValue, err := getDTOFieldValue(dto, fieldName)
+	fieldValue, err := getRequestParamsValue(params, fieldName)
 	if err != nil {
 		return zero, err
 	}
 
 	if !fieldValue.IsValid() {
-		return zero, fserr.New("dto" + fieldValue.Type().String() + "的字段" + fieldName + "无法赋值")
+		return zero, fserr.New("请求参数" + fieldValue.Type().String() + "的字段" + fieldName + "无法赋值")
 	}
 
 	retValue, ok := fieldValue.Interface().(T)
 	if !ok {
-		return zero, fserr.New("dto" + fieldValue.Type().String() + "的字段" + fieldName + "无法转换类型")
+		return zero, fserr.New("请求参数" + fieldValue.Type().String() + "的字段" + fieldName + "无法转换类型")
 	}
 
 	return retValue, nil
 }
 
-func ToConcrete[T DTO](dto DTO) (T, error) {
+func ToConcrete[T Params](params Params) (T, error) {
 	var zero T
 
-	if dto == nil {
-		return zero, fserr.New("DTO为nil")
+	if params == nil {
+		return zero, fserr.New("请求参数为nil")
 	}
 
-	concrete, ok := dto.(T)
+	concrete, ok := params.(T)
 	if !ok {
-		return zero, fserr.New("DTO转化失败")
+		return zero, fserr.New("请求参数转化失败")
 	}
 
 	return concrete, nil
 }
 
-func getDTOFieldValue(dto DTO, fieldName string) (*reflect.Value, error) {
-	if dto == nil {
-		return nil, fserr.New("DTO为nil")
+func getRequestParamsValue(params Params, fieldName string) (*reflect.Value, error) {
+	if params == nil {
+		return nil, fserr.New("请求参数为nil")
 	}
 
-	dtoValue := reflect.ValueOf(dto)
+	paramsValue := reflect.ValueOf(params)
 
-	if reflectutils.IsValueStructOrStructPointer(dtoValue) {
-		return nil, fserr.New("dto必须是结构或结构指针")
+	if reflectutils.IsValueStructOrStructPointer(paramsValue) {
+		return nil, fserr.New("请求参数必须是结构或结构指针")
 	}
 
-	fieldValue := reflectutils.PointerValueElem(dtoValue).FieldByName(fieldName)
+	fieldValue := reflectutils.PointerValueElem(paramsValue).FieldByName(fieldName)
 
 	return &fieldValue, nil
 }

binding/request/dto_func.go

@@ -5,26 +5,26 @@ import (
 	"github.com/gin-gonic/gin/binding"
 )
 
-func JsonBody(c *api.Context, dto DTO) error {
-	return c.ShouldBindJSON(dto)
+func JsonBody(c *api.Context, params Params) error {
+	return c.ShouldBindJSON(params)
 }
 
-func QueryParams(c *api.Context, dto DTO) error {
-	return c.ShouldBindQuery(dto)
+func QueryParams(c *api.Context, params Params) error {
+	return c.ShouldBindQuery(params)
 }
 
-func PathParams(c *api.Context, dto DTO) error {
-	return c.ShouldBindUri(dto)
+func PathParams(c *api.Context, params Params) error {
+	return c.ShouldBindUri(params)
 }
 
-func MultipartForm(c *api.Context, dto DTO) error {
-	return c.ShouldBindWith(dto, binding.FormMultipart)
+func MultipartForm(c *api.Context, params Params) error {
+	return c.ShouldBindWith(params, binding.FormMultipart)
 }
 
-func FormBody(c *api.Context, dto DTO) error {
-	return c.ShouldBindWith(dto, binding.Form)
+func FormBody(c *api.Context, params Params) error {
+	return c.ShouldBindWith(params, binding.Form)
 }
 
-func XMLBody(c *api.Context, dto DTO) error {
-	return c.ShouldBindXML(dto)
+func XMLBody(c *api.Context, params Params) error {
+	return c.ShouldBindXML(params)
 }

binding/simple_bind_item.go

@@ -24,9 +24,9 @@ func GetBind[O any](binder *Binder, item *SimpleBindItem[O], middlewares ...api.
 	item.bind(binder, http.MethodGet, middlewares...)
 }
 
-type DTOBindFunc func(c *api.Context, dto request.DTO) error
-type FormDomainObjectsFunc func(c *api.Context, dto request.DTO) ([]domain.Object, error)
-type ServiceFunc[O any] func(c *api.Context, dto request.DTO, objects []domain.Object, i *infrastructure.Infrastructure) (O, error)
+type RequestParamsBindFunc func(c *api.Context, params request.Params) error
+type FormDomainObjectsFunc func(c *api.Context, params request.Params) ([]domain.Object, error)
+type ServiceFunc[O any] func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (O, error)
 type ResponseFunc[O any] func(c *api.Context, statusCode int, data O, err error)
 
 // SimpleBindItem 简化的BindItem
@@ -34,18 +34,18 @@ type SimpleBindItem[O any] struct {
 	// URL相对路径
 	Path string
 
-	// 使用的dto，非必传，当dto为nil时，说明该接口没有参数
-	DTO request.DTO
+	// 使用的请求参数，非必传，当请求参数为nil时，说明该接口没有参数
+	RequestParams request.Params
 
-	// 可选的dto绑定函数
+	// 可选的请求参数绑定函数
 	// 非必传，POST和PUT请求默认为JsonBody，DELETE默认为PathParams，GET默认为QueryParams
 	// 额外还提供了一些转化函数：
 	// MultipartForm: 绑定multipart form
 	// FormBody: 绑定form body
 	// XMLBody: 绑定XML body
-	DTOBindFunc DTOBindFunc
+	RequestParamsBindFunc RequestParamsBindFunc
 
-	// 通过DTO构造使用的领域对象，之后在ServiceFunc中会按照构造实体的顺序进行回调
+	// 通过请求参数构造使用的领域对象，之后在ServiceFunc中会按照构造实体的顺序进行回调
 	// 非必传，如果为nil，则说明没有领域对象
 	// 与Objects字段二选一使用，如果都指定，会按照该字段处理
 	FormDomainObjectsFunc FormDomainObjectsFunc

examples/binding/main.go

@@ -147,18 +147,18 @@ func main() {
 		RegisterVersionedRouter("v1")
 
 	entity.BindSimple[ClassInfo](app.Binder("v1"), &entity.Simple[ClassInfo]{
-		Entity:         &Class{},
-		TableName:      tableName,
-		DBExecutorType: binding.DBExecutorOperations,
-		DomainPath:     "/class",
-		CreateDTO:      &CreateClassJsonBody{},
-		CreateNeedTx:   true,
-		DeleteDTO:      &DeleteClassPathParams{},
-		DeleteNeedTx:   false,
-		UpdateDTO:      &UpdateClassJsonBody{},
-		UpdateNeedTx:   false,
-		QueryDTO:       &QueryClassesQueryParams{},
-		GetByIDDTO:     &GetClassQueryParams{},
+		Entity:             &Class{},
+		TableName:          tableName,
+		DBExecutorType:     binding.DBExecutorOperations,
+		DomainPath:         "/class",
+		CreateJsonBody:     &CreateClassJsonBody{},
+		CreateNeedTx:       true,
+		DeleteQueryParams:  &DeleteClassPathParams{},
+		DeleteNeedTx:       false,
+		UpdateJsonBody:     &UpdateClassJsonBody{},
+		UpdateNeedTx:       false,
+		QueryParams:        &QueryClassesQueryParams{},
+		GetByIDQueryParams: &GetClassQueryParams{},
 	})
 
 	go func() {

examples/binding_ds/main.go

@@ -102,18 +102,18 @@ func main() {
 		RegisterVersionedRouter("v1")
 
 	entity.BindSimple[ClassInfo](app.Binder("v1"), &entity.Simple[ClassInfo]{
-		Entity:         &Class{},
-		TableName:      tableName,
-		DBExecutorType: binding.DBExecutorDataService,
-		DomainPath:     "/class",
-		CreateDTO:      &CreateClassJsonBody{},
-		CreateNeedTx:   false,
-		DeleteDTO:      &DeleteClassPathParams{},
-		DeleteNeedTx:   false,
-		UpdateDTO:      &UpdateClassJsonBody{},
-		UpdateNeedTx:   true,
-		QueryDTO:       &QueryClassesQueryParams{},
-		GetByIDDTO:     &GetClassQueryParams{},
+		Entity:             &Class{},
+		TableName:          tableName,
+		DBExecutorType:     binding.DBExecutorDataService,
+		DomainPath:         "/class",
+		CreateJsonBody:     &CreateClassJsonBody{},
+		CreateNeedTx:       false,
+		DeleteQueryParams:  &DeleteClassPathParams{},
+		DeleteNeedTx:       false,
+		UpdateJsonBody:     &UpdateClassJsonBody{},
+		UpdateNeedTx:       true,
+		QueryParams:        &QueryClassesQueryParams{},
+		GetByIDQueryParams: &GetClassQueryParams{},
 	})
 
 	go func() {