一、SpringBoot入门

1.1、SpringBoot介绍

    SpringBoot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。通过这种方式，Spring Boot致力于在蓬勃发展的快速应用开发领域(rapid application development)成为领导者。
    SpringBoot能够快发开发的原因是因为配置文件从xml转移到了java文件中，减少了配置文件的书写。

1.2、JavaConfig

    JavaConfig的技术是用于替代目前繁琐的xml文件的配置，他最为重要的替代方式就是使用了大量的注解。

1.2.1、项目准备

<properties>
        <spring.version>5.0.8.RELEASE</spring.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
</properties>
<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.16.22</version>
        <scope>provided</scope>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context-support</artifactId>
        <version>${spring.version}</version>
    </dependency>
</dependencies>

1.2.2、配置类替代配置文件之控制反转

1.2.2.1、创建Bean

public class OneBean {
}

1.2.2.2、创建配置类

// 配置类注解，贴上表明这个类是一个配置类
@Configuration
public class AppConfig {
    // Bean实例注解，贴有该注解的方法为实例方法，在功能上等价于：<bean name="someBean" class="cn.linstudy.onfig.OmeBean" ></bean>
    @Bean
    public OneBean oneBean(){
        // 注意：实例方法的返回对象会交由Spring容器管理起来
        return new SomeBean();
    }
}

1.2.2.3、测试

@RunWith(SpringRunner.class)
// 引用配置类的注解
@ContextConfiguration(classes = AppConfig.class) 
public class App {
    @Autowired
    private ApplicationContext ctx;
    @Test
    public void testApp(){
        OmeBean omeBean = ctx.getBean("omeBean", SomeBean.class);
        System.out.println(omeBean);
    }
}

1.2.3、配置类替代配置文件之组件扫描

1.2.3.1、Bean组件扫描

    学习spring框架时， Spring有4个版型标签（代表的含义相同，仅仅只是为了标注表示的对象不同）。当spring容器扫描器扫描到贴有版型标签的类，会自动创建这些类的实例对象，并交给容器管理。

@Controller  //标记控制层
public class EmployeeController{
}
@Service    //标记服务层
public class EmployeeServiceImpl{
}
@Repository  //标记持久层
public class EmployeeDAOImpl{
}
@Component   //其他类
public class EmployeeListener{
}

    我们除了使用上述注解，还需要在xml文件中进行配置。

<context:component-scan base-package="指定扫描的包路径"></context:component-scan>

    换成了JavaConfig，我们需要贴注解来告诉Spring需要扫描这个类并且创建对象。

@Component  //版型标签
public class OmeBean {
}

    spring组件扫描注解， 扫描basePackages属性指定包及其子包下所有的贴有版型标签类，并创建对象交给Spring容器管理。如果不指定basePackages属性，表示扫描当前类所有包及其子包。

@Configuration
//组件扫描标签
@ComponentScan(basePackages ="cn.linstudy.config") 
public class AppConfig {
}

1.2.4、@Bean注解详解

1.2.4.1、创建一个OneBean类

@Setter
@Getter
public class OneBean {
    public OneBean() {
        System.out.println("OneBean被创建");
    }
    public void init() {
        System.out.println("OneBean被初始化");
    }
    public void destroy() {
        System.out.println("OneBean被销毁");
    }
}

1.2.4.2、书写配置类

@Scope("singleton")
@Bean(value = "ob",initMethod = "init", destroyMethod = "destroy")
public OomeBean oomeBean(){
    return new OomeBean();
}

1.2.4.3、总结

1. bean标签中的name属性 = @Bean注解中的name/value属性。
2. bena标签中的id属性 = 实例方法的方法名。
3. bean标签中的init-method = @Bean注解中的initMethod属性。
4. bean标签中destroy-method属性 = @Bean注解中destroyMethod属性。
5. bean标签中scope属性 = 实例方法中的@Scope注解

1.2.5、配置类替代配置文件之依赖注入

1.2.5.1、创建新类

public class TwoBean {
}

@Setter
@Getter
public class OneBean {
    private Two twoBean;
}

1.2.5.1、实现方式一

    我们可以直接调用实例方法来实现依赖注入。

    JavaConfig实现传统依赖注意需要注意：

1. omeBean对象可以从容器中获取。
2. twoBean可以从容器中获取。
3. omeBean对象通过getTwoBean()方法获得的bean应该从容器获取的twoBean对象相等。

@Configuration
public class AppConfig {
    @Bean
    public OmeBean omeBean(){
        OmeBean omeBean = new OmeBean();
        OmeBean.setTwoBean(twoBean());
        return someBean;
    }
    @Bean
    public TwoBean twoBean(){
        return new TwoBean();
    }
}

    需要注意的点：

