SpringBoot学习笔记

SpringBoot学习笔记

---

文章目录

• SpringBoot学习笔记
• 自己对SpringBoot的理解
• 1.父依赖
• • 1.1启动器 spring-boot-starter
  • 1.2默认的主启动类
  • 1.3@SpringBootApplication
  • 1.4@ComponentScan
  • 1.5@SpringBootConfiguration
  • 1.6@EnableAutoConfiguration
  • 1.7spring.factories
  • 1.8不简单的方法
  • 1.9SpringApplication
  • 1.2.0run方法流程分析
  • 1.2.1SpringBoot理解
• 2.yaml配置
• • 2.1配置文件
  • 2.2yaml概述
  • 2.3yaml基础语法
  • 2.4yaml注入配置文件
  • 2.5加载指定的配置文件
  • 2.6配置文件占位符
  • 2.7回顾properties配置
  • 对比小结
• 3.JSR303数据校验及多环境切换
• • 3.1先看看如何使用
  • 3.2常见参数
  • 3.3多配置文件
  • 3.4yaml的多文档块
  • 3.5配置文件加载位置
  • 3.6拓展，运维小技巧
• 4.SpringBoot Web开发
• • 4.1.jar：webapp!
  • 4. 2.模板引擎
  • 4.3引入Thymeleaf
• 5.MVC配置原理
• • 5.1扩展SpringMvc
• 6.员工管理系统
• • 6.1准备工作
  • 准备工作
  • 配置文件编写
  • 配置文件生效探究
  • 配置页面国际化值
  • 配置国际化解析
• 7.Data
• • 创建测试项目测试数据源
  • JDBCTemplate
  • 测试
• 8.Myabtis整合
• • 整合测试
  • 我们增加一个员工类再测试下，为之后做准备
• 9.SpringSecurity(安全)
• • 安全简介
  • 实战测试
  • • 实验环境搭建
    • 认识SpringSecurity
    • 认证和授权
    • 权限控制和注销
    • 记住我
    • 定制登录页
  • 完整配置代码
• 10.Shiro
• • 1、Shiro简介
  • • 【1】什么是Shiro?
    • 【2】Shiro 的特点
  • 2、核心组件
  • Shiro报错
• 11.Shirio大整合
• 12.Swagger
• • 1.导入依赖：
  • 2.配置Config 开启Swagger
  • 配置Swagger
  • Swagger配置扫描接口

---

自己对SpringBoot的理解

1.首先SpringBoot的@Configuration是让我们知道他是一个配置类，然后SpringBoot会有一个自动匹配注解，去识别我们现在的环境是什么，是普通java还是javaweb，随即去激活所相应的要使用的配置文件，以及配置类，再进行自动加载，在properties中，我们用什么，他就会去匹配什么并且进行自动加载，我们进行yaml配置文件进行配置的时候，其实都是在SpringBoot封装的文件里面，在AutoConfiguration和properties进行配置绑定，这样我们就可以使用自定义了。

我们之前写的HelloSpringBoot，到底是怎么运行的呢，Maven项目，我们一般从pom.xml文件探究起；

---

笔记基本上是复刻和原本的狂神笔记

1.父依赖

其中它主要是依赖一个父项目，主要是管理项目的资源过滤及插件！

<parent>    <groupId>org.springframework.bootgroupId>    <artifactId>spring-boot-starter-parentartifactId>    <version>2.2.5.RELEASEversion>    <relativePath/> parent>

点进去，发现还有一个父依赖

<parent>    <groupId>org.springframework.bootgroupId>    <artifactId>spring-boot-dependenciesartifactId>    <version>2.2.5.RELEASEversion>    <relativePath>../../spring-boot-dependenciesrelativePath>parent>

这里才是真正管理SpringBoot应用里面所有依赖版本的地方，SpringBoot的版本控制中心；

以后我们导入依赖默认是不需要写版本；但是如果导入的包没有在依赖中管理着就需要手动配置版本了；

1.1启动器 spring-boot-starter

<dependency>    <groupId>org.springframework.bootgroupId>    <artifactId>spring-boot-starter-webartifactId>dependency>

springboot-boot-starter-xxx：就是spring-boot的场景启动器

spring-boot-starter-web：帮我们导入了web模块正常运行所依赖的组件；

SpringBoot将所有的功能场景都抽取出来，做成一个个的starter （启动器），只需要在项目中引入这些starter即可，所有相关的依赖都会导入进来 ， 我们要用什么功能就导入什么样的场景启动器即可 ；我们未来也可以自己自定义 starter；

主启动类

分析完了 pom.xml 来看看这个启动类

1.2默认的主启动类

//@SpringBootApplication 来标注一个主程序类//说明这是一个Spring Boot应用@SpringBootApplicationpublic class SpringbootApplication {
   public static void main(String[] args) {     //以为是启动了一个方法，没想到启动了一个服务      SpringApplication.run(SpringbootApplication.class, args);   }
}

