SpringBoot-01快速入门【基础总结】

SpringBoot是什么?

Spring Boot

什么是SpringBoot?

springboot在spring的基础之上，搭建起来的框架，能够帮助我们整合市面上最流行的框架，帮助我们快速搭建起来项目。

springboot不是新的技术，而是新的框架，是基于spring来搭建起来的。

---

特性：约定大于配置！

为什么使用SpringBoot?

• 开发效率快，内置有配置好的版本依赖。
• 基于spring。
• 轻松上手
• springboot使用起来方便，能快速搭建spirng环境。
• springboot官网帮我们配置了大部分参数。直接使用即可。
• 用JavaBean替代xml配置。配置更少了。看起来也简洁了不少。
• 添加很多新的组合注释。例如：Rest
• 能与其它框架快速集成，减少配置的编写。

微服务架构

传统的单体应用架构?

所谓的单体应用架构(all in one)是指,我们将一个应用的所有服务都封装在一个应用中。即把数据库访问,web访问等等功能放到一个war包内。

---

好处：

• 易于开发和测试,也方便部署;
• 当需要扩展时,只需要将war包复制多份,然后放到不同的多个服务器上,再做个负载均衡即可。

缺点:

• 哪怕修改一个小地方,都需要暂停整个服务,重新打包,重新部署这个web应用的war包。
• 特别是对于一个大型应用,不可能把所有内容都放在一个应用里面,这样的话如何维护,如何分工合作都是问题。

什么是微服务?

微服务是一种架构风格,它要求我们在开发一个应用的时候,这个应用必须构建成一系列的小服务的组合;然后小服务间可以通过http的方式进行通信。

什么是微服务架构?

打破之前all in one的单体应用架构方式,把每个功能元素独立出来,做为一个个的功能组件,再对这些功能元素/功能组件进行动态组合；

需要的功能元素才去拿来组合,需要多一些功能元素时可以整合多个功能元素;

所以微服务架构是对功能元素进行复制,而不是对整个应用进行复制。

---

好处:

• 每个功能元素的服务都是一个可替换的,可独立升级的软件模块。

如何构建微服务?

一个大型系统的微服务架构,就像一个复杂的神经网络,每一个功能元素就是一个神经元,它们各自完成自己的功能,然后通过Http相互请求调用。

---

比如一个电商系统,包括: 查缓存,连数据库,浏览页面,结账,支付等服务,它们都是一个个独立的功能服务,都可以被微化,它们作为一个个的微服务共同构建了一个庞大的系统。如果修改其中的一个功能,只需要更新升级其中一个功能服务单元即可。

---

但是这种庞大的系统架构给部署和运维带来很大的难度。

于是,Spring带来了构建大型分布式微服务的全套,全程产品。

• 构建一个个功能独立的微服务应用单元,可以使用Spring Boot.

  其可以帮助我们快速构建一个应用单元。

• 大型分布式网络服务的调用,可以由Spring Cloud完成,实现分布式。

• 在分布式的中间,进行流式数据计算,批处理,则可以使用Spring Cloud Data Flow.

• 故: Spring给我们带来了整个从开始构建应用到大型分布式应用的全流程方案

入门Demo

1.创建SpringBoot项目脚手架的两种方式:

• 要么可以在Spring官网中直接生成war包,再导入到IDEA中。

  【导入项目注意: 选择src目录的上级目录进行导入】

  【web项目注意添加启动器依赖:spring-boot-starter-web】

  

• 要么直接使用IDEA创建一个Spring Boot项目。【推荐】

  

  【web项目注意添加启动器依赖:spring-boot-starter-web】

  

---

得到最终项目结构如下:

注：

• 其中的SpringbootDemoApplication.java文件是Spring Boot项目运行的程序入口,即欲启动项目即运行这个Java文件即可。
• 新建文件夹需要在SpringbootDemoApplication.java文件的上级目录中新建,即保持SpringbootDemoApplication.java文件是唯一的没有存放在文件夹中的java文件。
• application.properties文件是Spring Boot项目的核心配置文件。
• Test文件夹中的SpringbootDemoApplicationTests.java文件则是起到单元测试的作用

---

注意若遇到运行主启动类运行失败,需要降低spring-boot-starter-parent的版本到3.0以下!

---

2. 创建一个controller文件夹并在其中创建一个HelloController.java文件：

   @RestController
   public class HelloController {
       @GetMapping("/")
       public String hello(){
           return "Hello springboot";
       }
   }
   

3. 启动项目: 运行SpringbootDemoApplication.java文件：

   

   如下:启动成功,发现端口是8080.

   

