修改命名

binding/entity_crud/service.go

@@ -15,7 +15,7 @@ import (
 	"reflect"
 )
 
-func CommonEntityCreate(tableName string, dbExecutor database.Executor, callbacks *Callbacks[string]) binding.ServiceFunc[string] {
+func CreateEntity(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) {
 		e, ok := objects[0].(domain.Entity)
 		if !ok {
@@ -50,7 +50,7 @@ func CommonEntityCreate(tableName string, dbExecutor database.Executor, callback
 	}
 }
 
-func CommonEntityDelete(tableName string, dbExecutor database.Executor, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
+func DeleteEntity(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) {
 		e, ok := objects[0].(domain.Entity)
 		if !ok {
@@ -94,7 +94,7 @@ func CommonEntityDelete(tableName string, dbExecutor database.Executor, callback
 	}
 }
 
-func CommonEntityUpdate(tableName string, dbExecutor database.Executor, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
+func UpdateEntity(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) {
 		e, ok := objects[0].(domain.Entity)
 		if !ok {
@@ -140,7 +140,7 @@ func CommonEntityUpdate(tableName string, dbExecutor database.Executor, callback
 
 type ConditionFieldCallback func(conditions *sql.Conditions, fieldName string, columnName string, value any) (hasDeal bool)
 
-func CommonEntityQuery[O any](tableName string, dbExecutor database.Executor, callbacks *Callbacks[response.InfosData[O]], conditionFieldCallback ConditionFieldCallback) binding.ServiceFunc[response.InfosData[O]] {
+func QueryEntities[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)
 		if !ok {
@@ -209,7 +209,7 @@ func CommonEntityQuery[O any](tableName string, dbExecutor database.Executor, ca
 	}
 }
 
-func CommonEntityQueryByID[O any](tableName string, dbExecutor database.Executor, callbacks *Callbacks[O]) binding.ServiceFunc[O] {
+func GetEntityByID[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) {
 		var outputZero O
 		outputZeroValue := reflect.Zero(reflect.TypeOf(outputZero))

binding/entity_crud/simple.go

@@ -64,10 +64,10 @@ type Simple[O any] struct {
 	QueryCallbacks *Callbacks[response.InfosData[O]]
 
 	// 根据ID查询使用的DTO，注意是WithID类型
-	QueryByIDDTO request.WithID
+	GetByIDDTO request.WithID
 
 	// 根据ID查询回调
-	QueryByIDCallbacks *Callbacks[O]
+	GetByIDCallbacks *Callbacks[O]
 }
 
 func (crud *Simple[O]) bind(binder *binding.Binder) {
@@ -80,7 +80,7 @@ func (crud *Simple[O]) bind(binder *binding.Binder) {
 			ResponseFunc: response.SendIDResponse[string],
 			DTO:          crud.CreateDTO,
 			Objects:      []domain.Object{crud.Entity},
-			ServiceFunc:  CommonEntityCreate(crud.TableName, dbExecutor, crud.CreateCallbacks),
+			ServiceFunc:  CreateEntity(crud.TableName, dbExecutor, crud.CreateCallbacks),
 		})
 	} else {
 		binding.PostBind(binder, &binding.SimpleBindItem[string]{
@@ -99,7 +99,7 @@ func (crud *Simple[O]) bind(binder *binding.Binder) {
 			ResponseFunc: response.SendMsgResponse,
 			DTO:          crud.DeleteDTO,
 			Objects:      []domain.Object{crud.Entity},
-			ServiceFunc:  CommonEntityDelete(crud.TableName, dbExecutor, crud.DeleteCallbacks),
+			ServiceFunc:  DeleteEntity(crud.TableName, dbExecutor, crud.DeleteCallbacks),
 		})
 	} else {
 		binding.DeleteBind(binder, &binding.SimpleBindItem[any]{
@@ -118,7 +118,7 @@ func (crud *Simple[O]) bind(binder *binding.Binder) {
 			ResponseFunc: response.SendMsgResponse,
 			DTO:          crud.UpdateDTO,
 			Objects:      []domain.Object{crud.Entity},
-			ServiceFunc:  CommonEntityUpdate(crud.TableName, dbExecutor, crud.UpdateCallbacks),
+			ServiceFunc:  UpdateEntity(crud.TableName, dbExecutor, crud.UpdateCallbacks),
 		})
 	} else {
 		binding.PutBind(binder, &binding.SimpleBindItem[any]{
@@ -136,15 +136,15 @@ func (crud *Simple[O]) bind(binder *binding.Binder) {
 		ResponseFunc: response.SendInfosResponse[O],
 		DTO:          crud.QueryDTO,
 		Objects:      []domain.Object{crud.Entity},
-		ServiceFunc:  CommonEntityQuery[O](crud.TableName, dbExecutor, crud.QueryCallbacks, crud.QueryConditionFieldCallback),
+		ServiceFunc:  QueryEntities[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.QueryByIDDTO,
+		DTO:          crud.GetByIDDTO,
 		Objects:      []domain.Object{crud.Entity},
-		ServiceFunc:  CommonEntityQueryByID[O](crud.TableName, dbExecutor, crud.QueryByIDCallbacks),
+		ServiceFunc:  GetEntityByID[O](crud.TableName, dbExecutor, crud.GetByIDCallbacks),
 	})
 }

binding/value_object/service.go

@@ -0,0 +1,407 @@
+package entity_crud
+
+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"
+	"git.sxidc.com/go-framework/baize/domain"
+	"git.sxidc.com/go-framework/baize/infrastructure"
+	"git.sxidc.com/go-framework/baize/infrastructure/database"
+	"git.sxidc.com/go-framework/baize/infrastructure/database/sql"
+	"git.sxidc.com/go-framework/baize/tag/sql/sql_mapping"
+	"git.sxidc.com/go-tools/utils/strutils"
+	"git.sxidc.com/service-supports/fserr"
+	"reflect"
+)
+
+func CommonEntityCreate(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) {
+		e, ok := objects[0].(domain.Entity)
+		if !ok {
+			return "", fserr.New("需要传递领域对象应该为实体")
+		}
+
+		err := e.GenerateID()
+		if err != nil {
+			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, "")
+		}
+
+		err = callbackBeforeDBOperate(callbacks, e, dbExecutor)
+		if err != nil {
+			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, "")
+		}
+
+		err = database.InsertEntity(dbExecutor, tableName, e)
+		if err != nil {
+			if database.IsErrorDBRecordHasExist(err) {
+				err = fserr.New(e.DomainCNName() + "已存在")
+			}
+
+			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, "")
+		}
+
+		err = callbackAfterDBOperate(callbacks, e, dbExecutor)
+		if err != nil {
+			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, "")
+		}
+
+		return callbackOnSuccessReturn(callbacks, e, dbExecutor, e.GetID())
+	}
+}
+
+func CommonEntityDelete(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) {
+		e, ok := objects[0].(domain.Entity)
+		if !ok {
+			return nil, fserr.New("需要传递领域对象应该为实体")
+		}
+
+		if strutils.IsStringEmpty(e.GetID()) {
+			err := fserr.New("领域实体ID为空")
+			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
+		}
+
+		exist, err := database.CheckExist(dbExecutor, &sql.CheckExistExecuteParams{
+			TableName:  tableName,
+			Conditions: sql.NewConditions().Equal(e.IDColumnName(), e.GetID()),
+		})
+		if err != nil {
+			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
+		}
+
+		if !exist {
+			err := fserr.New(e.DomainCNName() + "不存在")
+			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
+		}
+
+		err = callbackBeforeDBOperate(callbacks, e, dbExecutor)
+		if err != nil {
+			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
+		}
+
+		err = database.DeleteEntity(dbExecutor, tableName, e)
+		if err != nil {
+			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
+		}
+
+		err = callbackAfterDBOperate(callbacks, e, dbExecutor)
+		if err != nil {
+			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
+		}
+
+		return callbackOnSuccessReturn(callbacks, e, dbExecutor, nil)
+	}
+}
+
+func CommonEntityUpdate(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) {
+		e, ok := objects[0].(domain.Entity)
+		if !ok {
+			return nil, fserr.New("需要传递领域对象应该为实体")
+		}
+
+		if strutils.IsStringEmpty(e.GetID()) {
+			err := fserr.New("领域实体ID为空")
+			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
+		}
+
+		exist, err := database.CheckExist(dbExecutor, &sql.CheckExistExecuteParams{
+			TableName:  tableName,
+			Conditions: sql.NewConditions().Equal(e.IDColumnName(), e.GetID()),
+		})
+		if err != nil {
+			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
+		}
+
+		if !exist {
+			err := fserr.New(e.DomainCNName() + "不存在")
+			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
+		}
+
+		err = callbackBeforeDBOperate(callbacks, e, dbExecutor)
+		if err != nil {
+			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
+		}
+
+		err = database.UpdateEntity(dbExecutor, tableName, e)
+		if err != nil {
+			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
+		}
+
+		err = callbackAfterDBOperate(callbacks, e, dbExecutor)
+		if err != nil {
+			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
+		}
+
+		return callbackOnSuccessReturn(callbacks, e, dbExecutor, nil)
+	}
+}
+
+type ConditionFieldCallback func(conditions *sql.Conditions, fieldName string, columnName string, value any) (hasDeal bool)
+
+func CommonEntityQuery[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)
+		if !ok {
+			return response.InfosData[O]{}, fserr.New("DTO不是Query")
+		}
+
+		e, ok := objects[0].(domain.Entity)
+		if !ok {
+			return response.InfosData[O]{}, fserr.New("需要传递领域对象应该为实体")
+		}
+
+		conditions := sql.NewConditions()
+
+		fields, err := sql_mapping.DefaultUsage(e)
+		if err != nil {
+			return response.InfosData[O]{}, err
+		}
+
+		for _, field := range fields {
+			hasDeal := false
+			if conditionFieldCallback != nil {
+				hasDeal = conditionFieldCallback(conditions, field.FieldName, field.ColumnName, field.Value)
+			}
+
+			if !hasDeal {
+				fieldValue := reflect.ValueOf(field.Value)
+				if !fieldValue.IsZero() {
+					conditions.Equal(field.ColumnName, field.Value)
+				}
+			}
+		}
+
+		err = callbackBeforeDBOperate(callbacks, e, dbExecutor)
+		if err != nil {
+			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, response.InfosData[O]{})
+		}
+
+		results, totalCount, err := database.Query(dbExecutor, &sql.QueryExecuteParams{
+			TableName:  tableName,
+			Conditions: conditions,
+			PageNo:     queryDTO.GetPageNo(),
+			PageSize:   queryDTO.GetPageSize(),
+		})
+		if err != nil {
+			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, response.InfosData[O]{})
+		}
+
+		err = callbackAfterDBOperate(callbacks, e, dbExecutor)
+		if err != nil {
+			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, response.InfosData[O]{})
+		}
+
+		infos := make([]O, 0)
+		err = sql.ParseSqlResult(results, &infos)
+		if err != nil {
+			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, response.InfosData[O]{})
+		}
+
+		output := response.InfosData[O]{
+			Infos:      infos,
+			TotalCount: totalCount,
+			PageNo:     queryDTO.GetPageNo(),
+		}
+
+		return callbackOnSuccessReturn(callbacks, e, dbExecutor, output)
+	}
+}
+
+func CommonEntityQueryByID[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) {
+		var outputZero O
+		outputZeroValue := reflect.Zero(reflect.TypeOf(outputZero))
+		if outputZeroValue.Kind() == reflect.Pointer {
+			outputZeroValue.Set(reflect.New(outputZeroValue.Type().Elem()))
+		}
+
+		e, ok := objects[0].(domain.Entity)
+		if !ok {
+			return outputZero, fserr.New("需要传递领域对象应该为实体")
+		}
+
+		if strutils.IsStringEmpty(e.GetID()) {
+			err := fserr.New("领域实体ID为空")
+			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, outputZero)
+		}
+
+		err := callbackBeforeDBOperate(callbacks, e, dbExecutor)
+		if err != nil {
+			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, outputZero)
+		}
+
+		result, err := database.QueryOne(dbExecutor, &sql.QueryOneExecuteParams{
+			TableName:  tableName,
+			Conditions: sql.NewConditions().Equal(e.IDColumnName(), e.GetID()),
+		})
+		if err != nil {
+			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, outputZero)
+		}
+
+		err = callbackAfterDBOperate(callbacks, e, dbExecutor)
+		if err != nil {
+			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, outputZero)
+		}
+
+		var info O
+		var infoPointer any
+
+		infoPointer = &info
+		if outputZeroValue.Kind() == reflect.Pointer {
+			infoPointer = info
+		}
+
+		err = sql.ParseSqlResult(result, infoPointer)
+		if err != nil {
+			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, outputZero)
+		}
+
+		return callbackOnSuccessReturn(callbacks, e, dbExecutor, info)
+	}
+}
+
+func CommonEntityCreateTx(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) {
+		e, ok := objects[0].(domain.Entity)
+		if !ok {
+			return "", fserr.New("需要传递领域对象应该为实体")
+		}
+
+		err := e.GenerateID()
+		if err != nil {
+			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, "")
+		}
+
+		err = database.Transaction(dbExecutor, func(tx database.Executor) error {
+			err = callbackBeforeDBOperate(callbacks, e, tx)
+			if err != nil {
+				return err
+			}
+
+			err = database.InsertEntity(tx, tableName, e)
+			if err != nil {
+				if database.IsErrorDBRecordHasExist(err) {
+					err = fserr.New(e.DomainCNName() + "已存在")
+				}
+
+				return err
+			}
+
+			err = callbackAfterDBOperate(callbacks, e, tx)
+			if err != nil {
+				return err
+			}
+
+			return nil
+		})
+		if err != nil {
+			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, "")
+		}
+
+		return callbackOnSuccessReturn(callbacks, e, dbExecutor, e.GetID())
+	}
+}
+
+func CommonEntityDeleteTx(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) {
+		e, ok := objects[0].(domain.Entity)
+		if !ok {
+			return nil, fserr.New("需要传递领域对象应该为实体")
+		}
+
+		if strutils.IsStringEmpty(e.GetID()) {
+			err := fserr.New("领域实体ID为空")
+			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
+		}
+
+		exist, err := database.CheckExist(dbExecutor, &sql.CheckExistExecuteParams{
+			TableName:  tableName,
+			Conditions: sql.NewConditions().Equal(e.IDColumnName(), e.GetID()),
+		})
+		if err != nil {
+			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
+		}
+
+		if !exist {
+			err := fserr.New(e.DomainCNName() + "不存在")
+			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
+		}
+
+		err = database.Transaction(dbExecutor, func(tx database.Executor) error {
+			err = callbackBeforeDBOperate(callbacks, e, tx)
+			if err != nil {
+				return err
+			}
+
+			err = database.DeleteEntity(tx, tableName, e)
+			if err != nil {
+				return err
+			}
+
+			err = callbackAfterDBOperate(callbacks, e, tx)
+			if err != nil {
+				return err
+			}
+
+			return nil
+		})
+		if err != nil {
+			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
+		}
+
+		return callbackOnSuccessReturn(callbacks, e, dbExecutor, nil)
+	}
+}
+
+func CommonEntityUpdateTx(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) {
+		e, ok := objects[0].(domain.Entity)
+		if !ok {
+			return nil, fserr.New("需要传递领域对象应该为实体")
+		}
+
+		if strutils.IsStringEmpty(e.GetID()) {
+			err := fserr.New("领域实体ID为空")
+			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
+		}
+
+		exist, err := database.CheckExist(dbExecutor, &sql.CheckExistExecuteParams{
+			TableName:  tableName,
+			Conditions: sql.NewConditions().Equal(e.IDColumnName(), e.GetID()),
+		})
+		if err != nil {
+			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
+		}
+
+		if !exist {
+			err := fserr.New(e.DomainCNName() + "不存在")
+			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
+		}
+
+		err = database.Transaction(dbExecutor, func(tx database.Executor) error {
+			err = callbackBeforeDBOperate(callbacks, e, tx)
+			if err != nil {
+				return err
+			}
+
+			err = database.UpdateEntity(tx, tableName, e)
+			if err != nil {
+				return err
+			}
+
+			err = callbackAfterDBOperate(callbacks, e, tx)
+			if err != nil {
+				return err
+			}
+
+			return nil
+		})
+		if err != nil {
+			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
+		}
+
+		return callbackOnSuccessReturn(callbacks, e, dbExecutor, nil)
+	}
+}