1. 多次调用twoBean()方法， spring容器只会执行一次twoBean对象的构建，原因：twoBean()方法被spring容器代理了，每次调用前都会执行容器bean检查，当发现容器中已经有了，直接从容器中拿。如果没有，则执行方法，并将返回值放置到容器中。

1.2.5.2、实现方式二

    方式二是可以通过注入实例对象的方式来实现依赖注入。

@Configuration
public class AppConfig {
    @Bean
    public OneBean omeBean(TwoBean twoBean){
        OneBean omeBean = new OneBean();
        omeBean.setTwoBean(twoBean);
        return omeBean;
    }
    @Bean
    public TwoBean twoBean(){
        return new TwoBean();
    }
}

1.2.6、配置文件互相导入

1.2.6.1、@import

    配置类导入注解，贴在配置类上，作用等价于：<import resource=“xxx配置.xml”></import>标签该标签用于配置类与配置类间的导入。

1.2.6.2、@ImportResource

    配置文件导入注解，贴在配置类上，作用等价于：<import resource=“xxx配置.xml”></import>标签该标签用于配置类与配置文件间的导入。

1.2.7、配置文件的加载与取值

1.2.7.1、加载

    我们可以使用@PropertySource这个注解来进行资源配置文件加载注解，贴在配置类上，用于将properties类型文件加载到spring容器中。

<context:property-placeholder location="classpath:xxx.perperties"/>

1.2.7.2、取值

    当加载了一个配置文件的时候，如果我们需要取值，可以使用@Value注解从properties配置中获取配置的数据。

1.2.7.2.1、创建db.properties

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://192.168.126.129:3306/car_crm
jdbc.username=root
jdbc.password=123456

1.2.7.2.2、定义一个类

@Setter
@Getter
@ToString
public class MyDataSource {
    private String driverClassName;
    private String url;
    private String username;
    private String password;
}

1.2.7.2.3、接收值

@PropertySource("classpath:db.properties")
@Configuration
public class AppConfig {


    @Value("${jdbc.driverClassName}")
    private String driverClassName;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;

    @Bean
    public MyDataSource myDataSource(){
        MyDataSource source = new MyDataSource();
        source.setDriverClassName(driverClassName);
        source.setUrl(url);
        source.setUsername(username);
        source.setPassword(password);
        return source;
    }
}

1.3、SpringBoot自动装配原理

