01-SpringBoot基础入门

提前预知

• 课程笔记来源于雷神的SpringBoot2教程
• 参考文档地址：参考文档

1.Spring能做什么？

Spring：

• 宏观指得是Spring全家桶，Spring生态系统，具体可以看Spring官网
• 微观指的是Spring Framework框架

2.什么是SpringBoot？

• 凌驾于Spring其他框架之上的一个更高级的框架，可以组合Spring全家桶里面的各种框架，相当于一个Boot(启动)框架。
• 简单来说：就是可以组装各种Spring框架：Spring Framework Spring Security，Spring Data等
• 由于Spring5对Spring做了重大升级，引入了响应式编程，所以SpringBoot2和SpringBoot1也有诸多不同(知道就行了。。。)。
  

2.1.SpringBoot优点

注意：下面说的这些优点对于刚接触SpringBoot的人可能不知道说的是什么，如果你用过SSM框架，再使用SpringBoot框架，你可能就会理解这些优点，不知道也不要紧，先了解即可。

1.Create stand-alone Spring applications：创建独立Spring应用

2.Embed Tomcat, Jetty or Undertow directly (no need to deploy WAR files)：内嵌web服务器

3.Provide opinionated ‘starter’ dependencies to simplify your build configuration：自动starter依赖，简化构建配置

4. Automatically configure Spring and 3rd party libraries whenever possible：自动配置Spring以及第三方功能

5.Provide production-ready features such as metrics, health checks, and externalized configuration：提供生产级别的监控、健康检查及外部化配置

6. Absolutely no code generation and no requirement for XML configuration：无代码生成、无需编写XML

2.2.SpringBoot缺点

• 人称版本帝，迭代快，需要时刻关注变化
• 封装太深，内部原理复杂，不容易精通

2.3.微服务(了解)

微服务是一种架构风格，即一个应用拆分为一组小型服务，每个服务运行在自己的进程内，也就是可独立部署和升级，服务之间使用轻量级HTTP交互，服务围绕业务功能拆分，可以由全自动部署机制独立部署，去中心化，服务自治。服务可以使用不同的语言、不同的存储技术。

2.4.分布式的困难(了解)

• 远程调用
• 服务发现
• 负载均衡
• 服务容错
• 配置管理
• 服务监控
• 链路追踪
• 日志管理
• 任务调度
• …

2.5.分布式的解决方案

SpringBoot + SpringCloud

2.6.如何学习SpringBoot？

学习框架的最好的方式就是会查看官方文档：官方文档地址

每个版本更新的日志在这里查看(the project release notes section)

3.快去体验SpringBoot？

具体参考：官方文档的这个章节：2.4. Developing Your First Spring Boot Application，手动创建一个springboot项目(从创建一个Maven管理的项目，一步一步的改造成SpringBoot项目)。

要想学会使用官方文档，就要多查阅，多查阅。

注意：

• 当你导入一个启动类包的时候，在终端使用这个命令可以查看导入包的依赖关系：mvn dependency:tree
• 在这个章节：Common Application properties，可以查看application.properties 配置文件的配置方法，例如，如何更改端口。

在pom文件中添加打包的插件，然后就可以使用命令把我们的SpringBoot项目打成jar包

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
    </plugins>
</build>

我们做测试，直接运行main方法即可，无需打成包。

4.自动配置原理入门（难点）？

4.1.SpringBoot特点

4.1.1.依赖管理

父项目做依赖版本管理，引入父项目之后，后面引入的依赖就无需要指定版本号，其实真正做版本管理的是父POM文件引入的父POM文件，类似套娃，学习SpringBoot要习惯这种套娃操作，因为每一次套娃都会对功能进行加强。

<!--我们引入的父POM-->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.3.4.RELEASE</version>
</parent>

<!--引入父POM文件中引入的父POM文件-->
<parent>
   <groupId>org.springframework.boot</groupId>
    <!--几乎声明了所有开发中常用的依赖的版本号,自动版本仲裁机制-->
   <artifactId>spring-boot-dependencies</artifactId>
   <version>2.3.4.RELEASE</version>
</parent>

开发导入starter场景启动器

1、见到很多 spring-boot-starter-* ： *就某种场景
2、只要引入starter，这个场景的所有常规需要的依赖都会帮我们自动引入
3、SpringBoot所有支持的场景可以在参考文档中的这个章节:3.1.5. Starters查看到
4、见到的  *-spring-boot-starter： 第三方为我们提供的简化开发的场景启动器。