4. 访问：http://localhost:8080/

   

---

小技巧:

1. 更改web程序的启动端口号:

可以直接在application.properties文件中书写以下内容:

server.port = xxxx

2. 自定义springboot项目启动时的Banner图:

即:在resources目录下新建文件banner.txt文件,

其中banner.txt文件要保存自定义的图案内容。

注意Banner.txt文件的左下标符号中要显示图案,代表识别成功!

如下:

---

细节知识

• 原项目中java目录下的文件和recource目录下的文件经过编译后，都会放到WEB-INF/classes目录下：

  

  

  一般说的类路径/classpath路径,都指的是编译后的WEB-INF/classes目录,

  而类路径对应原先的项目目录的话,就是指java目录下的文件和recource目录下的文件!

原理知识/难点

分析SpringBoot自动装配原理

我们以HttpEncodingAutoConfiguration（Http编码自动配置为例。

解释自动配置原理；

@Configuration //表示这是一个配置类，和以前编写的配置文件一样，也可以给容器中添加组件；
//启动指定类的ConfigurationProperties功能；
  //进入这个HttpProperties查看，将配置文件中对应的值和HttpProperties绑定起来；
  //并把HttpProperties加入到ioc容器中
@EnableConfigurationProperties({HttpProperties.class}) 
//Spring底层@Conditional注解
  //根据不同的条件判断，如果满足指定的条件，整个配置类里面的配置就会生效；
  //这里的意思就是判断当前应用是否是web应用，如果是，当前配置类生效
@ConditionalOnWebApplication(type = Type.SERVLET)
//判断当前项目有没有这个类CharacterEncodingFilter；SpringMVC中进行乱码解决的过滤器；
@ConditionalOnClass({CharacterEncodingFilter.class})
//判断配置文件中是否存在某个配置：spring.http.encoding.enabled；
  //如果不存在，判断也是成立的
  //即使我们配置文件中不配置spring.http.encoding.enabled=true，也是默认生效的；
@ConditionalOnProperty(
    prefix = "spring.http.encoding",
    value = {"enabled"},
    matchIfMissing = true
)
public class HttpEncodingAutoConfiguration {
    //他已经和SpringBoot的配置文件映射了
    private final Encoding properties;
    //只有一个有参构造器的情况下，参数的值就会从容器中拿
    public HttpEncodingAutoConfiguration(HttpProperties properties) {
        this.properties = properties.getEncoding();
    }
    //给容器中添加一个组件，这个组件的某些值需要从properties中获取
    @Bean
    @ConditionalOnMissingBean //判断容器没有这个组件？
    public CharacterEncodingFilter characterEncodingFilter() {
        CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
        filter.setEncoding(this.properties.getCharset().name());
        filter.setForceRequestEncoding(this.properties.shouldForce(org.springframework.boot.autoconfigure.http.HttpProperties.Encoding.Type.REQUEST));
        filter.setForceResponseEncoding(this.properties.shouldForce(org.springframework.boot.autoconfigure.http.HttpProperties.Encoding.Type.RESPONSE));
        return filter;
    }
    //。。。。。。。
}

一句话总结 ：根据当前不同的条件判断，决定这个配置类是否生效！

如果没有把对应的依赖引用进来，这个配置类也会不生效。

通过不同的条件来进行判断是否要启动配置。

• 一但这个配置类生效；这个配置类就会给容器中添加各种组件；
• 这些组件的属性是从对应的properties类中获取的，这些类里面的每一个属性又是和配置文件绑定的；
• 这样就可以形成我们的配置文件可以动态的修改springboot的内容。
• 所有在配置文件中能配置的属性都是在xxxxProperties类中封装着；
• 配置文件能配置什么就可以参照某个功能对应的这个属性类

总结:

1、SpringBoot启动时会加载大量的自动配置类

2、我们看我们需要的功能有没有在SpringBoot默认写好的自动配置类当中

3、我们再来看这个自动配置类中到底配置了哪些组件；（只要我们要用的组件存在其中，我们就不需要再去手动配置了，如果不存在我们再手动配置）

4、给容器中自动配置类添加组件的时候，会从properties类中获取某些属性，我们只需要在配置文件中指定这些属性即可；

---

• XXXXAutoConfiguration：自动配置类:给容器添加组件，这些组件要赋值就需要绑定一个XXXXProperties类

• XXXXProperties：里面封装配置文件中相关属性；

---

SpringBoot的主启动类怎么运行

它不是简单的运行了一个main方法,而是开启了一个服务；

