Spring Boot是Spring开源组织下的子项目，是Spring组件一站式解决方案，主要是简化了使用Spring的难度，简省了繁重的配置，提供了各种启动器，开发者能快速上手。

SpringBoot优点

1、独立运行

SpringBoot内嵌了各种servlet容器，tomcat，jetty等，现在不再需要打成war包部署到容器中，SpringBoot只要达成一个可执行的jar包就能独立运行，所有的依赖包都在一个jar包内。

2、简化配置

spring-boot-starter-web启动器自动依赖其他组件，简少了maven的配置。

自动依赖其他组件

3、自动配置

Spring Boot能根据当前类路径下的类、jar包来自动配置bean，如添加一个spring-boot-starter-web启动器就能拥有web的功能，无需其他配置。

4、无代码生成和XML配置

Spring Boot配置过程中无代码生成，也无需XML配置文件就能完成所有配置工作，这一切都是借助于条件注解完成的，这也是Spring4.x的核心功能之一。

5、SpringBoot添加依赖包两种方式

第一种

<dependencyManagement>
      <dependencies>
        <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-dependencies</artifactId>
          <version>1.5.6.RELEASE</version>  
          <type>pom</type>      
          <scope>import</scope>      
        </dependency>
  <dependencies>
</dependencyManagement>

第二种

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.6.RELEASE</version>
</parent>

SpringBoot的优点在于依赖传递

但是springboot也有一些缺点，在我们项目的pom文件中继承了父项目spring-boot-starter-parent，这里规定了一部分坐标的版本、依赖管理、插件管理都提前定好，所以我们的pom文件继承spring-boot-starter-parent就直接依赖父项目的所有版本，并且pom文件的便捷性也就体现在版本的传递性

SpringBoot依赖覆盖只对继承有效

我们可以在添加的依赖中设置版本，但是只对上文继承依赖有效，对第二种导入依赖方式无效

<properties>
      <slf4j.version>1.7.25<slf4j.version>
</properties>

如果希望实现导入方式的版本升级需要把要升级的组件放到导入的springboot父依赖之上

<dependencyManagement>
    <dependencies>
<!-- Override Spring Data release train provided by Spring Boot -->
        <dependency>          
            <groupId>org.springframework.data</groupId>    
            <artifactId>spring-data-releasetrain</artifactId>         
            <version>Fowler-SR2</version>        
            <scope>import</scope>
            <type>pom</type>    
        </dependency>
        <dependency>         
            <groupId>org.springframework.boot</groupId>           
            <artifactId>spring-boot-dependencies</artifactId>
            <version>1.5.6.RELEASE</version>
            <type>pom</type>            
            <scope>import</scope>        
        </dependency>    
    </dependencies>
</dependencyManagement>

需要注意，要修改Spring Boot的依赖组件版本可能会造成不兼容的问题。

SpringBoot的自动配置原理

从启动类的@SpringBootApplication可以找到@EnableAutoConfiguration
所以可以看到Spring Boot的自动配置注解就是@EnableAutoConfiguration

@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}
)}
)

我们找到@EnableAutoConfiguration中的@Import({AutoConfigurationImportSelector.class})，从该类的引用包@import中可以找到import org.springframework.core.io.support.SpringFactoriesLoader;，在这个类的

public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {
        String factoryClassName = factoryClass.getName();
        return (List)loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
    }

方法可以加载springboot中的配置文件，这个方法会调用本类中

private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
        MultiValueMap<String, String> result = (MultiValueMap)cache.get(classLoader);
        if (result != null) {
            return result;
        } else {
            try {
                Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
                LinkedMultiValueMap result = new LinkedMultiValueMap();

                while(urls.hasMoreElements()) {
                    URL url = (URL)urls.nextElement();
                    UrlResource resource = new UrlResource(url);
                    Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                    Iterator var6 = properties.entrySet().iterator();

                    while(var6.hasNext()) {
                        Entry<?, ?> entry = (Entry)var6.next();
                        String factoryClassName = ((String)entry.getKey()).trim();
                        String[] var9 = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
                        int var10 = var9.length;

                        for(int var11 = 0; var11 < var10; ++var11) {
                            String factoryName = var9[var11];
                            result.add(factoryClassName, factoryName.trim());
                        }
                    }
                }

                cache.put(classLoader, result);
                return result;
            } catch (IOException var13) {
                throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var13);
            }
        }
    }

这个方法会加载类路径及所有jar包下META-INF/spring.factories配置中映射的自动配置的类public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";这个常量可以去加载Sring自动配置的所有类
我们继续查看项目的maven依赖，发现

maven依赖中自动配置的包

# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration,\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,\
org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration,\
org.springframework.boot.autoconfigure.cassandra.CassandraAutoConfiguration,\
org.springframework.boot.autoconfigure.cloud.CloudServiceConnectorsAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.jdbc.JdbcRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.jpa.JpaRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.ldap.LdapRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoReactiveDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoReactiveRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.neo4j.Neo4jDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.neo4j.Neo4jRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,\
……

在这一块配置文件中所有配置自动加载的类都会被加载到springboot中。比如我们看一下关于Redis的自动配置类

@Configuration
@ConditionalOnClass({RedisOperations.class})
@EnableConfigurationProperties({RedisProperties.class})
@Import({LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class})
public class RedisAutoConfiguration {
    public RedisAutoConfiguration() {
    }

    @Bean
    @ConditionalOnMissingBean(
        name = {"redisTemplate"}
    )
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
        RedisTemplate<Object, Object> template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }

类被@EnableConfigurationProperties注解，所以SpringBoot会触发对RedisProperties执行自动绑定属性值。

此类会自动创建bean对象: redis连接池JedisConnectionFactory和redis模板类(RedisTemplate和StringRedisTemplate)。直接在应用中通过@Autowired就可以注入以上对象。
继续查看RedisProperties.class

package org.springframework.boot.autoconfigure.data.redis;

import java.time.Duration;
import java.util.List;
import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties(
    prefix = "spring.redis"
)
public class RedisProperties {
    private int database = 0;
    private String url;
    private String host = "localhost";
    private String password;
    private int port = 6379;
    private boolean ssl;
    private Duration timeout;
    private RedisProperties.Sentinel sentinel;
    private RedisProperties.Cluster cluster;
    private final RedisProperties.Jedis jedis = new RedisProperties.Jedis();
    private final RedisProperties.Lettuce lettuce = new RedisProperties.Lettuce();
}

RedisProperties类被@ConfigurationProperties注解，表示从外部文件（如application.properties）注入属性值。application.properties中的参数会被自动封装到RedisProperties中，然后加载到自动配置类的RedisTemplate的初始化对象中我们就可以直接注入。
因此我们得到Redis和SpringBoot整合后可以加载的整个流程：
1、启动类开始执行run方法
2、启动类main方法被@SpringBootApplication标注，@SpringBootApplication涵盖@EnableAutoConfiguration，@EnableAutoConfiguration引入自动导入选择器AutoConfigurationImportSelector.class，这个类调用SpringFactoriesLoader.loadFactoryNames（）方法加载maven依赖中自动导入包下META-INF下的spring.factories文件，开始自动配置这里面的组件，以RedisAutoConfiguration为例包含

@Configuration
@ConditionalOnClass({RedisOperations.class})
@EnableConfigurationProperties({RedisProperties.class})

三个核心注解，其中@EnableConfigurationProperties可以自动绑定配置文件，并且RedisProperties.class又被RedisProperties类被@ConfigurationProperties注解，表示从外部文件（如application.properties）注入属性值。application.properties中的参数会被自动封装到RedisProperties中。