5、所有场景启动器最底层的依赖，每个场景启动器都会包含这个org.springframework.boot依赖:
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter</artifactId>
  <version>2.3.4.RELEASE</version>
  <scope>compile</scope>
</dependency>

无需关注版本号，自动版本仲裁：遵循就近原则

• 1、引入依赖默认都可以不写版本，在spring-boot-dependencies中已经指点好了默认的版本
• 2、引入非版本仲裁的jar，我们要写版本号，即覆盖spring-boot-dependencies中的版本号

我们可以修改默认版本号：遵循就近原则

• 1、首先查看spring-boot-dependencies里面规定当前依赖的版本用的 key，看看人家是如何写的。
• 2、在当前项目的POM文件里面进行重新配置，导入我们需要版本的jar包

<!--引入版本：5.1.43-->
<properties>
	<mysql.version>5.1.43</mysql.version>
</properties>

4.1.2.自动配置

关于导入web启动器的自动配置：

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-web</artifactId>
</dependency>

• 1.自动配好Tomcat：

1.引入Tomcat依赖
2.配置Tomcat

• 2.自动配好SpringMVC：

1.引入SpringMVC全套组件
2.自动配好SpringMVC常用组件（功能）

• 3.自动配好Web常见功能，如：字符编码问题

SpringBoot帮我们配置好了所有web开发的常见场景

默认的包结构：默认的包扫描规则

主程序(main方法)所在包及其下面的所有子包里面的组件都会被默认扫描进来

无需以前的包扫描配置，即在主配置类中添加各种包扫描

• 想要改变包的扫描路径使用注解：@ComponentScan
• 例如：@ComponentScan (“com.aismall”)
• 还可以在SpringBoot的主配置类中：@SpringBootApplication(scanBasePackages=“com.aismall”)
• 注意：在SpringBoot项目中，之所以让启动类(主配置类)和子包目录同级，这样SpringBoot默认包扫扫描规则可以帮我们扫描到所有的子包，不需要我们在配置类中在额外指定包扫描路径。
  

4.2.容器功能

4.2.1.组件添加：下面这些注解需要掌握

注意：这些注解如果不会用，可以百度，也可以听雷神的Spring注解版的课，B站就有。

• @Configuration：表明一个类是配置类，给容器中添加组件

• @Bean：给容器中添加一个Bean

• @Component：给容器中添加组件

• @Controller：表明一个类是控制类

• @Service：表明一个类是服务类

• @Repository：表明一个类是数据操作类

• @ComponentScan：指定包扫描路径

• @Import：导入某个类到容器

• @Conditional：按条件添加组件，判断为true的时候才执行

• @ImportResource：原生配置文件引入

@Configuration(proxyBeanMethods = true)

• Full模式与Lite模式

配置类组件之间无依赖关系用Lite模式加速容器启动过程，减少判断

配置类组件之间有依赖关系，方法会被调用得到之前单实例组件，用Full模式

/*
 *1、配置类里面使用@Bean标注在方法上给容器注册组件，默认也是单实例的
 *
 *2、配置类本身也是组件
 *
 *3、默认@Configuration中的proxyBeanMethods属性为true：
 *    proxyBeanMethods：代理bean的方法
 *      Full(proxyBeanMethods = true)、保证每个@Bean方法被调用多少次返回的组件都是单实例的
 *      Lite(proxyBeanMethods = false)、每个@Bean方法被调用多少次返回的组件都是新创建的
 *      组件依赖必须使用Full模式默认。其他默认是否Lite模式
 *
 *4、@Import({User.class,Cat.class})
 *      给容器中自动创建出这两个类型的组件、默认组件的名字就是全类名
 *
 *5、@ImportResource("classpath:beans.xml")导入Spring的配置文件，
 *
 *6、按条件添加的注解，当容器中有这个Bean的时候才进行注入
 *  @ConditionalOnBean(value = {Cat.class})
 *
 * */

/*
 * @EnableConfigurationProperties(Car.class)：这个注解要写在配置类中
 * 1、开启Car配置绑定功能
 * 2、把这个Car这个组件自动注册到容器中*/

@Configuration //表明这是一个配置类
public class MainConfig01 {
    @Bean //给容器中添加组件。以方法名作为组件的id。返回类型就是组件类型。返回的值，就是组件在容器中的实例
    public User user(){
        return new User("AISMALL",18);
    }
    
