01｜项目示例

基于Spring boot构建一个简单的web项目

  • 1、引入依赖 ```java <?xml version=”1.0” encoding=”UTF-8”?> <project xmlns=”http://maven.apache.org/POM/4.0.0“ xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance“

    1.    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">

    4.0.0 white.colde spring-boot-study 0.0.1-SNAPSHOT

    spring-boot-study 

    1.   <java.version>11</java.version>

    org.springframework.boot spring-boot-starter-parent 2.4.1 org.springframework.boot spring-boot-starter-web org.springframework.boot spring-boot-maven-plugin 

  2. - 2、创建测试接口
  3. ```java
  4. @RestController
  5. public class TestController {
  7.     @GetMapping
  8.     public String index(){
  9.         return "hello spring boot";
  10.     }
  12. }

  • 3、创建启动类 ```java @SpringBootApplication public class SpringBootStudyApplication {

    public static void main(String[] args) {

    1.   SpringApplication.run(SpringBootStudyApplication.class, args);

    }

}

  2. <a name="YXNcO"></a>
  3. ## 02｜IoC容器源码解析
  4. <a name="2F6J4"></a>
  5. ### 2.1｜核心类
  6. <a name="xA2H7"></a>
  7. #### 1、SpringApplication
  8. SpringBoot应用入口类，核心方法如下：
  9. ```java
  10. public class SpringApplication{
  11.     public ConfigurableApplicationContext run(String... args) {
  12.         StopWatch stopWatch = new StopWatch();
  13.         stopWatch.start();
  14.         DefaultBootstrapContext bootstrapContext = createBootstrapContext();
  15.         ConfigurableApplicationContext context = null;
  16.         configureHeadlessProperty();
  17.         SpringApplicationRunListeners listeners = getRunListeners(args);
  18.         listeners.starting(bootstrapContext, this.mainApplicationClass);
  19.         try {
  20.             ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
  21.             ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
  22.             configureIgnoreBeanInfo(environment);
  23.             Banner printedBanner = printBanner(environment);
  24.             // 创建应用上下文，会依据当前运行环境创建不同的应用上下文对象
  25.             // 由于这里为web环境，即此处创建的是AnnotationConfigServletWebServerApplicationContext对象
  26.             context = createApplicationContext();
  27.             context.setApplicationStartup(this.applicationStartup);
  28.             prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
  29.             // 开始容器初始化，解析装载bean到容器当中
  30.             refreshContext(context);
  31.             afterRefresh(context, applicationArguments);
  32.             stopWatch.stop();
  33.             if (this.logStartupInfo) {
  34.                 new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
  35.             }
  36.             listeners.started(context);
  37.             callRunners(context, applicationArguments);
  38.         }
  39.         catch (Throwable ex) {
  40.             handleRunFailure(context, ex, listeners);
  41.             throw new IllegalStateException(ex);
  42.         }
  44.         try {
  45.             listeners.running(context);
  46.         }
  47.         catch (Throwable ex) {
  48.             handleRunFailure(context, ex, null);
  49.             throw new IllegalStateException(ex);
  50.         }
  51.         return context;
  52.     }
  53. }

