完成优化

convenient/domain/configuration/api.go

@@ -27,14 +27,14 @@ func (simple *Simple) bind(binder *binding.Binder) {
 	options := simple.options
 
 	configurationTableName := domain.TableName(simple.Schema, &Entity{})
-	valueObjectOptions := []value_object_crud.Option[any]{value_object_crud.WithDisableQuery[any]()}
+	valueObjectOptions := []any{value_object_crud.WithDisableQuery[any]()}
 
 	if options.disableCreate {
-		valueObjectOptions = append(valueObjectOptions, value_object_crud.WithDisableCreate[any]())
+		valueObjectOptions = append(valueObjectOptions, value_object_crud.WithDisableCreate())
 	}
 
 	if options.disableDelete {
-		valueObjectOptions = append(valueObjectOptions, value_object_crud.WithDisableDelete[any]())
+		valueObjectOptions = append(valueObjectOptions, value_object_crud.WithDisableDelete())
 	}
 
 	value_object_crud.BindSimple(binder, &value_object_crud.Simple[any]{

convenient/value_object_crud/service.go

@@ -15,7 +15,7 @@ import (
 	"reflect"
 )
 
-func Create(tableName string, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
+func Create(tableName string, callbacks *CreateCallbacks) binding.ServiceFunc[any] {
 	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
 		object := objects[0]
 		if object == nil {
@@ -31,12 +31,17 @@ func Create(tableName string, callbacks *Callbacks[any]) binding.ServiceFunc[any
 
 		err := valueObject.ForCreate()
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, valueObject, err, i, nil)
+			return nil, callbackOnCreateErrorReturn(callbacks, valueObject, make(map[string]any), err, i)
 		}
 
-		err = callbackBeforeDBOperate(callbacks, valueObject, i, dbExecutor)
+		prepared, err := callbackPrepareCreate(callbacks, valueObject, i)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, valueObject, err, i, nil)
+			return nil, callbackOnCreateErrorReturn(callbacks, valueObject, make(map[string]any), err, i)
+		}
+
+		err = callbackBeforeCreate(callbacks, valueObject, prepared, i, nil)
+		if err != nil {
+			return nil, callbackOnCreateErrorReturn(callbacks, valueObject, prepared, err, i)
 		}
 
 		err = database.InsertEntity(dbExecutor, tableName, valueObject)
@@ -45,19 +50,19 @@ func Create(tableName string, callbacks *Callbacks[any]) binding.ServiceFunc[any
 				err = fserr.New(valueObject.DomainCNName() + "已存在")
 			}
 
-			return callbackOnErrorReturn(callbacks, valueObject, err, i, nil)
+			return nil, callbackOnCreateErrorReturn(callbacks, valueObject, prepared, err, i)
 		}
 
-		err = callbackAfterDBOperate(callbacks, valueObject, i, dbExecutor)
+		err = callbackAfterCreate(callbacks, valueObject, prepared, i, nil)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, valueObject, err, i, nil)
+			return nil, callbackOnCreateErrorReturn(callbacks, valueObject, prepared, err, i)
 		}
 
-		return callbackOnSuccessReturn(callbacks, valueObject, i, nil)
+		return nil, callbackOnCreateSuccessReturn(callbacks, valueObject, prepared, i)
 	}
 }
 
-func Delete(tableName string, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
+func Delete(tableName string, callbacks *DeleteCallbacks) binding.ServiceFunc[any] {
 	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
 		object := objects[0]
 		if object == nil {
@@ -73,31 +78,36 @@ func Delete(tableName string, callbacks *Callbacks[any]) binding.ServiceFunc[any
 
 		err := valueObject.CheckKeyFields()
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, valueObject, err, i, nil)
+			return nil, callbackOnDeleteErrorReturn(callbacks, valueObject, make(map[string]any), err, i)
 		}
 
-		err = callbackBeforeDBOperate(callbacks, valueObject, i, dbExecutor)
+		prepared, err := callbackPrepareDelete(callbacks, valueObject, i)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, valueObject, err, i, nil)
+			return nil, callbackOnDeleteErrorReturn(callbacks, valueObject, make(map[string]any), err, i)
+		}
+
+		err = callbackBeforeDelete(callbacks, valueObject, prepared, i, nil)
+		if err != nil {
+			return nil, callbackOnDeleteErrorReturn(callbacks, valueObject, make(map[string]any), err, i)
 		}
 
 		err = database.DeleteEntity(dbExecutor, tableName, valueObject)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, valueObject, err, i, nil)