1.3.1、SpringBoot的核心注解

    SpringBoot的核心是@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 {

1.3.2、SpringBoot自动装配原理。

1.3.2.1、综述

    SpringBoot启动会加载大量的自动配置类。@SpringBootApplication包含以下三个注解：

1. @SpringBootConfiguration：我们点进去以后可以发现底层是Configuration注解，说白了就是支持JavaConfig的方式来进行配置(使用Configuration配置类等同于XML文件)。
2. @EnableAutoConfiguration：开启自动配置功能。
3. @ComponentScan：这个就是扫描注解，默认是扫描当前类下的package。将@Controller/@Service/@Component/@Repository等注解加载到IOC容器中。

    我们进入到@EnableAutoConfiguration，就会发现他导入了@implort注解导入了AutoConfigurationImportSelector配置类，该类有一个getCandidateConfiguration方法获取候选的配置方法，可以读取依赖中META-INF/spring.factories中各种候选的配置类，根据你引入的依赖作为条件引入预先设置好的各种配置。

1.3.2.2、AutoConfigurationImportSelector

    @EnableAutoConfiguration注解导入了一个AutoConfigurationImportSelector自动配置类选择器，该类可以实现配置类批量载入spring容器。其核心方法是getCandidateConfigurations目的是在于候选的配置。

protected List<String> getCandidateConfigurations(
    AnnotationMetadata metadata, AnnotationAttributes attributes) {
    List<String> configurations = SpringFactoriesLoader.loadFactoryNames(
        getSpringFactoriesLoaderFactoryClass(),getBeanClassLoader());
    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.");
    return configurations;
}

1.3.2.3、SpringFactoriesLoader

    getCandidateConfigurations方法作用是委托SpringFactoriesLoader去读取jar包中的META-INF/spring.factories文件, 并加载里面配置的自动配置对象。这是自动装配的核心。
    写启动器需要遵循SpringBoot的规范，都需要编写META-INF/spring.factories，里面指定启动器的自动配置类，告诉SpringBoot需要提前放置哪些配置，等满足条件就直接加载。

1.2.3.4、RedisAutoConfiguration分析

    我们以RedisAutoConfiguration配置类分析。

    我们点进去看源码，可以发现有四个注解:

1. @Configuration：表示这个类是一个配置类。
2. @ConditionalOnWebApplication(type = Type.SERVLET)：表示在满足项目的类是是Type.SERVLET类型。
3. @ConditionalOnMissingBean({RepositoryRestMvcConfiguration.class})：表示如果环境中没有RepositoryRestMvcConfiguration这个Bean对象才生效。这个就是自定义配置的入口。
4. @ConditionalOnClass({RepositoryRestMvcConfiguration.class})：表示满足容器中存在RepositoryRestMvcConfiguration这个Bean对象的时候才会生效。

@Configuration(
  proxyBeanMethods = false
)
@ConditionalOnWebApplication(
  type = Type.SERVLET
)
@ConditionalOnMissingBean({RepositoryRestMvcConfiguration.class})
@ConditionalOnClass({RepositoryRestMvcConfiguration.class})
@AutoConfigureAfter({HttpMessageConvertersAutoConfiguration.class, JacksonAutoConfiguration.class})
@EnableConfigurationProperties({RepositoryRestProperties.class})
@Import({RepositoryRestMvcConfiguration.class})
public class RepositoryRestMvcAutoConfiguration {
  public RepositoryRestMvcAutoConfiguration() {
  }

  @Bean
  public SpringBootRepositoryRestConfigurer springBootRepositoryRestConfigurer() {
    return new SpringBootRepositoryRestConfigurer();
  }
}

1.4、注意

1.4.1、为什么打成war包不是jar包

    SpringBoot的默认打包方式是jar包。
   在以前的开发中，Tomcat猫和web项目是独立的，必须满足一定的规则，Tomcat猫才可以部署war包。但是SpringBoot的项目是内嵌Tomcat，部署和运行一气呵成，所以就打成jar包方便。

1.4.2、pom.xml文件中的spring-boot-starter的作用

    我们在创建SpringBoot项目的时候，可以发现引入了很多的start，他收集了市面上常用的jar包以及各种依赖，并且对这些依赖进行了版本管理，避免了很多的版本冲突问题，大大简化了我们的开发，在后续的项目中我们如果需要引入某个依赖，只需引入他的start即可，依赖的版本无需引入。列举额一些SpringBoot的常用的启动器：

spring-boot-starter: 核心启动器 , 提供了自动配置,日志和YAML配置支持

spring-boot-starter-aop: 支持使用 `Spring AOP` 和 `AspectJ` 进行切面编程。

spring-boot-starter-freemarker: 支持使用 `FreeMarker` 视图构建Web 应用

spring-boot-starter-test: 支持使用 `JUnit`， 测试 `Spring Boot` 应用

spring-boot-starter-web: 支持使用 `Spring MVC` 构建 Web 应用，包括 `RESTful` 应用，使用 `Tomcat` 作为默认的嵌入式容器。

spring-boot-starter-actuator: 支持使用 Spring Boot Actuator 提供生产级别的应用程序监控和管理功能。

spring-boot-starter-logging:  提供了对日志的支持 , 默认使用Logback 

1.4.3、mave中强大的功能——继承

    继承是 Maven 中很强大的一种功能，继承可以使得子POM可以获得 parent 中的部分配置(groupId,version,dependencies,build,dependencyManagement等)，可以对子pom进行统一的配置和依赖管理。

1.4.4、DepencyManagement & dependencies区别

    在SpringBoot的pom文件中，dependencies是放在DepencyManagement中的，那么这两者的区别何在：

1. dependencies：即使在子项目中不写该依赖项，那么子项目仍然会从父项目中继承该依赖项（全部继承）。
2. dependencyManagement：里只是声明依赖，并不实现引入，因此子项目需要显示的声明需要用的依赖。如果不在子项目中声明依赖，是不会从父项目中继承下来的；只有在子项目中写了该依赖项，并且没有指定具体版本，才会从父项目中继承该项，并且version和scope都读取自父pom;另外如果子项目中指定了版本号，那么会使用子项目中指定的jar版本（部分继承）。

1.4.5、SpringBoot在没有Tomcat的情况下如何启动

    springboot使用嵌入式tomcat，编程实现，默认端口是8080，可以在application.properties中使用server.port进行设置。

1.4.6、SpringBoot的启动类的main方法中SpringApplication.run(…)详解

    启动类中的主方法有四个作用：

1. 启动SpringBoot程序。
2. 加载自定义的配置类，完成自动装配。
3. 将当前项目部署到内嵌的Tomcat中。
4. 启动Tomcat运行项目。