修改函数

binding/binder.go

@@ -3,7 +3,6 @@ package binding
 import (
 	"git.sxidc.com/go-framework/baize/api"
 	"git.sxidc.com/go-framework/baize/infrastructure"
-	"git.sxidc.com/go-framework/baize/infrastructure/database"
 )
 
 type Binder struct {
@@ -17,19 +16,3 @@ func NewBinder(router api.Router, i *infrastructure.Infrastructure) *Binder {
 		i:      i,
 	}
 }
-
-const (
-	DBExecutorOperations  = "operations"
-	DBExecutorDataService = "data_service"
-)
-
-func (binder *Binder) ChooseDBExecutor(dataExecutorType string) database.Executor {
-	switch dataExecutorType {
-	case DBExecutorOperations:
-		return binder.i.DBOperations()
-	case DBExecutorDataService:
-		return binder.i.DataService()
-	default:
-		return binder.i.DBOperations()
-	}
-}

convenient/domain/configuration/api.go

@@ -0,0 +1,64 @@
+package configuration
+
+import (
+	"git.sxidc.com/go-framework/baize/binding"
+	"git.sxidc.com/go-framework/baize/binding/response"
+	"git.sxidc.com/go-framework/baize/convenient/value_object"
+	"git.sxidc.com/go-framework/baize/domain"
+	"git.sxidc.com/go-tools/utils/strutils"
+)
+
+func BindConfiguration(binder *binding.Binder, opts ...Option) {
+	options := new(Options)
+
+	for _, opt := range opts {
+		opt(options)
+	}
+
+	configurationTableName := tableName
+	if strutils.IsStringNotEmpty(options.schema) {
+		configurationTableName = tableName + "." + options.schema
+	}
+
+	dbExecutorType := binding.DBExecutorOperations
+	if strutils.IsStringNotEmpty(options.dbExecutorType) {
+		dbExecutorType = options.dbExecutorType
+	}
+
+	value_object.BindSimple(binder, &value_object.Simple[any]{
+		ValueObject:       &Entity{},
+		TableName:         configurationTableName,
+		DBExecutorType:    dbExecutorType,
+		DomainPath:        "/configuration",
+		CreateJsonBody:    &AddConfigurationJsonBody{},
+		DeleteQueryParams: &RemoveConfigurationQueryParams{},
+	}, value_object.WithDisableQuery[any]())
+
+	binding.GetBind(binder, &binding.SimpleBindItem[map[string]any]{
+		Path:           "/configuration/values",
+		RequestParams:  &GetConfigurationValuesQueryParams{},
+		Objects:        []domain.Object{&Entity{}},
+		Infrastructure: binder.ChooseDBExecutor(dbExecutorType),
+		ServiceFunc:    nil,
+		ResponseFunc:   response.SendMapResponse,
+	})
+}
+
+type Option func(options *Options)
+
+type Options struct {
+	schema         string
+	dbExecutorType string
+}
+
+func WithSchema(schema string) Option {
+	return func(options *Options) {
+		options.schema = schema
+	}
+}
+
+func WithDBExecutorType(dbExecutorType string) Option {
+	return func(options *Options) {
+		options.dbExecutorType = dbExecutorType
+	}
+}

convenient/domain/configuration/entity.go

@@ -0,0 +1,27 @@
+package configuration
+
+import (
+	"git.sxidc.com/go-tools/utils/strutils"
+	"git.sxidc.com/service-supports/fserr"
+)
+
+const (
+	tableName = "configurations"
+)
+
+type Entity struct {
+	Group string `sqlmapping:"column:group;key;notUpdate;" sqlresult:"column:group;"`
+	Value string `sqlmapping:"column:value;notUpdate;" sqlresult:"column:value;"`
+}
+
+func (e *Entity) DomainCNName() string {
+	return "配置"
+}
+
+func (e *Entity) CheckKeyFields() error {
+	if strutils.IsStringEmpty(e.Group) {
+		return fserr.New("没有传递配置组")
+	}
+
+	return nil
+}

convenient/domain/configuration/request_params.go

@@ -0,0 +1,19 @@
+package configuration
+
+import "git.sxidc.com/go-framework/baize/binding/request"
+
+type (
+	AddConfigurationJsonBody struct {
+		GroupName string `json:"group" binding:"required" assign:"toField:Group"`
+		Value     string `json:"value" binding:"required" assign:"toField:value"`
+	}
+
+	RemoveConfigurationQueryParams struct {
+		GroupName string `form:"group" binding:"required" assign:"toField:Group"`
+	}
+
+	GetConfigurationValuesQueryParams struct {
+		request.BaseQuery
+		GroupName string `form:"group" binding:"required" assign:"toField:Group"`
+	}
+)

convenient/entity/service.go

@@ -14,8 +14,10 @@ import (
 	"reflect"
 )
 
-func Create(tableName string, dbExecutor database.Executor, callbacks *Callbacks[string]) binding.ServiceFunc[string] {
+func Create(tableName string, callbacks *Callbacks[string]) binding.ServiceFunc[string] {
 	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (string, error) {
+		dbExecutor := i.DBExecutor()
+
 		e, ok := objects[0].(domain.Entity)
 		if !ok {
 			return "", fserr.New("需要传递领域对象应该为实体")
@@ -23,17 +25,17 @@ func Create(tableName string, dbExecutor database.Executor, callbacks *Callbacks
 
 		err := e.GenerateID()
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, "")
+			return callbackOnErrorReturn(callbacks, e, err, i, "")
 		}
 
 		err = e.CheckID()
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, "")
+			return callbackOnErrorReturn(callbacks, e, err, i, "")
 		}
 
-		err = callbackBeforeDBOperate(callbacks, e, dbExecutor)
+		err = callbackBeforeDBOperate(callbacks, e, i, dbExecutor)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, "")
+			return callbackOnErrorReturn(callbacks, e, err, i, "")
 		}
 
 		err = database.InsertEntity(dbExecutor, tableName, e)
@@ -42,20 +44,22 @@ func Create(tableName string, dbExecutor database.Executor, callbacks *Callbacks
 				err = fserr.New(e.DomainCNName() + "已存在")
 			}
 
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, "")
+			return callbackOnErrorReturn(callbacks, e, err, i, "")
 		}
 
-		err = callbackAfterDBOperate(callbacks, e, dbExecutor)
+		err = callbackAfterDBOperate(callbacks, e, i, dbExecutor)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, "")
+			return callbackOnErrorReturn(callbacks, e, err, i, "")
 		}
 
-		return callbackOnSuccessReturn(callbacks, e, dbExecutor, e.GetID())
+		return callbackOnSuccessReturn(callbacks, e, i, e.GetID())
 	}
 }
 
-func Delete(tableName string, dbExecutor database.Executor, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
+func Delete(tableName string, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
 	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
+		dbExecutor := i.DBExecutor()
+
 		e, ok := objects[0].(domain.Entity)
 		if !ok {
 			return nil, fserr.New("需要传递领域对象应该为实体")
@@ -63,30 +67,32 @@ func Delete(tableName string, dbExecutor database.Executor, callbacks *Callbacks
 
 		err := e.CheckID()
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
+			return callbackOnErrorReturn(callbacks, e, err, i, nil)
 		}
 
-		err = callbackBeforeDBOperate(callbacks, e, dbExecutor)
+		err = callbackBeforeDBOperate(callbacks, e, i, dbExecutor)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
+			return callbackOnErrorReturn(callbacks, e, err, i, nil)
 		}
 
 		err = database.DeleteEntity(dbExecutor, tableName, e)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
+			return callbackOnErrorReturn(callbacks, e, err, i, nil)
 		}
 
-		err = callbackAfterDBOperate(callbacks, e, dbExecutor)
+		err = callbackAfterDBOperate(callbacks, e, i, dbExecutor)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
+			return callbackOnErrorReturn(callbacks, e, err, i, nil)
 		}
 
-		return callbackOnSuccessReturn(callbacks, e, dbExecutor, nil)
+		return callbackOnSuccessReturn(callbacks, e, i, nil)
 	}
 }
 