但是**一个简单的启动类并不简单！**我们来分析一下这些注解都干了什么

1.3@SpringBootApplication

作用：标注在某个类上说明这个类是SpringBoot的主配置类 ， SpringBoot就应该运行这个类的main方法来启动SpringBoot应用；

进入这个注解：可以看到上面还有很多其他注解！

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

1.4@ComponentScan

这个注解在Spring中很重要 ,它对应XML配置中的元素。

作用：自动扫描并加载符合条件的组件或者bean ， 将这个bean定义加载到IOC容器中

1.5@SpringBootConfiguration

作用：SpringBoot的配置类 ，标注在某个类上 ， 表示这是一个SpringBoot的配置类；

我们继续进去这个注解查看

// 点进去得到下面的 @Component@Configurationpublic @interface SpringBootConfiguration {}
@Componentpublic @interface Configuration {}

这里的 @Configuration，说明这是一个配置类 ，配置类就是对应Spring的xml 配置文件；

里面的 @Component 这就说明，启动类本身也是Spring中的一个组件而已，负责启动应用！

我们回到 SpringBootApplication 注解中继续看。

1.6@EnableAutoConfiguration

@EnableAutoConfiguration ：开启自动配置功能

以前我们需要自己配置的东西，而现在SpringBoot可以自动帮我们配置 ；@EnableAutoConfiguration告诉SpringBoot开启自动配置功能，这样自动配置才能生效；

点进注解接续查看：

@AutoConfigurationPackage ：自动配置包

@Import({Registrar.class})public @interface AutoConfigurationPackage {}

@import ：Spring底层注解@import ， 给容器中导入一个组件

Registrar.class 作用：将主启动类的所在包及包下面所有子包里面的所有组件扫描到Spring容器 ；

这个分析完了，退到上一步，继续看

@Import({AutoConfigurationImportSelector.class}) ：给容器导入组件 ；

AutoConfigurationImportSelector ：自动配置导入选择器，那么它会导入哪些组件的选择器呢？我们点击去这个类看源码：

1、这个类中有一个这样的方法

// 获得候选的配置protected List getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {    //这里的getSpringFactoriesLoaderFactoryClass（）方法    //返回的就是我们最开始看的启动自动导入配置文件的注解类；EnableAutoConfiguration    List configurations = javaSpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.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;}

2、这个方法又调用了 SpringFactoriesLoader 类的静态方法！我们进入SpringFactoriesLoader类loadFactoryNames() 方法

