go依赖注入

go依赖注入

http.HandleFunc("/", func(w http.ResponseWriter,r *http.Request) {
   fmt.Fprintf(w, "Hello world!")
}

// +ioc:autowire=true
// +ioc:autowire:type=singleton
type App struct {
     // 将实现注入至结构体指针，字段本身已经可以定位期望被注入的结构，因此不需要在标签中给定期望被注入的结构名
    ServiceStruct *ServiceStruct `singleton:""`
    // 将实现注入至接口，框架自动为 main.ServiceImpl 结构创建代理，并将代理结构注入在 ServiceImpl 字段
    ServiceImpl Service `singleton:"main.ServiceImpl"`
}

app, err := GetAppSingleton()   // 获取真实结构体指针

func GetAppSingleton() (*App, error) {
   if _appSDID == "" {
      _appSDID = util.GetSDIDByStructPtr(new(App))
   }
   i, err := singleton.GetImpl(_appSDID, nil)
   if err != nil {
      return nil, err
   }
   impl := i.(*App)
   return impl, nil
}


app, err := GetAppIOCInterfaceSingleton()   // 获得封装了代理层的接口

// 注册
singleton.RegisterStructDescriptor(appStructDescriptor)
  // <id,sd>
  var singletonStructDescriptorsMap = make(map[string]*autowire.StructDescriptor)
  autowire.RegisterStructDescriptor(sd)
    // <id,sd>
    structDescriptorsMap[sd.ID()] = sd
    registerImplements(sd)        // 建立 sd 实现的interface 与 sd的关联关系


// 获取
singleton.GetImpl(_appSDID, nil)
  autowire.Impl(Name, sdId, param)
    sd := GetStructDescriptor(targetSDID)
    WrapperAutowireImpl.ImplWithParam(targetSDID, param, expectWithProxy=false, force)
      rawPtr, err = w.Autowire.Factory(sdID)    // 实例化目标对象 得到 rawPtr, sd.Factory
      rawPtr, err = w.Autowire.Construct(sdID, rawPtr, param) //  construct field, sd.Contstruct
      w.inject(rawPtr, sdID)  // 根据rawPtr 获取目标对象的类型，进而获取其包含的字段，再根据字段类型 实例化字段对象   

// 注册
normal.RegisterStructDescriptor(&autowire.StructDescriptor{
    Factory: func() interface{} {
        return &app_{}
    },
})

// 获取
singleton.GetImplWithProxy(_appSDID, nil)
  autowire.ImplWithProxy(Name, sdId, param)
    wrapperAutowire.ImplWithParam(targetSDID, param, expectWithProxy=true, force)
      rawPtr, err = w.Autowire.Factory(sdID)    
      rawPtr, err = w.Autowire.Construct(sdID, rawPtr, param)
      w.inject(rawPtr, sdID)  
      finalPtr = GetProxyFunction()(rawPtr)
        proxyFunction(rawPtr)
          proxyStructPtr, err := normal.GetImpl(proxySDID, nil) // 即代理struct 
          implProxy(rawPtr, proxyStructPtr, sdid)   // 为代理struct field（本质是一个方法） 赋值
            proxyFunc = makeProxyFunction  // 构造代理后的方法
          return proxyStructPtr
      proxyPtr = finalPtr
impl := i.(AppIOCInterface)

func makeProxyFunction(proxyPtr interface{}, rf reflect.Value, sdid, methodName string, isVariadic bool) func(in []reflect.Value) []reflect.Value {
	rawFunction := rf
	interceptorImpls := getInterceptors()
	proxyFunc := func(in []reflect.Value) []reflect.Value {
		invocationCtx := NewInvocationContext(proxyPtr, sdid, methodName, common.CurrentCallingMethodName(3), in)
		for _, i := range interceptorImpls {
			i.BeforeInvoke(invocationCtx)    // 前置方法
		}
		defer func() {
			for _, i := range interceptorImpls {
				i.AfterInvoke(invocationCtx) // 前置方法
			}
		}()
		if isVariadic {
			varParam := in[len(in)-1]
			in = in[:len(in)-1]
			for j, l := 0, varParam.Len(); j < l; j++ {
				in = append(in, varParam.Index(j))
			}
		}
		out := rawFunction.Call(in) // 原方法调用
		invocationCtx.SetReturnValues(out)
		return out
	}
	return proxyFunc
}

// github.com/alibaba/IOC-golang/aop/aop.go
type Interceptor interface {
	BeforeInvoke(ctx *InvocationContext)
	AfterInvoke(ctx *InvocationContext)
}
var interceptorFactories = make([]interceptorFactory, 0)
func RegisterAOP(aopImpl AOP) {
	aops = append(aops, aopImpl)
	if aopImpl.InterceptorFactory != nil {
		interceptorFactories = append(interceptorFactories, aopImpl.InterceptorFactory)
	}
	if aopImpl.RPCInterceptorFactory != nil {
		rpcInterceptorFactories = append(rpcInterceptorFactories, aopImpl.RPCInterceptorFactory)
	}
	if aopImpl.GRPCServiceRegister != nil {
		grpcServiceRegisters = append(grpcServiceRegisters, aopImpl.GRPCServiceRegister)
	}
	if aopImpl.ConfigLoader != nil {
		configLoaderFuncs = append(configLoaderFuncs, aopImpl.ConfigLoader)
	}
}

// github.com/alibaba/IOC-golang/extension/aop/log/aop.go
func init() {
	aop.RegisterAOP(aop.AOP{
		Name: Name,
		InterceptorFactory: func() aop.Interceptor {
			// get loaded logInterceptor singleton
			logInterceptorSingleton, _ := GetlogInterceptorIOCInterfaceSingleton(nil)
			return logInterceptorSingleton
		},
        GRPCServiceRegister: func(server *grpc.Server) {...},
		ConfigLoader: func(aopConfig *common.Config) {...},
	})
}
// github.com/alibaba/IOC-golang/extension/aop/log/interceptor.go

// +ioc:autowire=true
// +ioc:autowire:type=singleton
// +ioc:autowire:proxy:autoInjection=false
// +ioc:autowire:paramType=logInterceptorParams
// +ioc:autowire:constructFunc=initLogInterceptor
type logInterceptor struct {
	...
}
func (w *logInterceptor) BeforeInvoke(ctx *aop.InvocationContext) {
	...
}
func (w *logInterceptor) AfterInvoke(ctx *aop.InvocationContext) {
	...
}