3万字的Spring Boot 干货总结 ！

// 默认容器实现
 DefaultListableBeanFactory beanRegistry = new DefaultListableBeanFactory();
 // 根据业务对象构造相应的BeanDefinition
 AbstractBeanDefinition definition = new RootBeanDefinition(Business.class,true);
 // 将bean定义注册到容器中
 beanRegistry.registerBeanDefinition("beanName",definition);
 // 如果有多个bean，还可以指定各个bean之间的依赖关系
 // ........

  // 然后可以从容器中获取这个bean的实例
 // 注意：这里的beanRegistry其实实现了BeanFactory接口，所以可以强转，
 // 单纯的BeanDefinitionRegistry是无法强制转换到BeanFactory类型的
 BeanFactory container = (BeanFactory)beanRegistry;
 Business business = (Business)container.getBean("beanName");

// 通常为BeanDefinitionRegistry的实现类，这里以DeFaultListabeBeanFactory为例
 BeanDefinitionRegistry beanRegistry = new DefaultListableBeanFactory();
  // XmlBeanDefinitionReader实现了BeanDefinitionReader接口，用于解析XML文件
 XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReaderImpl(beanRegistry);
 // 加载配置文件 beanDefinitionReader.loadBeanDefinitions("classpath:spring-bean.xml");
  // 从容器中获取bean实例
 BeanFactory container = (BeanFactory)beanRegistry;
 Business business = (Business)container.getBean("beanName");

// 通常为BeanDefinitionRegistry的实现类，这里以DeFaultListabeBeanFactory为例
 BeanDefinitionRegistry beanRegistry = new DefaultListableBeanFactory();
  // XmlBeanDefinitionReader实现了BeanDefinitionReader接口，用于解析XML文件
 XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReaderImpl(beanRegistry);
 // 加载配置文件 beanDefinitionReader.loadBeanDefinitions("classpath:spring-bean.xml");
  // 从容器中获取bean实例
 BeanFactory container = (BeanFactory)beanRegistry;
 Business business = (Business)container.getBean("beanName");