binding/value_object/service_callbacks.go

@@ -0,0 +1,61 @@
+package entity_crud
+
+import (
+	"git.sxidc.com/go-framework/baize/domain"
+	"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)
+}
+
+func callbackBeforeDBOperate[O any](callbacks *Callbacks[O], valueObject domain.ValueObject, dbExecutor database.Executor) error {
+	if callbacks == nil {
+		return nil
+	}
+
+	if callbacks.BeforeDBOperate == nil {
+		return callbacks.BeforeDBOperate(valueObject, dbExecutor)
+	}
+
+	return nil
+}
+
+func callbackAfterDBOperate[O any](callbacks *Callbacks[O], valueObject domain.ValueObject, dbExecutor database.Executor) error {
+	if callbacks == nil {
+		return nil
+	}
+
+	if callbacks.AfterDBOperate == nil {
+		return callbacks.AfterDBOperate(valueObject, dbExecutor)
+	}
+
+	return nil
+}
+
+func callbackOnSuccessReturn[O any](callbacks *Callbacks[O], valueObject domain.ValueObject, dbExecutor database.Executor, output O) (O, error) {
+	if callbacks == nil {
+		return output, nil
+	}
+
+	if callbacks.OnSuccessReturn == nil {
+		return callbacks.OnSuccessReturn(valueObject, dbExecutor, output)
+	}
+
+	return output, nil
+}
+
+func callbackOnErrorReturn[O any](callbacks *Callbacks[O], valueObject domain.ValueObject, err error, dbExecutor database.Executor, defaultErrOutput O) (O, error) {
+	if callbacks == nil {
+		return defaultErrOutput, err
+	}
+
+	if callbacks.OnErrorReturn == nil {
+		return callbacks.OnErrorReturn(valueObject, err, dbExecutor, defaultErrOutput)
+	}
+
+	return defaultErrOutput, err
+}

