话不多说，先看图：

 springboot_web是一个简单的springboot项目，上面有一个PangjhController,里面有一个方法getMessge()的@RequestMapping的值是“/hello”，在启动项目的时候，控制台会打印出{[/hello]}这个信息，这个到底是在底层哪里打印的呢？

下面我将带你们详细地带你们走完源码的整个流程：

第一步当然是从我们的启动类开始：

@SpringBootApplicationpublic class SpringbootFoundApplication {    public static void main(String[] args) {        SpringApplication.run(SpringbootFoundApplication.class, args);    }}

 

进入run方法：

public static ConfigurableApplicationContext run(Class
      primarySource,            String... args) {        return run(new Class
     [] { primarySource }, args);    }

 

再进：

public static ConfigurableApplicationContext run(Class
     [] primarySources,            String[] args) {        return new SpringApplication(primarySources).run(args);    }

 

上面new SpringApplication(primarySources)主要是给SpringApplication一些初始化的赋值，我们再进run方法：

public ConfigurableApplicationContext run(String... args) {        StopWatch stopWatch = new StopWatch();        stopWatch.start();        ConfigurableApplicationContext context = null;        Collection
     
       exceptionReporters = new ArrayList<>();        configureHeadlessProperty();        SpringApplicationRunListeners listeners = getRunListeners(args);        listeners.starting();        try {            ApplicationArguments applicationArguments = new DefaultApplicationArguments(                    args);            ConfigurableEnvironment environment = prepareEnvironment(listeners,                    applicationArguments);            configureIgnoreBeanInfo(environment);            Banner printedBanner = printBanner(environment);            context = createApplicationContext();            exceptionReporters = getSpringFactoriesInstances(                    SpringBootExceptionReporter.class,                    new Class[] { ConfigurableApplicationContext.class }, context);            prepareContext(context, environment, listeners, applicationArguments,                    printedBanner);            refreshContext(context);            afterRefresh(context, applicationArguments);            stopWatch.stop();            if (this.logStartupInfo) {                new StartupInfoLogger(this.mainApplicationClass)                        .logStarted(getApplicationLog(), stopWatch);            }            listeners.started(context);            callRunners(context, applicationArguments);        }        catch (Throwable ex) {            handleRunFailure(context, listeners, exceptionReporters, ex);            throw new IllegalStateException(ex);        }        listeners.running(context);        return context;    }
     

 

然后进入refreshContext(context);方法：