// 代码来自：org.springframework.context.support.ApplicationContextAwareProcessor
 // 其postProcessBeforeInitialization方法调用了invokeAwareInterfaces方法
 private void invokeAwareInterfaces(Object bean){
     if (bean instanceof EnvironmentAware){
         ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
     }
     if (bean instanceof ApplicationContextAware){
         ((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
     }
     // ......
}

"bookService" class="cn.moondev.service.BookServiceImpl">bean>

@Configuration
 public class
 MoonBookConfiguration
 {
      // 任何标志了@Bean的方法，其返回值将作为一个bean注册到Spring的IOC容器中
     // 方法名默认成为该bean定义的id
     @Bean
     public BookService bookService() {
         return new BookServiceImpl();
     }
 }

"bookService" class="cn.moondev.service.BookServiceImpl">
     <property name="dependencyService" ref="dependencyService"/>
 bean>

  "otherService" class="cn.moondev.service.OtherServiceImpl">
     <property name="dependencyService" ref="dependencyService"/>
 bean>

  "dependencyService" class="DependencyServiceImpl"/>

@Configuration
 public class MoonBookConfiguration {
      // 如果一个bean依赖另一个bean，则直接调用对应JavaConfig类中依赖bean的创建方法即可
     // 这里直接调用dependencyService()
     @Bean
     public BookService bookService() {
         return new BookServiceImpl(dependencyService());
     }
      @Bean
     public OtherService otherService() {
         return new OtherServiceImpl(dependencyService());
     }
      @Bean
     public DependencyService dependencyService() {
         return new DependencyServiceImpl();
     }
 }

@Configuration
 public class MoonBookConfiguration{
     @Bean
     public BookService bookService() {
         return new BookServiceImpl();
     }
 }

@Configuration
 // 可以同时导入多个配置类，比如：@Import({A.class,B.class})
 @Import(MoonBookConfiguration.class)
 public class MoonUserConfiguration
 {
     @Bean
     public UserService userService(BookService bookService) {
         return new BookServiceImpl(bookService);
     }
 }

public class JdbcTemplateCondition implements Condition {

      @Override
     public boolean matches(ConditionContext
 conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
         try {
         conditionContext.getClassLoader().loadClass("org.springframework.jdbc.core.JdbcTemplate");
             return true;
         }
 catch (ClassNotFoundException e) {
             e.printStackTrace();
         }
         return false;
     }
 }

@Conditional(JdbcTemplateCondition.class) @Service public MyService service() { ...... }

// jdbc config
 jdbc.mysql.url=jdbc:mysql://localhost:3306/sampledb
 jdbc.mysql.username=root
 jdbc.mysql.password=123456
 ......

  // 配置数据源
 @Configuration
 public class HikariDataSourceConfiguration {

      @Value("jdbc.mysql.url")
     public String url;
     @Value("jdbc.mysql.username")
     public String user;
     @Value("jdbc.mysql.password")
     public String password;

          @Bean
     public HikariDataSource dataSource() {
         HikariConfig hikariConfig = new HikariConfig();
         hikariConfig.setJdbcUrl(url);
         hikariConfig.setUsername(user);
         hikariConfig.setPassword(password);
         // 省略部分代码
         return new HikariDataSource(hikariConfig);
     }
 }

@Component
 // 还可以通过@PropertySource("classpath:jdbc.properties")来指定配置文件
 @ConfigurationProperties("jdbc.mysql")
 // 前缀=jdbc.mysql，会在配置文件中寻找jdbc.mysql.*的配置项
 pulic class JdbcConfig {
     public String url;
     public String username;
     public String password;
 }
  @Configuration
 public class HikariDataSourceConfiguration {

      @AutoWired
     public JdbcConfig config;

          @Bean
     public HikariDataSource dataSource() {
         HikariConfig hikariConfig = new HikariConfig();
         hikariConfig.setJdbcUrl(config.url);
         hikariConfig.setUsername(config.username);
         hikariConfig.setPassword(config.password);
         // 省略部分代码
         return new HikariDataSource(hikariConfig);
   }
 }

#App
 app.menus[0].title=Home
 app.menus[0].name=Home
 app.menus[0].path=/
 app.menus[1].title=Login
 app.menus[1].name=Login
 app.menus[1].path=/login

  app.compiler.timeout=5
 app.compiler.output-folder=/temp/

  app.error=/error/

@Component
 @ConfigurationProperties("app")
 public class AppProperties {

      public String error;
     public List menus = new ArrayList<>();
     public Compiler compiler = new Compiler();

      public static class Menu {
         public String name;
         public String path;
         public String title;
     }
      public static class Compiler {
         public String timeout;
         public String outputFolder;
     }
 }

protected Class loadClass(String name, boolean resolve) {
     synchronized (getClassLoadingLock(name)) {
     // 首先，检查该类是否已经被加载，如果从JVM缓存中找到该类，则直接返回
     Class c = findLoadedClass(name);
     if (c == null) {
         try {
             // 遵循双亲委派的模型，首先会通过递归从父加载器开始找，
             // 直到父类加载器是BootstrapClassLoader为止
             if (parent != null) {
                 c = parent.loadClass(name, false);
             } else {
                 c = findBootstrapClassOrNull(name);
             }
        } catch (ClassNotFoundException e) {}
         if (c == null) {
             // 如果还找不到，尝试通过findClass方法去寻找
             // findClass是留给开发者自己实现的，也就是说
             // 自定义类加载器时，重写此方法即可
            c = findClass(name);
         }
     }
     if (resolve) {
        resolveClass(c);
     }
     return c;
     }
 }

for (String aDriver : driversList) {
     try {
         // 直接使用AppClassLoader
         Class.forName(aDriver, true, ClassLoader.getSystemClassLoader());
     } catch (Exception ex) {
         println("DriverManager.Initialize: load failed: " + ex);
      }
   }

Thread.currentThread().getClassLoader()Thread.currentThread().getContextClassLoader()

public Enumeration<URL> getResources(String name) throws IOException {
     Enumeration<URL>[] tmp = (Enumeration<URL>[]) new Enumeration>[2];
     if (parent != null) {
         tmp[0] = parent.getResources(name);
     } else {
         tmp[0] = getBootstrapResources(name);
     }
     tmp[1] = findResources(name);
     return new CompoundEnumeration<>(tmp);
 }

// 寻找Array.class文件
 public static void main(String[] args) throws Exception{
     // Array.class的完整路径
     String name = "java/sql/Array.class";
     Enumeration urls = Thread.currentThread().getContextClassLoader().getResources(name);
     while (urls.hasMoreElements()) {
         URL url = urls.nextElement();
         System.out.println(url.toString());
     }
 }

$JAVA_HOME/jre/lib/rt.jar!/java/sql/Array.class

public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";
 // spring.factories文件的格式为：key=value1,value2,value3
 // 从所有的jar包中找到META-INF/spring.factories文件
 // 然后从文件中解析出key=factoryClass类名称的所有value值
 public static List<String> loadFactoryNames(Class factoryClass, ClassLoader classLoader) {
     String factoryClassName = factoryClass.getName();
     // 取得资源文件的URL
     Enumeration urls = (classLoader != null ? classLoader.getResources(FACTORIES_RESOURCE_LOCATION) : ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
     List<String> result = new ArrayList<String>();
     // 遍历所有的URL
     while (urls.hasMoreElements()) {
         URL url = urls.nextElement();
         // 根据资源文件URL解析properties文件
         Properties properties = PropertiesLoaderUtils.loadProperties(new UrlResource(url));
         String factoryClassNames = properties.getProperty(factoryClassName);
         // 组装数据，并返回
         result.addAll(Arrays.asList(StringUtils.commaDelimitedListToStringArray(factoryClassNames)));
     }
     return result;
 }

// 来自 org.springframework.boot.autoconfigure下的META-INF/spring.factories
 // EnableAutoConfiguration后文会讲到，它用于开启Spring Boot自动配置功能
 org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
 org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
 org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
 org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration\

public class MethodMonitorEvent extends EventObject {
     // 时间戳，用于记录方法开始执行的时间
     public long timestamp;

      public MethodMonitorEvent(Object source) {
         super(source);
     }
 }

// 1、定义事件监听接口
 public interface MethodMonitorEventListener extends EventListener {
     // 处理方法执行之前发布的事件
     public void onMethodBegin(MethodMonitorEvent event);
     // 处理方法结束时发布的事件
     public void onMethodEnd(MethodMonitorEvent event);
 }
 // 2、事件监听接口的实现：如何处理
 public class AbstractMethodMonitorEventListener implements MethodMonitorEventListener {
      @Override
     public void onMethodBegin(MethodMonitorEvent event) {
         // 记录方法开始执行时的时间
         event.timestamp = System.currentTimeMillis();
     }
      @Override
     public void onMethodEnd(MethodMonitorEvent event) {
         // 计算方法耗时
         long duration = System.currentTimeMillis() - event.timestamp;
         System.out.println("耗时：" + duration);
     }
 }

public class MethodMonitorEventPublisher {

      private List listeners = new ArrayList();

      public void methodMonitor() {
         MethodMonitorEvent eventObject = new MethodMonitorEvent(this);
         publishEvent("begin",eventObject);
         // 模拟方法执行：休眠5秒钟
         TimeUnit.SECONDS.sleep(5);
         publishEvent("end",eventObject);
      }

      private void publishEvent(String status,MethodMonitorEvent event) {
         // 避免在事件处理期间，监听器被移除，这里为了安全做一个复制操作
         List copyListeners = ➥ new ArrayList(listeners);
         for (MethodMonitorEventListener listener : copyListeners) {
             if ("begin".equals(status)) {
                 listener.onMethodBegin(event);
             } else {
                 listener.onMethodEnd(event);
             }
         }
     }
         public static void main(String[] args) {
         MethodMonitorEventPublisher publisher = new MethodMonitorEventPublisher();
         publisher.addEventListener(new AbstractMethodMonitorEventListener());
         publisher.methodMonitor();
     }
     // 省略实现
     public void addEventListener(MethodMonitorEventListener listener) {}
     public void removeEventListener(MethodMonitorEventListener listener) {}
     public void removeAllListeners() {}

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

@Target(ElementType.TYPE)
 @Retention(RetentionPolicy.RUNTIME)
@Documented @Inherited
 @SpringBootConfiguration
 @EnableAutoConfiguration
 @ComponentScan(excludeFilters = {
        @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
         @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
 public @interface SpringBootApplication {
     // ......
 }

@Target(ElementType.TYPE)
 @Retention(RetentionPolicy.RUNTIME)
 @Documented
 @Inherited
 @AutoConfigurationPackage
 @Import(EnableAutoConfigurationImportSelector.class)
 public @interface EnableAutoConfiguration {
     // ......
 }

public String[] selectImports(AnnotationMetadata annotationMetadata) {
     // 省略了大部分代码，保留一句核心代码
     // 注意：SpringBoot最近版本中，这句代码被封装在一个单独的方法中
     // SpringFactoriesLoader相关知识请参考前文
     List<String> factories = new ArrayList<String>(new LinkedHashSet<String>(
           SpringFactoriesLoader.loadFactoryNames(EnableAutoConfiguration.class, this.beanClassLoader)));
 }

// 来自 org.springframework.boot.autoconfigure下的META-INF/spring.factories
 // 配置的key = EnableAutoConfiguration，与代码中一致
 org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
 org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,\
 org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
 org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration\
 .....

@Configuration
 @ConditionalOnClass({ DataSource.class, EmbeddedDatabaseType.class })
 @EnableConfigurationProperties(DataSourceProperties.class)
 @Import({ Registrar.class, DataSourcePoolMetadataProvidersConfiguration.class })
 public class DataSourceAutoConfiguration {
 }

// 提供对datasource配置信息的支持，所有的配置前缀为：spring.datasource
 @ConfigurationProperties(prefix = "spring.datasource")
 public class DataSourceProperties {
     private ClassLoader classLoader;
     private Environment environment;
     private String name = "testdb";
     ......
 }

@Configuration
 public class DataSourcePoolMetadataProvidersConfiguration {

      @Configuration
     @ConditionalOnClass(org.apache.tomcat.jdbc.pool.DataSource.class)
     static class TomcatDataSourcePoolMetadataProviderConfiguration {
         @Bean
         public DataSourcePoolMetadataProvider tomcatPoolDataSourceMetadataProvider() {
             .....
         }
     }
   ......
 }

private void initialize(Object[] sources) {
      if (sources != null && sources.length > 0) {
          this.sources.addAll(Arrays.asList(sources));
      }
      // 判断是否是Web项目
      this.webEnvironment = deduceWebEnvironment();
      setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
      setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
      // 找到入口类
      this.mainApplicationClass = deduceMainApplicationClass();
 }

org.springframework.context.ApplicationListener=\ cn.moondev.listeners.xxxxListener\

public ConfigurableApplicationContext run(String... args) {
         StopWatch stopWatch = new StopWatch();
         stopWatch.start();
         ConfigurableApplicationContext context = null;
         FailureAnalyzers analyzers = null;
         configureHeadlessProperty();
         // ①
         SpringApplicationRunListeners listeners = getRunListeners(args);
         listeners.starting();
         try {
             // ②
ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
             ConfigurableEnvironment environment = prepareEnvironment(listeners,applicationArguments);
             // ③
             Banner printedBanner = printBanner(environment);
             // ④
             context = createApplicationContext();
             // ⑤
             analyzers = new FailureAnalyzers(context);
             // ⑥
             prepareContext(context, environment, listeners, applicationArguments,printedBanner);
             // ⑦
              refreshContext(context);
             // ⑧
             afterRefresh(context, applicationArguments);
             // ⑨
             listeners.finished(context, null);
             stopWatch.stop();
             return context;
        }
         catch (Throwable ex) {
             handleRunFailure(context, listeners, analyzers, ex);
             throw new IllegalStateException(ex);
         }
     }

public interface SpringApplicationRunListener {

      // 运行run方法时立即调用此方法，可以用户非常早期的初始化工作
     void starting();

          // Environment准备好后，并且ApplicationContext创建之前调用
     void environmentPrepared(ConfigurableEnvironment environment);

      // ApplicationContext创建好后立即调用
     void contextPrepared(ConfigurableApplicationContext context);

      // ApplicationContext加载完成，在refresh之前调用
     void contextLoaded(ConfigurableApplicationContext context);

      // 当run方法结束之前调用
     void finished(ConfigurableApplicationContext
 context, Throwable exception);
  }

public void starting() {
     // 发布一个ApplicationStartedEvent
     this.initialMulticaster.multicastEvent(new ApplicationStartedEvent(this.application, this.args));
 }

listeners.environmentPrepared(environment);

. ____          _            __ _ _
  /\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \
 ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
  \\/ ___)| |_)| | | | | || (_| | ) ) ) )
   ' |____| .__|_| |_|_| |_\__, | / / / /
  =========|_|==============|___/=/_/_/_/
 :: Spring Boot :: (v1.5.6.RELEASE)

// 摘自refresh()方法中一句代码
 invokeBeanFactoryPostProcessors(beanFactory);

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
     PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
     ......
 }

ConfigurationWarningsApplicationContextInitializer$ConfigurationWarningsPostProcessor
 SharedMetadataReaderFactoryContextInitializer$CachingMetadataReaderFactoryPostProcessor
 ConfigFileApplicationListener$PropertySourceOrderingPostProcessor

public void initialize(ConfigurableApplicationContext context) {
     context.addBeanFactoryPostProcessor(new ConfigurationWarningsPostProcessor(getChecks()));
 }