func (s *ControllerPool) GetControllerFuncName(controllerName string) (string, bool) {
	s.mu.RLock()
	defer s.mu.RUnlock()
	if len(s.controllerFuncMap) == 0 {
		return "", false
	}
	funcName, ok := s.controllerFuncMap[controllerName]
	return funcName, ok
}
GetControllerFuncName get controller func name
package application
import (
	"fmt"
	"reflect"
	"strings"
	"sync"
	"github.com/PolarPanda611/trinitygo/startup"
	"github.com/gin-gonic/gin"
	"github.com/kataras/golog"
)
type ControllerPool struct {
	mu                   sync.RWMutex
	instanceMap          map[string]reflect.Type
	controllerMap        []string
	controllerFuncMap    map[string]string
	controllerValidators map[string][]Validator
}
func NewControllerPool() *ControllerPool {
	result := new(ControllerPool)
	result.mu.Lock()
	defer result.mu.Unlock()
	result.instanceMap = make(map[string]reflect.Type)
	result.controllerFuncMap = make(map[string]string)
	result.controllerValidators = make(map[string][]Validator)
	return result
}
func (s *ControllerPool) NewController(controllerType string, instance reflect.Type) {
	s.mu.Lock()
	defer s.mu.Unlock()
	s.instanceMap[controllerType] = instance
	s.controllerMap = append(s.controllerMap, controllerType)
}
func (s *ControllerPool) NewControllerFunc(controllerType string, funcName string) {
	s.mu.Lock()
	defer s.mu.Unlock()
	s.controllerFuncMap[controllerType] = funcName
}
func (s *ControllerPool) NewControllerValidators(controllerType string, validator ...Validator) {
	s.mu.Lock()
	defer s.mu.Unlock()
	s.controllerValidators[controllerType] = validator
}
func (s *ControllerPool) GetControllerMap() []string {
	s.mu.RLock()
	defer s.mu.RUnlock()
	return s.controllerMap
}
func (s *ControllerPool) ControllerFuncSelfCheck(instancePool *InstancePool, isLog bool, logger *golog.Logger) {
	s.mu.RLock()
	defer s.mu.RUnlock()
	for controllerName, instanceName := range s.instanceMap {
		controllerNameDecode := strings.Split(controllerName, "@")
		if len(controllerNameDecode) == 1 {
			return
		}
		funcName, funcExist := s.controllerFuncMap[controllerName]
		if funcName == "" || !funcExist {
			funcName = controllerNameDecode[0]
			logger.Fatalf("booting self func checking controller %v , no func registered , self check failed ...", controllerName)
		}
		pool, ok := instancePool.poolMap[instanceName]
		if !ok {
			logger.Fatalf("booting self func checking controller %v , no instance %v registered , self check failed ...", controllerName, instanceName)
		}
		instance := pool.Get()
		defer pool.Put(instance)
		m, funcImpled := reflect.TypeOf(instance).MethodByName(funcName)
		if !funcImpled {
			logger.Fatalf("booting self func checking controller %v , func %v not registered , self check failed ...", controllerName, funcName)
		}
		if isLog {
			startup.AppendStartupDebuggerInfo(fmt.Sprintf("booting self func checking controller %v , func %v checked ", controllerName, funcName))
		}
		if m.Type.NumIn() < -1 {
			logger.Fatalf("booting self func checking controller %v , func %v should have at least 1 in args  , self check failed ...", controllerName, funcName)
		}
		if m.Type.NumOut() > 2 {
			logger.Fatalf("booting self func checking controller %v , func %v should have at most 2 out args  , self check failed ...", controllerName, funcName)
		}
	}
	return
}
func (s *ControllerPool) GetController(controllerName string, tctx Context, app Application, c *gin.Context) (interface{}, map[reflect.Type]interface{}, map[reflect.Type]interface{}) {
	s.mu.RLock()
	instanceName, ok := s.instanceMap[controllerName]
	s.mu.RUnlock()
	if !ok {
		panic(fmt.Sprintf("unknown controller name : %v", controllerName))
	}
	InjectingInstanceMap := make(map[reflect.Type]interface{})
	return app.InstancePool().GetInstance(instanceName, tctx, app, c, InjectingInstanceMap)
}