Add @configuration supported

Author: limpo1989

README.md

@@ -29,6 +29,7 @@ In addition to implementing a powerful IoC container similar to Java Spring, Go-
 | `@Value` 								                     | `value:"${}"` 				             |
 | `@Autowired` `@Qualifier` `@Required` | `autowire:"?"` 				            |
 | `@Configurable` 						                | `WireBean()` 					             |
+| `@Configuration`                      | `Configuration()`              |
 | `@Profile` 							                    | `ConditionOnProfile()` 		      |
 | `@Primary` 							                    | `Primary()` 					              |
 | `@DependsOn` 							                  | `DependsOn()` 				             |

gs/app.go

@@ -69,7 +69,7 @@ func (app *App) Run(resourceLocator ...ResourceLocator) error {
 
 func (app *App) run(resourceLocator ResourceLocator) error {
 
-	e := NewConfiguration(resourceLocator)
+	e := NewAppConfiguration(resourceLocator)
 
 	if err := e.Load(app.container.props); nil != err {
 		return err
@@ -216,7 +216,17 @@ func (app *App) Provide(ctor interface{}, args ...arg.Arg) *BeanDefinition {
 	return app.container.Accept(NewBean(ctor, args...))
 }
 
+// Configuration scan that the object `i` has `NewXXX` methods to Ioc container.
+func (app *App) Configuration(i interface{}) *BeanDefinition {
+	return app.container.Configuration(i)
+}
+
 // AllowCircularReferences enable circular-references.
 func (app *App) AllowCircularReferences() {
 	app.container.AllowCircularReferences()
 }
+
+// Go start a goroutine managed by the IoC container.
+func (app *App) Go(fn func(ctx context.Context)) {
+	app.container.Go(fn)
+}

gs/app_configuration.go

@@ -24,17 +24,17 @@ import (
 	"github.com/go-spring-projects/go-spring/conf"
 )
 
-type Configuration struct {
+type AppConfiguration struct {
 	resourceLocator  ResourceLocator
 	ActiveProfiles   []string `value:"${spring.config.profiles:=}"`
 	ConfigExtensions []string `value:"${spring.config.extensions:=.properties,.yaml,.yml,.toml,.tml}"`
 }
 
-func NewConfiguration(resourceLocator ResourceLocator) *Configuration {
-	return &Configuration{resourceLocator: resourceLocator}
+func NewAppConfiguration(resourceLocator ResourceLocator) *AppConfiguration {
+	return &AppConfiguration{resourceLocator: resourceLocator}
 }
 
-func (e *Configuration) Load(props *conf.Properties) error {
+func (e *AppConfiguration) Load(props *conf.Properties) error {
 	p := conf.New()
 
 	if err := loadSystemEnv(p); err != nil {
@@ -62,7 +62,7 @@ func (e *Configuration) Load(props *conf.Properties) error {
 	return nil
 }
 
-func (e *Configuration) loadProperties(props *conf.Properties) error {
+func (e *AppConfiguration) loadProperties(props *conf.Properties) error {
 	var resources []Resource
 
 	for _, ext := range e.ConfigExtensions {
@@ -106,7 +106,7 @@ func (e *Configuration) loadProperties(props *conf.Properties) error {
 	return nil
 }
 
-func (e *Configuration) loadResource(filename string) ([]Resource, error) {
+func (e *AppConfiguration) loadResource(filename string) ([]Resource, error) {
 
 	var locators []ResourceLocator
 	locators = append(locators, e.resourceLocator)

gs/boot.go

@@ -56,25 +56,30 @@ func Property(key string, fn interface{}) {
 
 // Accept register bean to Ioc container.
 func Accept(b *BeanDefinition) *BeanDefinition {
-	return bootApp.container.Accept(b)
+	return bootApp.Accept(b)
 }
 
 // Object register bean to Ioc container.
 func Object(i interface{}) *BeanDefinition {
-	return bootApp.container.Accept(NewBean(reflect.ValueOf(i)))
+	return bootApp.Accept(NewBean(reflect.ValueOf(i)))
 }
 
 // Provide register bean to Ioc container.
 func Provide(ctor interface{}, args ...arg.Arg) *BeanDefinition {
-	return bootApp.container.Accept(NewBean(ctor, args...))
+	return bootApp.Accept(NewBean(ctor, args...))
+}
+
+// Configuration scan the object `i` has `NewXXX` methods to Ioc container.
+func Configuration(i interface{}) *BeanDefinition {
+	return bootApp.Configuration(i)
 }
 
 // Go start a goroutine managed by the IoC container.
 func Go(fn func(ctx context.Context)) {
-	bootApp.container.Go(fn)
+	bootApp.Go(fn)
 }
 
 // AllowCircularReferences enable circular-references.
 func AllowCircularReferences() {
-	bootApp.container.AllowCircularReferences()
+	bootApp.AllowCircularReferences()
 }

gs/gs.go

@@ -59,6 +59,7 @@ type Container interface {
 	AllowCircularReferences()
 	Object(i interface{}) *BeanDefinition
 	Provide(ctor interface{}, args ...arg.Arg) *BeanDefinition
+	Configuration(i interface{}) *BeanDefinition
 	Refresh() error
 	Close()
 }
@@ -187,6 +188,81 @@ func (c *container) AllowCircularReferences() {
 	c.allowCircularReferences = true
 }
 
+// Configuration scan that the object `i` has `NewXXX` methods to Ioc container.
+//
+// example:
+//
+// func(x *T) NewFoo() *Foo
+//
+// func(x *T) NewBar(foo *Foo) *Bar
+//
+// func(x *T) NewSubject(bar *Bar) (*Subject, error)
+//
+// func(x *T) NewServer() *gs.BeanDefinition
+func (c *container) Configuration(i interface{}) *BeanDefinition {
+
+	bValue := reflect.ValueOf(i)
+	bType := bValue.Type()
+
+	for j := 0; j < bType.NumMethod(); j++ {
+		method := bType.Method(j)
+		if !strings.HasPrefix(method.Name, "New") {
+			continue
+		}
+
+		switch method.Type.NumOut() {
+		case 1: // func(x *T) NewFoo() *Foo
+			outType := method.Type.Out(0)
+			if !utils.IsBeanType(outType) {
+				continue
+			}
+
+			if outType == bdType {
+				if method.Type.NumIn() != 1 {
+					panic(fmt.Errorf("non-parameter constructor required: %s", method.Type.String()))
+				}
+
+				bdValues := method.Func.Call([]reflect.Value{bValue})
+				bdInst := bdValues[0].Interface()
+				c.Accept(bdInst.(*BeanDefinition))
+			} else {
+				c.Provide(method.Func.Interface())
+			}
+
+		case 2:
+			out0Type := method.Type.Out(0)
+			if !utils.IsBeanType(out0Type) {
+				continue
+			}
+
+			out1Type := method.Type.Out(1)
+			if !utils.IsErrorType(out1Type) {
+				panic(fmt.Errorf("%s: second return type must be error", method.Type.String()))
+			}
+
+			if out0Type == bdType {
+				if method.Type.NumIn() != 1 {
+					panic(fmt.Errorf("non-parameter constructor required: %s", method.Type.String()))
+				}
+
+				bdValues := method.Func.Call([]reflect.Value{bValue})
+				bdInst := bdValues[0].Interface()
+				bdErr := bdValues[1].Interface()
+				if err, ok := bdErr.(error); ok && nil != err {
+					panic(fmt.Errorf("%s: %w", method.Type.String(), err))
+				}
+				c.Accept(bdInst.(*BeanDefinition))
+			} else {
+				c.Provide(method.Func.Interface())
+			}
+		}
+
+		// ignore other methods
+	}
+
+	return c.Accept(NewBean(bValue))
+}
+
 // Dependencies return the dependency order list in either ascending or descending order.
 func (c *container) Dependencies(asc bool) (deps []*BeanDefinition) {
 	if !asc {

gs/gs_bean.go

@@ -98,6 +98,9 @@ type BeanDefinition struct {
 	exports []reflect.Type // 导出的接口
 }
 
+// bdType type of *BeanDefinition
+var bdType = reflect.TypeOf((*BeanDefinition)(nil))
+
 // Type Return the type of the bean.
 func (d *BeanDefinition) Type() reflect.Type {
 	return d.t

gs/gs_test.go

@@ -2949,3 +2949,62 @@ func TestLogLogger(t *testing.T) {
 	assert.Matches(t, stdWriter.String(), "json info message")
 
 }
+
+type testFoo struct {
+	prefix string
+}
+
+type testBar struct {
+	foo *testFoo
+}
+
+type testSubject struct {
+	Bar *testBar `autowire:""`
+}
+
+type testAutoConfiguration struct {
+	Prefix string `value:"${prefix}"`
+}
+
+func (tac *testAutoConfiguration) MakeXX() *testFoo {
+	panic("unreadable code")
+}
+
+func (tac *testAutoConfiguration) NewEmpty() *BeanDefinition {
+	return NewBean(new(struct{})).Name("empty")
+}
+
+func (tac *testAutoConfiguration) NewFoo() *testFoo {
+	return &testFoo{prefix: tac.Prefix}
+}
+
+func (tac *testAutoConfiguration) NewBar(foo *testFoo) (*testBar, error) {
+	return &testBar{foo: foo}, nil
+}
+
+func (tac *testAutoConfiguration) NewSubject() (*BeanDefinition, error) {
+	return NewBean(new(testSubject)).On(cond.OnProperty("open", cond.HavingValue("true"))), nil
+}
+
+type testConfiguration struct {
+	Subject *testSubject `autowire:""`
+}
+
+func TestConfiguration(t *testing.T) {
+	c := New()
+	p := conf.New()
+	p.Set("prefix", "hello")
+	p.Set("open", "true")
+
+	err := c.Properties().Refresh(p)
+	assert.Nil(t, err)
+
+	c.Configuration(new(testAutoConfiguration))
+	bd := c.Object(new(testConfiguration))
+
+	err = c.Refresh()
+	assert.Nil(t, err)
+
+	subject := bd.Interface().(*testConfiguration)
+	assert.Equal(t, subject.Subject.Bar.foo.prefix, "hello")
+}