feat(core): 添加懒加载选项并优化循环依赖检测

- 新增懒加载选项，标记依赖在实际注入时加载
- 优化循环依赖检测逻辑，支持懒加载依赖
- 更新相关测试用例，验证懒加载功能

Author: dapeng

core.go

@@ -3,6 +3,7 @@ package gone
 import (
 	"fmt"
 	"reflect"
+	"strings"
 )
 
 type actionType int8
@@ -14,8 +15,33 @@ const (
 	DefaultProviderName            = "core-provider"
 	optionTag                      = "option"
 	allowNil                       = "allowNil"
+	lazy                           = "lazy"
 )
 
+func filedHasOption(filed *reflect.StructField, tagName string, optionName string) bool {
+	value, ok := filed.Tag.Lookup(tagName)
+	if !ok {
+		return false
+	}
+	if value == "" {
+		return false
+	}
+	split := strings.Split(value, ",")
+	for _, v := range split {
+		if v == optionName {
+			return true
+		}
+	}
+	return false
+}
+
+func isAllowNilField(filed *reflect.StructField) bool {
+	return filedHasOption(filed, optionTag, allowNil)
+}
+func isLazyField(filed *reflect.StructField) bool {
+	return filedHasOption(filed, optionTag, lazy)
+}
+
 // Flag is a marker struct used to identify components that can be managed by the gone framework.
 // Embedding this struct in another struct indicates that it can be used with gone's dependency injection.
 type Flag struct{}
@@ -283,8 +309,7 @@ func (s *Core) fillOne(coffin *coffin) error {
 				goneName = DefaultProviderName
 			}
 