+			return nil, callbackOnDeleteErrorReturn(callbacks, valueObject, make(map[string]any), err, i)
 		}
 
-		err = callbackAfterDBOperate(callbacks, valueObject, i, dbExecutor)
+		err = callbackAfterDelete(callbacks, valueObject, prepared, i, nil)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, valueObject, err, i, nil)
+			return nil, callbackOnDeleteErrorReturn(callbacks, valueObject, make(map[string]any), err, i)
 		}
 
-		return callbackOnSuccessReturn(callbacks, valueObject, i, nil)
+		return nil, callbackOnDeleteSuccessReturn(callbacks, valueObject, prepared, i)
 	}
 }
 
 type ConditionFieldCallback func(conditions *sql.Conditions, fieldName string, columnName string, value any) (hasDeal bool)
 
-func Query[O any](tableName string, callbacks *Callbacks[response.InfosData[O]], conditionFieldCallback ConditionFieldCallback) binding.ServiceFunc[response.InfosData[O]] {
+func Query[O any](tableName string, callbacks *QueryCallbacks[O], conditionFieldCallback ConditionFieldCallback) binding.ServiceFunc[response.InfosData[O]] {
 	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (response.InfosData[O], error) {
 		errResponse := response.InfosData[O]{
 			Infos: make([]O, 0),
@@ -145,9 +155,9 @@ func Query[O any](tableName string, callbacks *Callbacks[response.InfosData[O]],
 			}
 		}
 
-		err = callbackBeforeDBOperate(callbacks, valueObject, i, dbExecutor)
+		err = callbackBeforeQuery(callbacks, valueObject, i)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, valueObject, err, i, errResponse)
+			return callbackOnQueryErrorReturn(callbacks, valueObject, err, i)
 		}
 
 		results, totalCount, err := database.Query(dbExecutor, &sql.QueryExecuteParams{
@@ -157,18 +167,18 @@ func Query[O any](tableName string, callbacks *Callbacks[response.InfosData[O]],
 			PageSize:   queryParams.GetPageSize(),
 		})
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, valueObject, err, i, errResponse)
+			return callbackOnQueryErrorReturn(callbacks, valueObject, err, i)
 		}
 
-		err = callbackAfterDBOperate(callbacks, valueObject, i, dbExecutor)
+		err = callbackAfterQuery(callbacks, valueObject, i)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, valueObject, err, i, errResponse)
+			return callbackOnQueryErrorReturn(callbacks, valueObject, err, i)
 		}
 
 		infos := make([]O, 0)
 		err = sql.ParseSqlResult(results, &infos)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, valueObject, err, i, errResponse)
+			return callbackOnQueryErrorReturn(callbacks, valueObject, err, i)
 		}
 
 		output := response.InfosData[O]{
@@ -177,11 +187,11 @@ func Query[O any](tableName string, callbacks *Callbacks[response.InfosData[O]],
 			PageNo:     queryParams.GetPageNo(),
 		}
 
-		return callbackOnSuccessReturn(callbacks, valueObject, i, output)
+		return callbackOnQuerySuccessReturn(callbacks, valueObject, i, output)
 	}
 }
 