SpringApplication主要做以下几个工作：

  • 执行容器初始化前的一些准备工作，如运行环境推断、解析根配置类信息等
  • 创建应用上下文

  • 调用Context的refresh方法，执行容器初始化逻辑

    2、AnnotationConfigServletWebServerApplicationContext

    SpringBoot web环境下默认创建的上下文对象，其类图如下：
    image.png
    在SpringApplication创建了AnnotationConfigServletWebServerApplicationContext类的对象，并调用了其refresh方法，而refresh方法的具体实现是在其父类AbstractApplicationContext中。

    3、AbstractApplicationContext

    1. public abstract class AbstractApplicationContext extends DefaultResourceLoader
    2.       implements ConfigurableApplicationContext {
    3.   @Override
    4.   public void refresh() throws BeansException, IllegalStateException {
    5.       synchronized (this.startupShutdownMonitor) {
    6.           StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
    7.           // Prepare this context for refreshing.
    8.           prepareRefresh();
    9.           // 获取实际BeanFactory，默认实现是ConfigurableListableBeanFactory
    10.           // 该对象是在GenericApplicationContext的构造方法中初始化创建
    11.           ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    13.           prepareBeanFactory(beanFactory);
    14.           try {
    15.               // 提供了一个钩子方法供子类可以在BeanFactory准备工作完成后进行相应的逻辑处理调用
    16.               postProcessBeanFactory(beanFactory);
    18.               StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
    19.               // 实例化并调⽤实现了BeanFactoryPostProcessor接⼝的Bean
    20.               invokeBeanFactoryPostProcessors(beanFactory);
    22.               // 注册BeanPostProcessor（Bean的后置处理器），在创建bean的前后等执⾏
    23.               registerBeanPostProcessors(beanFactory);
    24.               beanPostProcess.end();
    26.               // 初始化MessageSource组件（做国际化功能；消息绑定，消息解析）
    27.               initMessageSource();
    29.               // 初始化事件派发器
    30.               initApplicationEventMulticaster();
    32.               // ⼦类重写这个⽅法，在容器刷新的时候可以⾃定义逻辑
    33.               onRefresh();
    35.               // 注册应⽤的监听器。就是注册实现了ApplicationListener接⼝的监听器bean
    36.               registerListeners();
    38.               // 初始化所有剩下的非懒加载的单例Bean
    39.               finishBeanFactoryInitialization(beanFactory);
    41.               // 完成容器的初始化，发布事件
    42.               finishRefresh();
    43.           }
    45.           catch (BeansException ex) {
    46.               if (logger.isWarnEnabled()) {
    47.                   logger.warn("Exception encountered during context initialization - " +
    48.                           "cancelling refresh attempt: " + ex);
    49.               }
    51.               // Destroy already created singletons to avoid dangling resources.
    52.               destroyBeans();
    54.               // Reset 'active' flag.
    55.               cancelRefresh(ex);
    57.               // Propagate exception to caller.
    58.               throw ex;
    59.           }
    61.           finally {
    62.               // Reset common introspection caches in Spring's core, since we
    63.               // might not ever need metadata for singleton beans anymore...
    64.               resetCommonCaches();
    65.               contextRefresh.end();
    66.           }
    67.       }
    68.   }
    69. }

    4、DefaultListableBeanFactory

    GenericApplicationContext构造方法中创建了一个DefaultListableBeanFactory类的实例，DefaultListableBeanFactory是Spring注册和加载Bean的默认实现类，ApplicationContext有关操作皆委托由DefaultListableBeanFactory进行实现，其类图如下：
    image.png

  • AliasRegistry：定义对alias的简单增删改等操作

  • SimpleAliasRegistry：主要使用map作为alias的缓存，并对接口AliasRegistry进行实现
  • SingletonBeanRegistry：定义对单例Bean的注册及获取
  • BeanFactory：定义了获取Bean及Bean的各种属性
  • HierarchicalBeanFactory：包含层次结构的BeanFactory，在BeanFactory的基础上增加了对parentFactory的支持
  • BeanDefinitionRegistry：定义对BeanDefinition的各种增删改操作
  • FactoryBeanRegistrySupport：在DefaultSingletonBeanRegistry基础上增加了对FactoryBean的特殊处理功能
  • ConfigurableBeanFactory：提供配置Factory的各种方法
  • ListableBeanFactory：根据各种条件获取Bean的配置清单
  • AbstractBeanFactory：综合FactoryBeanRegistrySupport和ConfigurationBeanFactory的功能
  • AutowireCapableBeanFactory：提供创建Bean、自动注入、初始化
  • AbstractAutowireCapableBeanFactory：综合AbstractBeanFactory并对AutowireCapableBeanFactory进行实现
  • ConfigurableListableBeanFactory：BeanFactory配置清单，指定忽略类型及接口等
  • DefaultListableBeanFactory：综合上面的所有功能，本身提供对Bean注册后的一些处理功能