@SpringBootApplication //这个注解表明这是SpringBoot项目的主启动类
public class SpringbootDemoApplication {
	public static void main(String[] args) {
        //该方法返回一个ConfigurableApplicationContext对象
        //参数一:应用入口的类    参数二:命令行参数
		SpringApplication.run(SpringbootDemoApplication.class, args);
	}

}

SpringApplication.run分析:

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

SpringApplication这个类主要做了四件事情:

1. 推断应用的类型是普通的项目还是Web项目
2. 查找并加载所有可用初始化器,设置到initializers属性中
3. 找出所有的应用程序监听器,设置到listeners属性中
4. 推断并设置main方法的定义类,找到运行的主类

---

run方法:

过程过于复杂,略过…

---

实用知识

yaml基本语法及使用

YAML是标记语言。

以前的配置文件,大多数使用XML来配置,如下:

<server>
    <port>8081</port>
</server>

而使用yml/yaml配置则如下:

server:
	port: 8081

---

特点:

• 语法要求严格
• 空格不能省略
• 以缩进来控制层级关系
• 对大小写敏感

# 普通格式(普通键值对)：
k: v
# 对象格式：
k:
  v1:
  v2:
# 数组模式：
k:
  - v
  - v
  - v
# 行内写法
k: {k1:v1,k2:v2}
k: {v,v,v}

注:

• 使用yml/yaml文件格式可以支持普通键值对,对象,数组,行内等写法。
• 而使用properties文件格式则只支持普通的键值对的写法。

---

Spring-Boot的配置文件

SpringBoot使用一个全局的配置文件,配置文件的名称是固定的,即: application

• application.properties

  • 语法结构: key=value

  • 例: server.port=8081

• application.yml 或 application.yaml

  • 语法结构: key: 空格 value

  • 例: server:

    ​ port: 8081

配置文件的作用?

答: 修改SpringBoot自动配置的默认值,因为SpringBoot在底层给我们自动配置好了

---

如果在同一位置有同时具有.properties和.yml格式的配置文件，.properties优先。

如果存在多个相同配置，会有优先级。

---

Java类读取Spring-boot配置文件

读取yaml/yml格式配置文件的方式【推荐】

案例：创建学生对象，用于默认就把配置信息加载进去。

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

student:
  name: Zhang San
  birthdate: 1990/09/01
  interests: [eat, sleep]

2、添加实体类

//注册bean到容器中
@Component
//@ConfigurationProperties注解的作用:
//将配置文件中配置的每一个属性的值,映射到这个类组件中;
//告诉SpringBoot将本类中的所有属性和配置文件中相关的配置进行绑定
//参数prefix="student":将配置文件中的student下面的属性一一对应
//只有这个类组件是已注册到容器中的组件,才能使用@ConfigurationProperties功能
@ConfigurationProperties(prefix = "student")
//lombok插件利用@Data注解自动生产getter和setter
@Data
public class Student {
    private String name;
    private Date birthdate;
    private List<String> interests;
}

idea提示没有找到springboot配置注解处理器。

然后需要添加springboot配置注解处理器，方便在Test测试。

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

3、测试类中测试。

@SpringBootTest
class DemoApplicationTests {
    @Autowired//引用数据类型,利用注解进行自动装配(即创建对象)
    private Student student;
    @Test//junit依赖的单元测试注解,添加这个注解之后这个方法就可以直接启动
    void contextLoads() {
        System.out.println(student);
    }
}

结果:

加载指定的配置文件

日常开发中，配置文件可能存在多个;

并且,由于SpringBoot会默认读取以application命名不同格式的配置文件,一旦配置文件不是以’application’命名,一般就读取不到配置文件;

---

所以,有必要学习如何加载指定的配置文件！！

以不同名的properties格式文件为例:

1、我们去在resources目录下新建一个student.properties文件;因为SpringBoot优先读取properties格式的配置文件,所以之前的yaml/yml格式的配置文件将不生效。

name=Zhang San
birthdate=1990/09/01
interests=[eat,sleep]

2、修改配置类

@Component
//利用下面这个注解,指定配置文件的路径
@PropertySource(value = "classpath:student.properties")
//lombok插件的注解,自动生成getter和setter
@Data
public class Student {
    //SPEL表达式取出配置文件的值,格式: @Value("${字段名}")
    @Value("${name}")
    private String name;
    @Value("${birthdate}")
    private Date birthdate;
    @Value("${interests}")
    private List<String> interests;
}

3、测试查看效果

结论:

