SpringBoot 能实现快速开发和部署的需求，越来越流行。

• 约定优于配置
  SpringBoot 重要概念之一 约定优配置。这是一种开发模式吧，按照行业的规则，规定，减少不必要的开发。
  如：
  驼峰规则。
  maven src 目录放源文件，resources 放资源文件，test 放测试文件。
  这就是种约定。
• 自动配置
  自动配置是SpringBoot 的核心思想，也是实现 ‘开箱即用’ 的原理。
  -加入依赖，按约定配置，即可以使用。
  比如我们需要使用 Redis 我们只需要加入 Redis的依赖 和 按约定配置Redis地址，密码就可以使用。无需再配置一大堆东西。
  这就是开箱即用和约定帮我们简化开发。
• 自动配置原理
  使用SpringBoot 我们经常看到 xxx-starter ,无论是官方的还是第三方的 starter，这些 starter 就是实现 自动配置 的 ‘元凶’。

打开这些 starter 都会发现每个starter 的 META-INF 目录下都会有一个 spring.factories 文件。

1. org.springframework.boot.autoconfigure.EnableAutoConfiguration=
2. com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceAutoConfigure

上面记录了 一个该 starter 的 ‘启动类’， SpringBoot 会扫描 ClassPath 下的 所有spring.factories 文件 并按照上面的‘启动类’ 去初始化我们的类。

这种思想类似 Java SPI 类似。

DruidDataSourceAutoConfigure 这个启动类就是去初始化我们数据源的启动类。

• 自动配置源码
  完成自动装配主要靠 @EnableAutoConfiguration 完成；

1. @Target({ElementType.TYPE})
2. @Retention(RetentionPolicy.RUNTIME)
3. @Documented
4. @Inherited
5. @AutoConfigurationPackage
6. @Import({EnableAutoConfigurationImportSelector.class})
7. public @interface EnableAutoConfiguration {
8. String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
9. Class<?>[] exclude() default {};
10. String[] excludeName() default {};
11. }

里面初始化了一个 EnableAutoConfigurationImportSelector.class ；
扫描 spring.factories 就是由这个类完成的。该类基础了
AutoConfigurationImportSelector.class
主要方法：

AutoConfigurationImportSelector：

1. protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
2. List<String> configurations = SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader());
3. Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you are using a custom packaging, make sure that file is correct.");
4. return configurations;
5. }

SpringFactoriesLoader： 扫描 Classpath下 spring.factories

1. public static List<String> loadFactoryNames(Class<?> factoryClass, ClassLoader classLoader) {
2. String factoryClassName = factoryClass.getName();
3. try {
4. Enumeration<URL> urls = classLoader != null?classLoader.getResources("META-INF/spring.factories"):ClassLoader.getSystemResources("META-INF/spring.factories");
5. ArrayList result = new ArrayList();
6. while(urls.hasMoreElements()) {
7. URL url = (URL)urls.nextElement();
8. Properties properties = PropertiesLoaderUtils.loadProperties(new UrlResource(url));
9. String factoryClassNames = properties.getProperty(factoryClassName);
10. result.addAll(Arrays.asList(StringUtils.commaDelimitedListToStringArray(factoryClassNames)));
11. }
12. return result;
13. } catch (IOException var8) {
14. throw new IllegalArgumentException("Unable to load [" + factoryClass.getName() + "] factories from location [" + "META-INF/spring.factories" + "]", var8);
15. }
16. }

• 自定义自己的 Starter
  命名规范：
  Spring 官方 Starter通常命名为spring-boot-starter-{name}如 spring-boot-starter-web， Spring官方建议非官方Starter命名应遵循 {name}-spring-boot-starter 的格式。

Starter一般有：
读取配置类
提供服务类
自动配置类
配置文件

读取配置类（MyProperties）用于读取 .properties 或者 .yml 约定的配置。

1. package com.linving.starter.properties;
2. import org.springframework.boot.context.properties.ConfigurationProperties;
3. /**
4. * Created by linli on 2018/1/20.
5. */
6. @ConfigurationProperties("linving")
7. public class MyProperties {
8. private String name;
9. private Integer age;
10. public String getName() {
11. return name;
12. }
13. public void setName(String name) {
14. this.name = name;
15. }
16. public Integer getAge() {
17. return age;
18. }
19. public void setAge(Integer age) {
20. this.age = age;
21. }
22. }

提供服务类（MyProvider） 对外提供服务的类。

1. package com.linving.starter.service;
2. /**
3. * Created by linli on 2018/1/20.
4. */
5. public class MyProvider {
6. private String name;
7. private Integer age;
8. public MyProvider(String name, Integer age) {
9. this.name = name;
10. this.age = age;
11. }
12. public String getName() {
13. return name;
14. }
15. public void setName(String name) {
16. this.name = name;
17. }
18. public Integer getAge() {
19. return age;
20. }
21. public void setAge(Integer age) {
22. this.age = age;
23. }
24. }

自动配置类 （MyAutoConfigure），给Springboot 自动配置的初始类 ，这个是必须的。

1. /**
2. * Created by linli on 2018/1/20.
3. */
4. @Configuration
5. @ConditionalOnClass(MyProvider.class)
6. @EnableConfigurationProperties(MyProperties.class)
7. @ConditionalOnProperty(prefix="linving",value="enabled",matchIfMissing=true)
8. public class MyAutoConfigure {
9. @Autowired
10. MyProperties properties;
11. @Bean
12. MyProvider myProvider(){
13. return new MyProvider(properties.getName(),properties.getAge());
14. }
15. }

@ConditionalOnClass，当classpath下发现该类（MyProvider）的情况下进行自动配置。
@ConditionalOnMissingBean，当Spring Context中不存在该Bean时。
@ConditionalOnProperty(prefix=”linving”,value=”enabled”,matchIfMissing=true)
，当配置文件中linving.enabled=true时，才会自动配置，初始化我们的 MyProvider等。

等还有很多配置

https://docs.spring.io/spring-boot/docs/1.5.9.RELEASE/reference/htmlsingle/#boot-features-bean-conditionsns

配置文件(spring.factories)；
上面说过这个的作用了。

1. # Auto Configure
2. org.springframework.boot.autoconfigure.EnableAutoConfiguration=
3. com.linving.starter.MyAutoConfigure

最后打包发布到 maven。

• 使用我们的 Starter

加入依赖（没有按规则命名）：

1. <dependency>
2. <groupId>com.linving.starter</groupId>
3. <artifactId>demo</artifactId>
4. <version>0.0.1-SNAPSHOT</version>
5. </dependency>

在 application.properties 配置我们的约定

1. linving.name=dog
2. linving.age=26

这里我们就可以直接使用 我们的MyProvider了。SpringBoot 启动的时候已经帮我们自动装配了。

1. @RestController
2. public class HelloController {
3. @Autowired
4. MyProvider provider;
5. @GetMapping("/hello")
6. public String input(){
7. return provider.getName()+"";
8. }
9. }

这就是一个简单的 Starter，也是SpringBoot 的核心思想。