-func Update(tableName string, dbExecutor database.Executor, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
+func Update(tableName string, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
 	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
+		dbExecutor := i.DBExecutor()
+
 		e, ok := objects[0].(domain.Entity)
 		if !ok {
 			return nil, fserr.New("需要传递领域对象应该为实体")
@@ -94,7 +100,7 @@ func Update(tableName string, dbExecutor database.Executor, callbacks *Callbacks
 
 		err := e.CheckID()
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
+			return callbackOnErrorReturn(callbacks, e, err, i, nil)
 		}
 
 		exist, err := database.CheckExist(dbExecutor, &sql.CheckExistExecuteParams{
@@ -102,37 +108,39 @@ func Update(tableName string, dbExecutor database.Executor, callbacks *Callbacks
 			Conditions: sql.NewConditions().Equal(e.IDColumnName(), e.GetID()),
 		})
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
+			return callbackOnErrorReturn(callbacks, e, err, i, nil)
 		}
 
 		if !exist {
 			err := fserr.New(e.DomainCNName() + "不存在")
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
+			return callbackOnErrorReturn(callbacks, e, err, i, nil)
 		}
 
-		err = callbackBeforeDBOperate(callbacks, e, dbExecutor)
+		err = callbackBeforeDBOperate(callbacks, e, i, dbExecutor)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
+			return callbackOnErrorReturn(callbacks, e, err, i, nil)
 		}
 
 		err = database.UpdateEntity(dbExecutor, tableName, e)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
+			return callbackOnErrorReturn(callbacks, e, err, i, nil)
 		}
 
-		err = callbackAfterDBOperate(callbacks, e, dbExecutor)
+		err = callbackAfterDBOperate(callbacks, e, i, dbExecutor)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
+			return callbackOnErrorReturn(callbacks, e, err, i, nil)
 		}
 
-		return callbackOnSuccessReturn(callbacks, e, dbExecutor, nil)
+		return callbackOnSuccessReturn(callbacks, e, i, nil)
 	}
 }
 
 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]] {
+func Query[O any](tableName string, callbacks *Callbacks[response.InfosData[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) {
+		dbExecutor := i.DBExecutor()
+
 		queryParams, ok := params.(request.Query)
 		if !ok {
 			return response.InfosData[O]{}, fserr.New("请求参数不是Query接口")
@@ -164,9 +172,9 @@ func Query[O any](tableName string, dbExecutor database.Executor, callbacks *Cal
 			}
 		}
 
-		err = callbackBeforeDBOperate(callbacks, e, dbExecutor)
+		err = callbackBeforeDBOperate(callbacks, e, i, dbExecutor)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, response.InfosData[O]{})
+			return callbackOnErrorReturn(callbacks, e, err, i, response.InfosData[O]{})
 		}
 
 		results, totalCount, err := database.Query(dbExecutor, &sql.QueryExecuteParams{
@@ -176,18 +184,18 @@ func Query[O any](tableName string, dbExecutor database.Executor, callbacks *Cal
 			PageSize:   queryParams.GetPageSize(),
 		})
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, response.InfosData[O]{})
+			return callbackOnErrorReturn(callbacks, e, err, i, response.InfosData[O]{})
 		}
 
-		err = callbackAfterDBOperate(callbacks, e, dbExecutor)
+		err = callbackAfterDBOperate(callbacks, e, i, dbExecutor)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, response.InfosData[O]{})
+			return callbackOnErrorReturn(callbacks, e, err, i, response.InfosData[O]{})
 		}
 
 		infos := make([]O, 0)
 		err = sql.ParseSqlResult(results, &infos)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, response.InfosData[O]{})
+			return callbackOnErrorReturn(callbacks, e, err, i, response.InfosData[O]{})
 		}
 
 		output := response.InfosData[O]{
@@ -196,12 +204,14 @@ func Query[O any](tableName string, dbExecutor database.Executor, callbacks *Cal
 			PageNo:     queryParams.GetPageNo(),
 		}
 
-		return callbackOnSuccessReturn(callbacks, e, dbExecutor, output)
+		return callbackOnSuccessReturn(callbacks, e, i, output)
 	}
 }
 
-func GetByID[O any](tableName string, dbExecutor database.Executor, callbacks *Callbacks[O]) binding.ServiceFunc[O] {
+func GetByID[O any](tableName string, callbacks *Callbacks[O]) binding.ServiceFunc[O] {
 	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (O, error) {
+		dbExecutor := i.DBExecutor()
+
 		var outputZero O
 		outputZeroValue := reflect.Zero(reflect.TypeOf(outputZero))
 		if outputZeroValue.Kind() == reflect.Pointer {
@@ -215,12 +225,12 @@ func GetByID[O any](tableName string, dbExecutor database.Executor, callbacks *C
 
 		err := e.CheckID()
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, outputZero)
+			return callbackOnErrorReturn(callbacks, e, err, i, outputZero)
 		}
 
-		err = callbackBeforeDBOperate(callbacks, e, dbExecutor)
+		err = callbackBeforeDBOperate(callbacks, e, i, dbExecutor)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, outputZero)
+			return callbackOnErrorReturn(callbacks, e, err, i, outputZero)
 		}
 
 		result, err := database.QueryOne(dbExecutor, &sql.QueryOneExecuteParams{
@@ -228,12 +238,12 @@ func GetByID[O any](tableName string, dbExecutor database.Executor, callbacks *C
 			Conditions: sql.NewConditions().Equal(e.IDColumnName(), e.GetID()),
 		})
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, outputZero)
+			return callbackOnErrorReturn(callbacks, e, err, i, outputZero)
 		}
 
-		err = callbackAfterDBOperate(callbacks, e, dbExecutor)
+		err = callbackAfterDBOperate(callbacks, e, i, dbExecutor)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, outputZero)
+			return callbackOnErrorReturn(callbacks, e, err, i, outputZero)
 		}
 
 		var info O
@@ -246,15 +256,17 @@ func GetByID[O any](tableName string, dbExecutor database.Executor, callbacks *C
 
 		err = sql.ParseSqlResult(result, infoPointer)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, outputZero)
+			return callbackOnErrorReturn(callbacks, e, err, i, outputZero)
 		}
 
-		return callbackOnSuccessReturn(callbacks, e, dbExecutor, info)
+		return callbackOnSuccessReturn(callbacks, e, i, info)
 	}
 }
 
-func CreateTx(tableName string, dbExecutor database.Executor, callbacks *Callbacks[string]) binding.ServiceFunc[string] {
+func CreateTx(tableName string, callbacks *Callbacks[string]) binding.ServiceFunc[string] {
 	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (string, error) {
+		dbExecutor := i.DBExecutor()
+
 		e, ok := objects[0].(domain.Entity)
 		if !ok {
 			return "", fserr.New("需要传递领域对象应该为实体")
@@ -262,16 +274,16 @@ func CreateTx(tableName string, dbExecutor database.Executor, callbacks *Callbac
 
 		err := e.GenerateID()
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, "")
+			return callbackOnErrorReturn(callbacks, e, err, i, "")
 		}
 
 		err = e.CheckID()
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, "")
+			return callbackOnErrorReturn(callbacks, e, err, i, "")
 		}
 
 		err = database.Transaction(dbExecutor, func(tx database.Executor) error {
-			err = callbackBeforeDBOperate(callbacks, e, tx)
+			err = callbackBeforeDBOperate(callbacks, e, i, tx)
 			if err != nil {
 				return err
 			}
@@ -285,7 +297,7 @@ func CreateTx(tableName string, dbExecutor database.Executor, callbacks *Callbac
 				return err
 			}
 
-			err = callbackAfterDBOperate(callbacks, e, tx)
+			err = callbackAfterDBOperate(callbacks, e, i, tx)
 			if err != nil {
 				return err
 			}
@@ -293,15 +305,17 @@ func CreateTx(tableName string, dbExecutor database.Executor, callbacks *Callbac
 			return nil
 		})
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, "")
+			return callbackOnErrorReturn(callbacks, e, err, i, "")
 		}
 