    @ConditionalOnBean(value = {User.class})
    @Bean(value = "tomcat")
    public Cat cat(){
        return new Cat("tomcat");
    }
}

4.2.2、原生配置文件引入

所谓原生配置文件：就是之前SSM中使用的XML配置文件，SpringBoot中默认使用的是properties结尾的配置文件。

• @ImportResource：原生配置文件引入

@ImportResource("classpath:beans.xml")

4.2.3、配置绑定

如何使用Java读取到properties文件中的内容，并且把它封装到JavaBean中，以供随时使用。、

• 之前的方法，读取配置文件中的内容，使用代码读取：

/*获取配置类中的内容*/
public class GetProperties {
    public static void main(String[] args) throws FileNotFoundException,IOException{
        Properties pps = new Properties();
        String path="propertiesPath";//配置文件路径
        pps.load(new FileInputStream(path));
        Enumeration enum1 = pps.propertyNames();//得到配置文件的名字
        while(enum1.hasMoreElements()) {
            String strKey = (String) enum1.nextElement();
            String strValue = pps.getProperty(strKey);
            System.out.println(strKey + "=" + strValue);
            //封装到JavaBean。
        }
    }
}

• 第一种方法，使用注解：@Component+@ConfigurationProperties

//在Car类上进行标注:自动获取配置文件中前缀为myCar的属性，绑定到Car的属性上
//注意:只有在容器中的组件才可以使用注解
@Component
@ConfigurationProperties(prefix = "myCar")

• 第二种方法，使用注解：@EnableConfigurationProperties + @ConfigurationProperties

/*
 * @EnableConfigurationProperties(Car.class)：这个注解要写在配置类中
 * 1、开启Car配置绑定功能
 * 2、把这个Car这个组件自动注册到容器中*/

@EnableConfigurationProperties(Car.class):标注在配置类上
@ConfigurationProperties(prefix = "myCar"):标注在Bean类上

4.3、自动配置原理入门

4.3.1、引导加载自动配置类

毋庸置疑：先看启动main方法上的注解：@SpringBootApplication，点进去查看如下：

@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
        @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication{}

• @SpringBootConfiguration：点进去查看如下：

@Configuration。代表当前是一个配置类

• @ComponentScan：

指定扫描哪些，Spring注解；

• @EnableAutoConfiguration：点进来看看

// 自动配置包
@AutoConfigurationPackage
//我们来看看导入的这个类是做什么的
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {}

@AutoConfigurationPackage：点进来看看，自动配置包，指定了默认的包规则

//给容器中导入一个组件
@Import(AutoConfigurationPackages.Registrar.class)  
public @interface AutoConfigurationPackage {}
//利用Registrar给容器中导入一系列组件
//将指定的一个包下的所有组件导入进来？MainApplication 所在包下。

@Import(AutoConfigurationImportSelector.class)

1、利用getAutoConfigurationEntry(annotationMetadata);给容器中批量导入一些组件
2、调用List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes)获取到所有需要导入到容器中的配置类
3、利用工厂加载 Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader)；得到所有的组件
4、从META-INF/spring.factories位置来加载一个文件。
    默认扫描我们当前系统里面所有META-INF/spring.factories位置的文件
    spring-boot-autoconfigure-2.3.4.RELEASE.jar包里面也有META-INF/spring.factories

文件里面写死了spring-boot一启动就要给容器中加载的所有配置类，在这个文件里面：
spring-boot-autoconfigure-2.3.4.RELEASE.jar/META-INF/spring.factories

里面一共100多个配置类

4.3.2、按需开启自动配置项：条件装配

虽然自动配置中有100多个场景的所有自动配置，在项目启动的时候，默认全部加载。xxxxAutoConfiguration
但是，通过观察被自动加载的包中的类可以发现，里面的类是按需加载的，进行了条件控制，如果不导入满足条件的类，这个包就不会被加载
也就是：按照条件装配规则（@Conditional），最终会按需配置。

例如：org.springframework.boot.autoconfigure.aop.AopAutoConfiguration.AspectJAutoProxyingConfiguration
//没有Advice这个类这个AspectJAutoProxyingConfiguration就不会被加载
@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(Advice.class)
static class AspectJAutoProxyingConfiguration {}

• 如何查看容器中有没有某个类：可以通过这个查看某个配置类是否会生效（条件判断）

//main方法下
//判断容器中是否有某个类
String[] beanTypes=run.getBeanNamesForType(CacheAspectSupport.class);
//也可通过循环遍历打印容器中加载的所有组件
System.out.println("========"+beanTypes.length+"=============");