public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {    String factoryClassName = factoryClass.getName();    //这里它又调用了 loadSpringFactories 方法    return (List)loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());}

3、我们继续点击查看 loadSpringFactories 方法

private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {    //获得classLoader ， 我们返回可以看到这里得到的就是EnableAutoConfiguration标注的类本身    MultiValueMap result = (MultiValueMap)cache.get(classLoader);    if (result != null) {        return result;    } else {        try {            //去获取一个资源 "META-INF/spring.factories"            Enumeration urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");            LinkedMultiValueMap result = new LinkedMultiValueMap();
            //将读取到的资源遍历，封装成为一个Properties            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);        }    }}

4、发现一个多次出现的文件：spring.factories，全局搜索它

1.7spring.factories

我们根据源头打开spring.factories ， 看到了很多自动配置的文件；这就是自动配置根源所在！

WebMvcAutoConfiguration

我们在上面的自动配置类随便找一个打开看看，比如 ：WebMvcAutoConfiguration

可以看到这些一个个的都是JavaConfig配置类，而且都注入了一些Bean，可以找一些自己认识的类，看着熟悉一下！

所以，自动配置真正实现是从classpath中搜寻所有的META-INF/spring.factories配置文件 ，并将其中对应的 org.springframework.boot.autoconfigure. 包下的配置项，通过反射实例化为对应标注了 @Configuration的JavaConfig形式的IOC容器配置类 ， 然后将这些都汇总成为一个实例并加载到IOC容器中。

结论：

1. SpringBoot在启动的时候从类路径下的META-INF/spring.factories中获取EnableAutoConfiguration指定的值
2. 将这些值作为自动配置类导入容器 ， 自动配置类就生效 ， 帮我们进行自动配置工作；
3. 整个J2EE的整体解决方案和自动配置都在springboot-autoconfigure的jar包中；
4. 它会给容器中导入非常多的自动配置类 （xxxAutoConfiguration）, 就是给容器中导入这个场景需要的所有组件 ， 并配置好这些组件 ；
5. 有了自动配置类 ， 免去了我们手动编写配置注入功能组件等的工作；

现在大家应该大概的了解了下，SpringBoot的运行原理，后面我们还会深化一次！

SpringApplication

1.8不简单的方法

我最初以为就是运行了一个main方法，没想到却开启了一个服务；

@SpringBootApplicationpublic class SpringbootApplication {    public static void main(String[] args) {        SpringApplication.run(SpringbootApplication.class, args);    }}

SpringApplication.run分析

分析该方法主要分两部分，一部分是SpringApplication的实例化，二是run方法的执行；

1.9SpringApplication

这个类主要做了以下四件事情：

1、推断应用的类型是普通的项目还是Web项目

2、查找并加载所有可用初始化器 ， 设置到initializers属性中

3、找出所有的应用程序监听器，设置到listeners属性中

4、推断并设置main方法的定义类，找到运行的主类

查看构造器：

public SpringApplication(ResourceLoader resourceLoader, Class... primarySources) {    // ......    this.webApplicationType = WebApplicationType.deduceFromClasspath();    this.setInitializers(this.getSpringFactoriesInstances();    this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));    this.mainApplicationClass = this.deduceMainApplicationClass();}

1.2.0run方法流程分析

跟着源码和这幅图就可以一探究竟了！

1.2.1SpringBoot理解

• 自动装配
• run（）

全面接管SpringMVC的配置！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-q5HrVyEC-1652436064033)(C:\Users\一字先生\AppData\Roaming\Typora\typora-user-images\image-20220328202504692.png)]

如果不配置使用了这个注解就会爆红，去官网拿个dependency

    org.springframework.boot
    spring-boot-configuration-processor
    true

或者使用javaconfig绑定配置文件的值

//加载指定的配置文件
@PropertySource(value="classpath:xxx.properties")
//SPEL表达式取出配置文件的值
@Value("${xx}")

2.yaml配置 2.1配置文件

SpringBoot使用一个全局的配置文件 ， 配置文件名称是固定的

• application.properties

• • 语法结构 ：key=value

• application.yml

• • 语法结构 ：key：空格 value

**配置文件的作用 ：**修改SpringBoot自动配置的默认值，因为SpringBoot在底层都给我们自动配置好了；

比如我们可以在配置文件中修改Tomcat 默认启动的端口号！测试一下！

server.port=8081

2.2yaml概述

YAML是 “YAML Ain’t a Markup Language” （YAML不是一种标记语言）的递归缩写。在开发的这种语言时，YAML 的意思其实是：“Yet Another Markup Language”（仍是一种标记语言）

这种语言以数据作为中心，而不是以标记语言为重点！

以前的配置文件，大多数都是使用xml来配置；比如一个简单的端口配置，我们来对比下yaml和xml

传统xml配置：

    8081

yaml配置：

server：  prot: 8080

2.3yaml基础语法

说明：语法要求严格！

1、空格不能省略

2、以缩进来控制层级关系，只要是左边对齐的一列数据都是同一个层级的。

3、属性和值的大小写都是十分敏感的。

字面量：普通的值 [ 数字，布尔值，字符串 ]

字面量直接写在后面就可以 ， 字符串默认不用加上双引号或者单引号；

k: v

注意：

• “ ” 双引号，不会转义字符串里面的特殊字符 ， 特殊字符会作为本身想表示的意思；

  比如 ：name: “kuang \n shen” 输出 ：kuang 换行 shen

• ‘’ 单引号，会转义特殊字符 ， 特殊字符最终会变成和普通字符一样输出

  比如 ：name: ‘kuang \n shen’ 输出 ：kuang \n shen

对象、Map（键值对）

#对象、Map格式k:     v1:    v2:

在下一行来写对象的属性和值得关系，注意缩进；比如：

student:    name: qinjiang    age: 3

行内写法

student: {name: qinjiang,age: 3}

数组（ List、set ）

用 - 值表示数组中的一个元素,比如：

pets: - cat - dog - pig

行内写法

pets: [cat,dog,pig]

修改SpringBoot的默认端口号

配置文件中添加，端口号的参数，就可以切换端口；

server:  port: 8082

注入配置文件

yaml文件更强大的地方在于，他可以给我们的实体类直接注入匹配值！

2.4yaml注入配置文件

1、在springboot项目中的resources目录下新建一个文件 application.yml

2、编写一个实体类 Dog；

package com.kuang.springboot.pojo;
@Component  //注册bean到容器中public class Dog {    private String name;    private Integer age;        //有参无参构造、get、set方法、toString()方法  }

3、思考，我们原来是如何给bean注入属性值的！@Value，给狗狗类测试一下：

@Component //注册beanpublic class Dog {    @Value("阿黄")    private String name;    @Value("18")    private Integer age;}

4、在SpringBoot的测试类下注入狗狗输出一下；

@SpringBootTestclass DemoApplicationTests {
    @Autowired //将狗狗自动注入进来    Dog dog;
    @Test    public void contextLoads() {        System.out.println(dog); //打印看下狗狗对象    }
}

结果成功输出，@Value注入成功，这是我们原来的办法对吧。

5、我们在编写一个复杂一点的实体类：Person 类

@Component //注册bean到容器中public class Person {    private String name;    private Integer age;    private Boolean happy;    private Date birth;    private Map maps;    private List