前言
SpringBoot本质上没有技术革新，而是在Spring框架的基础之上简化了系统的配置，核心功能是自动装配和starter组件
一、SpringBoot核心功能
1、独立运行程序（SpringBoot程序可以不依赖其他容器独立运行）
2、内嵌Servlet容器（内嵌Servlet容器，不依赖其他Web容器）
3、提供starter组件简化maven配置（只需要依赖一个starter组件就可以自动依赖相关jar包，简化maven配置）
4、自动装配配置（为大多数应用场景提供了默认配置，大幅度减少了应用配置）
二、SpringBoot常用注解
| 注解 | 修饰 | 用途 | 案例 |
| @ComponentScan | 类 | 自动扫描，修饰某个类则Spring会自动扫描当前类所在包路径下所以被@Component修饰的类,也可以通过basePackages自定义扫描包的根目录 | @ComponentScan(basePackages="com.test.lucky") |
| @Component | 类 | 声明当前类表示当前类为一个组件，Spring容器会很自动扫描被@Component修饰的类加载bean到Spring容器中 | @Component(value="beanName") |
| @Controller | 类 | 本质是一个Component，声明当前类表示当前类是一个控制器类，分发处理器会扫描被@Controller注解修饰的类的方法 | @Controller(value="testController") |
| @RequestMapping | 方法 | 声明方法表示请求URL映射的方法 | @RequestMapping(value="/test") |
| @ResponseBody | 方法/类 | 将controller的方法返回的对象通过适当的转换器转换为指定的格式之后，写入到response对象的body区，通常用来返回JSON数据或者是XML数据 | @ResponseBody |
| @RestController | 类 | 等同于@Controller + @ResponseBody组合，表示当前类的所有方法都自动被@ResponseBody注解修饰 | @RestController(value="testController") |
| @Service | 类 | 本质是一个Component, 声明当前类是Service层的bean | @Service(value="testService") |
| @Repository | 类 | 本质是一个Component, 声明当前类是Dao层的bean | @Repository(value="testDao") |
| @Configuration | 类 | 本质是一个Component, 表面当前类是一个配置类，会生成一个代理对象，表示当前类是@Bean定义的源类 | @Configuration |
| @Bean | 方法 | 相当于<bean>标签,被@Bean修饰的方法返回对象会被加载到Spring容器中 | @Bean(name="beanName") |
| @Import | 类 | 用于导入第三方包中的bean,导入的bean自动加载到Spring容器中 | @Import(value=Test.class) |
| @Value | 方法/属性 | 将常量、配置中的值、其他bean注入到变量中 | @Value("${properteis.test}") |
三、SpringBoot启动流程解析
SpringBoot的功能是基于Spring框架，所以启动时的核心步骤自然少不了Spring容器的初始化以及Spring容器的启动过程，另外SpringBoot还提供了自动装配配置功能。
1、SpringBootApplication.run()方法
SpringBoot程序启动类案例如下：
1 @SpringBootApplication 2 public class BootStrap { 3 4 public static void main(String[] args){ 5 ApplicationContext applicationContext = SpringApplication.run(BootStrap.class); 6 } 7 }
SpringBoot程序启动入口，代码比较简洁，除了被@SpringBootApplication注解修饰之外，main丰富直接调用SpringBootApplication类的静态方法run方法即可，最终会是调用了SpringBootApplication的实例方法run方法，核心逻辑如下：
1 public ConfigurableApplicationContext run(String... args) { 2 ConfigurableApplicationContext context = null; 3 /** 1.通过反射创建ApplicationContext对象 */ 4 context = createApplicationContext(); 5 /** 2.准备ApplicationContext上下文环境 */ 6 prepareContext(context, environment, listeners, applicationArguments, printedBanner); 7 /** 3.刷新ApplicationContext */ 8 refreshContext(context); 9 /** 4.刷新ApplicationContext后置处理*/ 10 afterRefresh(context, applicationArguments); 11 return context; 12 }
可以看出SpringBoot程序启动的核心逻辑实际就两步，1、创建IOC容器ApplicationContext实例；2、启动IOC容器。
而SpringBoot的其他核心功能很显然就是通过@SpringBootApplication注解来实现，这个注解才是SpringBoot的核心实现
2、@SpringBootApplication注解
@SpringBootApplication注解定义如下：
@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
从定义可以看出@SpringBootApplication是一个组合注解，内部包含了@SpringBootConfiguration、@EnableAutoConfiguration和@ComponentScan三个注解
2.1、@SpringBootConfiguration
@SpringBootConfiguration注解定义如下：
1 @Target(ElementType.TYPE) 2 @Retention(RetentionPolicy.RUNTIME) 3 @Documented 4 @Configuration 5 public @interface SpringBootConfiguration
可以看出@SpringBootConfiguration本质上就是一个@Configuration注解，标注当前类是一个配置类
2.2、@ComponentScan
@ComponentScan注解定义如下：
@Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE) @Documented @Repeatable(ComponentScans.class) public @interface ComponentScan
@ComponentScan注解表示自动扫描，会扫描当前类包路径下所有被@Component注解修饰的bean
2.3、@EnableAutoConfiguration
@EnableAutoConfiguration注解定义如下：
1 @Target(ElementType.TYPE) 2 @Retention(RetentionPolicy.RUNTIME) 3 @Documented 4 @Inherited 5 @AutoConfigurationPackage 6 @Import(AutoConfigurationImportSelector.class) 7 public @interface EnableAutoConfiguration
可以看出@EnableAutoConfiguration注解也是一个组合注解，包含了@AutoConfigurationPackage和@Import注解，再看@AutoConfigurationPackage注解的定义：
1 @Target(ElementType.TYPE) 2 @Retention(RetentionPolicy.RUNTIME) 3 @Documented 4 @Inherited 5 @Import(AutoConfigurationPackages.Registrar.class) 6 public @interface AutoConfigurationPackage
该注解内部包含了一个@Import注解，所以可以得出结论@EnableAutoConfiguration实际上就是由两个@Import注解组成，分别导入了AutoConfiguartionImportSelector和AutoConfigurationPackages.Registrar类的实例。
所以总结可以得出这两个类是实现SpringBoot自动装载配置的核心实现。
关于@Import注解的详细用法这里不多介绍，先简单介绍下，@Import注解有三种用法，分别如下：
1.显示引入需要加载的bean，如：@Import(value=TestService.class)
2.引入实现ImportSelector接口的类，如自定义MyImportSelector类实现ImportSelector并重写selectImports方法，返回需要导入的bean的数组，案例如下：
1 public class MyImportSelector implements ImportSelector { 2 @Override 3 public String[] selectImports(AnnotationMetadata importingClassMetadata) { 4 return new String[]{UserService.class.getName(), GoodsService.class.getName()}; 5 } 6 }
3.引入实现ImportBeanDefinitionRegistrar接口的类，如自定义MyImportBeanDefinitionRegistrar并重写registBeanDefinitions方法，手动注册需要加载的bean，案例如下：
1 public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar { 2 3 @Override 4 public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry, 5 BeanNameGenerator importBeanNameGenerator) { 6 /** 手动注册需要加载的bean*/ 7 registerBeanDefinitions(importingClassMetadata, registry); 8 } 9 }
回过头再看@EnableAutoConfiguration注解，分别导入了ImportSelector接口的实现类AutoConfigurationImportSelector和ImportBeanDefinitionRegistrar的实现类AutoConfigurationPackages.Registrar，接下来依次分析。
2.4、AutoConfigurationImportSelector
AutoConfigurationImportSelector实现了ImportSelector接口，所以会加载selectImports方法返回的String数组中的beanName，所以重点是selectImports方法，源码如下：
1 public String[] selectImports(AnnotationMetadata annotationMetadata) { 2 if (!isEnabled(annotationMetadata)) { 3 return NO_IMPORTS; 4 } 5 /** 加载元数据*/ 6 AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader 7 .loadMetadata(this.beanClassLoader); 8 AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(autoConfigurationMetadata, 9 annotationMetadata); 10 return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations()); 11 }
核心步骤就两步，第一步是执行loadMetadata方法，源码如下：
1 protected static final String PATH = "META-INF/spring-autoconfigure-metadata.properties"; 2 3 static AutoConfigurationMetadata loadMetadata(ClassLoader classLoader) { 4 /** 加载指定路径下的元数据*/ 5 return loadMetadata(classLoader, PATH); 6 } 7 8 static AutoConfigurationMetadata loadMetadata(ClassLoader classLoader, String path) { 9 try { 10 Enumeration<URL> urls = (classLoader != null) ? classLoader.getResources(path) 11 : ClassLoader.getSystemResources(path); 12 Properties properties = new Properties(); 13 /** 遍历Spring-autoconfigure-metadata.properties配置文件,读取数据封装为AutoConfigurationMetadata对象*/ 14 while (urls.hasMoreElements()) { 15 properties.putAll(PropertiesLoaderUtils.loadProperties(new UrlResource(urls.nextElement()))); 16 } 17 return loadMetadata(properties); 18 } 19 catch (IOException ex) { 20 throw new IllegalArgumentException("Unable to load @ConditionalOnClass location [" + path + "]", ex); 21 } 22 }
逻辑是从加载路径下找到spring-autoconfigure-metadata.properties配置文件，然后遍历读取配置文件内容加入到Properties对象中，并封装成AutoConfigurationMetadata对象
spring-autoconfigure-metadata.properties配置文件位于spring-boot-autoconfigure包中的META-INF目录下，暂时可以不关心作用是什么，目前可以得出的结论是会先把这个配置中的内容全部加载出来。
再看第二步getAutoConfigurationEntry方法的实现，源码如下：
1 protected AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata, 2 AnnotationMetadata annotationMetadata) { 3 if (!isEnabled(annotationMetadata)) { 4 return EMPTY_ENTRY; 5 } 6 /** 封装加载的配置元数据为AnnotationAttributes对象*/ 7 AnnotationAttributes attributes = getAttributes(annotationMetadata); 8 /** 获取所有候选的配置信息集合 (IOC容器需要加载的bean) 9 * 实际是加载META-INF/spring.factories配置文件中的bean 10 * */ 11 List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes); 12 /** 去除重复的*/ 13 configurations = removeDuplicates(configurations); 14 /** 去除排除的*/ 15 Set<String> exclusions = getExclusions(annotationMetadata, attributes); 16 checkExcludedClasses(configurations, exclusions); 17 configurations.removeAll(exclusions); 18 /** 去除过滤的*/ 19 configurations = filter(configurations, autoConfigurationMetadata); 20 fireAutoConfigurationImportEvents(configurations, exclusions); 21 /** 封装成AutoConfigurationEntry对象*/ 22 return new AutoConfigurationEntry(configurations, exclusions); 23 }
目的是加载META-INF/spring.factories配置文件，得到所有需要加载的类，然后通过去除、排除的方式筛选需要加载的类
而spring.factories中有一个key为EnableAutoConfiguration，value是一个集合，包含了几乎常用的所有各种中间件的自动配置类，这些类都在spring-boot-autoconfigure包中，包括常用的有：
MongoDataAutoConfiguration、RedisAutoConfiguration、DataSourceAutoConfiguration、RabbitAutoConfiguration、ElasticsearchAutoConfiguration等等，每个类都封装了各自的自动配置类
tips：那么问题来了，SpringBoot默认提供了各种各有的配置类，如果我们的程序中并没有用到相关的组件，会不会讲这些无用的配置类也加载到容器中呢？
答案很显然是否定的，spring-autoconfigure-metadata.properties中定义了各种组件的ConditionalOnClass的key，值为对应的Class全路径，比如：
org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration.ConditionalOnClass=org.springframework.data.redis.core.RedisOperations org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration.ConditionalOnClass=com.rabbitmq.client.Channel,org.springframework.amqp.rabbit.core.RabbitTemplate org.springframework.boot.autoconfigure.jdbc.JdbcTemplateAutoConfiguration.ConditionalOnClass=javax.sql.DataSource,org.springframework.jdbc.core.JdbcTemplate
ConditionalOnClass代表如果要加载对应的属性，必要要加载对应的类，比如程序中用到了RabbitMQ，那么肯定依赖了RabbitMQ对应的jar包，所以肯定会加载RabbitTemplate类，那么此时才会加载RabbitAutoConfiguration类，同理适用RedisAutoConfiguration类的前提是需要先加载RedisOperations类，只有先加载了对应的类才会加载对应的AutoConfiiguration类
总结
1、SpringBoot启动时会通过@EnableAutoConfiguration注解导入AutoConfigurationImportSelector对象，会从扫描包路径下META-INF/spring.factories中的配置，该配置文件中包含了各种组件的自动配置类对应的AutoConfiguration类，然后通过加载各种组件的AutoConfiguration类从而可以加载对应的自动配置类，并且通过ConditionalOnClass来过滤需要的自动配置类，去除掉程序中没有使用的自动配置类
2、@SpringBootApplication是个组合注解，分别是@SpringBootConfiguration、@ComponentScan和@EnableAutoConfiguration三个组件，其中@SpringBootConfiguration和@ComponentScan两个组件保证可以扫描用户自定义的bean，@EnableAutoConfiguration用于扫描加载默认的第三方的bean
3、SpringBoot程序启动的流程实际就是IOC容器创建和启动的过程，然后通过扫描用户自定义的bean和第三方的bean完成bean的加载。
四、SpringBoot内置Tomcat源码解析
SpringBoot既然内置了web容器，那么就不会只内置Tomcat一个容器，还有Jetty、Undertow，所以从设计者的角度就会在这三个具体容器之上进行抽象，定义了一个WebServer接口，WebServer接口定义如下：
public interface WebServer { /** 启动web容器*/ void start() throws WebServerException; /** 关闭web容器*/ void stop() throws WebServerException; /** 获取web容器监听的端口 */ int getPort(); }
而Tomcat、Jetty、Undertow等容器就会有各自的实现类实现了WebServer接口，分别是TomcatWebServer、JettyWebServer、UndertowWebServer，而SpringBoot采用了工厂模式来决定使用哪一个容器模式，所以定义了工厂类ServertWebServerFactory。在spring.factories配置文件中就定义了ServletWebServerFactoryAutoConfiguration，该类的定义如下：
1 @Configuration(proxyBeanMethods = false) 2 @AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE) 3 @ConditionalOnClass(ServletRequest.class) 4 @ConditionalOnWebApplication(type = Type.SERVLET) 5 @EnableConfigurationProperties(ServerProperties.class) 6 @Import({ ServletWebServerFactoryAutoConfiguration.BeanPostProcessorsRegistrar.class, 7 ServletWebServerFactoryConfiguration.EmbeddedTomcat.class, 8 ServletWebServerFactoryConfiguration.EmbeddedJetty.class, 9 ServletWebServerFactoryConfiguration.EmbeddedUndertow.class }) 10 public class ServletWebServerFactoryAutoConfiguration
可以看出该类通过@Import注解分别导入了EmbeddedTomcat、EmbeddedJetty、EmbeddedUndertow的bean，以EmbeddedTomcat为例，定义如下：
1 @Configuration(proxyBeanMethods = false) 2 @ConditionalOnClass({ Servlet.class, Tomcat.class, UpgradeProtocol.class }) 3 @ConditionalOnMissingBean(value = ServletWebServerFactory.class, search = SearchStrategy.CURRENT) 4 public static class EmbeddedTomcat { 5 6 @Bean 7 public TomcatServletWebServerFactory tomcatServletWebServerFactory( 8 ObjectProvider<TomcatConnectorCustomizer> connectorCustomizers, 9 ObjectProvider<TomcatContextCustomizer> contextCustomizers, 10 ObjectProvider<TomcatProtocolHandlerCustomizer<?>> protocolHandlerCustomizers) { 11 TomcatServletWebServerFactory factory = new TomcatServletWebServerFactory(); 12 factory.getTomcatConnectorCustomizers() 13 .addAll(connectorCustomizers.orderedStream().collect(Collectors.toList())); 14 factory.getTomcatContextCustomizers() 15 .addAll(contextCustomizers.orderedStream().collect(Collectors.toList())); 16 factory.getTomcatProtocolHandlerCustomizers() 17 .addAll(protocolHandlerCustomizers.orderedStream().collect(Collectors.toList())); 18 return factory; 19 } 20 21 }
该类内部通过@Bean注解定义了一个TomcatServletWebServerFactory对象，该对象就是TomcatWebServer的工厂类，TomcatServletWebServerFactory有一个getWebServer方法，定义如下：
1 @Override 2 public WebServer getWebServer(ServletContextInitializer... initializers) { 3 if (this.disableMBeanRegistry) { 4 Registry.disableRegistry(); 5 } 6 Tomcat tomcat = new Tomcat(); 7 File baseDir = (this.baseDirectory != null) ? this.baseDirectory : createTempDir("tomcat"); 8 tomcat.setBaseDir(baseDir.getAbsolutePath()); 9 Connector connector = new Connector(this.protocol); 10 connector.setThrowOnFailure(true); 11 tomcat.getService().addConnector(connector); 12 customizeConnector(connector); 13 tomcat.setConnector(connector); 14 tomcat.getHost().setAutoDeploy(false); 15 configureEngine(tomcat.getEngine()); 16 for (Connector additionalConnector : this.additionalTomcatConnectors) { 17 tomcat.getService().addConnector(additionalConnector); 18 } 19 prepareContext(tomcat.getHost(), initializers); 20 return getTomcatWebServer(tomcat); 21 }
1 protected TomcatWebServer getTomcatWebServer(Tomcat tomcat) { 2 return new TomcatWebServer(tomcat, getPort() >= 0); 3 }
源码不复杂，创建了一个Tomcat对象，然后初始化参数，再传给TomcatWebServer的构造函数创建TomcatWebServer对象，TomcatWebServer构造函数中会调用Tomcat的start方法启动Tomcat服务器
tips：那么问题来了，getWebServer方法是何时调用的呢？
在Spring容器创建之后会执行刷新操作，ApplicationContext的子类ServletWebServerApplicationContext实现了ApplicationContext的onRefresh方法，源码如下：
1 protected void onRefresh() { 2 super.onRefresh(); 3 try { 4 createWebServer(); 5 } 6 catch (Throwable ex) { 7 throw new ApplicationContextException("Unable to start web server", ex); 8 } 9 }
首先是调用父类的onRefresh方法，然后执行createWebServer方法创建WebServer对象，逻辑就是从IOC容器中找到ServletWebServerFactory对象，执行getWebServer方法获取WebServer对象。
apache的Tomcat实现原理解析可参考：
五、如何实现自定义starter
1、新建项目spring-boot-mytest-starter（官方提供的starter命名为spring-boot-starter-xxx，自定义的通常命名为spring-boot-xxx-starter，用于和官方提供的区分开）