课程笔记丨《手把手带你写一个 Web 框架》

// HandlersChain defines a HandlerFunc slice.
type HandlersChain []HandlerFunc

// HandlerFunc defines the handler used by gin middleware as return value.
type HandlerFunc func(*Context)

// IRouter defines all router handle interface includes single and group router.
type IRouter interface {
	IRoutes
	Group(string, ...HandlerFunc) *RouterGroup
}

const abortIndex int8 = math.MaxInt8 >> 1

func (c *Context) Next() {
	c.index++   // 初始化 c.index = -1
	for c.index < int8(len(c.handlers)) {
		if c.handlers[c.index] != nil {
			c.handlers[c.index](c)
		}
		c.index++
	}
}

func (c *Context) Abort() {
	c.index = abortIndex  // 设置为最大值，后面的 next 就会直接返回
}

// NewInstance is a function that creates a new instance of a service
type NewInstance func(...any) (any, error)

// ServiceProvider is an interface that defines a service provider
type ServiceProvider interface {
	// Register a service provider into the container,
	// whether to initialize the service or not determined by the IsDefer method
	Register(Container) NewInstance
	// Boot the service provider, this method will be called after the container is initialized.
	// Is id recommend to do some initialization work in this method.
	// If returns error, the service initialization will be failed.
	Boot(Container) error
	// IsDefer determines whether the service provider should be deferred.
	// If true, the service provider will be deferred until the first time the service is used.
	IsDefer() bool
	// Params are the parameters which would be passed to the NewInstance function.
	Params(Container) []any
	// Name is a method that returns the unique name of the service provider.
	Name() string
}

// Container is a service provider container, provides methods to register and resolve service providers.
type Container interface {
	// Bind binds a service provider into the container,
	// if the service provider is already bound, it would panic.
	Bind(provider ServiceProvider) error
	// IsBind checks if a service provider is bound into the container
	IsBind(key string) bool
	// Make resolves a service provider from the container
	Make(key string) (any, error)
	// MustMake resolves a service provider from the container, if not found, it will panic
	MustMake(key string) any
	// MakeNew creates a new instance of a service provider,
	// it is useful when you need to create a new instance of a service provider
	// and pass some different parameters to the service provider's constructor.
	MakeNew(key string, params ...any) (any, error)
}

// Helps to check if the Container interface is implemented
var _ Container = (*HdwebContainer)(nil)

// HdwebContainer is the default implementation of the Container interface
type HdwebContainer struct {
	// providers is a map of service providers, key is the name of the service provider
	providers map[string]ServiceProvider
	// instances is a map of service instances, key is the name of the service
	instances map[string]any
	// lock is used to protect the container from concurrent access
	lock sync.RWMutex
}

// NewHdwebContainer creates a new HdwebContainer
func NewHdwebContainer() *HdwebContainer {
	return &HdwebContainer{
		providers: make(map[string]ServiceProvider),
		instances: make(map[string]any),
		lock:      sync.RWMutex{},
	}
}

// Bind binds a service provider into the container,
// if the service provider is already bound, '
// it will replace the existing one and return an error.
func (h *HdwebContainer) Bind(provider ServiceProvider) error {
	h.lock.Lock()
	key := provider.Name()
	if _, ok := h.providers[key]; ok {
		h.lock.Unlock()
		panic("service provider already bound: " + key)
	}
	h.providers[key] = provider
	h.lock.Unlock()

	if provider.IsDefer() {
		return nil
	}

	if err := provider.Boot(h); err != nil {
		return err
	}

	params := provider.Params(h)
	method := provider.Register(h)

	instance, err := method(params...)
	if err != nil {
		return err
	}

	h.lock.Lock()
	defer h.lock.Unlock()
	if _, ok := h.instances[key]; ok {
		panic("service provider already resolved: " + key)
	}
	h.instances[key] = instance
	return nil
}

// IsBind checks if a service provider is bound into the container
func (h *HdwebContainer) IsBind(key string) bool {
	return h.findServiceProvider(key) != nil
}

// Make resolves a service provider from the container
func (h *HdwebContainer) Make(key string) (any, error) {
	return h.make(key, nil, false)
}

// MakeNew creates a new instance of a service provider,
// it is useful when you need to create a new instance of a service provider
// and pass some different parameters to the service provider's constructor.
func (h *HdwebContainer) MakeNew(key string, params ...any) (any, error) {
	return h.make(key, params, true)
}

// MustMake resolves a service provider from the container, if not found, it will panic
func (h *HdwebContainer) MustMake(key string) any {
	ins, err := h.make(key, nil, false)
	if err != nil {
		panic(err)
	}
	return ins
}

func (h *HdwebContainer) make(key string, params []any, forceNew bool) (any, error) {
	sp := h.findServiceProvider(key)
	if sp == nil {
		return nil, errors.New("service provider not found: " + key)
	}
	if forceNew {
		return h.newInstance(sp, params)
	}

	if ins := h.getInstance(key); ins != nil {
		return ins, nil
	}

	h.lock.Lock()
	defer h.lock.Unlock()
	if ins, ok := h.instances[key]; ok {
		return ins, nil
	}
	ins, err := h.newInstance(sp, params)
	if err != nil {
		return nil, err
	}
	h.instances[key] = ins
	return ins, nil
}

func (h *HdwebContainer) getInstance(key string) any {
	h.lock.RLock()
	defer h.lock.RUnlock()
	return h.instances[key]
}

func (h *HdwebContainer) newInstance(sp ServiceProvider, params []any) (any, error) {
	if err := sp.Boot(h); err != nil {
		return nil, err
	}
	if params == nil {
		params = sp.Params(h)
	}
	method := sp.Register(h)
	return method(params...)
}

func (h *HdwebContainer) findServiceProvider(key string) ServiceProvider {
	h.lock.RLock()
	defer h.lock.RUnlock()
	return h.providers[key]
}