4.3.3、修改默认配置

/*
功能：如果用户注册的MultipartResolver.class类型的组件的名字不是multipartResolver，则对其进行改名，改为multipartResolver
*/
@Bean
//容器中有这个类型组件:MultipartResolver.class
@ConditionalOnBean(MultipartResolver.class)  
//容器中没有这个名字:multipartResolver 组件
@ConditionalOnMissingBean(name = DispatcherServlet.MULTIPART_RESOLVER_BEAN_NAME)

public MultipartResolver multipartResolver(MultipartResolver resolver) {
    //给@Bean标注的方法传入了对象参数，这个参数的值就会从容器中找。MultipartResolver类型的值
    //在容器中找到这个类型的值，然后赋值给resolver，这时候MultipartResolver类型组件的名字就变成了multipartResolver
    //可以防止有些用户配置的文件上传解析器不符合规范
       return resolver;
     }

• SpringBoot默认会在底层配好所有的组件。但是如果用户自己配置了以用户的优先

@Bean
@ConditionalOnMissingBean
//这个注解就有效解决了优先级问题，用户配了之后会注册到容器，如果容器中有这个类型的组件，SpringBoot的自动配置就不会生效
public CharacterEncodingFilter characterEncodingFilter() {
    }

4.3.4、总结

• SpringBoot先加载所有的自动配置类 ：xxxxxAutoConfiguration
• 每个自动配置类按照条件进行生效，默认都会绑定配置文件指定的值。xxxxProperties里面拿。xxxProperties和配置文件进行了绑定
• 生效的配置类就会给容器中装配很多组件
• 只要容器中有这些组件，相当于这些功能就有了
• 定制化配置

用户直接自己@Bean替换底层的组件

用户去看这个组件是获取的配置文件什么值就去可以修改：
xxxxxAutoConfiguration —> 组件 —> xxxxProperties里面拿值 ----> application.properties

• 组件需要的值都被抽取出来了，我们直接修改配置文件，组件会去配置文件里面取值。

4.3.5、实践

• 引入场景依赖

SpringBoot所有支持的场景可以在参考文档中的这个章节:3.1.5. Starters查看到

• 查看自动配置了哪些（选做）

自己分析，引入场景对应的自动配置一般都生效了

配置文件中：debug=true开启自动配置报告。Negative（不生效）\Positive（生效）

• 是否需要修改

参照文档修改配置项:
https://docs.spring.io/spring-boot/docs/current/reference/html/appendix-application-properties.html#common-application-properties
自己分析。xxxxProperties绑定了配置文件的哪些。

自定义加入或者替换组件
@Bean、@Component。。。

自定义器 XXXXXCustomizer；

4.4、开发小技巧

4.4.1、Lombok

• 简化JavaBean开发

<!-- 第一步：引入依赖idea中搜索安装lombok插件-->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
</dependency>

<!-- 第二步：在idea中搜索安装lombok插件-->

安装完之后，项目在编译的时候会自动帮我们生成getter和setter方法，我们项目中的bean组件中不用再写了，看着舒服

@Data  :属性赋值
@ToString	:toString方法
@AllArgsConstructor	:全参构造
@NoArgsConstructor	:无参构造

@Slf4j	:简化日志开发，log.info("log....");

4.4.2、dev-tools

• 项目或者页面修改以后，不用重启项目，使用：Ctrl+F9，就会生效

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <optional>true</optional>
</dependency>

4.4.3、Spring Initailizr（项目初始化向导）

• IDE都支持使用Spring的项目创建向导快速创建一个Spring Boot项目

• 在IDEA中使用Spring Initializer快速创建Spring Boot项目（要联网）

• 步骤：

  第一步：创建一个新项目(Create New Project)

  注意：Artifact中的内容不可以大小写混着写

  第二步：选择 Spring Initializer，最后点击Finish完成项目创建

• 如果没有Spring Initializer选项，解决办法如下：

在settings -> Plugins 里面搜索spring boot，勾选上，然后再重启下idea，就可以了。

• 项目resource文件夹介绍

static：保存所有的静态资源； js css images；

templates：保存所有的模板页面，（Spring Boot默认jar包使用嵌入式的Tomcat，默认不支持JSP页面），可以使用模板引（freemarker、thymeleaf）

application.properties：Spring Boot应用的配置文件，可以修改一些默认设置