fix: barry quick fix, 2025-06-08 10:42:50

Author: kooksee

dix.go

@@ -36,11 +36,11 @@ func New(opts ...Option) Container {
 // 提供了统一的依赖注入接口，简化API设计。
 //
 // 支持的输入类型：
-//   - 函数：func(deps...) - 解析函数参数并调用函数
+//   - 函数：func(deps...) 或 func(deps...) error - 解析函数参数并调用函数
 //   - 结构体指针：&struct{} - 注入到结构体字段
 //
 // 函数注入规则：
-//   - 函数只能有入参，不能有出参
+//   - 函数可以没有返回值，或者有一个 error 返回值
 //   - 函数参数类型必须在容器中已注册
 //   - 支持的参数类型：指针(*T)、接口(interface{})、结构体(struct{})、切片([]T)、映射(map[string]T)
 //   - 不支持基本类型参数：string, int, bool 等
@@ -63,7 +63,7 @@ func New(opts ...Option) Container {
 //
 // 示例：
 //
-//	// 函数注入
+//	// 函数注入（无返回值）
 //	_, err := dix.Inject(container, func(logger Logger, db *Database, handlers []Handler) {
 //	    // 使用注入的依赖启动服务器
 //	    startServer(logger, db, handlers)
@@ -72,6 +72,15 @@ func New(opts ...Option) Container {
 //	    log.Fatal(err)
 //	}
 //
+//	// 函数注入（error 返回值）
+//	_, err := dix.Inject(container, func(logger Logger, db *Database) error {
+//	    // 执行可能失败的初始化操作
+//	    return initializeSystem(logger, db)
+//	})
+//	if err != nil {
+//	    log.Fatal(err)
+//	}
+//
 //	// 结构体注入
 //	type Service struct {
 //	    Logger Logger

dixglobal/global.go

@@ -1,9 +1,10 @@
 package dixglobal
 
 import (
-	"github.com/pubgo/funk/errors"
 	"reflect"
 
+	"github.com/pubgo/funk/errors"
+
 	"github.com/pubgo/dix/dixinternal"
 )
 
@@ -19,6 +20,14 @@ var _container = dixinternal.New(dixinternal.WithValuesNull())
 //		server.ListenAndServe()
 //	})
 //
+//	// 或者带错误处理的函数注入
+//	Inject(func(server *http.Server, db *Database) error {
+//		if err := db.Connect(); err != nil {
+//			return err
+//		}
+//		return server.ListenAndServe()
+//	})
+//
 //	// 或者使用结构体注入
 //	type App struct {
 //		Server *http.Server

dixinternal/container.go

@@ -132,19 +132,42 @@ func (c *ContainerImpl) getAllProviders() map[reflect.Type][]Provider {
 
 // removeProvider 移除提供者（用于回滚）
 func (c *ContainerImpl) removeProvider(provider Provider) {
-	typ := provider.Type()
-	providers := c.resolver.providers[typ]
-
-	for i, p := range providers {
-		if p == provider {
-			// 移除该提供者
-			c.resolver.providers[typ] = append(providers[:i], providers[i+1:]...)
-			break
+	// 移除该 provider 在所有其能提供的类型下的注册
+	providedTypes := provider.ProvidedTypes()
+
+	for _, typ := range providedTypes {
+		providers := c.resolver.providers[typ]
+
+		for i, p := range providers {
+			if p == provider {
+				// 移除该提供者
+				c.resolver.providers[typ] = append(providers[:i], providers[i+1:]...)
+				break
+			}
+		}
+
+		// 如果该类型没有提供者了，删除整个条目
+		if len(c.resolver.providers[typ]) == 0 {
+			delete(c.resolver.providers, typ)
 		}
 	}
 
-	// 如果该类型没有提供者了，删除整个条目
-	if len(c.resolver.providers[typ]) == 0 {
-		delete(c.resolver.providers, typ)
+	// 向后兼容：如果没有 ProvidedTypes，使用传统的 PrimaryType() 方法
+	if len(providedTypes) == 0 {
+		typ := provider.PrimaryType()
+		providers := c.resolver.providers[typ]
+
+		for i, p := range providers {
+			if p == provider {
+				// 移除该提供者
+				c.resolver.providers[typ] = append(providers[:i], providers[i+1:]...)
+				break
+			}
+		}
+
+		// 如果该类型没有提供者了，删除整个条目
+		if len(c.resolver.providers[typ]) == 0 {
+			delete(c.resolver.providers, typ)
+		}
 	}
 }

dixinternal/cycle_detector.go

@@ -29,14 +29,48 @@ func (cd *CycleDetectorImpl) buildDependencyGraph(providers map[reflect.Type][]P
 		graph[outputType] = make(map[reflect.Type]bool)
 	}
 
+	// 跟踪已处理的 provider，避免重复处理多类型 provider
+	processedProviders := make(map[Provider]bool)
+
 	// 构建依赖关系图
-	for outputType, providerList := range providers {
+	for _, providerList := range providers {
 		for _, provider := range providerList {
-			for _, dep := range provider.Dependencies() {
-				// 递归获取所有依赖类型
-				depTypes := cd.getAllDependencyTypes(dep)
-				for _, depType := range depTypes {
-					graph[outputType][depType] = true
+			// 跳过已处理的 provider，避免多类型 provider 被重复处理
+			if processedProviders[provider] {
+				continue
+			}
+			processedProviders[provider] = true
+
+			// 获取该 provider 能提供的所有类型
+			providedTypes := provider.ProvidedTypes()
+			if len(providedTypes) == 0 {
+				// 向后兼容：使用 PrimaryType
+				providedTypes = []reflect.Type{provider.PrimaryType()}
+			}
+
+			// 为每个提供的类型建立依赖关系
+			for _, providedType := range providedTypes {
+				if graph[providedType] == nil {
+					graph[providedType] = make(map[reflect.Type]bool)
+				}
+
+				for _, dep := range provider.Dependencies() {
+					// 递归获取所有依赖类型
+					depTypes := cd.getAllDependencyTypes(dep)
+					for _, depType := range depTypes {
+						// 避免自依赖（同一个 provider 提供的类型之间不应该有依赖关系）
+						isProvidedBySameProvider := false
+						for _, pt := range providedTypes {
+							if pt == depType {
+								isProvidedBySameProvider = true
+								break
+							}
+						}
+
+						if !isProvidedBySameProvider {
+							graph[providedType][depType] = true
+						}
+					}
 				}
 			}
 		}

dixinternal/injector.go

@@ -50,6 +50,12 @@ func (inj *InjectorImpl) InjectStruct(target reflect.Value, opts Options) (err e
 			continue
 		}
 
+		// 只对支持的字段类型进行注入
+		if !isInjectableFieldType(field.Type) {
+			logger.Debug().Msgf("skipping non-injectable field: %s (type: %s)", field.Name, field.Type.String())
+			continue
+		}
+
 		err := inj.injectField(fieldValue, field, opts)
 		if err != nil {
 			return WrapError(err, ErrorTypeInjection, "failed to inject struct field").
@@ -84,8 +90,19 @@ func (inj *InjectorImpl) InjectFunc(fn reflect.Value, opts Options) (err error)
 	}
 
 	fnType := fn.Type()
-	if fnType.NumOut() != 0 {
-		return NewValidationError("injectable function must have no return values").
+
+	// 检查返回值：允许没有返回值或者只有一个 error 返回值
+	var hasErrorReturn bool
+	if fnType.NumOut() == 1 {
+		// 如果有一个返回值，必须是 error 类型
+		errorType := fnType.Out(0)
+		if !errorType.Implements(reflect.TypeOf((*error)(nil)).Elem()) {
+			return NewValidationError("injectable function can only return error type").
+				WithDetail("return_type", errorType.String())
+		}
+		hasErrorReturn = true
+	} else if fnType.NumOut() > 1 {
+		return NewValidationError("injectable function can have at most one return value (error)").
 			WithDetail("return_count", fnType.NumOut())
 	}
 
@@ -94,8 +111,8 @@ func (inj *InjectorImpl) InjectFunc(fn reflect.Value, opts Options) (err error)
 			WithDetail("parameter_count", fnType.NumIn())
 	}
 
-	// 解析函数参数依赖
-	dependencies, err := parseDependencies(fnType)
+	// 解析函数参数依赖（对于普通函数注入，不需要结构体字段展开）
+	dependencies, err := parseBasicDependencies(fnType)
 	if err != nil {
 		return WrapError(err, ErrorTypeValidation, "failed to parse function dependencies")
 	}
@@ -107,7 +124,18 @@ func (inj *InjectorImpl) InjectFunc(fn reflect.Value, opts Options) (err error)
 	}
 
 	// 调用函数
-	fn.Call(args)
+	results := fn.Call(args)
+
+	// 如果函数有 error 返回值，检查并处理
+	if hasErrorReturn && len(results) > 0 {
+		errorValue := results[0]
+		if !errorValue.IsNil() {
+			if funcErr, ok := errorValue.Interface().(error); ok {
+				return WrapError(funcErr, ErrorTypeInjection, "injected function returned error")
+			}
+		}
+	}
+
 	return nil
 }
 
@@ -178,6 +206,11 @@ func (inj *InjectorImpl) injectField(fieldValue reflect.Value, field reflect.Str
 		// 解析并设置值
 		val, err := inj.resolver.Resolve(field.Type, opts)
 		if err != nil {
+			// 如果无法解析，尝试从结构体字段依赖中获取
+			if structFieldVal := inj.tryResolveFromStructFields(field.Type, opts); structFieldVal.IsValid() {
+				fieldValue.Set(structFieldVal)
+				return nil
+			}
 			return WrapError(err, ErrorTypeInjection, "failed to resolve field value").
 				WithDetail("field_name", field.Name).
 				WithDetail("field_type", field.Type.String())
@@ -220,15 +253,22 @@ func (inj *InjectorImpl) injectField(fieldValue reflect.Value, field reflect.Str
 		}
 
 	default:
-		return NewValidationError("unsupported field type for injection").
-			WithDetail("field_name", field.Name).
-			WithDetail("field_type", field.Type.String()).
-			WithDetail("field_kind", field.Type.Kind().String())
+		// 对于不支持的字段类型，直接跳过而不是报错
+		logger.Debug().Msgf("skipping field with unsupported type: %s (type: %s)", field.Name, field.Type.String())
+		return nil
 	}
 
 	return nil
 }
 
+// tryResolveFromStructFields 尝试从结构体字段依赖中解析类型
+func (inj *InjectorImpl) tryResolveFromStructFields(fieldType reflect.Type, opts Options) reflect.Value {
+	// 这是一个辅助方法，用于处理结构体字段的递归依赖解析
+	// 在实际实现中，这可能需要与resolver的内部实现更紧密地集成
+	// 目前先返回零值，表示无法解析
+	return reflect.Value{}
+}
+
 // injectMethods 注入方法
 func (inj *InjectorImpl) injectMethods(target reflect.Value, opts Options) error {
 	targetType := target.Type()