-func CreateTx(tableName string, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
+func CreateTx(tableName string, callbacks *CreateCallbacks) binding.ServiceFunc[any] {
 	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
 		object := objects[0]
 		if object == nil {
@@ -195,8 +205,13 @@ func CreateTx(tableName string, callbacks *Callbacks[any]) binding.ServiceFunc[a
 			return nil, fserr.New("需要传递领域对象应该为值对象")
 		}
 
-		err := database.Transaction(dbExecutor, func(tx database.Executor) error {
-			err := callbackBeforeDBOperate(callbacks, valueObject, i, tx)
+		prepared, err := callbackPrepareCreate(callbacks, valueObject, i)
+		if err != nil {
+			return nil, callbackOnCreateErrorReturn(callbacks, valueObject, make(map[string]any), err, i)
+		}
+
+		err = database.Transaction(dbExecutor, func(tx database.Executor) error {
+			err := callbackBeforeCreate(callbacks, valueObject, prepared, i, tx)
 			if err != nil {
 				return err
 			}
@@ -210,7 +225,7 @@ func CreateTx(tableName string, callbacks *Callbacks[any]) binding.ServiceFunc[a
 				return err
 			}
 
-			err = callbackAfterDBOperate(callbacks, valueObject, i, tx)
+			err = callbackAfterCreate(callbacks, valueObject, prepared, i, tx)
 			if err != nil {
 				return err
 			}
@@ -218,14 +233,14 @@ func CreateTx(tableName string, callbacks *Callbacks[any]) binding.ServiceFunc[a
 			return nil
 		})
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, valueObject, err, i, nil)
+			return nil, callbackOnCreateErrorReturn(callbacks, valueObject, prepared, err, i)
 		}
 
-		return callbackOnSuccessReturn(callbacks, valueObject, i, nil)
+		return nil, callbackOnCreateSuccessReturn(callbacks, valueObject, prepared, i)
 	}
 }
 
-func DeleteTx(tableName string, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
+func DeleteTx(tableName string, callbacks *DeleteCallbacks) binding.ServiceFunc[any] {
 	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
 		object := objects[0]
 		if object == nil {
@@ -241,11 +256,16 @@ func DeleteTx(tableName string, callbacks *Callbacks[any]) binding.ServiceFunc[a
 
 		err := valueObject.CheckKeyFields()
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, valueObject, err, i, nil)
+			return nil, callbackOnDeleteErrorReturn(callbacks, valueObject, make(map[string]any), err, i)
+		}
+
+		prepared, err := callbackPrepareDelete(callbacks, valueObject, i)
+		if err != nil {
+			return nil, callbackOnDeleteErrorReturn(callbacks, valueObject, make(map[string]any), err, i)
 		}
 
 		err = database.Transaction(dbExecutor, func(tx database.Executor) error {
-			err = callbackBeforeDBOperate(callbacks, valueObject, i, tx)
+			err = callbackBeforeDelete(callbacks, valueObject, prepared, i, tx)
 			if err != nil {
 				return err
 			}
@@ -255,7 +275,7 @@ func DeleteTx(tableName string, callbacks *Callbacks[any]) binding.ServiceFunc[a
 				return err
 			}
 
-			err = callbackAfterDBOperate(callbacks, valueObject, i, tx)
+			err = callbackAfterDelete(callbacks, valueObject, prepared, i, tx)
 			if err != nil {
 				return err
 			}
@@ -263,9 +283,9 @@ func DeleteTx(tableName string, callbacks *Callbacks[any]) binding.ServiceFunc[a
 			return nil
 		})
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, valueObject, err, i, nil)
+			return nil, callbackOnDeleteErrorReturn(callbacks, valueObject, prepared, err, i)
 		}
 
-		return callbackOnSuccessReturn(callbacks, valueObject, i, nil)
+		return nil, callbackOnDeleteSuccessReturn(callbacks, valueObject, prepared, i)
 	}
 }

convenient/value_object_crud/service_callbacks.go

@@ -1,62 +1,203 @@
 package value_object_crud
 
 import (
+	"git.sxidc.com/go-framework/baize/framework/binding/response"
 	"git.sxidc.com/go-framework/baize/framework/core/domain/value_object"
 	"git.sxidc.com/go-framework/baize/framework/core/infrastructure"
 	"git.sxidc.com/go-framework/baize/framework/core/infrastructure/database"
 )
 
-type Callbacks[O any] struct {
-	BeforeDBOperate func(valueObject value_object.ValueObject, i *infrastructure.Infrastructure, dbExecutor database.Executor) error
-	AfterDBOperate  func(valueObject value_object.ValueObject, i *infrastructure.Infrastructure, dbExecutor database.Executor) error
-	OnSuccessReturn func(valueObject value_object.ValueObject, i *infrastructure.Infrastructure, output O) (O, error)
-	OnErrorReturn   func(valueObject value_object.ValueObject, err error, i *infrastructure.Infrastructure, defaultErrOutput O) (O, error)
+type CreateCallbacks struct {
+	Prepare         func(valueObject value_object.ValueObject, i *infrastructure.Infrastructure) (map[string]any, error)
+	Before          func(valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error
+	After           func(valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error
+	OnSuccessReturn func(valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure) error
+	OnErrorReturn   func(valueObject value_object.ValueObject, prepared map[string]any, err error, i *infrastructure.Infrastructure) error
 }
 
-func callbackBeforeDBOperate[O any](callbacks *Callbacks[O], valueObject value_object.ValueObject, i *infrastructure.Infrastructure, dbExecutor database.Executor) error {
+func callbackPrepareCreate(callbacks *CreateCallbacks, valueObject value_object.ValueObject, i *infrastructure.Infrastructure) (map[string]any, error) {
+	if callbacks == nil {
+		return make(map[string]any), nil
+	}
+
+	if callbacks.Prepare == nil {
+		return make(map[string]any), nil
+	}
+
+	return callbacks.Prepare(valueObject, i)
+}
+
+func callbackBeforeCreate(callbacks *CreateCallbacks, valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
 	if callbacks == nil {
 		return nil
 	}
 
-	if callbacks.BeforeDBOperate != nil {
-		return callbacks.BeforeDBOperate(valueObject, i, dbExecutor)
+	if callbacks.Before == nil {
+		return nil
 	}
 
-	return nil
+	return callbacks.Before(valueObject, prepared, i, tx)
 }
 
-func callbackAfterDBOperate[O any](callbacks *Callbacks[O], valueObject value_object.ValueObject, i *infrastructure.Infrastructure, dbExecutor database.Executor) error {
+func callbackAfterCreate(callbacks *CreateCallbacks, valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
 	if callbacks == nil {
 		return nil
 	}
 
-	if callbacks.AfterDBOperate != nil {
-		return callbacks.AfterDBOperate(valueObject, i, dbExecutor)
+	if callbacks.After == nil {
+		return nil
 	}
 
-	return nil
+	return callbacks.After(valueObject, prepared, i, tx)
 }
 
-func callbackOnSuccessReturn[O any](callbacks *Callbacks[O], valueObject value_object.ValueObject, i *infrastructure.Infrastructure, output O) (O, error) {
+func callbackOnCreateSuccessReturn(callbacks *CreateCallbacks, valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure) error {
+	if callbacks == nil {
+		return nil
+	}
+
+	if callbacks.OnSuccessReturn == nil {
+		return nil
+	}
+
+	return callbacks.OnSuccessReturn(valueObject, prepared, i)
+}
+
+func callbackOnCreateErrorReturn(callbacks *CreateCallbacks, valueObject value_object.ValueObject, prepared map[string]any, err error, i *infrastructure.Infrastructure) error {
+	if callbacks == nil {
+		return err
+	}
+
+	if callbacks.OnErrorReturn == nil {
+		return err
+	}
+
+	return callbacks.OnErrorReturn(valueObject, prepared, err, i)
+}
+
+type DeleteCallbacks struct {
+	Prepare         func(valueObject value_object.ValueObject, i *infrastructure.Infrastructure) (map[string]any, error)
+	Before          func(valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error
+	After           func(valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error
+	OnSuccessReturn func(valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure) error
+	OnErrorReturn   func(valueObject value_object.ValueObject, prepared map[string]any, err error, i *infrastructure.Infrastructure) error
+}
+
+func callbackPrepareDelete(callbacks *DeleteCallbacks, valueObject value_object.ValueObject, i *infrastructure.Infrastructure) (map[string]any, error) {
+	if callbacks == nil {
+		return make(map[string]any), nil
+	}
+
+	if callbacks.Prepare == nil {
+		return make(map[string]any), nil
+	}
+
+	return callbacks.Prepare(valueObject, i)
+}
+
+func callbackBeforeDelete(callbacks *DeleteCallbacks, valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
+	if callbacks == nil {
+		return nil
+	}
+
+	if callbacks.Before == nil {
+		return nil
+	}
+
+	return callbacks.Before(valueObject, prepared, i, tx)
+}
+
+func callbackAfterDelete(callbacks *DeleteCallbacks, valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
+	if callbacks == nil {
+		return nil
+	}
+
+	if callbacks.After == nil {
+		return nil
+	}
+
+	return callbacks.After(valueObject, prepared, i, tx)
+}
+
+func callbackOnDeleteSuccessReturn(callbacks *DeleteCallbacks, valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure) error {
+	if callbacks == nil {
+		return nil
+	}
+
+	if callbacks.OnSuccessReturn == nil {
+		return nil
+	}
+
+	return callbacks.OnSuccessReturn(valueObject, prepared, i)
+}
+
+func callbackOnDeleteErrorReturn(callbacks *DeleteCallbacks, valueObject value_object.ValueObject, prepared map[string]any, err error, i *infrastructure.Infrastructure) error {
+	if callbacks == nil {
+		return err
+	}
+
+	if callbacks.OnErrorReturn == nil {
+		return err
+	}
+
+	return callbacks.OnErrorReturn(valueObject, prepared, err, i)
+}
+
+type QueryCallbacks[O any] struct {
+	Before          func(valueObject value_object.ValueObject, i *infrastructure.Infrastructure) error
+	After           func(valueObject value_object.ValueObject, i *infrastructure.Infrastructure) error
+	OnSuccessReturn func(valueObject value_object.ValueObject, i *infrastructure.Infrastructure, output response.InfosData[O]) (response.InfosData[O], error)
+	OnErrorReturn   func(valueObject value_object.ValueObject, err error, i *infrastructure.Infrastructure) (response.InfosData[O], error)
+}
+
+func callbackBeforeQuery[O any](callbacks *QueryCallbacks[O], valueObject value_object.ValueObject, i *infrastructure.Infrastructure) error {
+	if callbacks == nil {
+		return nil
+	}
+
+	if callbacks.Before == nil {
+		return nil
+	}
+
+	return callbacks.Before(valueObject, i)
+}
+
+func callbackAfterQuery[O any](callbacks *QueryCallbacks[O], valueObject value_object.ValueObject, i *infrastructure.Infrastructure) error {
+	if callbacks == nil {
+		return nil
+	}
+
+	if callbacks.After == nil {
+		return nil
+	}
+
+	return callbacks.After(valueObject, i)
+}
+
+func callbackOnQuerySuccessReturn[O any](callbacks *QueryCallbacks[O], valueObject value_object.ValueObject, i *infrastructure.Infrastructure, output response.InfosData[O]) (response.InfosData[O], error) {
 	if callbacks == nil {
 		return output, nil
 	}
 
-	if callbacks.OnSuccessReturn != nil {
-		return callbacks.OnSuccessReturn(valueObject, i, output)
+	if callbacks.OnSuccessReturn == nil {
+		return output, nil
 	}
 
-	return output, nil
+	return callbacks.OnSuccessReturn(valueObject, i, output)
 }
 
-func callbackOnErrorReturn[O any](callbacks *Callbacks[O], valueObject value_object.ValueObject, err error, i *infrastructure.Infrastructure, defaultErrOutput O) (O, error) {
+func callbackOnQueryErrorReturn[O any](callbacks *QueryCallbacks[O], valueObject value_object.ValueObject, err error, i *infrastructure.Infrastructure) (response.InfosData[O], error) {
 	if callbacks == nil {
-		return defaultErrOutput, err
+		return response.InfosData[O]{
+			Infos: make([]O, 0),
+		}, err
 	}
 
-	if callbacks.OnErrorReturn != nil {
-		return callbacks.OnErrorReturn(valueObject, err, i, defaultErrOutput)
+	if callbacks.OnErrorReturn == nil {
+		return response.InfosData[O]{
+			Infos: make([]O, 0),
+		}, err
 	}
 
-	return defaultErrOutput, err
+	return callbacks.OnErrorReturn(valueObject, err, i)
 }

convenient/value_object_crud/simple.go

@@ -28,24 +28,28 @@ type Simple[I any] struct {
 	QueryQueryParams request.QueryRequestParams
 
 	// 可选配置项，通过WithXXX配置
-	options *Options[I]
+	creatOptions  *CreateOptions
+	deleteOptions *DeleteOptions
+	queryOptions  *QueryOptions[I]
 }
 
 func (simple *Simple[I]) bind(binder *binding.Binder) {
-	options := simple.options
+	createOptions := simple.creatOptions
+	deleteOptions := simple.deleteOptions
+	queryOptions := simple.queryOptions
 
 	tableName := domain.TableName(simple.Schema, simple.ValueObject)
 	domainPath := domain.RelativeDomainPath(simple.ValueObject)
 
 	// 创建
-	if !options.disableCreate {
-		if !options.createNeedTx {
+	if !createOptions.disableCreate {
+		if !createOptions.createNeedTx {
 			binding.PostBind(binder, &binding.SimpleBindItem[any]{
 				Path:          domainPath + "/create",
 				ResponseFunc:  response.SendMsgResponse,
 				RequestParams: simple.CreateJsonBody,
 				Objects:       []domain.Object{simple.ValueObject},
-				ServiceFunc:   Create(tableName, options.createCallbacks),
+				ServiceFunc:   Create(tableName, createOptions.createCallbacks),
 			})
 		} else {
 			binding.PostBind(binder, &binding.SimpleBindItem[any]{
@@ -53,21 +57,21 @@ func (simple *Simple[I]) bind(binder *binding.Binder) {
 				ResponseFunc:  response.SendMsgResponse,
 				RequestParams: simple.CreateJsonBody,
 				Objects:       []domain.Object{simple.ValueObject},
-				ServiceFunc:   CreateTx(tableName, options.createCallbacks),
+				ServiceFunc:   CreateTx(tableName, createOptions.createCallbacks),
 			})
 		}
 	}
 
 	// 删除
-	if !options.disableDelete {
-		if !options.deleteNeedTx {
+	if !deleteOptions.disableDelete {
+		if !deleteOptions.deleteNeedTx {
 			binding.PostBind(binder, &binding.SimpleBindItem[any]{
 				Path:                  domainPath + "/delete",
 				ResponseFunc:          response.SendMsgResponse,
 				RequestParams:         simple.DeleteJsonBody,
 				RequestParamsBindFunc: request.JsonBody,
 				Objects:               []domain.Object{simple.ValueObject},
-				ServiceFunc:           Delete(tableName, options.deleteCallbacks),
+				ServiceFunc:           Delete(tableName, deleteOptions.deleteCallbacks),
 			})
 		} else {
 			binding.PostBind(binder, &binding.SimpleBindItem[any]{
@@ -76,38 +80,53 @@ func (simple *Simple[I]) bind(binder *binding.Binder) {
 				RequestParams:         simple.DeleteJsonBody,
 				RequestParamsBindFunc: request.JsonBody,
 				Objects:               []domain.Object{simple.ValueObject},
-				ServiceFunc:           DeleteTx(tableName, options.deleteCallbacks),
+				ServiceFunc:           DeleteTx(tableName, deleteOptions.deleteCallbacks),
 			})
 		}
 	}
 
 	// 查询
-	if !options.disableQuery {
+	if !queryOptions.disableQuery {
 		binding.GetBind(binder, &binding.SimpleBindItem[response.InfosData[I]]{
 			Path:          domainPath + "/query",
 			ResponseFunc:  response.SendInfosResponse[I],
 			RequestParams: simple.QueryQueryParams,
 			Objects:       []domain.Object{simple.ValueObject},
-			ServiceFunc:   Query(tableName, options.queryCallbacks, options.queryConditionFieldCallback),
+			ServiceFunc:   Query(tableName, queryOptions.queryCallbacks, queryOptions.queryConditionFieldCallback),
 		})
 	}
 }
 
-func BindSimple[I any](binder *binding.Binder, simple *Simple[I], opts ...Option[I]) {
-	options := new(Options[I])
+func BindSimple[I any](binder *binding.Binder, simple *Simple[I], opts ...any) {
+	createOptions := new(CreateOptions)
+	deleteOptions := new(DeleteOptions)
+	queryOptions := new(QueryOptions[I])
 
 	for _, opt := range opts {
-		opt(options)
+		switch o := opt.(type) {
+		case CreateOption:
+			o(createOptions)
+		case DeleteOption:
+			o(deleteOptions)
+		case QueryOption[I]:
+			o(queryOptions)
+		default:
+			continue
+		}
 	}
 
-	simple.options = options
+	simple.creatOptions = createOptions
+	simple.deleteOptions = deleteOptions
+	simple.queryOptions = queryOptions
 
 	simple.bind(binder)
 }
 
-type Option[I any] func(options *Options[I])
+type CreateOption func(options *CreateOptions)
+type DeleteOption func(options *DeleteOptions)
+type QueryOption[I any] func(options *QueryOptions[I])
 
-type Options[I any] struct {
+type CreateOptions struct {
 	// 关闭创建
 	disableCreate bool
 
@@ -115,11 +134,13 @@ type Options[I any] struct {
 	createNeedTx bool
 
 	// 创建回调
-	createCallbacks *Callbacks[any]
+	createCallbacks *CreateCallbacks
 
 	// 创建中间件
 	createMiddlewares []api.Handler
+}
 
+type DeleteOptions struct {
 	// 关闭删除
 	disableDelete bool
 
@@ -127,11 +148,13 @@ type Options[I any] struct {
 	deleteNeedTx bool
 
 	// 删除回调
-	deleteCallbacks *Callbacks[any]
+	deleteCallbacks *DeleteCallbacks
 
 	// 删除中间件
 	deleteMiddlewares []api.Handler
+}
 
+type QueryOptions[I any] struct {
 	// 关闭查询
 	disableQuery bool
 
@@ -139,80 +162,80 @@ type Options[I any] struct {
 	queryConditionFieldCallback ConditionFieldCallback
 
 	// 查询回调
-	queryCallbacks *Callbacks[response.InfosData[I]]
+	queryCallbacks *QueryCallbacks[I]
 
 	// 查询中间件
 	queryMiddlewares []api.Handler
 }
 
-func WithDisableCreate[I any]() Option[I] {
-	return func(options *Options[I]) {
+func WithDisableCreate() CreateOption {
+	return func(options *CreateOptions) {
 		options.disableCreate = true
 	}
 }
 
-func WithCreateTx[I any]() Option[I] {
-	return func(options *Options[I]) {
+func WithCreateTx() CreateOption {
+	return func(options *CreateOptions) {
 		options.createNeedTx = true
 	}
 }
 
-func WithCreateCallbacks[I any](callbacks *Callbacks[any]) Option[I] {
-	return func(options *Options[I]) {
+func WithCreateCallbacks(callbacks *CreateCallbacks) CreateOption {
+	return func(options *CreateOptions) {
 		options.createCallbacks = callbacks
 	}
 }
 
-func WithCreateMiddlewares[I any](middlewares []api.Handler) Option[I] {
-	return func(options *Options[I]) {
+func WithCreateMiddlewares(middlewares []api.Handler) CreateOption {
+	return func(options *CreateOptions) {
 		options.createMiddlewares = middlewares
 	}
 }
 
-func WithDisableDelete[I any]() Option[I] {
-	return func(options *Options[I]) {
+func WithDisableDelete() DeleteOption {
+	return func(options *DeleteOptions) {
 		options.disableDelete = true
 	}
 }
 
-func WithDeleteTx[I any]() Option[I] {
-	return func(options *Options[I]) {
+func WithDeleteTx() DeleteOption {
+	return func(options *DeleteOptions) {
 		options.deleteNeedTx = true
 	}
 }
 
-func WithDeleteCallbacks[I any](callbacks *Callbacks[any]) Option[I] {
-	return func(options *Options[I]) {
+func WithDeleteCallbacks(callbacks *DeleteCallbacks) DeleteOption {
+	return func(options *DeleteOptions) {
 		options.deleteCallbacks = callbacks
 	}
 }
 
-func WithDeleteMiddlewares[I any](middlewares []api.Handler) Option[I] {
-	return func(options *Options[I]) {
+func WithDeleteMiddlewares(middlewares []api.Handler) DeleteOption {
+	return func(options *DeleteOptions) {
 		options.deleteMiddlewares = middlewares
 	}
 }
 
-func WithDisableQuery[I any]() Option[I] {
-	return func(options *Options[I]) {
+func WithDisableQuery[I any]() QueryOption[I] {
+	return func(options *QueryOptions[I]) {
 		options.disableQuery = true
 	}
 }
 
-func WithQueryConditionFieldCallback[I any](callback ConditionFieldCallback) Option[I] {
-	return func(options *Options[I]) {
+func WithQueryConditionFieldCallback[I any](callback ConditionFieldCallback) QueryOption[I] {
+	return func(options *QueryOptions[I]) {
 		options.queryConditionFieldCallback = callback
 	}
 }
 
-func WithQueryCallbacks[I any](callbacks *Callbacks[response.InfosData[I]]) Option[I] {
-	return func(options *Options[I]) {
+func WithQueryCallbacks[I any](callbacks *QueryCallbacks[I]) QueryOption[I] {
+	return func(options *QueryOptions[I]) {
 		options.queryCallbacks = callbacks
 	}
 }
 
-func WithQueryMiddlewares[I any](middlewares []api.Handler) Option[I] {
-	return func(options *Options[I]) {
+func WithQueryMiddlewares[I any](middlewares []api.Handler) QueryOption[I] {
+	return func(options *QueryOptions[I]) {
 		options.queryMiddlewares = middlewares
 	}
 }