-		return callbackOnSuccessReturn(callbacks, e, dbExecutor, e.GetID())
+		return callbackOnSuccessReturn(callbacks, e, i, e.GetID())
 	}
 }
 
-func DeleteTx(tableName string, dbExecutor database.Executor, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
+func DeleteTx(tableName string, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
 	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
+		dbExecutor := i.DBExecutor()
+
 		e, ok := objects[0].(domain.Entity)
 		if !ok {
 			return nil, fserr.New("需要传递领域对象应该为实体")
@@ -309,11 +323,11 @@ func DeleteTx(tableName string, dbExecutor database.Executor, callbacks *Callbac
 
 		err := e.CheckID()
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
+			return callbackOnErrorReturn(callbacks, e, err, i, nil)
 		}
 
 		err = database.Transaction(dbExecutor, func(tx database.Executor) error {
-			err = callbackBeforeDBOperate(callbacks, e, tx)
+			err = callbackBeforeDBOperate(callbacks, e, i, tx)
 			if err != nil {
 				return err
 			}
@@ -323,7 +337,7 @@ func DeleteTx(tableName string, dbExecutor database.Executor, callbacks *Callbac
 				return err
 			}
 
-			err = callbackAfterDBOperate(callbacks, e, tx)
+			err = callbackAfterDBOperate(callbacks, e, i, tx)
 			if err != nil {
 				return err
 			}
@@ -331,15 +345,17 @@ func DeleteTx(tableName string, dbExecutor database.Executor, callbacks *Callbac
 			return nil
 		})
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
+			return callbackOnErrorReturn(callbacks, e, err, i, nil)
 		}
 
-		return callbackOnSuccessReturn(callbacks, e, dbExecutor, nil)
+		return callbackOnSuccessReturn(callbacks, e, i, nil)
 	}
 }
 
-func UpdateTx(tableName string, dbExecutor database.Executor, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
+func UpdateTx(tableName string, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
 	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
+		dbExecutor := i.DBExecutor()
+
 		e, ok := objects[0].(domain.Entity)
 		if !ok {
 			return nil, fserr.New("需要传递领域对象应该为实体")
@@ -347,7 +363,7 @@ func UpdateTx(tableName string, dbExecutor database.Executor, callbacks *Callbac
 
 		err := e.CheckID()
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
+			return callbackOnErrorReturn(callbacks, e, err, i, nil)
 		}
 
 		exist, err := database.CheckExist(dbExecutor, &sql.CheckExistExecuteParams{
@@ -355,16 +371,16 @@ func UpdateTx(tableName string, dbExecutor database.Executor, callbacks *Callbac
 			Conditions: sql.NewConditions().Equal(e.IDColumnName(), e.GetID()),
 		})
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
+			return callbackOnErrorReturn(callbacks, e, err, i, nil)
 		}
 
 		if !exist {
 			err := fserr.New(e.DomainCNName() + "不存在")
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
+			return callbackOnErrorReturn(callbacks, e, err, i, nil)
 		}
 
 		err = database.Transaction(dbExecutor, func(tx database.Executor) error {
-			err = callbackBeforeDBOperate(callbacks, e, tx)
+			err = callbackBeforeDBOperate(callbacks, e, i, tx)
 			if err != nil {
 				return err
 			}
@@ -374,7 +390,7 @@ func UpdateTx(tableName string, dbExecutor database.Executor, callbacks *Callbac
 				return err
 			}
 
-			err = callbackAfterDBOperate(callbacks, e, tx)
+			err = callbackAfterDBOperate(callbacks, e, i, tx)
 			if err != nil {
 				return err
 			}
@@ -382,9 +398,9 @@ func UpdateTx(tableName string, dbExecutor database.Executor, callbacks *Callbac
 			return nil
 		})
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
+			return callbackOnErrorReturn(callbacks, e, err, i, nil)
 		}
 
-		return callbackOnSuccessReturn(callbacks, e, dbExecutor, nil)
+		return callbackOnSuccessReturn(callbacks, e, i, nil)
 	}
 }

convenient/entity/service_callbacks.go

@@ -2,59 +2,60 @@ package entity
 
 import (
 	"git.sxidc.com/go-framework/baize/domain"
+	"git.sxidc.com/go-framework/baize/infrastructure"
 	"git.sxidc.com/go-framework/baize/infrastructure/database"
 )
 
 type Callbacks[O any] struct {
-	BeforeDBOperate func(e domain.Entity, dbExecutor database.Executor) error
-	AfterDBOperate  func(e domain.Entity, dbExecutor database.Executor) error
-	OnSuccessReturn func(e domain.Entity, dbExecutor database.Executor, output O) (O, error)
-	OnErrorReturn   func(e domain.Entity, err error, dbExecutor database.Executor, defaultErrOutput O) (O, error)
+	BeforeDBOperate func(e domain.Entity, i *infrastructure.Infrastructure, dbExecutor database.Executor) error
+	AfterDBOperate  func(e domain.Entity, i *infrastructure.Infrastructure, dbExecutor database.Executor) error
+	OnSuccessReturn func(e domain.Entity, i *infrastructure.Infrastructure, output O) (O, error)
+	OnErrorReturn   func(e domain.Entity, err error, i *infrastructure.Infrastructure, defaultErrOutput O) (O, error)
 }
 
-func callbackBeforeDBOperate[O any](callbacks *Callbacks[O], e domain.Entity, dbExecutor database.Executor) error {
+func callbackBeforeDBOperate[O any](callbacks *Callbacks[O], e domain.Entity, i *infrastructure.Infrastructure, dbExecutor database.Executor) error {
 	if callbacks == nil {
 		return nil
 	}
 
 	if callbacks.BeforeDBOperate == nil {
-		return callbacks.BeforeDBOperate(e, dbExecutor)
+		return callbacks.BeforeDBOperate(e, i, dbExecutor)
 	}
 
 	return nil
 }
 
-func callbackAfterDBOperate[O any](callbacks *Callbacks[O], e domain.Entity, dbExecutor database.Executor) error {
+func callbackAfterDBOperate[O any](callbacks *Callbacks[O], e domain.Entity, i *infrastructure.Infrastructure, dbExecutor database.Executor) error {
 	if callbacks == nil {
 		return nil
 	}
 
 	if callbacks.AfterDBOperate == nil {
-		return callbacks.AfterDBOperate(e, dbExecutor)
+		return callbacks.AfterDBOperate(e, i, dbExecutor)
 	}
 
 	return nil
 }
 
-func callbackOnSuccessReturn[O any](callbacks *Callbacks[O], e domain.Entity, dbExecutor database.Executor, output O) (O, error) {
+func callbackOnSuccessReturn[O any](callbacks *Callbacks[O], e domain.Entity, i *infrastructure.Infrastructure, output O) (O, error) {
 	if callbacks == nil {
 		return output, nil
 	}
 
 	if callbacks.OnSuccessReturn == nil {
-		return callbacks.OnSuccessReturn(e, dbExecutor, output)
+		return callbacks.OnSuccessReturn(e, i, output)
 	}
 
 	return output, nil
 }
 
-func callbackOnErrorReturn[O any](callbacks *Callbacks[O], e domain.Entity, err error, dbExecutor database.Executor, defaultErrOutput O) (O, error) {
+func callbackOnErrorReturn[O any](callbacks *Callbacks[O], e domain.Entity, err error, i *infrastructure.Infrastructure, defaultErrOutput O) (O, error) {
 	if callbacks == nil {
 		return defaultErrOutput, err
 	}
 
 	if callbacks.OnErrorReturn == nil {
-		return callbacks.OnErrorReturn(e, err, dbExecutor, defaultErrOutput)
+		return callbacks.OnErrorReturn(e, err, i, defaultErrOutput)
 	}
 
 	return defaultErrOutput, err

convenient/entity/simple.go

@@ -17,11 +17,6 @@ type Simple[I any] struct {
 	// 表名
 	TableName string
 
-	// 选择要使用的数据库Executor
-	// DBExecutorOperations operations 数据库操作
-	// DBExecutorDataService data_service 数据服务
-	DBExecutorType string
-
 	// URL领域相对路径，如/class，后面会自动补充
 	DomainPath string
 
@@ -45,83 +40,92 @@ type Simple[I any] struct {
 }
 
 func (simple *Simple[I]) bind(binder *binding.Binder) {
-	dbExecutor := binder.ChooseDBExecutor(simple.DBExecutorType)
 	options := simple.options
 
 	// 创建
-	if !options.createNeedTx {
-		binding.PostBind(binder, &binding.SimpleBindItem[string]{
-			Path:          simple.DomainPath + "/create",
-			ResponseFunc:  response.SendIDResponse[string],
-			RequestParams: simple.CreateJsonBody,
-			Objects:       []domain.Object{simple.Entity},
-			ServiceFunc:   Create(simple.TableName, dbExecutor, options.createCallbacks),
-		}, options.createMiddlewares...)
-	} else {
-		binding.PostBind(binder, &binding.SimpleBindItem[string]{
-			Path:          simple.DomainPath + "/create",
-			ResponseFunc:  response.SendIDResponse[string],
-			RequestParams: simple.CreateJsonBody,
-			Objects:       []domain.Object{simple.Entity},
-			ServiceFunc:   CreateTx(simple.TableName, dbExecutor, options.createCallbacks),
-		}, options.createMiddlewares...)
+	if !options.disableCreate {
+		if !options.createNeedTx {
+			binding.PostBind(binder, &binding.SimpleBindItem[string]{
+				Path:          simple.DomainPath + "/create",
+				ResponseFunc:  response.SendIDResponse[string],
+				RequestParams: simple.CreateJsonBody,
+				Objects:       []domain.Object{simple.Entity},
+				ServiceFunc:   Create(simple.TableName, options.createCallbacks),
+			}, options.createMiddlewares...)
+		} else {
+			binding.PostBind(binder, &binding.SimpleBindItem[string]{
+				Path:          simple.DomainPath + "/create",
+				ResponseFunc:  response.SendIDResponse[string],
+				RequestParams: simple.CreateJsonBody,
+				Objects:       []domain.Object{simple.Entity},
+				ServiceFunc:   CreateTx(simple.TableName, options.createCallbacks),
+			}, options.createMiddlewares...)
+		}
 	}
 
 	// 删除
-	if !options.deleteNeedTx {
-		binding.DeleteBind(binder, &binding.SimpleBindItem[any]{
-			Path:          simple.DomainPath + "/:id/delete",
-			ResponseFunc:  response.SendMsgResponse,
-			RequestParams: simple.DeleteQueryParams,
-			Objects:       []domain.Object{simple.Entity},
-			ServiceFunc:   Delete(simple.TableName, dbExecutor, options.deleteCallbacks),
-		}, options.deleteMiddlewares...)
-	} else {
-		binding.DeleteBind(binder, &binding.SimpleBindItem[any]{
-			Path:          simple.DomainPath + "/:id/delete",
-			ResponseFunc:  response.SendMsgResponse,
-			RequestParams: simple.DeleteQueryParams,
-			Objects:       []domain.Object{simple.Entity},
-			ServiceFunc:   DeleteTx(simple.TableName, dbExecutor, options.deleteCallbacks),
-		}, options.deleteMiddlewares...)
+	if !options.disableDelete {
+		if !options.deleteNeedTx {
+			binding.DeleteBind(binder, &binding.SimpleBindItem[any]{
+				Path:          simple.DomainPath + "/:id/delete",
+				ResponseFunc:  response.SendMsgResponse,
+				RequestParams: simple.DeleteQueryParams,
+				Objects:       []domain.Object{simple.Entity},
+				ServiceFunc:   Delete(simple.TableName, options.deleteCallbacks),
+			}, options.deleteMiddlewares...)
+		} else {
+			binding.DeleteBind(binder, &binding.SimpleBindItem[any]{
+				Path:          simple.DomainPath + "/:id/delete",
+				ResponseFunc:  response.SendMsgResponse,
+				RequestParams: simple.DeleteQueryParams,
+				Objects:       []domain.Object{simple.Entity},
+				ServiceFunc:   DeleteTx(simple.TableName, options.deleteCallbacks),
+			}, options.deleteMiddlewares...)
+		}
 	}
 
 	// 修改
-	if !options.updateNeedTx {
-		binding.PutBind(binder, &binding.SimpleBindItem[any]{
-			Path:          simple.DomainPath + "/update",
-			ResponseFunc:  response.SendMsgResponse,
-			RequestParams: simple.UpdateJsonBody,
-			Objects:       []domain.Object{simple.Entity},
-			ServiceFunc:   Update(simple.TableName, dbExecutor, options.updateCallbacks),
-		}, options.updateMiddlewares...)
-	} else {
-		binding.PutBind(binder, &binding.SimpleBindItem[any]{
-			Path:          simple.DomainPath + "/update",
-			ResponseFunc:  response.SendMsgResponse,
-			RequestParams: simple.UpdateJsonBody,
-			Objects:       []domain.Object{simple.Entity},
-			ServiceFunc:   UpdateTx(simple.TableName, dbExecutor, options.updateCallbacks),
-		}, options.updateMiddlewares...)
+	if !options.disableUpdate {
+		if !options.updateNeedTx {
+			binding.PutBind(binder, &binding.SimpleBindItem[any]{
+				Path:          simple.DomainPath + "/update",
+				ResponseFunc:  response.SendMsgResponse,
+				RequestParams: simple.UpdateJsonBody,
+				Objects:       []domain.Object{simple.Entity},
+				ServiceFunc:   Update(simple.TableName, options.updateCallbacks),
+			}, options.updateMiddlewares...)
+		} else {
+			binding.PutBind(binder, &binding.SimpleBindItem[any]{
+				Path:          simple.DomainPath + "/update",
+				ResponseFunc:  response.SendMsgResponse,
+				RequestParams: simple.UpdateJsonBody,
+				Objects:       []domain.Object{simple.Entity},
+				ServiceFunc:   UpdateTx(simple.TableName, options.updateCallbacks),
+			}, options.updateMiddlewares...)
+		}
 	}
 
 	// 查询
-	binding.GetBind(binder, &binding.SimpleBindItem[response.InfosData[I]]{
-		Path:          simple.DomainPath + "/query",
-		ResponseFunc:  response.SendInfosResponse[I],
-		RequestParams: simple.QueryParams,
-		Objects:       []domain.Object{simple.Entity},
-		ServiceFunc:   Query[I](simple.TableName, dbExecutor, options.queryCallbacks, options.queryConditionFieldCallback),
-	}, options.queryMiddlewares...)
+	if !options.disableQuery {
+		binding.GetBind(binder, &binding.SimpleBindItem[response.InfosData[I]]{
+			Path:          simple.DomainPath + "/query",
+			ResponseFunc:  response.SendInfosResponse[I],
+			RequestParams: simple.QueryParams,
+			Objects:       []domain.Object{simple.Entity},
+			ServiceFunc:   Query[I](simple.TableName, options.queryCallbacks, options.queryConditionFieldCallback),
+		}, options.queryMiddlewares...)
+	}
 
 	// 通过ID获取
-	binding.GetBind(binder, &binding.SimpleBindItem[I]{
-		Path:          simple.DomainPath + "/get",
-		ResponseFunc:  response.SendInfoResponse[I],
-		RequestParams: simple.GetByIDQueryParams,
-		Objects:       []domain.Object{simple.Entity},
-		ServiceFunc:   GetByID[I](simple.TableName, dbExecutor, options.getByIDCallbacks),
-	}, options.getByIDMiddlewares...)
+	if !options.disableQueryByID {
+		binding.GetBind(binder, &binding.SimpleBindItem[I]{
+			Path:          simple.DomainPath + "/get",
+			ResponseFunc:  response.SendInfoResponse[I],
+			RequestParams: simple.GetByIDQueryParams,
+			Objects:       []domain.Object{simple.Entity},
+			ServiceFunc:   GetByID[I](simple.TableName, options.getByIDCallbacks),
+		}, options.getByIDMiddlewares...)
+	}
 }
 
 func BindSimple[I any](binder *binding.Binder, simple *Simple[I], opts ...Option[I]) {
@@ -139,6 +143,9 @@ func BindSimple[I any](binder *binding.Binder, simple *Simple[I], opts ...Option
 type Option[I any] func(options *Options[I])
 
 type Options[I any] struct {
+	// 关闭创建
+	disableCreate bool
+
 	// 创建是否使用事务
 	createNeedTx bool
 
@@ -148,6 +155,9 @@ type Options[I any] struct {
 	// 创建中间件
 	createMiddlewares []api.Handler
 
+	// 关闭删除
+	disableDelete bool
+
 	// 删除是否使用事务
 	deleteNeedTx bool
 
@@ -157,6 +167,9 @@ type Options[I any] struct {
 	// 删除中间件
 	deleteMiddlewares []api.Handler
 
+	// 关闭更新
+	disableUpdate bool
+
 	// 更新是否使用事务
 	updateNeedTx bool
 
@@ -166,6 +179,9 @@ type Options[I any] struct {
 	// 更新中间件
 	updateMiddlewares []api.Handler
 
+	// 关闭查询
+	disableQuery bool
+
 	// 查询条件构造回调
 	queryConditionFieldCallback ConditionFieldCallback
 
@@ -175,6 +191,9 @@ type Options[I any] struct {
 	// 查询中间件
 	queryMiddlewares []api.Handler
 
+	// 关闭根据ID查询
+	disableQueryByID bool
+
 	// 根据ID查询回调
 	getByIDCallbacks *Callbacks[I]
 
@@ -182,6 +201,12 @@ type Options[I any] struct {
 	getByIDMiddlewares []api.Handler
 }
 
+func WithDisableCreate[I any]() Option[I] {
+	return func(options *Options[I]) {
+		options.disableCreate = true
+	}
+}
+
 func WithCreateTx[I any]() Option[I] {
 	return func(options *Options[I]) {
 		options.createNeedTx = true
@@ -200,6 +225,12 @@ func WithCreateMiddlewares[I any](middlewares []api.Handler) Option[I] {
 	}
 }
 
+func WithDisableDelete[I any]() Option[I] {
+	return func(options *Options[I]) {
+		options.disableDelete = true
+	}
+}
+
 func WithDeleteTx[I any]() Option[I] {
 	return func(options *Options[I]) {
 		options.deleteNeedTx = true
@@ -218,6 +249,12 @@ func WithDeleteMiddlewares[I any](middlewares []api.Handler) Option[I] {
 	}
 }
 
+func WithDisableUpdate[I any]() Option[I] {
+	return func(options *Options[I]) {
+		options.disableUpdate = true
+	}
+}
+
 func WithUpdateTx[I any]() Option[I] {
 	return func(options *Options[I]) {
 		options.updateNeedTx = true
@@ -236,6 +273,12 @@ func WithUpdateMiddlewares[I any](middlewares []api.Handler) Option[I] {
 	}
 }
 
+func WithDisableQuery[I any]() Option[I] {
+	return func(options *Options[I]) {
+		options.disableQuery = true
+	}
+}
+
 func WithQueryConditionFieldCallback[I any](callback ConditionFieldCallback) Option[I] {
 	return func(options *Options[I]) {
 		options.queryConditionFieldCallback = callback
@@ -254,6 +297,12 @@ func WithQueryMiddlewares[I any](middlewares []api.Handler) Option[I] {
 	}
 }
 
+func WithDisableQueryByID[I any]() Option[I] {
+	return func(options *Options[I]) {
+		options.disableQueryByID = true
+	}
+}
+
 func WithGetByIDCallbacks[I any](callbacks *Callbacks[I]) Option[I] {
 	return func(options *Options[I]) {
 		options.getByIDCallbacks = callbacks

convenient/value_object/service.go

@@ -14,16 +14,18 @@ import (
 	"reflect"
 )
 
-func Create(tableName string, dbExecutor database.Executor, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
+func Create(tableName string, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
 	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
+		dbExecutor := i.DBExecutor()
+
 		valueObject, ok := objects[0].(domain.ValueObject)
 		if !ok {
 			return nil, fserr.New("需要传递领域对象应该为值对象")
 		}
 
-		err := callbackBeforeDBOperate(callbacks, valueObject, dbExecutor)
+		err := callbackBeforeDBOperate(callbacks, valueObject, i, dbExecutor)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, valueObject, err, dbExecutor, nil)
+			return callbackOnErrorReturn(callbacks, valueObject, err, i, nil)
 		}
 
 		err = database.InsertEntity(dbExecutor, tableName, valueObject)
@@ -32,20 +34,22 @@ func Create(tableName string, dbExecutor database.Executor, callbacks *Callbacks
 				err = fserr.New(valueObject.DomainCNName() + "已存在")
 			}
 
-			return callbackOnErrorReturn(callbacks, valueObject, err, dbExecutor, nil)
+			return callbackOnErrorReturn(callbacks, valueObject, err, i, nil)
 		}
 
-		err = callbackAfterDBOperate(callbacks, valueObject, dbExecutor)
+		err = callbackAfterDBOperate(callbacks, valueObject, i, dbExecutor)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, valueObject, err, dbExecutor, nil)
+			return callbackOnErrorReturn(callbacks, valueObject, err, i, nil)
 		}
 
-		return callbackOnSuccessReturn(callbacks, valueObject, dbExecutor, nil)
+		return callbackOnSuccessReturn(callbacks, valueObject, i, nil)
 	}
 }
 
-func Delete(tableName string, dbExecutor database.Executor, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
+func Delete(tableName string, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
 	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
+		dbExecutor := i.DBExecutor()
+
 		valueObject, ok := objects[0].(domain.ValueObject)
 		if !ok {
 			return nil, fserr.New("需要传递领域对象应该为值对象")
@@ -53,32 +57,34 @@ func Delete(tableName string, dbExecutor database.Executor, callbacks *Callbacks
 
 		err := valueObject.CheckKeyFields()
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, valueObject, err, dbExecutor, nil)
+			return callbackOnErrorReturn(callbacks, valueObject, err, i, nil)
 		}
 
-		err = callbackBeforeDBOperate(callbacks, valueObject, dbExecutor)
+		err = callbackBeforeDBOperate(callbacks, valueObject, i, dbExecutor)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, valueObject, err, dbExecutor, nil)
+			return callbackOnErrorReturn(callbacks, valueObject, err, i, nil)
 		}
 
 		err = database.DeleteEntity(dbExecutor, tableName, valueObject)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, valueObject, err, dbExecutor, nil)
+			return callbackOnErrorReturn(callbacks, valueObject, err, i, nil)
 		}
 
-		err = callbackAfterDBOperate(callbacks, valueObject, dbExecutor)
+		err = callbackAfterDBOperate(callbacks, valueObject, i, dbExecutor)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, valueObject, err, dbExecutor, nil)
+			return callbackOnErrorReturn(callbacks, valueObject, err, i, nil)
 		}
 
-		return callbackOnSuccessReturn(callbacks, valueObject, dbExecutor, nil)
+		return callbackOnSuccessReturn(callbacks, valueObject, i, nil)
 	}
 }
 
 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]] {
+func Query[O any](tableName string, callbacks *Callbacks[response.InfosData[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) {
+		dbExecutor := i.DBExecutor()
+
 		queryParams, ok := params.(request.Query)
 		if !ok {
 			return response.InfosData[O]{}, fserr.New("请求参数不是Query接口")
@@ -110,9 +116,9 @@ func Query[O any](tableName string, dbExecutor database.Executor, callbacks *Cal
 			}
 		}
 
-		err = callbackBeforeDBOperate(callbacks, valueObject, dbExecutor)
+		err = callbackBeforeDBOperate(callbacks, valueObject, i, dbExecutor)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, valueObject, err, dbExecutor, response.InfosData[O]{})
+			return callbackOnErrorReturn(callbacks, valueObject, err, i, response.InfosData[O]{})
 		}
 
 		results, totalCount, err := database.Query(dbExecutor, &sql.QueryExecuteParams{
@@ -122,18 +128,18 @@ func Query[O any](tableName string, dbExecutor database.Executor, callbacks *Cal
 			PageSize:   queryParams.GetPageSize(),
 		})
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, valueObject, err, dbExecutor, response.InfosData[O]{})
+			return callbackOnErrorReturn(callbacks, valueObject, err, i, response.InfosData[O]{})
 		}
 
-		err = callbackAfterDBOperate(callbacks, valueObject, dbExecutor)
+		err = callbackAfterDBOperate(callbacks, valueObject, i, dbExecutor)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, valueObject, err, dbExecutor, response.InfosData[O]{})
+			return callbackOnErrorReturn(callbacks, valueObject, err, i, response.InfosData[O]{})
 		}
 
 		infos := make([]O, 0)
 		err = sql.ParseSqlResult(results, &infos)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, valueObject, err, dbExecutor, response.InfosData[O]{})
+			return callbackOnErrorReturn(callbacks, valueObject, err, i, response.InfosData[O]{})
 		}
 
 		output := response.InfosData[O]{
@@ -142,19 +148,21 @@ func Query[O any](tableName string, dbExecutor database.Executor, callbacks *Cal
 			PageNo:     queryParams.GetPageNo(),
 		}
 
-		return callbackOnSuccessReturn(callbacks, valueObject, dbExecutor, output)
+		return callbackOnSuccessReturn(callbacks, valueObject, i, output)
 	}
 }
 
-func CreateTx(tableName string, dbExecutor database.Executor, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
+func CreateTx(tableName string, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
 	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
+		dbExecutor := i.DBExecutor()
+
 		valueObject, ok := objects[0].(domain.ValueObject)
 		if !ok {
 			return nil, fserr.New("需要传递领域对象应该为值对象")
 		}
 
 		err := database.Transaction(dbExecutor, func(tx database.Executor) error {
-			err := callbackBeforeDBOperate(callbacks, valueObject, dbExecutor)
+			err := callbackBeforeDBOperate(callbacks, valueObject, i, tx)
 			if err != nil {
 				return err
 			}
@@ -168,7 +176,7 @@ func CreateTx(tableName string, dbExecutor database.Executor, callbacks *Callbac
 				return err
 			}
 
-			err = callbackAfterDBOperate(callbacks, valueObject, dbExecutor)
+			err = callbackAfterDBOperate(callbacks, valueObject, i, tx)
 			if err != nil {
 				return err
 			}
@@ -176,15 +184,17 @@ func CreateTx(tableName string, dbExecutor database.Executor, callbacks *Callbac
 			return nil
 		})
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, valueObject, err, dbExecutor, nil)
+			return callbackOnErrorReturn(callbacks, valueObject, err, i, nil)
 		}
 
-		return callbackOnSuccessReturn(callbacks, valueObject, dbExecutor, nil)
+		return callbackOnSuccessReturn(callbacks, valueObject, i, nil)
 	}
 }
 
-func DeleteTx(tableName string, dbExecutor database.Executor, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
+func DeleteTx(tableName string, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
 	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
+		dbExecutor := i.DBExecutor()
+
 		valueObject, ok := objects[0].(domain.ValueObject)
 		if !ok {
 			return nil, fserr.New("需要传递领域对象应该为值对象")
@@ -192,11 +202,11 @@ func DeleteTx(tableName string, dbExecutor database.Executor, callbacks *Callbac
 
 		err := valueObject.CheckKeyFields()
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, valueObject, err, dbExecutor, nil)
+			return callbackOnErrorReturn(callbacks, valueObject, err, i, nil)
 		}
 
 		err = database.Transaction(dbExecutor, func(tx database.Executor) error {
-			err = callbackBeforeDBOperate(callbacks, valueObject, dbExecutor)
+			err = callbackBeforeDBOperate(callbacks, valueObject, i, tx)
 			if err != nil {
 				return err
 			}
@@ -206,7 +216,7 @@ func DeleteTx(tableName string, dbExecutor database.Executor, callbacks *Callbac
 				return err
 			}
 
-			err = callbackAfterDBOperate(callbacks, valueObject, dbExecutor)
+			err = callbackAfterDBOperate(callbacks, valueObject, i, tx)
 			if err != nil {
 				return err
 			}
@@ -214,9 +224,9 @@ func DeleteTx(tableName string, dbExecutor database.Executor, callbacks *Callbac
 			return nil
 		})
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, valueObject, err, dbExecutor, nil)
+			return callbackOnErrorReturn(callbacks, valueObject, err, i, nil)
 		}
 
-		return callbackOnSuccessReturn(callbacks, valueObject, dbExecutor, nil)
+		return callbackOnSuccessReturn(callbacks, valueObject, i, nil)
 	}
 }

convenient/value_object/service_callbacks.go

@@ -2,59 +2,60 @@ package value_object
 
 import (
 	"git.sxidc.com/go-framework/baize/domain"
+	"git.sxidc.com/go-framework/baize/infrastructure"
 	"git.sxidc.com/go-framework/baize/infrastructure/database"
 )
 
 type Callbacks[O any] struct {
-	BeforeDBOperate func(valueObject domain.ValueObject, dbExecutor database.Executor) error
-	AfterDBOperate  func(valueObject domain.ValueObject, dbExecutor database.Executor) error
-	OnSuccessReturn func(valueObject domain.ValueObject, dbExecutor database.Executor, output O) (O, error)
-	OnErrorReturn   func(valueObject domain.ValueObject, err error, dbExecutor database.Executor, defaultErrOutput O) (O, error)
+	BeforeDBOperate func(valueObject domain.ValueObject, i *infrastructure.Infrastructure, dbExecutor database.Executor) error
+	AfterDBOperate  func(valueObject domain.ValueObject, i *infrastructure.Infrastructure, dbExecutor database.Executor) error
+	OnSuccessReturn func(valueObject domain.ValueObject, i *infrastructure.Infrastructure, output O) (O, error)
+	OnErrorReturn   func(valueObject domain.ValueObject, err error, i *infrastructure.Infrastructure, defaultErrOutput O) (O, error)
 }
 
-func callbackBeforeDBOperate[O any](callbacks *Callbacks[O], valueObject domain.ValueObject, dbExecutor database.Executor) error {
+func callbackBeforeDBOperate[O any](callbacks *Callbacks[O], valueObject domain.ValueObject, i *infrastructure.Infrastructure, dbExecutor database.Executor) error {
 	if callbacks == nil {
 		return nil
 	}
 
 	if callbacks.BeforeDBOperate == nil {
-		return callbacks.BeforeDBOperate(valueObject, dbExecutor)
+		return callbacks.BeforeDBOperate(valueObject, i, dbExecutor)
 	}
 
 	return nil
 }
 
-func callbackAfterDBOperate[O any](callbacks *Callbacks[O], valueObject domain.ValueObject, dbExecutor database.Executor) error {
+func callbackAfterDBOperate[O any](callbacks *Callbacks[O], valueObject domain.ValueObject, i *infrastructure.Infrastructure, dbExecutor database.Executor) error {
 	if callbacks == nil {
 		return nil
 	}
 
 	if callbacks.AfterDBOperate == nil {
-		return callbacks.AfterDBOperate(valueObject, dbExecutor)
+		return callbacks.AfterDBOperate(valueObject, i, dbExecutor)
 	}
 
 	return nil
 }
 
-func callbackOnSuccessReturn[O any](callbacks *Callbacks[O], valueObject domain.ValueObject, dbExecutor database.Executor, output O) (O, error) {
+func callbackOnSuccessReturn[O any](callbacks *Callbacks[O], valueObject domain.ValueObject, i *infrastructure.Infrastructure, output O) (O, error) {
 	if callbacks == nil {
 		return output, nil
 	}
 
 	if callbacks.OnSuccessReturn == nil {
-		return callbacks.OnSuccessReturn(valueObject, dbExecutor, output)
+		return callbacks.OnSuccessReturn(valueObject, i, output)
 	}
 
 	return output, nil
 }
 
-func callbackOnErrorReturn[O any](callbacks *Callbacks[O], valueObject domain.ValueObject, err error, dbExecutor database.Executor, defaultErrOutput O) (O, error) {
+func callbackOnErrorReturn[O any](callbacks *Callbacks[O], valueObject domain.ValueObject, err error, i *infrastructure.Infrastructure, defaultErrOutput O) (O, error) {
 	if callbacks == nil {
 		return defaultErrOutput, err
 	}
 
 	if callbacks.OnErrorReturn == nil {
-		return callbacks.OnErrorReturn(valueObject, err, dbExecutor, defaultErrOutput)
+		return callbacks.OnErrorReturn(valueObject, err, i, defaultErrOutput)
 	}
 
 	return defaultErrOutput, err

convenient/value_object/simple.go

@@ -17,11 +17,6 @@ type Simple[I any] struct {
 	// 表名
 	TableName string
 
-	// 选择要使用的数据库Executor
-	// DBExecutorOperations operations 数据库操作
-	// DBExecutorDataService data_service 数据服务
-	DBExecutorType string
-
 	// URL领域相对路径，如/class，后面会自动补充
 	DomainPath string
 
@@ -29,7 +24,7 @@ type Simple[I any] struct {
 	CreateJsonBody request.Params
 
 	// 删除使用的请求参数，注意是WithID类型
-	DeleteQueryParams request.WithID
+	DeleteQueryParams request.Params
 
 	// 查询使用的请求参数，注意是Query类型
 	QueryParams request.Query
@@ -39,64 +34,80 @@ type Simple[I any] struct {
 }
 
 func (simple *Simple[I]) bind(binder *binding.Binder) {
-	dbExecutor := binder.ChooseDBExecutor(simple.DBExecutorType)
 	options := simple.options
 
 	// 创建
-	if !options.createNeedTx {
-		binding.PostBind(binder, &binding.SimpleBindItem[any]{
-			Path:          simple.DomainPath + "/create",
-			ResponseFunc:  response.SendMsgResponse,
-			RequestParams: simple.CreateJsonBody,
-			Objects:       []domain.Object{simple.ValueObject},
-			ServiceFunc:   Create(simple.TableName, dbExecutor, options.createCallbacks),
-		})
-	} else {
-		binding.PostBind(binder, &binding.SimpleBindItem[any]{
-			Path:          simple.DomainPath + "/create",
-			ResponseFunc:  response.SendMsgResponse,
-			RequestParams: simple.CreateJsonBody,
-			Objects:       []domain.Object{simple.ValueObject},
-			ServiceFunc:   CreateTx(simple.TableName, dbExecutor, options.createCallbacks),
-		})
+	if !options.disableCreate {
+		if !options.createNeedTx {
+			binding.PostBind(binder, &binding.SimpleBindItem[any]{
+				Path:          simple.DomainPath + "/create",
+				ResponseFunc:  response.SendMsgResponse,
+				RequestParams: simple.CreateJsonBody,
+				Objects:       []domain.Object{simple.ValueObject},
+				ServiceFunc:   Create(simple.TableName, options.createCallbacks),
+			})
+		} else {
+			binding.PostBind(binder, &binding.SimpleBindItem[any]{
+				Path:          simple.DomainPath + "/create",
+				ResponseFunc:  response.SendMsgResponse,
+				RequestParams: simple.CreateJsonBody,
+				Objects:       []domain.Object{simple.ValueObject},
+				ServiceFunc:   CreateTx(simple.TableName, options.createCallbacks),
+			})
+		}
 	}
 
 	// 删除班级
-	if !options.deleteNeedTx {
-		binding.DeleteBind(binder, &binding.SimpleBindItem[any]{
-			Path:          simple.DomainPath + "/:id/delete",
-			ResponseFunc:  response.SendMsgResponse,
-			RequestParams: simple.DeleteQueryParams,
-			Objects:       []domain.Object{simple.ValueObject},
-			ServiceFunc:   Delete(simple.TableName, dbExecutor, options.deleteCallbacks),
-		})
-	} else {
-		binding.DeleteBind(binder, &binding.SimpleBindItem[any]{
-			Path:          simple.DomainPath + "/:id/delete",
-			ResponseFunc:  response.SendMsgResponse,
-			RequestParams: simple.DeleteQueryParams,
-			Objects:       []domain.Object{simple.ValueObject},
-			ServiceFunc:   DeleteTx(simple.TableName, dbExecutor, options.deleteCallbacks),
-		})
+	if options.disableDelete {
+		if !options.deleteNeedTx {
+			binding.DeleteBind(binder, &binding.SimpleBindItem[any]{
+				Path:          simple.DomainPath + "/:id/delete",
+				ResponseFunc:  response.SendMsgResponse,
+				RequestParams: simple.DeleteQueryParams,
+				Objects:       []domain.Object{simple.ValueObject},
+				ServiceFunc:   Delete(simple.TableName, options.deleteCallbacks),
+			})
+		} else {
+			binding.DeleteBind(binder, &binding.SimpleBindItem[any]{
+				Path:          simple.DomainPath + "/:id/delete",
+				ResponseFunc:  response.SendMsgResponse,
+				RequestParams: simple.DeleteQueryParams,
+				Objects:       []domain.Object{simple.ValueObject},
+				ServiceFunc:   DeleteTx(simple.TableName, options.deleteCallbacks),
+			})
+		}
 	}
 
 	// 查询班级
-	binding.GetBind(binder, &binding.SimpleBindItem[response.InfosData[I]]{
-		Path:          simple.DomainPath + "/query",
-		ResponseFunc:  response.SendInfosResponse[I],
-		RequestParams: simple.QueryParams,
-		Objects:       []domain.Object{simple.ValueObject},
-		ServiceFunc:   Query(simple.TableName, dbExecutor, options.queryCallbacks, options.queryConditionFieldCallback),
-	})
+	if options.disableQuery {
+		binding.GetBind(binder, &binding.SimpleBindItem[response.InfosData[I]]{
+			Path:          simple.DomainPath + "/query",
+			ResponseFunc:  response.SendInfosResponse[I],
+			RequestParams: simple.QueryParams,
+			Objects:       []domain.Object{simple.ValueObject},
+			ServiceFunc:   Query(simple.TableName, options.queryCallbacks, options.queryConditionFieldCallback),
+		})
+	}
 }
 
-func BindSimple[I any](binder *binding.Binder, crud *Simple[I]) {
-	crud.bind(binder)
+func BindSimple[I any](binder *binding.Binder, simple *Simple[I], opts ...Option[I]) {
+	options := new(Options[I])
+
+	for _, opt := range opts {
+		opt(options)
+	}
+
+	simple.options = options
+
+	simple.bind(binder)
 }
 
 type Option[I any] func(options *Options[I])
 
 type Options[I any] struct {
+	// 关闭创建
+	disableCreate bool
+
 	// 创建是否使用事务
 	createNeedTx bool
 
@@ -106,6 +117,9 @@ type Options[I any] struct {
 	// 创建中间件
 	createMiddlewares []api.Handler
 
+	// 关闭删除
+	disableDelete bool
+
 	// 删除是否使用事务
 	deleteNeedTx bool
 
@@ -115,6 +129,9 @@ type Options[I any] struct {
 	// 删除中间件
 	deleteMiddlewares []api.Handler
 
+	// 关闭查询
+	disableQuery bool
+
 	// 查询条件构造回调
 	queryConditionFieldCallback ConditionFieldCallback
 
@@ -125,6 +142,12 @@ type Options[I any] struct {
 	queryMiddlewares []api.Handler
 }
 
+func WithDisableCreate[I any]() Option[I] {
+	return func(options *Options[I]) {
+		options.disableCreate = true
+	}
+}
+
 func WithCreateTx[I any]() Option[I] {
 	return func(options *Options[I]) {
 		options.createNeedTx = true
@@ -143,6 +166,12 @@ func WithCreateMiddlewares[I any](middlewares []api.Handler) Option[I] {
 	}
 }
 
+func WithDisableDelete[I any]() Option[I] {
+	return func(options *Options[I]) {
+		options.disableDelete = true
+	}
+}
+
 func WithDeleteTx[I any]() Option[I] {
 	return func(options *Options[I]) {
 		options.deleteNeedTx = true
@@ -161,6 +190,12 @@ func WithDeleteMiddlewares[I any](middlewares []api.Handler) Option[I] {
 	}
 }
 
+func WithDisableQuery[I any]() Option[I] {
+	return func(options *Options[I]) {
+		options.disableQuery = true
+	}
+}
+
 func WithQueryConditionFieldCallback[I any](callback ConditionFieldCallback) Option[I] {
 	return func(options *Options[I]) {
 		options.queryConditionFieldCallback = callback

examples/binding/main.go

@@ -3,7 +3,6 @@ package main
 import (
 	"git.sxidc.com/go-framework/baize"
 	"git.sxidc.com/go-framework/baize/application"
-	"git.sxidc.com/go-framework/baize/binding"
 	"git.sxidc.com/go-framework/baize/binding/request"
 	"git.sxidc.com/go-framework/baize/convenient/entity"
 	"git.sxidc.com/go-framework/baize/domain"
@@ -98,50 +97,6 @@ func main() {
 		baize.DestroyApplication(app)
 	}()
 
-	dbOperations := app.Infrastructure().DBOperations()
-	err := dbOperations.AutoMigrate(operations.Table{
-		TableName: tableName,
-		Columns: []operations.TableColumn{
-			{
-				Name:       "id",
-				Type:       "varchar(32)",
-				Comment:    "id",
-				PrimaryKey: true,
-			},
-			{
-				Name:    "name",
-				Type:    "varchar(128)",
-				Comment: "名称",
-				NotNull: true,
-				Index:   true,
-			},
-			{
-				Name:    "student_num",
-				Type:    "integer",
-				Comment: "学生数量",
-				NotNull: true,
-				Index:   true,
-			},
-			{
-				Name:    "created_time",
-				Type:    "timestamp with time zone",
-				Comment: "创建时间",
-				NotNull: true,
-				Index:   true,
-			},
-			{
-				Name:    "last_updated_time",
-				Type:    "timestamp with time zone",
-				Comment: "更新时间",
-				NotNull: true,
-				Index:   true,
-			},
-		},
-	})
-	if err != nil {
-		panic(err)
-	}
-
 	app.Api().
 		PrefixRouter().
 		RegisterVersionedRouter("v1")
@@ -149,7 +104,6 @@ func main() {
 	entity.BindSimple[ClassInfo](app.Binder("v1"), &entity.Simple[ClassInfo]{
 		Entity:             &Class{},
 		TableName:          tableName,
-		DBExecutorType:     binding.DBExecutorOperations,
 		DomainPath:         "/class",
 		CreateJsonBody:     &CreateClassJsonBody{},
 		DeleteQueryParams:  &DeleteClassPathParams{},

examples/binding/resources.yaml

@@ -0,0 +1,53 @@
+kind: Namespace
+spec:
+  name: baize
+
+---
+
+kind: DataSource
+spec:
+  type: database
+  namespace: baize
+  name: baize-binding
+  spec:
+    type: postgres
+    user_name: test
+    password: "123456"
+    address: "10.0.0.84"
+    port: "30432"
+    database: test
+    max_connections: 40
+    max_idle_connections: 10
+
+---
+
+kind: DataContainer
+spec:
+  namespace: baize
+  data_source: baize-binding
+  name: baize-binding
+  spec:
+    table_name: test.classes
+    columns:
+      - name: id
+        type: varchar(32)
+        comment: id
+        primary_key: true
+      - name: name
+        type: varchar(128)
+        comment: 班名
+        not_null: true
+        index: true
+      - name: student_num
+        type: integer
+        comment: 学生数量
+        not_null: true
+        index: true
+      - name: created_time
+        type: "timestamp with time zone"
+        comment: 创建时间
+        not_null: true
+      - name: last_updated_time
+        type: "timestamp with time zone"
+        comment: 最近更新时间
+        not_null: true

examples/binding_ds/main.go

@@ -3,7 +3,6 @@ package main
 import (
 	"git.sxidc.com/go-framework/baize"
 	"git.sxidc.com/go-framework/baize/application"
-	"git.sxidc.com/go-framework/baize/binding"
 	"git.sxidc.com/go-framework/baize/binding/request"
 	"git.sxidc.com/go-framework/baize/convenient/entity"
 	"git.sxidc.com/go-framework/baize/domain"
@@ -104,7 +103,6 @@ func main() {
 	entity.BindSimple[ClassInfo](app.Binder("v1"), &entity.Simple[ClassInfo]{
 		Entity:             &Class{},
 		TableName:          tableName,
-		DBExecutorType:     binding.DBExecutorDataService,
 		DomainPath:         "/class",
 		CreateJsonBody:     &CreateClassJsonBody{},
 		DeleteQueryParams:  &DeleteClassPathParams{},

infrastructure/infrastructure.go

@@ -1,6 +1,7 @@
 package infrastructure
 
 import (
+	"git.sxidc.com/go-framework/baize/infrastructure/database"
 	"git.sxidc.com/go-framework/baize/infrastructure/database/data_service"
 	"git.sxidc.com/go-framework/baize/infrastructure/database/operations"
 )
@@ -15,29 +16,27 @@ type DatabaseConfig struct {
 }
 
 type Infrastructure struct {
-	dbOperations *operations.Operations
-	dataService  *data_service.DataService
+	dbExecutor database.Executor
 }
 
 func NewInfrastructure(config Config) *Infrastructure {
 	i := new(Infrastructure)
 
+	// 数据库执行器多选一
 	if config.DatabaseConfig.Operations != nil {
 		op, err := operations.NewOperations(config.DatabaseConfig.Operations)
 		if err != nil {
 			panic("创建数据库操作失败" + err.Error())
 		}
 
-		i.dbOperations = op
-	}
-
-	if config.DatabaseConfig.DataService != nil {
+		i.dbExecutor = op
+	} else if config.DatabaseConfig.DataService != nil {
 		dataService, err := data_service.NewDataService(config.DatabaseConfig.DataService)
 		if err != nil {
 			panic("创建数据服务失败" + err.Error())
 		}
 
-		i.dataService = dataService
+		i.dbExecutor = dataService
 	}
 
 	return i
@@ -48,27 +47,27 @@ func DestroyInfrastructure(i *Infrastructure) {
 		return
 	}
 
-	if i.dataService != nil {
-		err := data_service.DestroyDataService(i.dataService)
-		if err != nil {
-			panic("销毁数据服务失败" + err.Error())
+	if i.dbExecutor != nil {
+		switch dbExecutor := i.dbExecutor.(type) {
+		case *operations.Operations:
+			err := operations.DestroyOperation(dbExecutor)
+			if err != nil {
+				panic("销毁数据库操作失败" + err.Error())
+			}
+		case *data_service.DataService:
+			err := data_service.DestroyDataService(dbExecutor)
+			if err != nil {
+				panic("销毁数据服务失败" + err.Error())
+			}
+		default:
+			panic("不支持的数据库执行器类型")
 		}
-	}
 
-	if i.dbOperations != nil {
-		err := operations.DestroyOperation(i.dbOperations)
-		if err != nil {
-			panic("销毁数据库操作失败" + err.Error())
-		}
 	}
 
 	return
 }
 
-func (i Infrastructure) DBOperations() *operations.Operations {
-	return i.dbOperations
-}
-
-func (i Infrastructure) DataService() *data_service.DataService {
-	return i.dataService
+func (i Infrastructure) DBExecutor() database.Executor {
+	return i.dbExecutor
 }