domain/entity.go

@@ -19,7 +19,7 @@ type BaseEntity struct {
 }
 
 func (e *BaseEntity) DomainCNName() string {
-	return "基础实体"
+	panic("领域实体没有实现DomainCNName接口")
 }
 
 func (e *BaseEntity) GenerateID() error {

domain/value_object.go

@@ -0,0 +1,8 @@
+package domain
+
+type ValueObject interface {
+	Object
+	DomainCNName() string
+	GetKeyColumnAndValues() map[string]any
+	CheckKeyColumnAndValues(errCode int) error
+}

examples/binding/main.go

@@ -158,7 +158,7 @@ func main() {
 		UpdateDTO:      &UpdateClassJsonBody{},
 		UpdateNeedTx:   false,
 		QueryDTO:       &QueryClassesQueryParams{},
-		QueryByIDDTO:   &GetClassQueryParams{},
+		GetByIDDTO:     &GetClassQueryParams{},
 	})
 
 	go func() {

examples/binding_ds/main.go

@@ -113,7 +113,7 @@ func main() {
 		UpdateDTO:      &UpdateClassJsonBody{},
 		UpdateNeedTx:   true,
 		QueryDTO:       &QueryClassesQueryParams{},
-		QueryByIDDTO:   &GetClassQueryParams{},
+		GetByIDDTO:     &GetClassQueryParams{},
 	})
 
 	go func() {