• 配置yml和配置properties都可以获取到值,但强烈推荐yml
• 如果我们在某个业务中,只需要获取配置文件中的某个值,可以使用一下@value
• 如果说,我们专门编写了一个JavaBean来和配置文件进行映射,就直接使用@ConfigurationProperties，不要犹豫!!

---

配置文件的读取路径/存放路径

Springboot 启动会扫描以下位置的application.properties或者application.yml文件作为Spring boot的默认配置文件：

1.项目根路径
  1.项目根路径/config包
  2.项目根路径
2.java目录 或者 resources目录
  1.java/config子目录 或者 resources/config子目录
  2.java目录 或者 resources目录

多配置环境的切换

我们在主配置文件编写的时候，文件名可以是 application-{profile}.properties/yml , 用来指定多个环境版本；

其中大括号中的profile是Spring对不同环境提供不同配置功能的支持，可以通过激活不同的环境版本，实现快速切换环境；

例如:

application-test.yml：代表测试环境配置

application-dev.yml：代表开发环境配置

但是Springboot并不会直接启动这些配置文件，它默认使用application.properties主配置文件，如果没有就会找application.yml。

我们需要通过在主配置文件中书写以下配置来选择需要激活的环境：

• 如果是yml/yaml格式的配置文件:

spring:
  profiles:
    active: dev #使用开发环境,只需要写横杠后的单词即可,这里是dev

• 如果是properties格式的配置文件:

spring.profiles.active = dev #使用开发环境,只需要写横杠后的单词即可,这里是dev

SpringBoot启动器

我们在创建项目的时候添加了一个web的依赖。

通过pom.xml查看。

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

会发现，只添加spring-boot-starter-web就可以进行web开发了。并且不用声明版本号。

启动器包含许多依赖项，包括版本号，可以添加这些依赖项使项目快速启动并运行。

官方启动器命名规则：spring-boot-starter-*，其中*是特定类型的应用程序。例如，spring-boot-starter-web。

第三方启动器命名规则：以项目名称开头*-boot-starter。例如，MyBatis-Plus。他的命名是mybatis-plus-boot-starter

Spring Boot 应用程序启动器

官方文档：https://docs.spring.io/spring-boot/docs/2.6.11/reference/htmlsingle/#using.build-systems.starters

---

Web开发

静态资源

可以存放的三个位置

• 默认情况下，Spring Boot 将静态内容存放于类路径中的/static (或/public 或/resources);
• 若对应原项目路径,即:
  • resources目录下的/static 【读取的优先级位于中间】
  • resources目录下的/public 【读取的优先级最低】
  • resources目录下的/resources 【读取的优先级最高】

---

SpringBoot默认的浏览器中的静态资源的访问路径: 当前项目根路径/ + 静态资源名

例子:

添加图片到resource下的static里：

访问 ： 当前项目根路径/ + 静态资源名

请求进来，先去找Controller看能不能处理。不能处理的所有请求又都交给静态资源处理器。静态资源也找不到则响应404页面.

---

若要更改默认的静态资源的访问路径前缀:

可以添加访问静态资源前缘。

