func CreateServerChain() (*aggregatorapiserver.APIAggregator, error) {
    // 1.
	apiExtensionsServer, err := createAPIExtensionsServer(apiExtensionsConfig, genericapiserver.NewEmptyDelegate())
}

func createAPIExtensionsServer(/*参数省略*/) (*apiextensionsapiserver.CustomResourceDefinitions, error) {
    // 2.
	return apiextensionsConfig.Complete().New(delegateAPIServer)
}

func (c completedConfig) New(delegationTarget genericapiserver.DelegationTarget) (*CustomResourceDefinitions, error) {
    //3.
	genericServer, err := c.GenericConfig.New("apiextensions-apiserver", delegationTarget)
	return s, nil
}


func (c completedConfig) New(name string, delegationTarget DelegationTarget) (*GenericAPIServer, error) {
	
    // 4. 
	handlerChainBuilder := func(handler http.Handler) http.Handler {
		return c.BuildHandlerChainFunc(handler, c.Config)
	}
     //5.
	apiServerHandler := NewAPIServerHandler(name, c.Serializer, handlerChainBuilder, delegationTarget.UnprotectedHandler())
	
    // 6.
	s := &GenericAPIServer{
		Handler: apiServerHandler,
		listedPathProvider: apiServerHandler,
	}
	return s, nil
}

// 7. 
func NewAPIServerHandler() *APIServerHandler {
    // 8.
	nonGoRestfulMux := mux.NewPathRecorderMux(name)
    // 9.
	if notFoundHandler != nil {
		nonGoRestfulMux.NotFoundHandler(notFoundHandler)
	}

    // 10. goreset
	gorestfulContainer := restful.NewContainer()
	gorestfulContainer.ServeMux = http.NewServeMux()
	gorestfulContainer.Router(restful.CurlyRouter{}) 
	gorestfulContainer.RecoverHandler(func(panicReason interface{}, httpWriter http.ResponseWriter) {
		logStackOnRecover(s, panicReason, httpWriter)
	})
	gorestfulContainer.ServiceErrorHandler(func(serviceErr restful.ServiceError, request *restful.Request, response *restful.Response) {
		serviceErrorHandler(s, serviceErr, request, response)
	})

    // 11
	director := director{
		name:               name,
		goRestfulContainer: gorestfulContainer,
		nonGoRestfulMux:    nonGoRestfulMux,
	}
	return &APIServerHandler{
		FullHandlerChain:   handlerChainBuilder(director),
		GoRestfulContainer: gorestfulContainer,
		NonGoRestfulMux:    nonGoRestfulMux,
		Director:           director,
	}
}

func (s *APIAggregator) PrepareRun() (preparedAPIAggregator, error) {
      // 可以看到GenericServer占据了C位
      prepared := s.GenericAPIServer.PrepareRun()
    return preparedAPIAggregator{APIAggregator: s, runnable: prepared}, nil
}

func (s *GenericAPIServer) PrepareRun() preparedGenericAPIServer {
	s.delegationTarget.PrepareRun()
	return preparedGenericAPIServer{s}
}

func (s preparedGenericAPIServer) Run(stopCh <-chan struct{}) error {
    // 1.
	delayedStopCh := make(chan struct{})
    go func() {
		defer close(delayedStopCh)
		<-stopCh
		close(s.readinessStopCh)

		time.Sleep(s.ShutdownDelayDuration)
	}()

	// 2.
	stoppedCh, err := s.NonBlockingRun(delayedStopCh)
    // 3.
	<-stopCh
	err = s.RunPreShutdownHooks()
    // 4.
    <-stoppedCh
	s.HandlerChainWaitGroup.Wait()
	return nil
}

func (s preparedGenericAPIServer) NonBlockingRun(stopCh <-chan struct{}) (<-chan struct{}, error) {
	internalStopCh := make(chan struct{})
	var stoppedCh <-chan struct{}
	if s.SecureServingInfo != nil && s.Handler != nil {
		var err error
        // 5.
		stoppedCh, err = s.SecureServingInfo.Serve(s.Handler, s.ShutdownTimeout, internalStopCh)
	}
	// 6.
	s.RunPostStartHooks(stopCh)
	return stoppedCh, nil
}

func (s *SecureServingInfo) Serve(handler http.Handler, shutdownTimeout time.Duration, stopCh <-chan struct{}) (<-chan struct{}, error) {
    // 1.
	secureServer := &http.Server{
		Addr:           s.Listener.Addr().String(),
        // 2.
		Handler:        handler,
		MaxHeaderBytes: 1 << 20,
		TLSConfig:      tlsConfig,
	}
    // 设置http服务器的各种参数，比如读写数据流的帧(FrameSize)大小
    
	return RunServer(secureServer, s.Listener, shutdownTimeout, stopCh)
}

func RunServer(
	server *http.Server,
	ln net.Listener,
	shutDownTimeout time.Duration,
	stopCh <-chan struct{},
) (<-chan struct{}, error) {
	go func() {
		defer utilruntime.HandleCrash()
		var listener net.Listener
		listener = tcpKeepAliveListener{ln}
        // 3.
		err := server.Serve(listener)
		select {
		case <-stopCh:
			klog.Info(msg)
		default:
			panic(fmt.Sprintf("%s due to error: %v", msg, err))
		}
	}()

	return stoppedCh, nil
}

type GenericAPIServer struct {
    Handler *APIServerHandler
}

type APIServerHandler struct {
	FullHandlerChain http.Handler
	GoRestfulContainer *restful.Container
	NonGoRestfulMux *mux.PathRecorderMux
	Director http.Handler
}

func NewAPIServerHandler(name string, s runtime.NegotiatedSerializer, handlerChainBuilder HandlerChainBuilderFn, notFoundHandler http.Handler) *APIServerHandler {
	director := director{
		name:               name,
		goRestfulContainer: gorestfulContainer,
		nonGoRestfulMux:    nonGoRestfulMux,
	}

	return &APIServerHandler{
        // 1.
		FullHandlerChain:   handlerChainBuilder(director),
		GoRestfulContainer: gorestfulContainer,
		NonGoRestfulMux:    nonGoRestfulMux,
		Director:           director,
	}
}

func (a *APIServerHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    // 2.
	a.FullHandlerChain.ServeHTTP(w, r)
}

func (d director) ServeHTTP(w http.ResponseWriter, req *http.Request) {
	path := req.URL.Path

    // 1. 
	for _, ws := range d.goRestfulContainer.RegisteredWebServices() {
		switch {
		case ws.RootPath() == "/apis":
			if path == "/apis" || path == "/apis/" {
				d.goRestfulContainer.Dispatch(w, req)
				return
			}

		case strings.HasPrefix(path, ws.RootPath()):
			// ensure an exact match or a path boundary match
			if len(path) == len(ws.RootPath()) || path[len(ws.RootPath())] == '/' {
				d.goRestfulContainer.Dispatch(w, req)
				return
			}
		}
	}
	// 2.
	d.nonGoRestfulMux.ServeHTTP(w, req)
}

func (m *PathRecorderMux) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	m.mux.Load().(*pathHandler).ServeHTTP(w, r)
}

func (h *pathHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    // 3.
	if exactHandler, ok := h.pathToHandler[r.URL.Path]; ok {
		exactHandler.ServeHTTP(w, r)
		return
	}
	for _, prefixHandler := range h.prefixHandlers {
		if strings.HasPrefix(r.URL.Path, prefixHandler.prefix) {
			prefixHandler.handler.ServeHTTP(w, r)
			return
		}
	}

    // 4.
	h.notFoundHandler.ServeHTTP(w, r)
}