mirror of
https://github.com/kataras/iris.git
synced 2025-01-23 02:31:04 +01:00
ok make it cleaner, it's working well and blazing fast but I have to do a lot cleaning and commenting and docs as well before push it to master --- hope at christmas day, also thinking some internal ideas - the whole code is not ready to be readen by a third person yet.
Former-commit-id: 0b3fb2841d5032ff47bdca42a6f4ccfeb789ce3c
This commit is contained in:
Gerasimos (Makis) Maropoulos
parent
4261b5784a
commit
c15763c556
|
|
@ -13,7 +13,9 @@ import (
|
|||
|
||||
func main() {
|
||||
app := iris.New()
|
||||
mvc.New(app.Party("/api/values/{id}")).Register(new(controllers.ValuesController))
|
||||
mvc.New(app.Party("/api/values/{id}")).
|
||||
Register(new(controllers.ValuesController))
|
||||
|
||||
app.Run(iris.Addr(":5000"), iris.WithoutVersionChecker)
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -35,7 +35,7 @@ type BeforeActivation interface {
|
|||
type AfterActivation interface {
|
||||
shared
|
||||
DependenciesReadOnly() di.ValuesReadOnly
|
||||
IsRequestScoped() bool
|
||||
Singleton() bool
|
||||
}
|
||||
|
||||
var (
|
||||
|
|
@ -85,14 +85,10 @@ func newControllerActivator(router router.Party, controller interface{}, depende
|
|||
val = reflect.ValueOf(controller)
|
||||
typ = val.Type()
|
||||
|
||||
// the full name of the controller, it's its type including the package path.
|
||||
// the full name of the controller: its type including the package path.
|
||||
fullName = getNameOf(typ)
|
||||
)
|
||||
|
||||
// add the manual filled fields to the dependencies.
|
||||
filledFieldValues := di.LookupNonZeroFieldsValues(val)
|
||||
dependencies.AddValue(filledFieldValues...)
|
||||
|
||||
c := &ControllerActivator{
|
||||
// give access to the Router to the end-devs if they need it for some reason,
|
||||
// i.e register done handlers.
|
||||
|
|
@ -141,26 +137,16 @@ func (c *ControllerActivator) Router() router.Party {
|
|||
return c.router
|
||||
}
|
||||
|
||||
// IsRequestScoped returns new if each request has its own instance
|
||||
// of the controller and it contains dependencies that are not manually
|
||||
// filled by the struct initialization from the caller.
|
||||
func (c *ControllerActivator) IsRequestScoped() bool {
|
||||
// if the c.injector == nil means that is not seted to invalidate state,
|
||||
// so it contains more fields that are filled by the end-dev.
|
||||
// This "strange" check happens because the `IsRequestScoped` may
|
||||
// called before the controller activation complete its task (see Handle: if c.injector == nil).
|
||||
if c.injector == nil { // is nil so it contains more fields, maybe request-scoped or dependencies.
|
||||
return true
|
||||
// Singleton returns new if all incoming clients' requests
|
||||
// have the same controller instance.
|
||||
// This is done automatically by iris to reduce the creation
|
||||
// of a new controller on each request, if the controller doesn't contain
|
||||
// any unexported fields and all fields are services-like, static.
|
||||
func (c *ControllerActivator) Singleton() bool {
|
||||
if c.injector == nil {
|
||||
panic("MVC: IsRequestScoped used on an invalid state the API gives access to it only `AfterActivation`, report this as bug")
|
||||
}
|
||||
if c.injector.Valid {
|
||||
// if injector is not nil:
|
||||
// if it is !Valid then all fields are manually filled by the end-dev (see `newControllerActivator`).
|
||||
// if it is Valid then it's filled on the first `Handle`
|
||||
// and it has more than one valid dependency from the registered values.
|
||||
return true
|
||||
}
|
||||
// it's not nil and it's !Valid.
|
||||
return false
|
||||
return c.injector.State == di.Singleton
|
||||
}
|
||||
|
||||
// checks if a method is already registered.
|
||||
|
|
@ -191,21 +177,16 @@ func (c *ControllerActivator) parseMethod(m reflect.Method) {
|
|||
// register all available, exported methods to handlers if possible.
|
||||
func (c *ControllerActivator) parseMethods() {
|
||||
n := c.Type.NumMethod()
|
||||
// wg := &sync.WaitGroup{}
|
||||
// wg.Add(n)
|
||||
for i := 0; i < n; i++ {
|
||||
m := c.Type.Method(i)
|
||||
c.parseMethod(m)
|
||||
}
|
||||
// wg.Wait()
|
||||
}
|
||||
|
||||
func (c *ControllerActivator) activate() {
|
||||
c.parseMethods()
|
||||
}
|
||||
|
||||
var emptyIn = []reflect.Value{}
|
||||
|
||||
// Handle registers a route based on a http method, the route's path
|
||||
// and a function name that belongs to the controller, it accepts
|
||||
// a forth, optionally, variadic parameter which is the before handlers.
|
||||
|
|
@ -221,6 +202,30 @@ func (c *ControllerActivator) Handle(method, path, funcName string, middleware .
|
|||
return nil
|
||||
}
|
||||
|
||||
// Remember:
|
||||
// we cannot simply do that and expect to work:
|
||||
// hasStructInjector = c.injector != nil && c.injector.Valid
|
||||
// hasFuncInjector = funcInjector != nil && funcInjector.Valid
|
||||
// because
|
||||
// the `Handle` can be called from `BeforeActivation` callbacks
|
||||
// and before activation, the c.injector is nil because
|
||||
// we may not have the dependencies binded yet. But if `c.injector.Valid`
|
||||
// inside the Handelr works because it's set on the `activate()` method.
|
||||
// To solve this we can make check on the FIRST `Handle`,
|
||||
// if c.injector is nil, then set it with the current bindings,
|
||||
// so the user should bind the dependencies needed before the `Handle`
|
||||
// this is a logical flow, so we will choose that one ->
|
||||
if c.injector == nil {
|
||||
// first, set these bindings to the passed controller, they will be useless
|
||||
// if the struct contains any dynamic value because this controller will
|
||||
// be never fired as it's but we make that in order to get the length of the static
|
||||
// matched dependencies of the struct.
|
||||
c.injector = di.MakeStructInjector(c.Value, hijacker, typeChecker, c.dependencies...)
|
||||
if c.injector.HasFields {
|
||||
golog.Debugf("MVC dependencies of '%s':\n%s", c.fullName, c.injector.String())
|
||||
}
|
||||
}
|
||||
|
||||
// get the method from the controller type.
|
||||
m, ok := c.Type.MethodByName(funcName)
|
||||
if !ok {
|
||||
|
|
@ -238,77 +243,17 @@ func (c *ControllerActivator) Handle(method, path, funcName string, middleware .
|
|||
return nil
|
||||
}
|
||||
|
||||
// add this as a reserved method name in order to
|
||||
// be sure that the same func will not be registered again, even if a custom .Handle later on.
|
||||
c.reservedMethods = append(c.reservedMethods, funcName)
|
||||
|
||||
// get the function's input.
|
||||
funcIn := getInputArgsFromFunc(m.Type)
|
||||
|
||||
// get the path parameters bindings from the template,
|
||||
// use the function's input except the receiver which is the
|
||||
// end-dev's controller pointer.
|
||||
pathParams := getPathParamsForInput(tmpl.Params, funcIn[1:]...)
|
||||
// get the function's input arguments' bindings.
|
||||
funcDependencies := c.dependencies.Clone()
|
||||
funcDependencies.AddValue(pathParams...)
|
||||
funcDependencies.AddValues(pathParams...)
|
||||
|
||||
// fmt.Printf("for %s | values: %s\n", funcName, funcDependencies)
|
||||
funcInjector := di.MakeFuncInjector(m.Func, hijacker, typeChecker, funcDependencies...)
|
||||
// fmt.Printf("actual injector's inputs length: %d\n", funcInjector.Length)
|
||||
|
||||
// the element value, not the pointer, wil lbe used to create a
|
||||
// new controller on each incoming request.
|
||||
|
||||
// Remember:
|
||||
// we cannot simply do that and expect to work:
|
||||
// hasStructInjector = c.injector != nil && c.injector.Valid
|
||||
// hasFuncInjector = funcInjector != nil && funcInjector.Valid
|
||||
// because
|
||||
// the `Handle` can be called from `BeforeActivation` callbacks
|
||||
// and before activation, the c.injector is nil because
|
||||
// we may not have the dependencies binded yet. But if `c.injector.Valid`
|
||||
// inside the Handelr works because it's set on the `activate()` method.
|
||||
// To solve this we can make check on the FIRST `Handle`,
|
||||
// if c.injector is nil, then set it with the current bindings,
|
||||
// so the user should bind the dependencies needed before the `Handle`
|
||||
// this is a logical flow, so we will choose that one ->
|
||||
if c.injector == nil {
|
||||
// check if manually filled + any dependencies are only static, if so
|
||||
// and the total struct's fields are equal these static dependencies length
|
||||
// then we don't need to create a new struct on each request.
|
||||
//
|
||||
// We use our custom NumFields here because the std "reflect" package
|
||||
// checks only for the current struct and not for embedded's exported fields.
|
||||
totalFieldsLength := di.NumFields(di.IndirectType(c.Type))
|
||||
|
||||
// first, set these bindings to the passed controller, they will be useless
|
||||
// if the struct contains any dynamic value because this controller will
|
||||
// be never fired as it's but we make that in order to get the length of the static
|
||||
// matched dependencies of the struct.
|
||||
c.injector = di.MakeStructInjector(c.Value, hijacker, typeChecker, c.dependencies...)
|
||||
matchedStaticDependenciesLength := c.injector.InjectElemStaticOnly(di.IndirectValue(c.Value))
|
||||
|
||||
if c.injector.Valid {
|
||||
golog.Debugf("MVC dependencies of '%s':\n%s", c.fullName, c.injector.String())
|
||||
}
|
||||
|
||||
if matchedStaticDependenciesLength == totalFieldsLength {
|
||||
// all fields are filled by the end-developer or via static dependencies (if context is there then it will be filled by the MakeStructInjector so we don't worry about it),
|
||||
// the controller doesn't contain any other field neither any dynamic binding as well.
|
||||
// Therefore we don't need to create a new controller each time.
|
||||
// Set the c.injector now instead on the first `Handle` and set it to invalid state
|
||||
// in order to `buildControllerHandler` ignore the
|
||||
// creation of a new controller value on each incoming request.
|
||||
c.injector = &di.StructInjector{Valid: false}
|
||||
}
|
||||
}
|
||||
|
||||
if funcInjector.Valid {
|
||||
golog.Debugf("MVC dependencies of method '%s.%s':\n%s", c.fullName, funcName, funcInjector.String())
|
||||
}
|
||||
|
||||
handler := buildControllerHandler(m, c.Type, c.Value, c.injector, funcInjector, funcIn)
|
||||
handler := c.handlerOf(m, funcDependencies)
|
||||
|
||||
// register the handler now.
|
||||
route := c.router.Handle(method, path, append(middleware, handler)...)
|
||||
|
|
@ -316,98 +261,55 @@ func (c *ControllerActivator) Handle(method, path, funcName string, middleware .
|
|||
// change the main handler's name in order to respect the controller's and give
|
||||
// a proper debug message.
|
||||
route.MainHandlerName = fmt.Sprintf("%s.%s", c.fullName, funcName)
|
||||
|
||||
// add this as a reserved method name in order to
|
||||
// be sure that the same func will not be registered again,
|
||||
// even if a custom .Handle later on.
|
||||
c.reservedMethods = append(c.reservedMethods, funcName)
|
||||
}
|
||||
|
||||
return route
|
||||
}
|
||||
|
||||
// buildControllerHandler has many many dublications but we do that to achieve the best
|
||||
// performance possible, to use the information we know
|
||||
// and calculate what is needed and what not in serve-time.
|
||||
func buildControllerHandler(m reflect.Method, typ reflect.Type, initRef reflect.Value, structInjector *di.StructInjector, funcInjector *di.FuncInjector, funcIn []reflect.Type) context.Handler {
|
||||
var (
|
||||
hasStructInjector = structInjector != nil && structInjector.Valid
|
||||
hasFuncInjector = funcInjector != nil && funcInjector.Valid
|
||||
|
||||
implementsBase = isBaseController(typ)
|
||||
// we will make use of 'n' to make a slice of reflect.Value
|
||||
// to pass into if the function has input arguments that
|
||||
// are will being filled by the funcDependencies.
|
||||
n = len(funcIn)
|
||||
|
||||
elemTyp = di.IndirectType(typ)
|
||||
)
|
||||
|
||||
// if it doesn't implement the base controller,
|
||||
// it may have struct injector and/or func injector.
|
||||
if !implementsBase {
|
||||
|
||||
if !hasStructInjector {
|
||||
// if the controller doesn't have a struct injector
|
||||
// and the controller's fields are empty or all set-ed by the end-dev
|
||||
// then we don't need a new controller instance, we use the passed controller instance.
|
||||
|
||||
if !hasFuncInjector {
|
||||
return func(ctx context.Context) {
|
||||
DispatchFuncResult(ctx, initRef.Method(m.Index).Call(emptyIn))
|
||||
}
|
||||
}
|
||||
|
||||
return func(ctx context.Context) {
|
||||
in := make([]reflect.Value, n, n)
|
||||
in[0] = initRef
|
||||
funcInjector.Inject(&in, reflect.ValueOf(ctx))
|
||||
if ctx.IsStopped() {
|
||||
return
|
||||
}
|
||||
|
||||
DispatchFuncResult(ctx, m.Func.Call(in))
|
||||
}
|
||||
}
|
||||
|
||||
// it has struct injector for sure and maybe a func injector.
|
||||
if !hasFuncInjector {
|
||||
return func(ctx context.Context) {
|
||||
ctrl := reflect.New(elemTyp)
|
||||
ctxValue := reflect.ValueOf(ctx)
|
||||
elem := ctrl.Elem()
|
||||
structInjector.InjectElem(elem, ctxValue)
|
||||
if ctx.IsStopped() {
|
||||
return
|
||||
}
|
||||
|
||||
DispatchFuncResult(ctx, ctrl.Method(m.Index).Call(emptyIn))
|
||||
}
|
||||
}
|
||||
|
||||
// has struct injector and func injector.
|
||||
return func(ctx context.Context) {
|
||||
ctrl := reflect.New(elemTyp)
|
||||
ctxValue := reflect.ValueOf(ctx)
|
||||
|
||||
elem := ctrl.Elem()
|
||||
structInjector.InjectElem(elem, ctxValue)
|
||||
if ctx.IsStopped() {
|
||||
return
|
||||
}
|
||||
|
||||
in := make([]reflect.Value, n, n)
|
||||
in[0] = ctrl
|
||||
funcInjector.Inject(&in, ctxValue)
|
||||
if ctx.IsStopped() {
|
||||
return
|
||||
}
|
||||
|
||||
DispatchFuncResult(ctx, m.Func.Call(in))
|
||||
}
|
||||
var emptyIn = []reflect.Value{}
|
||||
|
||||
func (c *ControllerActivator) handlerOf(m reflect.Method, funcDependencies []reflect.Value) context.Handler {
|
||||
// fmt.Printf("for %s | values: %s\n", funcName, funcDependencies)
|
||||
funcInjector := di.MakeFuncInjector(m.Func, hijacker, typeChecker, funcDependencies...)
|
||||
// fmt.Printf("actual injector's inputs length: %d\n", funcInjector.Length)
|
||||
if funcInjector.Valid {
|
||||
golog.Debugf("MVC dependencies of method '%s.%s':\n%s", c.fullName, m.Name, funcInjector.String())
|
||||
}
|
||||
|
||||
// if implements the base controller,
|
||||
// it may have struct injector and func injector as well.
|
||||
return func(ctx context.Context) {
|
||||
ctrl := reflect.New(elemTyp)
|
||||
var (
|
||||
implementsBase = isBaseController(c.Type)
|
||||
hasBindableFields = c.injector.CanInject
|
||||
hasBindableFuncInputs = funcInjector.Valid
|
||||
|
||||
call = m.Func.Call
|
||||
)
|
||||
|
||||
if !implementsBase && !hasBindableFields && !hasBindableFuncInputs {
|
||||
return func(ctx context.Context) {
|
||||
DispatchFuncResult(ctx, call(c.injector.NewAsSlice()))
|
||||
}
|
||||
}
|
||||
|
||||
n := m.Type.NumIn()
|
||||
return func(ctx context.Context) {
|
||||
var (
|
||||
ctrl = c.injector.New()
|
||||
ctxValue reflect.Value
|
||||
)
|
||||
|
||||
// inject struct fields first before the BeginRequest and EndRequest, if any,
|
||||
// in order to be able to have access there.
|
||||
if hasBindableFields {
|
||||
ctxValue = reflect.ValueOf(ctx)
|
||||
c.injector.InjectElem(ctrl.Elem(), ctxValue)
|
||||
}
|
||||
|
||||
// check if has BeginRequest & EndRequest, before try to bind the method's inputs.
|
||||
if implementsBase {
|
||||
// the Interface(). is faster than MethodByName or pre-selected methods.
|
||||
b := ctrl.Interface().(BaseController)
|
||||
|
|
@ -422,36 +324,20 @@ func buildControllerHandler(m reflect.Method, typ reflect.Type, initRef reflect.
|
|||
defer b.EndRequest(ctx)
|
||||
}
|
||||
|
||||
if !hasStructInjector && !hasFuncInjector {
|
||||
DispatchFuncResult(ctx, ctrl.Method(m.Index).Call(emptyIn))
|
||||
} else {
|
||||
ctxValue := reflect.ValueOf(ctx)
|
||||
if hasStructInjector {
|
||||
elem := ctrl.Elem()
|
||||
structInjector.InjectElem(elem, ctxValue)
|
||||
if ctx.IsStopped() {
|
||||
return
|
||||
}
|
||||
|
||||
// we do this in order to reduce in := make...
|
||||
// if not func input binders, we execute the handler with empty input args.
|
||||
if !hasFuncInjector {
|
||||
DispatchFuncResult(ctx, ctrl.Method(m.Index).Call(emptyIn))
|
||||
}
|
||||
}
|
||||
// otherwise, it has one or more valid input binders,
|
||||
// make the input and call the func using those.
|
||||
if hasFuncInjector {
|
||||
in := make([]reflect.Value, n, n)
|
||||
in[0] = ctrl
|
||||
funcInjector.Inject(&in, ctxValue)
|
||||
if ctx.IsStopped() {
|
||||
return
|
||||
}
|
||||
|
||||
DispatchFuncResult(ctx, m.Func.Call(in))
|
||||
if hasBindableFuncInputs {
|
||||
// means that ctxValue is not initialized before by the controller's struct injector.
|
||||
if !hasBindableFields {
|
||||
ctxValue = reflect.ValueOf(ctx)
|
||||
}
|
||||
|
||||
in := make([]reflect.Value, n, n)
|
||||
in[0] = ctrl
|
||||
funcInjector.Inject(&in, ctxValue)
|
||||
DispatchFuncResult(ctx, call(in))
|
||||
return
|
||||
}
|
||||
|
||||
DispatchFuncResult(ctx, ctrl.Method(m.Index).Call(emptyIn))
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -469,8 +469,8 @@ func (c *testControllerNotCreateNewDueManuallySettingAllFields) AfterActivation(
|
|||
-- got dependencies length: %d`, n)
|
||||
}
|
||||
|
||||
if a.IsRequestScoped() {
|
||||
c.T.Fatalf(`this controller shouldn't be tagged used as request scoped(create new instances on each request),
|
||||
if !a.Singleton() {
|
||||
c.T.Fatalf(`this controller should be tagged as Singleton. It shouldn't be tagged used as request scoped(create new instances on each request),
|
||||
it doesn't contain any dynamic value or dependencies that should be binded via the iris mvc engine`)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -85,22 +85,15 @@ func MakeFuncInjector(fn reflect.Value, hijack Hijacker, goodFunc TypeChecker, v
|
|||
}
|
||||
}
|
||||
|
||||
// s.Length = n
|
||||
s.Length = len(s.inputs)
|
||||
s.Valid = s.Length > 0
|
||||
|
||||
for i, in := range s.inputs {
|
||||
bindmethodTyp := "Static"
|
||||
|
||||
if in.Object.BindType == Dynamic {
|
||||
bindmethodTyp = "Dynamic"
|
||||
}
|
||||
|
||||
bindmethodTyp := bindTypeString(in.Object.BindType)
|
||||
typIn := typ.In(in.InputIndex)
|
||||
// remember: on methods that are part of a struct (i.e controller)
|
||||
// the input index = 1 is the begggining instead of the 0,
|
||||
// because the 0 is the controller receiver pointer of the method.
|
||||
|
||||
s.trace += fmt.Sprintf("[%d] %s binding: '%s' for input position: %d and type: '%s'\n", i+1, bindmethodTyp, in.Object.Type.String(), in.InputIndex, typIn.String())
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -12,6 +12,15 @@ const (
|
|||
Dynamic // dynamic value, depends on some input arguments from the caller.
|
||||
)
|
||||
|
||||
func bindTypeString(typ BindType) string {
|
||||
switch typ {
|
||||
case Dynamic:
|
||||
return "Dynamic"
|
||||
default:
|
||||
return "Static"
|
||||
}
|
||||
}
|
||||
|
||||
type BindObject struct {
|
||||
Type reflect.Type // the Type of 'Value' or the type of the returned 'ReturnValue' .
|
||||
Value reflect.Value
|
||||
|
|
|
|||
|
|
@ -66,6 +66,13 @@ func ValueOf(o interface{}) reflect.Value {
|
|||
return reflect.ValueOf(o)
|
||||
}
|
||||
|
||||
func ValuesOf(valuesAsInterface []interface{}) (values []reflect.Value) {
|
||||
for _, v := range valuesAsInterface {
|
||||
values = append(values, ValueOf(v))
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func IndirectType(typ reflect.Type) reflect.Type {
|
||||
switch typ.Kind() {
|
||||
case reflect.Ptr, reflect.Array, reflect.Chan, reflect.Map, reflect.Slice:
|
||||
|
|
@ -115,9 +122,10 @@ func structFieldIgnored(f reflect.StructField) bool {
|
|||
}
|
||||
|
||||
type field struct {
|
||||
Type reflect.Type
|
||||
Index []int // the index of the field, slice if it's part of a embedded struct
|
||||
Name string // the actual name
|
||||
Type reflect.Type
|
||||
Name string // the actual name.
|
||||
Index []int // the index of the field, slice if it's part of a embedded struct
|
||||
CanSet bool // is true if it's exported.
|
||||
|
||||
// this could be empty, but in our cases it's not,
|
||||
// it's filled with the bind object (as service which means as static value)
|
||||
|
|
@ -127,11 +135,11 @@ type field struct {
|
|||
|
||||
// NumFields returns the total number of fields, and the embedded, even if the embedded struct is not exported,
|
||||
// it will check for its exported fields.
|
||||
func NumFields(elemTyp reflect.Type) int {
|
||||
return len(lookupFields(elemTyp, nil))
|
||||
func NumFields(elemTyp reflect.Type, skipUnexported bool) int {
|
||||
return len(lookupFields(elemTyp, skipUnexported, nil))
|
||||
}
|
||||
|
||||
func lookupFields(elemTyp reflect.Type, parentIndex []int) (fields []field) {
|
||||
func lookupFields(elemTyp reflect.Type, skipUnexported bool, parentIndex []int) (fields []field) {
|
||||
if elemTyp.Kind() != reflect.Struct {
|
||||
return
|
||||
}
|
||||
|
|
@ -141,14 +149,15 @@ func lookupFields(elemTyp reflect.Type, parentIndex []int) (fields []field) {
|
|||
|
||||
if IndirectType(f.Type).Kind() == reflect.Struct &&
|
||||
!structFieldIgnored(f) {
|
||||
fields = append(fields, lookupFields(f.Type, append(parentIndex, i))...)
|
||||
fields = append(fields, lookupFields(f.Type, skipUnexported, append(parentIndex, i))...)
|
||||
continue
|
||||
}
|
||||
|
||||
// skip unexported fields here,
|
||||
// after the check for embedded structs, these can be binded if their
|
||||
// fields are exported.
|
||||
if f.PkgPath != "" {
|
||||
isExported := f.PkgPath == ""
|
||||
if skipUnexported && !isExported {
|
||||
continue
|
||||
}
|
||||
|
||||
|
|
@ -158,9 +167,10 @@ func lookupFields(elemTyp reflect.Type, parentIndex []int) (fields []field) {
|
|||
}
|
||||
|
||||
field := field{
|
||||
Type: f.Type,
|
||||
Name: f.Name,
|
||||
Index: index,
|
||||
Type: f.Type,
|
||||
Name: f.Name,
|
||||
Index: index,
|
||||
CanSet: isExported,
|
||||
}
|
||||
|
||||
fields = append(fields, field)
|
||||
|
|
@ -172,12 +182,13 @@ func lookupFields(elemTyp reflect.Type, parentIndex []int) (fields []field) {
|
|||
// LookupNonZeroFieldsValues lookup for filled fields based on the "v" struct value instance.
|
||||
// It returns a slice of reflect.Value (same type as `Values`) that can be binded,
|
||||
// like the end-developer's custom values.
|
||||
func LookupNonZeroFieldsValues(v reflect.Value) (bindValues []reflect.Value) {
|
||||
func LookupNonZeroFieldsValues(v reflect.Value, skipUnexported bool) (bindValues []reflect.Value) {
|
||||
elem := IndirectValue(v)
|
||||
fields := lookupFields(IndirectType(v.Type()), nil)
|
||||
for _, f := range fields {
|
||||
fields := lookupFields(IndirectType(v.Type()), skipUnexported, nil)
|
||||
|
||||
if fieldVal := elem.FieldByIndex(f.Index); f.Type.Kind() == reflect.Ptr && !IsZero(fieldVal) {
|
||||
for _, f := range fields {
|
||||
if fieldVal := elem.FieldByIndex(f.Index); /*f.Type.Kind() == reflect.Ptr &&*/
|
||||
!IsZero(fieldVal) {
|
||||
bindValues = append(bindValues, fieldVal)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
134
mvc/di/struct.go
134
mvc/di/struct.go
|
|
@ -5,6 +5,13 @@ import (
|
|||
"reflect"
|
||||
)
|
||||
|
||||
type State uint8
|
||||
|
||||
const (
|
||||
Stateless State = iota
|
||||
Singleton
|
||||
)
|
||||
|
||||
type (
|
||||
targetStructField struct {
|
||||
Object *BindObject
|
||||
|
|
@ -12,22 +19,38 @@ type (
|
|||
}
|
||||
|
||||
StructInjector struct {
|
||||
elemType reflect.Type
|
||||
initRef reflect.Value
|
||||
initRefAsSlice []reflect.Value // useful when the struct is passed on a func as input args via reflection.
|
||||
elemType reflect.Type
|
||||
//
|
||||
fields []*targetStructField
|
||||
Valid bool // is true when contains fields and it's a valid target struct.
|
||||
trace string // for debug info.
|
||||
// is true when contains bindable fields and it's a valid target struct,
|
||||
// it maybe 0 but struct may contain unexported fields or exported but no bindable (Stateless)
|
||||
// see `setState`.
|
||||
HasFields bool
|
||||
CanInject bool // if any bindable fields when the state is NOT singleton.
|
||||
State State
|
||||
}
|
||||
)
|
||||
|
||||
func (s *StructInjector) countBindType(typ BindType) (n int) {
|
||||
for _, f := range s.fields {
|
||||
if f.Object.BindType == typ {
|
||||
n++
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func MakeStructInjector(v reflect.Value, hijack Hijacker, goodFunc TypeChecker, values ...reflect.Value) *StructInjector {
|
||||
s := &StructInjector{
|
||||
elemType: IndirectType(v.Type()),
|
||||
initRef: v,
|
||||
initRefAsSlice: []reflect.Value{v},
|
||||
elemType: IndirectType(v.Type()),
|
||||
}
|
||||
|
||||
fields := lookupFields(s.elemType, nil)
|
||||
fields := lookupFields(s.elemType, true, nil)
|
||||
for _, f := range fields {
|
||||
|
||||
if hijack != nil {
|
||||
if b, ok := hijack(f.Type); ok && b != nil {
|
||||
s.fields = append(s.fields, &targetStructField{
|
||||
|
|
@ -55,28 +78,75 @@ func MakeStructInjector(v reflect.Value, hijack Hijacker, goodFunc TypeChecker,
|
|||
})
|
||||
break
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
s.Valid = len(s.fields) > 0
|
||||
|
||||
if s.Valid {
|
||||
for i, f := range s.fields {
|
||||
bindmethodTyp := "Static"
|
||||
if f.Object.BindType == Dynamic {
|
||||
bindmethodTyp = "Dynamic"
|
||||
}
|
||||
elemField := s.elemType.FieldByIndex(f.FieldIndex)
|
||||
s.trace += fmt.Sprintf("[%d] %s binding: '%s' for field '%s %s'\n", i+1, bindmethodTyp, f.Object.Type.String(), elemField.Name, elemField.Type.String())
|
||||
}
|
||||
}
|
||||
s.HasFields = len(s.fields) > 0
|
||||
// set the overall state of this injector.
|
||||
s.setState()
|
||||
s.fillStruct()
|
||||
|
||||
return s
|
||||
}
|
||||
|
||||
func (s *StructInjector) String() string {
|
||||
return s.trace
|
||||
// set the state, once.
|
||||
func (s *StructInjector) setState() {
|
||||
// note for zero length of struct's fields:
|
||||
// if struct doesn't contain any field
|
||||
// so both of the below variables will be 0,
|
||||
// so it's a singleton.
|
||||
// At the other hand the `s.HasFields` maybe false
|
||||
// but the struct may contain UNEXPORTED fields or non-bindable fields (request-scoped on both cases)
|
||||
// so a new controller/struct at the caller side should be initialized on each request,
|
||||
// we should not depend on the `HasFields` for singleton or no, this is the reason I
|
||||
// added the `.State` now.
|
||||
|
||||
staticBindingsFieldsLength := s.countBindType(Static)
|
||||
structFieldsLength := NumFields(s.elemType, false)
|
||||
|
||||
// println("staticBindingsFieldsLength: ", staticBindingsFieldsLength)
|
||||
// println("structFieldsLength: ", structFieldsLength)
|
||||
|
||||
// if the number of static values binded is equal to the
|
||||
// total struct's fields(including unexported fields this time) then set as singleton.
|
||||
if staticBindingsFieldsLength == structFieldsLength {
|
||||
s.State = Singleton
|
||||
return
|
||||
}
|
||||
|
||||
s.CanInject = s.State == Stateless && s.HasFields
|
||||
// the default is `Stateless`, which means that a new instance should be created
|
||||
// on each inject action by the caller.
|
||||
}
|
||||
|
||||
// fill the static bindings values once.
|
||||
func (s *StructInjector) fillStruct() {
|
||||
if !s.HasFields {
|
||||
return
|
||||
}
|
||||
// if field is Static then set it to the value that passed by the caller,
|
||||
// so will have the static bindings already and we can just use that value instead
|
||||
// of creating new instance.
|
||||
destElem := IndirectValue(s.initRef)
|
||||
for _, f := range s.fields {
|
||||
// if field is Static then set it to the value that passed by the caller,
|
||||
// so will have the static bindings already and we can just use that value instead
|
||||
// of creating new instance.
|
||||
if s.State == Singleton && f.Object.BindType == Static {
|
||||
destElem.FieldByIndex(f.FieldIndex).Set(f.Object.Value)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (s *StructInjector) String() (trace string) {
|
||||
for i, f := range s.fields {
|
||||
elemField := s.elemType.FieldByIndex(f.FieldIndex)
|
||||
trace += fmt.Sprintf("[%d] %s binding: '%s' for field '%s %s'\n",
|
||||
i+1, bindTypeString(f.Object.BindType), f.Object.Type.String(),
|
||||
elemField.Name, elemField.Type.String())
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
func (s *StructInjector) Inject(dest interface{}, ctx ...reflect.Value) {
|
||||
|
|
@ -91,25 +161,21 @@ func (s *StructInjector) Inject(dest interface{}, ctx ...reflect.Value) {
|
|||
func (s *StructInjector) InjectElem(destElem reflect.Value, ctx ...reflect.Value) {
|
||||
for _, f := range s.fields {
|
||||
f.Object.Assign(ctx, func(v reflect.Value) {
|
||||
// fmt.Printf("%s for %s at index: %d\n", destElem.Type().String(), f.Object.Type.String(), f.FieldIndex)
|
||||
destElem.FieldByIndex(f.FieldIndex).Set(v)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func (s *StructInjector) InjectElemStaticOnly(destElem reflect.Value) (n int) {
|
||||
for _, f := range s.fields {
|
||||
if f.Object.BindType != Static {
|
||||
continue
|
||||
}
|
||||
destElem.FieldByIndex(f.FieldIndex).Set(f.Object.Value)
|
||||
n++
|
||||
func (s *StructInjector) New() reflect.Value {
|
||||
if s.State == Singleton {
|
||||
return s.initRef
|
||||
}
|
||||
return
|
||||
return reflect.New(s.elemType)
|
||||
}
|
||||
|
||||
func (s *StructInjector) New(ctx ...reflect.Value) reflect.Value {
|
||||
dest := reflect.New(s.elemType)
|
||||
s.InjectElem(dest, ctx...)
|
||||
return dest
|
||||
func (s *StructInjector) NewAsSlice() []reflect.Value {
|
||||
if s.State == Singleton {
|
||||
return s.initRefAsSlice
|
||||
}
|
||||
return []reflect.Value{reflect.New(s.elemType)}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,6 +8,8 @@ type ValuesReadOnly interface {
|
|||
Has(value interface{}) bool
|
||||
// Len returns the length of the values.
|
||||
Len() int
|
||||
// Clone returns a copy of the current values.
|
||||
Clone() Values
|
||||
}
|
||||
|
||||
type Values []reflect.Value
|
||||
|
|
@ -27,21 +29,29 @@ func (bv Values) Clone() Values {
|
|||
return NewValues()
|
||||
}
|
||||
|
||||
// CloneWithFieldsOf will return a copy of the current values
|
||||
// plus the "v" struct's fields that are filled(non-zero) by the caller.
|
||||
func (bv Values) CloneWithFieldsOf(s interface{}) Values {
|
||||
values := bv.Clone()
|
||||
|
||||
// add the manual filled fields to the dependencies.
|
||||
filledFieldValues := LookupNonZeroFieldsValues(ValueOf(s), true)
|
||||
values = append(values, filledFieldValues...)
|
||||
return values
|
||||
}
|
||||
|
||||
func (bv Values) Len() int {
|
||||
return len(bv)
|
||||
}
|
||||
|
||||
// Add binds values to this controller, if you want to share
|
||||
// binding values between controllers use the Engine's `Bind` function instead.
|
||||
// Add adds values as dependencies, if the struct's fields
|
||||
// or the function's input arguments needs them, they will be defined as
|
||||
// bindings (at build-time) and they will be used (at serve-time).
|
||||
func (bv *Values) Add(values ...interface{}) {
|
||||
for _, val := range values {
|
||||
bv.AddValue(reflect.ValueOf(val))
|
||||
}
|
||||
bv.AddValues(ValuesOf(values)...)
|
||||
}
|
||||
|
||||
// AddValue same as `Add` but accepts reflect.Value
|
||||
// instead.
|
||||
func (bv *Values) AddValue(values ...reflect.Value) {
|
||||
func (bv *Values) AddValues(values ...reflect.Value) {
|
||||
for _, v := range values {
|
||||
if !goodVal(v) {
|
||||
continue
|
||||
|
|
@ -115,6 +125,6 @@ func (bv *Values) addIfNotExists(v reflect.Value) bool {
|
|||
return false
|
||||
}
|
||||
|
||||
bv.AddValue(v)
|
||||
bv.Add(v)
|
||||
return true
|
||||
}
|
||||
|
|
|
|||
|
|
@ -85,7 +85,9 @@ func (e *Engine) Handler(handler interface{}) context.Handler {
|
|||
//
|
||||
// Examples at: https://github.com/kataras/iris/tree/master/_examples/mvc.
|
||||
func (e *Engine) Controller(router router.Party, controller interface{}, beforeActivate ...func(BeforeActivation)) {
|
||||
ca := newControllerActivator(router, controller, e.Dependencies.Clone())
|
||||
// add the manual filled fields to the dependencies.
|
||||
dependencies := e.Dependencies.CloneWithFieldsOf(controller)
|
||||
ca := newControllerActivator(router, controller, dependencies)
|
||||
|
||||
// give a priority to the "beforeActivate"
|
||||
// callbacks, if any.
|
||||
|
|
|
|||
|
|
@ -165,8 +165,7 @@ func DispatchCommon(ctx context.Context,
|
|||
//
|
||||
// where Get is an HTTP METHOD.
|
||||
func DispatchFuncResult(ctx context.Context, values []reflect.Value) {
|
||||
numOut := len(values)
|
||||
if numOut == 0 {
|
||||
if len(values) == 0 {
|
||||
return
|
||||
}
|
||||
|
||||
|
|
@ -195,54 +194,107 @@ func DispatchFuncResult(ctx context.Context, values []reflect.Value) {
|
|||
)
|
||||
|
||||
for _, v := range values {
|
||||
|
||||
// order of these checks matters
|
||||
// for example, first we need to check for status code,
|
||||
// secondly the string (for content type and content)...
|
||||
// if !v.IsValid() || !v.CanInterface() {
|
||||
// continue
|
||||
// }
|
||||
if !v.IsValid() {
|
||||
continue
|
||||
}
|
||||
|
||||
f := v.Interface()
|
||||
/*
|
||||
if b, ok := f.(bool); ok {
|
||||
found = b
|
||||
if !found {
|
||||
// skip everything, we don't care about other return values,
|
||||
// this boolean is the higher in order.
|
||||
break
|
||||
}
|
||||
continue
|
||||
}
|
||||
|
||||
if b, ok := f.(bool); ok {
|
||||
found = b
|
||||
if i, ok := f.(int); ok {
|
||||
statusCode = i
|
||||
continue
|
||||
}
|
||||
|
||||
if s, ok := f.(string); ok {
|
||||
// a string is content type when it contains a slash and
|
||||
// content or custom struct is being calculated already;
|
||||
// (string -> content, string-> content type)
|
||||
// (customStruct, string -> content type)
|
||||
if (len(content) > 0 || custom != nil) && strings.IndexByte(s, slashB) > 0 {
|
||||
contentType = s
|
||||
} else {
|
||||
// otherwise is content
|
||||
content = []byte(s)
|
||||
}
|
||||
|
||||
continue
|
||||
}
|
||||
|
||||
if b, ok := f.([]byte); ok {
|
||||
// it's raw content, get the latest
|
||||
content = b
|
||||
continue
|
||||
}
|
||||
|
||||
if e, ok := f.(compatibleErr); ok {
|
||||
if e != nil { // it's always not nil but keep it here.
|
||||
err = e
|
||||
if statusCode < 400 {
|
||||
statusCode = DefaultErrStatusCode
|
||||
}
|
||||
break // break on first error, error should be in the end but we
|
||||
// need to know break the dispatcher if any error.
|
||||
// at the end; we don't want to write anything to the response if error is not nil.
|
||||
}
|
||||
continue
|
||||
}
|
||||
|
||||
// else it's a custom struct or a dispatcher, we'll decide later
|
||||
// because content type and status code matters
|
||||
// do that check in order to be able to correctly dispatch:
|
||||
// (customStruct, error) -> customStruct filled and error is nil
|
||||
if custom == nil && f != nil {
|
||||
custom = f
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
*/
|
||||
switch value := f.(type) {
|
||||
case bool:
|
||||
found = value
|
||||
if !found {
|
||||
// skip everything, we don't care about other return values,
|
||||
// skip everything, skip other values, we don't care about other return values,
|
||||
// this boolean is the higher in order.
|
||||
break
|
||||
}
|
||||
continue
|
||||
}
|
||||
|
||||
if i, ok := f.(int); ok {
|
||||
statusCode = i
|
||||
continue
|
||||
}
|
||||
|
||||
if s, ok := f.(string); ok {
|
||||
case int:
|
||||
statusCode = value
|
||||
case string:
|
||||
// a string is content type when it contains a slash and
|
||||
// content or custom struct is being calculated already;
|
||||
// (string -> content, string-> content type)
|
||||
// (customStruct, string -> content type)
|
||||
if (len(content) > 0 || custom != nil) && strings.IndexByte(s, slashB) > 0 {
|
||||
contentType = s
|
||||
if (len(content) > 0 || custom != nil) && strings.IndexByte(value, slashB) > 0 {
|
||||
contentType = value
|
||||
} else {
|
||||
// otherwise is content
|
||||
content = []byte(s)
|
||||
content = []byte(value)
|
||||
}
|
||||
|
||||
continue
|
||||
}
|
||||
|
||||
if b, ok := f.([]byte); ok {
|
||||
case []byte:
|
||||
// it's raw content, get the latest
|
||||
content = b
|
||||
continue
|
||||
}
|
||||
|
||||
if e, ok := f.(compatibleErr); ok {
|
||||
if e != nil { // it's always not nil but keep it here.
|
||||
err = e
|
||||
content = value
|
||||
case compatibleErr:
|
||||
if value != nil { // it's always not nil but keep it here.
|
||||
err = value
|
||||
if statusCode < 400 {
|
||||
statusCode = DefaultErrStatusCode
|
||||
}
|
||||
|
|
@ -250,17 +302,15 @@ func DispatchFuncResult(ctx context.Context, values []reflect.Value) {
|
|||
// need to know break the dispatcher if any error.
|
||||
// at the end; we don't want to write anything to the response if error is not nil.
|
||||
}
|
||||
continue
|
||||
default:
|
||||
// else it's a custom struct or a dispatcher, we'll decide later
|
||||
// because content type and status code matters
|
||||
// do that check in order to be able to correctly dispatch:
|
||||
// (customStruct, error) -> customStruct filled and error is nil
|
||||
if custom == nil && f != nil {
|
||||
custom = f
|
||||
}
|
||||
}
|
||||
|
||||
// else it's a custom struct or a dispatcher, we'll decide later
|
||||
// because content type and status code matters
|
||||
// do that check in order to be able to correctly dispatch:
|
||||
// (customStruct, error) -> customStruct filled and error is nil
|
||||
if custom == nil && f != nil {
|
||||
custom = f
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
DispatchCommon(ctx, statusCode, contentType, content, custom, err, found)
|
||||
|
|
|
|||
|
|
@ -15,6 +15,7 @@ import (
|
|||
// Therefore I should reduce some "freedom of change" for the shake of code maintanability in the core/router files: handler.go | router.go and single change on APIBuilder's field.
|
||||
func main() {
|
||||
app := iris.New()
|
||||
app.Logger().SetLevel("debug")
|
||||
mvc.New(app.Party("/todo")).Configure(TodoApp)
|
||||
// no let's have a clear "mvc" package without any conversions and type aliases,
|
||||
// it's one extra import path for a whole new world, it worths it.
|
||||
|
|
@ -74,8 +75,8 @@ func (c *TodoController) BeforeActivation(b mvc.BeforeActivation) {
|
|||
}
|
||||
|
||||
func (c *TodoController) AfterActivation(a mvc.AfterActivation) {
|
||||
if !a.IsRequestScoped() {
|
||||
panic("TodoController should be request scoped, we have a 'Session' which depends on the context.")
|
||||
if a.Singleton() {
|
||||
panic("TodoController should be stateless, a request-scoped, we have a 'Session' which depends on the context.")
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user