private void refreshContext(ConfigurableApplicationContext context) {        refresh(context);        if (this.registerShutdownHook) {            try {                context.registerShutdownHook();            }            catch (AccessControlException ex) {                // Not allowed in some environments.            }        }    }

 

然后进入refresh(context);方法：

/**     * Refresh the underlying {
    @link ApplicationContext}.     * @param applicationContext the application context to refresh     */    protected void refresh(ApplicationContext applicationContext) {        Assert.isInstanceOf(AbstractApplicationContext.class, applicationContext);        ((AbstractApplicationContext) applicationContext).refresh();    }

 

然后进入((AbstractApplicationContext) applicationContext).refresh();方法：

@Override    public void refresh() throws BeansException, IllegalStateException {        synchronized (this.startupShutdownMonitor) {            // Prepare this context for refreshing.            prepareRefresh();            // Tell the subclass to refresh the internal bean factory.            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();            // Prepare the bean factory for use in this context.            prepareBeanFactory(beanFactory);            try {                // Allows post-processing of the bean factory in context subclasses.                postProcessBeanFactory(beanFactory);                // Invoke factory processors registered as beans in the context.                invokeBeanFactoryPostProcessors(beanFactory);                // Register bean processors that intercept bean creation.                registerBeanPostProcessors(beanFactory);                // Initialize message source for this context.                initMessageSource();                // Initialize event multicaster for this context.                initApplicationEventMulticaster();                // Initialize other special beans in specific context subclasses.                onRefresh();                // Check for listener beans and register them.                registerListeners();                // Instantiate all remaining (non-lazy-init) singletons.                finishBeanFactoryInitialization(beanFactory);                // Last step: publish corresponding event.                finishRefresh();            }            catch (BeansException ex) {                if (logger.isWarnEnabled()) {                    logger.warn("Exception encountered during context initialization - " +                            "cancelling refresh attempt: " + ex);                }                // Destroy already created singletons to avoid dangling resources.                destroyBeans();                // Reset 'active' flag.                cancelRefresh(ex);                // Propagate exception to caller.                throw ex;            }            finally {                // Reset common introspection caches in Spring's core, since we                // might not ever need metadata for singleton beans anymore...                resetCommonCaches();            }        }    }

 

然后进入finishBeanFactoryInitialization(beanFactory);方法：

/**     * Finish the initialization of this context's bean factory,     * initializing all remaining singleton beans.     */    protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {        // Initialize conversion service for this context.        if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&                beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {            beanFactory.setConversionService(                    beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));        }        // Register a default embedded value resolver if no bean post-processor        // (such as a PropertyPlaceholderConfigurer bean) registered any before:        // at this point, primarily for resolution in annotation attribute values.        if (!beanFactory.hasEmbeddedValueResolver()) {            beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));        }        // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.        String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);        for (String weaverAwareName : weaverAwareNames) {            getBean(weaverAwareName);        }        // Stop using the temporary ClassLoader for type matching.        beanFactory.setTempClassLoader(null);        // Allow for caching all bean definition metadata, not expecting further changes.        beanFactory.freezeConfiguration();        // Instantiate all remaining (non-lazy-init) singletons.        beanFactory.preInstantiateSingletons();    }

 

然后进入beanFactory.preInstantiateSingletons();方法实现类：

@Override    public void preInstantiateSingletons() throws BeansException {        if (this.logger.isDebugEnabled()) {            this.logger.debug("Pre-instantiating singletons in " + this);        }        // Iterate over a copy to allow for init methods which in turn register new bean definitions.        // While this may not be part of the regular factory bootstrap, it does otherwise work fine.        List
     
       beanNames = new ArrayList<>(this.beanDefinitionNames);        // Trigger initialization of all non-lazy singleton beans...        for (String beanName : beanNames) {
    //这里是循环java底层的某些类，其中有一个类requestMappingHandlerMapping是我们要关注的类            RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);            if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {                if (isFactoryBean(beanName)) {                    Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);                    if (bean instanceof FactoryBean) {                        final FactoryBean
       factory = (FactoryBean
      ) bean;                        boolean isEagerInit;                        if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {                            isEagerInit = AccessController.doPrivileged((PrivilegedAction
      
       )                                            ((SmartFactoryBean
       ) factory)::isEagerInit,                                    getAccessControlContext());                        }                        else {                            isEagerInit = (factory instanceof SmartFactoryBean &&                                    ((SmartFactoryBean
       ) factory).isEagerInit());                        }                        if (isEagerInit) {                            getBean(beanName);                        }                    }                }                else {                    getBean(beanName);//当beanName值为requestMappingHandlerMapping的时候，我们进入getBean（beanName）;方法                }            }        }        // Trigger post-initialization callback for all applicable beans...        for (String beanName : beanNames) {            Object singletonInstance = getSingleton(beanName);            if (singletonInstance instanceof SmartInitializingSingleton) {                final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;                if (System.getSecurityManager() != null) {                    AccessController.doPrivileged((PrivilegedAction
       
      
     

 

进入getBean(beanName);方法：

@Override    public Object getBean(String name) throws BeansException {        return doGetBean(name, null, null, false);    }

 

再进doGetBean方法：

/**     * Return an instance, which may be shared or independent, of the specified bean.     * @param name the name of the bean to retrieve     * @param requiredType the required type of the bean to retrieve     * @param args arguments to use when creating a bean instance using explicit arguments     * (only applied when creating a new instance as opposed to retrieving an existing one)     * @param typeCheckOnly whether the instance is obtained for a type check,     * not for actual use     * @return an instance of the bean     * @throws BeansException if the bean could not be created     */    @SuppressWarnings("unchecked")    protected 
     
       T doGetBean(final String name, @Nullable final Class
      
        requiredType,            @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {        final String beanName = transformedBeanName(name);        Object bean;        // Eagerly check singleton cache for manually registered singletons.        Object sharedInstance = getSingleton(beanName);        if (sharedInstance != null && args == null) {            if (logger.isDebugEnabled()) {                if (isSingletonCurrentlyInCreation(beanName)) {                    logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +                            "' that is not fully initialized yet - a consequence of a circular reference");                }                else {                    logger.debug("Returning cached instance of singleton bean '" + beanName + "'");                }            }            bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);        }        else {            // Fail if we're already creating this bean instance:            // We're assumably within a circular reference.            if (isPrototypeCurrentlyInCreation(beanName)) {                throw new BeanCurrentlyInCreationException(beanName);            }            // Check if bean definition exists in this factory.            BeanFactory parentBeanFactory = getParentBeanFactory();            if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {                // Not found -> check parent.                String nameToLookup = originalBeanName(name);                if (parentBeanFactory instanceof AbstractBeanFactory) {                    return ((AbstractBeanFactory) parentBeanFactory).doGetBean(                            nameToLookup, requiredType, args, typeCheckOnly);                }                else if (args != null) {                    // Delegation to parent with explicit args.                    return (T) parentBeanFactory.getBean(nameToLookup, args);                }                else {                    // No args -> delegate to standard getBean method.                    return parentBeanFactory.getBean(nameToLookup, requiredType);                }            }            if (!typeCheckOnly) {                markBeanAsCreated(beanName);            }            try {                final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);                checkMergedBeanDefinition(mbd, beanName, args);                // Guarantee initialization of beans that the current bean depends on.                String[] dependsOn = mbd.getDependsOn();                if (dependsOn != null) {                    for (String dep : dependsOn) {                        if (isDependent(beanName, dep)) {                            throw new BeanCreationException(mbd.getResourceDescription(), beanName,                                    "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");                        }                        registerDependentBean(dep, beanName);                        getBean(dep);                    }                }                // Create bean instance.                if (mbd.isSingleton()) {                    sharedInstance = getSingleton(beanName, () -> {                        try {                            return createBean(beanName, mbd, args);                        }                        catch (BeansException ex) {                            // Explicitly remove instance from singleton cache: It might have been put there                            // eagerly by the creation process, to allow for circular reference resolution.                            // Also remove any beans that received a temporary reference to the bean.                            destroySingleton(beanName);                            throw ex;                        }                    });                    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);                }                else if (mbd.isPrototype()) {                    // It's a prototype -> create a new instance.                    Object prototypeInstance = null;                    try {                        beforePrototypeCreation(beanName);                        prototypeInstance = createBean(beanName, mbd, args);                    }                    finally {                        afterPrototypeCreation(beanName);                    }                    bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);                }                else {                    String scopeName = mbd.getScope();                    final Scope scope = this.scopes.get(scopeName);                    if (scope == null) {                        throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");                    }                    try {                        Object scopedInstance = scope.get(beanName, () -> {                            beforePrototypeCreation(beanName);                            try {                                return createBean(beanName, mbd, args);                            }                            finally {                                afterPrototypeCreation(beanName);                            }                        });                        bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);                    }                    catch (IllegalStateException ex) {                        throw new BeanCreationException(beanName,                                "Scope '" + scopeName + "' is not active for the current thread; consider " +                                "defining a scoped proxy for this bean if you intend to refer to it from a singleton",                                ex);                    }                }            }            catch (BeansException ex) {                cleanupAfterBeanCreationFailure(beanName);                throw ex;            }        }        // Check if required type matches the type of the actual bean instance.        if (requiredType != null && !requiredType.isInstance(bean)) {            try {                T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);                if (convertedBean == null) {                    throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());                }                return convertedBean;            }            catch (TypeMismatchException ex) {                if (logger.isDebugEnabled()) {                    logger.debug("Failed to convert bean '" + name + "' to required type '" +                            ClassUtils.getQualifiedName(requiredType) + "'", ex);                }                throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());            }        }        return (T) bean;    }
      
     

 

进入createBean(beanName, mbd, args);方法实现类：

/**     * Central method of this class: creates a bean instance,     * populates the bean instance, applies post-processors, etc.     * @see #doCreateBean     */    @Override    protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)            throws BeanCreationException {        if (logger.isDebugEnabled()) {            logger.debug("Creating instance of bean '" + beanName + "'");        }        RootBeanDefinition mbdToUse = mbd;        // Make sure bean class is actually resolved at this point, and        // clone the bean definition in case of a dynamically resolved Class        // which cannot be stored in the shared merged bean definition.        Class
      resolvedClass = resolveBeanClass(mbd, beanName);        if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {            mbdToUse = new RootBeanDefinition(mbd);            mbdToUse.setBeanClass(resolvedClass);        }        // Prepare method overrides.        try {            mbdToUse.prepareMethodOverrides();        }        catch (BeanDefinitionValidationException ex) {            throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),                    beanName, "Validation of method overrides failed", ex);        }        try {            // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.            Object bean = resolveBeforeInstantiation(beanName, mbdToUse);            if (bean != null) {                return bean;            }        }        catch (Throwable ex) {            throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,                    "BeanPostProcessor before instantiation of bean failed", ex);        }        try {            Object beanInstance = doCreateBean(beanName, mbdToUse, args);            if (logger.isDebugEnabled()) {                logger.debug("Finished creating instance of bean '" + beanName + "'");            }            return beanInstance;        }        catch (BeanCreationException ex) {            // A previously detected exception with proper bean creation context already...            throw ex;        }        catch (ImplicitlyAppearedSingletonException ex) {            // An IllegalStateException to be communicated up to DefaultSingletonBeanRegistry...            throw ex;        }        catch (Throwable ex) {            throw new BeanCreationException(                    mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);        }    }

 

再进入doCreateBean(beanName, mbdToUse, args);方法：

/**     * Actually create the specified bean. Pre-creation processing has already happened     * at this point, e.g. checking {
    @code postProcessBeforeInstantiation} callbacks.     * 
Differentiates between default bean instantiation, use of a     * factory method, and autowiring a constructor.     * @param beanName the name of the bean     * @param mbd the merged bean definition for the bean     * @param args explicit arguments to use for constructor or factory method invocation     * @return a new instance of the bean     * @throws BeanCreationException if the bean could not be created     * @see #instantiateBean     * @see #instantiateUsingFactoryMethod     * @see #autowireConstructor     */    protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)            throws BeanCreationException {        // Instantiate the bean.        BeanWrapper instanceWrapper = null;        if (mbd.isSingleton()) {            instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);        }        if (instanceWrapper == null) {            instanceWrapper = createBeanInstance(beanName, mbd, args);        }        final Object bean = instanceWrapper.getWrappedInstance();        Class
       beanType = instanceWrapper.getWrappedClass();        if (beanType != NullBean.class) {            mbd.resolvedTargetType = beanType;        }        // Allow post-processors to modify the merged bean definition.        synchronized (mbd.postProcessingLock) {            if (!mbd.postProcessed) {                try {                    applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);                }                catch (Throwable ex) {                    throw new BeanCreationException(mbd.getResourceDescription(), beanName,                            "Post-processing of merged bean definition failed", ex);                }                mbd.postProcessed = true;            }        }        // Eagerly cache singletons to be able to resolve circular references        // even when triggered by lifecycle interfaces like BeanFactoryAware.        boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&                isSingletonCurrentlyInCreation(beanName));        if (earlySingletonExposure) {            if (logger.isDebugEnabled()) {                logger.debug("Eagerly caching bean '" + beanName +                        "' to allow for resolving potential circular references");            }            addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));        }        // Initialize the bean instance.        Object exposedObject = bean;        try {            populateBean(beanName, mbd, instanceWrapper);            exposedObject = initializeBean(beanName, exposedObject, mbd);        }        catch (Throwable ex) {            if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {                throw (BeanCreationException) ex;            }            else {                throw new BeanCreationException(                        mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);            }        }        if (earlySingletonExposure) {            Object earlySingletonReference = getSingleton(beanName, false);            if (earlySingletonReference != null) {                if (exposedObject == bean) {                    exposedObject = earlySingletonReference;                }                else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {                    String[] dependentBeans = getDependentBeans(beanName);                    Set
      
        actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);                    for (String dependentBean : dependentBeans) {                        if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {                            actualDependentBeans.add(dependentBean);                        }                    }                    if (!actualDependentBeans.isEmpty()) {                        throw new BeanCurrentlyInCreationException(beanName,                                "Bean with name '" + beanName + "' has been injected into other beans [" +                                StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +                                "] in its raw version as part of a circular reference, but has eventually been " +                                "wrapped. This means that said other beans do not use the final version of the " +                                "bean. This is often the result of over-eager type matching - consider using " +                                "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");                    }                }            }        }        // Register bean as disposable.        try {            registerDisposableBeanIfNecessary(beanName, bean, mbd);        }        catch (BeanDefinitionValidationException ex) {            throw new BeanCreationException(                    mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);        }        return exposedObject;    }
      

 

 

再进入initializeBean(beanName, exposedObject, mbd);方法：

/**     * Initialize the given bean instance, applying factory callbacks     * as well as init methods and bean post processors.     * 
Called from {
    @link #createBean} for traditionally defined beans,     * and from {
    @link #initializeBean} for existing bean instances.     * @param beanName the bean name in the factory (for debugging purposes)     * @param bean the new bean instance we may need to initialize     * @param mbd the bean definition that the bean was created with     * (can also be {
    @code null}, if given an existing bean instance)     * @return the initialized bean instance (potentially wrapped)     * @see BeanNameAware     * @see BeanClassLoaderAware     * @see BeanFactoryAware     * @see #applyBeanPostProcessorsBeforeInitialization     * @see #invokeInitMethods     * @see #applyBeanPostProcessorsAfterInitialization     */    protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {        if (System.getSecurityManager() != null) {            AccessController.doPrivileged((PrivilegedAction

 

 

再进入invokeInitMethods(beanName, wrappedBean, mbd);方法：

/**     * Give a bean a chance to react now all its properties are set,     * and a chance to know about its owning bean factory (this object).     * This means checking whether the bean implements InitializingBean or defines     * a custom init method, and invoking the necessary callback(s) if it does.     * @param beanName the bean name in the factory (for debugging purposes)     * @param bean the new bean instance we may need to initialize     * @param mbd the merged bean definition that the bean was created with     * (can also be {
    @code null}, if given an existing bean instance)     * @throws Throwable if thrown by init methods or by the invocation process     * @see #invokeCustomInitMethod     */    protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)            throws Throwable {        boolean isInitializingBean = (bean instanceof InitializingBean);        if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {            if (logger.isDebugEnabled()) {                logger.debug("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");            }            if (System.getSecurityManager() != null) {                try {                    AccessController.doPrivileged((PrivilegedExceptionAction

 

 

再进入((InitializingBean) bean).afterPropertiesSet();方法，注意这个时候实现类要是AbstractHandlerMethodMapping：

public abstract class AbstractHandlerMethodMapping
     
       extends AbstractHandlerMapping implements InitializingBean {//...@Override    public void afterPropertiesSet() {        initializeCaches();    }//...}
     

 

 

再进入initializeCaches();方法：

/**     * Scan beans in the ApplicationContext, detect and register handler methods.     * @see #isHandler(Class)     * @see #getMappingForMethod(Method, Class)     * @see #handlerMethodsInitialized(Map)     */    protected void initHandlerMethods() {        if (logger.isDebugEnabled()) {            logger.debug("Looking for request mappings in application context: " + getApplicationContext());        }        String[] beanNames = (this.detectHandlerMethodsInAncestorContexts ?                BeanFactoryUtils.beanNamesForTypeIncludingAncestors(obtainApplicationContext(), Object.class) :                obtainApplicationContext().getBeanNamesForType(Object.class));        for (String beanName : beanNames) {            if (!beanName.startsWith(SCOPED_TARGET_NAME_PREFIX)) {                Class
      beanType = null;                try {                    beanType = obtainApplicationContext().getType(beanName);                }                catch (Throwable ex) {                    // An unresolvable bean type, probably from a lazy bean - let's ignore it.                    if (logger.isDebugEnabled()) {                        logger.debug("Could not resolve target class for bean with name '" + beanName + "'", ex);                    }                }                if (beanType != null && isHandler(beanType)) {                    detectHandlerMethods(beanName);                }            }        }        handlerMethodsInitialized(getHandlerMethods());    }

 

 

再进入detectHandlerMethods(beanName);方法：

/**     * Look for handler methods in a handler.     * @param handler the bean name of a handler or a handler instance     */    protected void detectHandlerMethods(final Object handler) {        Class
      handlerType = (handler instanceof String ?                obtainApplicationContext().getType((String) handler) : handler.getClass());        if (handlerType != null) {            final Class
      userType = ClassUtils.getUserClass(handlerType);            Map
     
       methods = MethodIntrospector.selectMethods(userType,                    (MethodIntrospector.MetadataLookup
      
       ) method -> {                        try {                            return getMappingForMethod(method, userType);                        }                        catch (Throwable ex) {                            throw new IllegalStateException("Invalid mapping on handler class [" +                                    userType.getName() + "]: " + method, ex);                        }                    });            if (logger.isDebugEnabled()) {                logger.debug(methods.size() + " request handler methods found on " + userType + ": " + methods);            }            for (Map.Entry
       
         entry : methods.entrySet()) {                Method invocableMethod = AopUtils.selectInvocableMethod(entry.getKey(), userType);                T mapping = entry.getValue();                registerHandlerMethod(handler, invocableMethod, mapping);            }        }    }
       
      
     

 

 

再进入registerHandlerMethod(handler, invocableMethod, mapping);方法：

/**     * Register a handler method and its unique mapping. Invoked at startup for     * each detected handler method.     * @param handler the bean name of the handler or the handler instance     * @param method the method to register     * @param mapping the mapping conditions associated with the handler method     * @throws IllegalStateException if another method was already registered     * under the same mapping     */    protected void registerHandlerMethod(Object handler, Method method, T mapping) {        this.mappingRegistry.register(mapping, handler, method);    }

 

 

再进入this.mappingRegistry.register(mapping, handler, method);方法，此方法就是最终输出到控制台的方法：

public void register(T mapping, Object handler, Method method) {            this.readWriteLock.writeLock().lock();            try {                HandlerMethod handlerMethod = createHandlerMethod(handler, method);                assertUniqueMethodMapping(handlerMethod, mapping);                if (logger.isInfoEnabled()) {                    logger.info("Mapped \"" + mapping + "\" onto " + handlerMethod);//这行代码就是把 Mapped "{[/hello]}" onto public java.lang.String com.pangjh.controller.PangjhController.getMessge()输出到控制台                }                this.mappingLookup.put(mapping, handlerMethod);                List
     
       directUrls = getDirectUrls(mapping);                for (String url : directUrls) {                    this.urlLookup.add(url, mapping);                }                String name = null;                if (getNamingStrategy() != null) {                    name = getNamingStrategy().getName(handlerMethod, mapping);                    addMappingName(name, handlerMethod);                }                CorsConfiguration corsConfig = initCorsConfiguration(handler, method, mapping);                if (corsConfig != null) {                    this.corsLookup.put(handlerMethod, corsConfig);                }                this.registry.put(mapping, new MappingRegistration<>(mapping, handlerMethod, directUrls, name));            }            finally {                this.readWriteLock.writeLock().unlock();            }        }
     

 

 

以上流程仅仅是系统启动到打印请求地址到控制台的流程，其他关于springboot启动的原理有待补充。