-			op, y := field.Tag.Lookup(optionTag)
-			isAllowNil := y && op == allowNil
+			isAllowNil := isAllowNilField(&field)
 
 			co, err := s.getDepByName(goneName)
 			if err != nil {

dep.go

@@ -9,7 +9,7 @@ import (
 // circularDepsError creates an error for circular dependencies
 // Parameters:
 // - circularDeps: list of coffins involved in circular dependencies
-// Returns: error object containing information about the circular dependency components
+// Returns: error object containing information about the circular dependency Goners
 func circularDepsError(circularDeps []dependency) Error {
 	var names []string
 	prefix := "\t"
@@ -203,6 +203,11 @@ func (s *Core) getGonerFillDeps(co *coffin) (fillDependencies []dependency, err
 	case reflect.Struct:
 		for i := 0; i < elem.NumField(); i++ {
 			field := elem.Field(i)
+
+			if isLazyField(&field) {
+				continue
+			}
+
 			if tag, ok := field.Tag.Lookup(goneTag); ok {
 				gonerName, _ := ParseGoneTag(tag)
 				if gonerName == "" || gonerName == "*" {
@@ -234,7 +239,7 @@ func (s *Core) getGonerFillDeps(co *coffin) (fillDependencies []dependency, err
 					} else {
 						depCo, err := s.getDepByType(field.Type)
 						if err != nil {
-							if t, ok := field.Tag.Lookup(optionTag); ok && t == allowNil {
+							if isAllowNilField(&field) {
 								continue
 							}
 							return nil, ToErrorWithMsg(err, fmt.Sprintf("Cannot find matched value for field %q of %q", field.Name, GetTypeName(elem)))

option.go

@@ -4,7 +4,7 @@ import (
 	"reflect"
 )
 
-// Option is an interface for configuring components loaded into the gone framework.
+// Option is an interface for configuring Goners loaded into the gone framework.
 type Option interface {
 	Apply(c *coffin) error
 }
@@ -20,8 +20,8 @@ func (o option) Apply(c *coffin) error {
 	return o.apply(c)
 }
 
-// IsDefault returns an Option that marks a component as the default implementation for its type.
-// When multiple components of the same type exist, the default one will be used for injection
+// IsDefault returns an Option that marks a Goner as the default implementation for its type.
+// When multiple Goners of the same type exist, the default one will be used for injection
 // if no specific name is requested.
 //
 // Example usage:
@@ -68,7 +68,7 @@ func IsDefault(objPointers ...any) Option {
 	}
 }
 
-// Order returns an Option that sets the start order for a component.
+// Order returns an Option that sets the start order for a Goner.
 // Components with lower order values will be started before those with higher values.
 // This can be used to control started sequence when specific ordering is required.
 //
@@ -100,15 +100,15 @@ func LowStartPriority() Option {
 	return Order(100)
 }
 
-// Name returns an Option that sets a custom name for a component.
+// Name returns an Option that sets a custom name for a Goner.
 // Components can be looked up by this name when injecting dependencies.
 //
 // Example usage:
 //
 //	gone.Load(&EnvConfigure{}, gone.GonerName("configure"))
 //
 // Parameters:
-//   - name: String identifier to use for this component
+//   - name: String identifier to use for this Goner
 func Name(name string) Option {
 	return option{
 		apply: func(c *coffin) error {
@@ -118,8 +118,8 @@ func Name(name string) Option {
 	}
 }
 
-// OnlyForName returns an Option that marks a component as only available for name-based injection.
-// When this option is used, the component will not be registered as a type provider,
+// OnlyForName returns an Option that marks a Goner as only available for name-based injection.
+// When this option is used, the Goner will not be registered as a type provider,
 // meaning it can only be injected by explicitly referencing its name.
 //
 // Example usage:
@@ -136,15 +136,15 @@ func OnlyForName() Option {
 	}
 }
 
-// ForceReplace returns an Option that allows replacing existing components with the same name or type.
-// When loading a component with this option:
-// - If a component with the same name already exists, it will be replaced
+// ForceReplace returns an Option that allows replacing loaded Goners with the same name or type.
+// When loading a Goner with this option:
+// - If a Goner with the same name already exists, it will be replaced
 // - If a provider for the same type already exists, it will be replaced
 //
 // Example usage:
 //
 //	gone.Load(&MyService{}, gone.GonerName("service"), gone.ForceReplace())
-//	// This will replace any existing component named "service"
+//	// This will replace any existing Goner named "service"
 func ForceReplace() Option {
 	return option{
 		apply: func(c *coffin) error {
@@ -154,14 +154,12 @@ func ForceReplace() Option {
 	}
 }
 
-// LazyFill returns an Option that marks a component as lazy-filled.
-// When this option is used, the component will not be loaded until it is actually injected.
-// This can be useful for components that are expensive to load or have external dependencies.
+// LazyFill returns an Option that marks a Goner as lazy-filled.
+// When this option is used, the Goner will be filled at last.
 //
 // Example usage:
 //
 //	gone.Load(&MyService{}, gone.GonerName("service"), gone.LazyFill())
-//	// This will load the component only when it is actually injected
 func LazyFill() Option {
 	return option{
 		apply: func(c *coffin) error {

use_case/circular_dep_test.go

@@ -44,6 +44,8 @@ func TestCircularDependency2(t *testing.T) {
 			if !strings.Contains(r.(error).Error(), "circular dependency") {
 				t.Errorf("Expected panic with circular dependency error, got: %v", r)
 			}
+		} else {
+			t.Errorf("Expected panic with circular dependency error, got: %v", r)
 		}
 	}()
 	gone.

use_case/lazy_option_test.go

@@ -0,0 +1,35 @@
+package use_case
+
+import (
+	"github.com/gone-io/gone/v2"
+	"testing"
+)
+
+type depA4 struct {
+	gone.Flag
+	dep *depB4 `gone:"*"`
+}
+
+func (d *depA4) Init() {}
+
+type depB4 struct {
+	gone.Flag
+	dep *depA4 `gone:"*" option:"lazy"`
+}
+
+func (d *depB4) Init() {}
+
+func TestCircularDependency4(t *testing.T) {
+	gone.
+		NewApp().
+		Load(&depA4{}).
+		Load(&depB4{}).
+		Run(func(a4 *depA4, b4 *depB4) {
+			if a4.dep == nil {
+				t.Error("a4.dep should be not nil")
+			}
+			if b4.dep == nil {
+				t.Error("b4.dep should be not nil")
+			}
+		})
+}