spring:
mvc:
 static-path-pattern: /res/**

现在访问路径就是： 当前项目根路径 + /res + 静态资源名

---

webjars

webjars官网：https://www.webjars.org/

WebJars是可以让大家以jar包的形式来使用前端的各种框架、组件。

例如，引用jquery，只需要从webjars的官网中添加maven依赖到pom.xml中即可。

<dependency>
    <groupId>org.webjars</groupId>
    <artifactId>jquery</artifactId>
    <version>3.6.1</version>
</dependency>

只要是从webjars中引入的依赖,

则其访问路径为：当前项目根路径/ + webjars/**。

疑问点: 上面路径中的/**这里的具体路径如何确定?

---

答: 以上面引入的jquery依赖为例:

​ 先从
中找到引入的jquery依赖:

再查看其文件的路径组成，如下图:

查看源码可知,我们输入的访问路径中的/webjars其实已经代表了隐藏的路径/META-INF/resources,所以我们在访问路径/**中输入的内容就对应了剩下的路径，即:/jquery/3.6.1/jquery/js

访问链接: http://localhost:8081/webjars/jquery/3.6.1/jquery.js

得到结果如下:

首页支持

定制的首页index.html可以存放的三个位置?

• 默认情况下，可以存放于类路径中的/static (或/public 或/resources);
• 若对应原项目路径,即:
  • resources目录下的/static 【读取的优先级位于中间】
  • resources目录下的/public 【读取的优先级最低】
  • resources目录下的/resources 【读取的优先级最高】

---

此时浏览器的访问路径: 当前项目根路径/ + index.html

---

可以配置静态资源路径,但不能与静态资源前缀共用。

spring:
  resources:
    static-locations: [classpath:/haha/]

请求参数处理

Restful风格

RESTFUL是一种网络应用程序的设计风格和开发方式。

对比：

功能	传统请求	Restful风格
获取用户	/user/getUser （GET请求）	/user （GET请求）
保存用户	/user/saveUse （POST请求）	/user （POST请求）
修改用户	/user/editUser （POST请求）	/user （PUT请求）
删除用户	/user/deleteUser（POST请求）	/user （DELETE请求）

1、开启页面表单的Restful功能

spring:
  mvc:
    hiddenmethod:
      filter:
        # 开启页面表单的Rest功能
        enabled: true

2、添加页面请求

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<script src="/webjars/jquery/3.6.1/jquery.js"></script>
<body>
    <h1>首页</h1>
    <button id="getUser">获取用户</button>
    <button id="saveUser">保存用户</button>
    <button id="editUser">修改用户</button>
    <button id="deleteUser">删除用户</button>
    <p id="msg"></p>
<script>
    $("#getUser").on("click",()=>{
        $.get("/user",(res)=>{
            $("#msg").text(res);
        })
    });
    $("#saveUser").on("click",()=>{
        sendAjax(null);
    });
    $("#editUser").on("click",()=>{
        sendAjax('PUT');
    });
    $("#deleteUser").on("click",()=>{
        sendAjax("DELETE");
    });
    function sendAjax(type){
        let data = {'_method':type}
        $.post("/user",data,(res)=>{
            $("#msg").text(res);
        })
    }
</script>
</body>
</html>

3、添加后端接口

// 组合注解，@Controller + RequestBody
@RestController
@RequestMapping("/user")
public class UserController {
    // 普通写法
    // @RequestMapping(value = "/user",method = RequestMethod.GET)
    // 精简写法
    @GetMapping
    public String getUser(){
        return "get user";
    }
    @PostMapping
    public String saveUser(){
        return "post user";
    }
    @PutMapping
    public String editUser(){
        return "put user";
    }
    @DeleteMapping
    public String deleteUser(){
        return "delete user";
    }
}

数据响应

数据响应，一般分两个类型：

• 响应页面
• 响应数据

响应数据的格式可以是json,xml,io流等。

SpringMVC支持返回值

Thymeleaf模板引擎

SpringBoot默认不支持 JSP，需要引入第三方模板引擎技术实现页面渲染。

官网：https://www.thymeleaf.org/

---

个人博客关于Thymeleaf的总结:

https://blog.csdn.net/weixin_46350177/article/details/121431056

前端显示页面，是html页面。我们以前开发，做的是jsp页面，jsp可以动态渲染一些数据在页面上，可以写Java代码。JSP+Servlet+JavaBean，是我们很早之前就不用了，企业也用得少。

现在SpringBoot推荐Thymeleaf模板引擎。

基本语法

表达式名字	语法	用途
变量取值	${…}	获取请求域、session域、对象等值
选择变量	*{…}	获取上下文对象值
消息	#{…}	获取国际化等值
链接	@{…}	生成链接
片段表达式	~{…}	jsp:include 作用，引入公共页面片段

<!-- 常用标签，一般都是  th:XXX -->
<!-- 需要设置头部(非标准HTML5 规范)，也可以不设置 -->
<html xmlns:th="http://www.thymeleaf.org">
<!-- 不设置头部的写法（符合HTML5规范） -->
<p data-th-text="${msg}">msg</p>
<!--设置文本-->
<p th:text="${msg}">提醒消息</p>
<!--设置文本-->
<a th:href="@{href}">超链接</a>
<!-- 设置属性值 -->
<input type="text" th:id="${student.id}" />
<!-- 获取session -->
<p th:id="${#session.user}" />

基本使用

1、添加thymeleaf依赖,如下:

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

2、创建文件，springboot帮我们配置好了。源码如下:

所以我们直接开发前端页面即可,然后将页面放入:resources目录下的templates文件夹中！！

示例前端页面如下: 在templates下新建thymeleaf.html:

<!doctype html>
<html>
<head>
    <meta charset="UTF-8">
    <meta name="viewport"
          content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
</head>
<body>
    <h1 data-th-text="${msg}">提醒消息</h1>
    <h2>
        <a data-th-href="${link}">超连接</a>
    </h2>
</body>
</html>

3、编写后端接口

//@Controller和@RestController都是标识该类是否可以处理HTTP请求
//@RestController//不会跳转页面,只会返回字符串
@Controller//这个注解才会跳转页面
public class IndexController {
    @GetMapping("/thymeleaf")
    public String index(Model model) {
        model.addAttribute("msg","hello thymeleaf");
        model.addAttribute("link","www.baidu.com");
        // 返回视图层
        //若是@RestController,return这里返回的仅仅就是字符串
        //若是@Controller,return这里返回的就是对应的页面的前缀/名字
        return "thymeleaf";
    }
}

效果:

---

登录功能+拦截器

例子：访问项目，需要登录，如果没有登录就不能访问。

1、添加登录页面。login.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>LOGIN</title>
    <style>
        * {
            margin: 0;
            padding: 0;
        }
        html {
            height: 100%;
        }
        body {
            height: 100%;
        }
        .container {
            height: 100%;
            background-image: linear-gradient(to right, #fbc2eb, #a6c1ee);
        }
        .login-wrapper {
            background-color: #fff;
            width: 358px;
            height: 588px;
            border-radius: 15px;
            padding: 0 50px;
            position: relative;
            left: 50%;
            top: 50%;
            transform: translate(-50%, -50%);
        }
        .header {
            font-size: 38px;
            font-weight: bold;
            text-align: center;
            line-height: 200px;
        }
        .input-item {
            display: block;
            width: 100%;
            margin-bottom: 20px;
            border: 0;
            padding: 10px;
            border-bottom: 1px solid rgb(128, 125, 125);
            font-size: 15px;
            outline: none;
        }
        .input-item:placeholder {
            text-transform: uppercase;
        }
        .btn {
            border: 0;
            font-size: 20px;
            text-align: center;
            padding: 10px;
            width: 100%;
            margin-top: 40px;
            background-image: linear-gradient(to right, #a6c1ee, #fbc2eb);
            color: #fff;
        }
        .msg {
            color:red;
            text-align: center;
            line-height: 88px;
        }
        a {
            text-decoration-line: none;
            color: #abc1ee;
        }
    </style>
</head>
<body>
<div class="container">
    <div class="login-wrapper">
        <div class="header">Login</div>
        <div class="form-wrapper">
            <form data-th-action="@{/login}" method="post">
                <input type="text" name="username" placeholder="username" class="input-item" /  >
                <input type="password" name="password" placeholder="password" class="input-item" />
                <input type="submit" class="btn" value="Login" />
            </form>
        </div>
        <div class="msg" data-th-text="${msg}">
            Don't have account?
            <a href="#">Sign up</a>
        </div>
    </div>
</div>
</body>
</html>

2、添加后端的登录接口。

@Controller
public class LoginController {
    @GetMapping("/")
    public String index() {
        // 返回视图层
        return "/login/login";
    }
    @PostMapping("/login")
    public String login(String username, String password, HttpSession session, Model model) {
        if(StringUtils.hasLength(username) && "123456".equals(password)){
            //把登陆成功的用户保存起来
            session.setAttribute("loginUserName",username);
            //登录成功重定向到 thymeleaf ;  重定向防止表单重复提交
            return "redirect:/thymeleaf";
        }else {
            model.addAttribute("msg","账号密码错误");
            //回到登录页面
            return "/";
        }
    }
}

3、添加拦截器。

继承HandlerInterceptor 接口。

@Slf4j
public class LoginInterceptor implements HandlerInterceptor {
    /**
     * 目标方法执行之前
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 请求路径 request.getRequestURI();
        //登录检查逻辑
        HttpSession session = request.getSession();
        Object loginUser = session.getAttribute("loginUserName");
        if(loginUser != null){
            //放行
            return true;
        }
        //拦截住。未登录。跳转到登录页
        request.setAttribute("msg","请先登录");
        // 跳转
        request.getRequestDispatcher("/").forward(request,response);
        return false;
    }
}

4、配置拦截器

@Configuration
public class AdminWebConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LoginInterceptor())
                // 所有请求都被拦截包括静态资源
                .addPathPatterns("/**")
                // 放行的请求
                .excludePathPatterns("/","/login","/css/**","/fonts/**","/images/**","/js/**");
    }
}

测试：

异常处理

错误处理

• 默认情况下，Spring Boot提供/error处理所有错误的映射
• 对于浏览器客户端，响应一个“ whitelabel”错误视图，以HTML格式呈现相同的数据
• 对于机器客户端，它将生成JSON响应，其中包含错误，HTTP状态和异常消息的详细信息。

SpringBoot也为我们提供了自定义错误页的功能。

自定义错误页的话可以在静态路径(如 /static/ ）下的error目录。或放在模板目录(如 /templates/ )下的error目录，都会被SpringBootz自动解析。

其中文件名要和错误代码保持一致!

---

数据库

数据库连接

1、添加jdbc的启动器依赖，其会自动导入有关数据库连接的额外依赖

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

查看其源码发现,添加jdbc启动器依赖后,里面同时包含了一个数据库连接池依赖:

2、添加数据库驱动。

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

查看其源码,查看其默认的Mysql驱动的版本是多少?

所以我们也可以手动修改mysql驱动的版本,操作如下:

<!-- 方法一，直接在依赖的下面写版本 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.49</version>
</dependency>

<!-- 方法二、重新声明版本（maven的属性的就近优先原则）-->
<properties>
    <mysql.version>5.1.49</mysql.version>
</properties>

3、修改SpringBoot项目配置文件的相关配置项:

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/sp_boot_demo
    username: root
    password: root
    driver-class-name: com.mysql.cj.jdbc.Driver

4、编写程序进行测试:

@SpringBootTest
class DemoApplicationTests {
    @Autowired(required = false)
    JdbcTemplate jdbcTemplate;//Springboot已经配置好模板bean,拿来即用,CRUD
    @Test
    void contextLoads() {
        String sql = "select count(*) from sys_user";
        Long totle = jdbcTemplate.queryForObject(sql, Long.class);
        System.out.println(totle);
    }
}

数据库连接池

1、什么是数据库连接池
就是一个容器持有多个数据库连接，当程序需要操作数据库的时候直接从池中取出连接，使用完之后再还回去，和线程池一个道理。

注意:

数据源是连接到数据库的一类路径，它包含了访问数据库的信息(地址、用户名、密码)。

---

数据源就像是排水管道.

Springboot默认支持4种数据源类型

1. org.apache.tomcat.jdbc.pool.DataSource
2. com.zaxxer.hikari.HikariDataSource
3. org.apache.commons.dbcp.BasicDataSource
4. org.apache.commons.dbcp2.BasicDataSource

2、为什么需要连接池，好处是什么？

• 节省资源，如果每次访问数据库都创建新的连接，创建和销毁都浪费系统资源

• 响应性更好，省去了创建的时间，响应性更好。

• 统一管理数据库连接，避免因为业务的膨胀导致数据库连接的无限增多。

• 便于监控。

3、都有哪些连接池实现方案

1、C3p0

这个连接池我很久之前看到过，但是当时自己还很弱小，并没有很好的理解，现在用的也很少了，爷爷级的连接池，可以忽略

2、DBCP (Database Connection Pool)

这个名字很直白，数据库连接池，从Tomcat 5.5开始，Tomcat 内置了DBCP的数据源实现，所以可以非常方便地配置DBCP数据源。

3、Druid

阿里开源的数据源，Druid能够提供强大的监控和扩展功能，强项在于监控。

4、HiKariCP

号称最快的数据库连接池，springboot2.0 也已经把默认的数据源改为了HikariCP，强于性能。

---

4、连接池需要关注的参数

例:

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName" value="${db.driverClassName}"/>
<property name="url" value="${db.url}"/>
<property name="username" value="${db.username}"/>
<property name="password" value="${db.password}"/>
<property name="initialSize" value="5"/>
<property name="maxIdle" value="10"/>
<property name="minIdle" value="5"/>
<property name="maxActive" value="15"/>
<property name="removeAbandoned" value="true"/>
<property name="removeAbandonedTimeout" value="180"/>
<property name="maxWait" value="3000"/>
<property name="validationQuery">
<value>SELECT 1</value>
</property>
<property name="testOnBorrow">
<value>true</value>
</property>
</bean>

1、driverClassName 使用的JDBC驱动的完整有效的Java类名,如连接 mysql com.mysql.cj.jdbc.Driver

2、jdbcUrl 数据库的连接。如 jdbc:mysql://127.0.0.1:3306/mydatabase

3、username 你懂的，数据库的用户名，如 root

4、password 太直白了 ，数据库的用户密码，如 p123456

5、initialSize 连接池创建的时候，自动创建的数据库连接数量，建议 10-50足够

6、maxIdle 最大空闲连接:连接池中允许保持空闲状态的最大连接数量,超过的空闲连接将被释放,如果设置为负数表示不限制，建议设置和 与initialSize相同，减少释放和创建的性能损耗。

7、minIdle 最小空闲连接:连接池中容许保持空闲状态的最小连接数量,低于这个数量将创建新的连接,如果设置为0则不创建

8、maxActive 最大同时激活的连接数量。

9、maxWait 如果连接池中没有可用的连接，最大的等待时间，超时则没有可用连接，单位毫秒，设置-1时表示无限等待，建议设置为100毫秒

10、testxxx 在对连接进行操作时，是否检测连接的有效性，如 testOnBorrow 在申请连接的时候会先检测连接的有效性，执行validationQuery ，建议线上的把此配置设置为false，因为会影响性能。

连接池和线程池的道理是一样的，池化资源，降低生成和销毁的损耗，提高系统的响应。

---

---

使用Druid数据源

druid官方github地址： https://github.com/alibaba/druid

Java程序很大一部分要操作数据库，为了提高操作数据库性能，又不得不使用数据库连接池。

Druid 是阿里巴巴开源平台上一个数据库连接池实现，结合了 C3P0、DBCP 等 DB 池的优点，同时加入了日志监控。

Spring Boot 2.0 以上默认使用 Hikari 数据源，可以说 Hikari 与 Driud 都是当前 Java Web 上最优秀的数据源，我们来重点介绍 Spring Boot 如何集成 Druid 数据源，如何实现数据库监控。

Druid相对于其他数据库连接池有着强大的监控特性，通过监控特性可以清楚知道连接池和SQL的工作情况。

Druid基本配置参数如下：

入门demo:

1、添加依赖

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.1.17</version>
</dependency>

2、在SpringBoot的配置文件中添加配置:

SpringBoot配置示例 ：https://github.com/alibaba/druid/tree/master/druid-spring-boot-starter

配置项列表： https://github.com/alibaba/druid/wiki/DruidDataSource%E9%85%8D%E7%BD%AE%E5%B1%9E%E6%80%A7%E5%88%97%E8%A1%A8

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/sp_boot_demo
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource
    
    
    druid:
      aop-patterns: com.atguigu.admin.*  #监控SpringBean
      filters: stat,wall     # 底层开启功能，stat（sql监控），wall（防火墙）
      stat-view-servlet:   # 配置监控页功能
        enabled: true
        login-username: admin
        login-password: admin
        resetEnable: false
      web-stat-filter:  # 监控web
        enabled: true
        urlPattern: /*
        exclusions: '*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*'
      filter:
        stat:    # 对上面filters里面的stat的详细配置
          slow-sql-millis: 1000
          logSlowSql: true
          enabled: true
        wall:
          enabled: true
          config:
            drop-table-allow: false

3、测试:

访问：http://localhost:8080/druid/login.html

---

整合MyBatis操作

github地址：https://github.com/mybatis/spring-boot-starter

SpringBoot配置文档：https://github.com/mybatis/spring-boot-starter/blob/master/mybatis-spring-boot-autoconfigure/src/site/zh/markdown/index.md

配置xml文件模式

1、添加启动器依赖:

<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.2.1</version>
</dependency>

2、在SpringBoot配置文件中增加配置:

# 配置mybatis规则
mybatis:
  #sql映射文件位置
  #mapper-locations: classpath:/mappers/*.xml #冒号后有/,代表从项目根目录
  mapper-locations: classpath:mappers/*.xml #冒号后没有/,代表类路径

3、测试添加mapper接口:

@Mapper//这个注解表示这是一个mybatis的mapper类：Dao
//a.将Mapper接口（如StudentMapper）交给Spring进行管理。
//b.不需要写Mapper接口的xml映射文件。
//c.为Mapper接口（如StudentMapper）生成一个实现类，让其他的类进行引用。
public interface UserMapper {
    public List<SysUser> userList();
}

4、一般在resources目录下新建mapper文件夹,再在其中添加UserMapper.xml配置文件:

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.demo.mapper.UserMapper">
    <select id="userList" resultType="com.example.demo.entity.SysUser">
        SELECT * FROM `sys_user`
    </select>
</mapper>

5、编写测试程序:

@SpringBootTest
class DemoApplicationTests {
    @Autowired
    UserMapper userMapper;
    @Test
    void contextLoads() {
        List<SysUser> sysUsers = userMapper.userList();
        System.out.println(sysUsers);
    }
}

结果:

---

使用注解模式

@Mapper
public interface UserMapper {
    public List<SysUser> userList();
    // 采用注释
    @Select("SELECT * FROM `sys_user` where id=#{id}")
    public SysUser getById(Long id);
}

测试结果：

SysUser user = userMapper.getById(1L);
System.out.println(user);

---

总结:

• 简单方法/sql语句直接使用注解方式进行开发
• 复杂方法/sql语句编写mapper.xml进行绑定映射进行开发

---

创作不易!!感谢观看!!