【编程不良人】快速入门SpringBoot学习笔记06---RestFul、异常处理、CORS跨域、Jasypt加密

痛定思痛。 2023-10-09 14:26 32阅读 0赞

### 1. RestFul ###

**配套视频：**[【编程不良人】2021年SpringBoot最新最全教程\_哔哩哔哩\_bilibili][2021_SpringBoot_bilibili]

#### 1.1 引言 ####

![acf6b372449b40988b2c3788bbd830db.png][]

REST全称是`(Resources) Representational State Transfer`，中文意思是表述（编者注：通常译为表征）性状态转移。 它首次出现在2000年Roy Fielding的博士论文中，Roy Fielding是HTTP规范的主要编写者之一。 他在论文中提到："我这篇文章的写作目的，就是想在符合架构原理的前提下，理解和评估以网络为基础的应用软件的架构设计，得到一个功能强、性能好、适宜通信的架构。REST指的是一组架构约束条件和原则。" 如果一个架构符合REST的约束条件和原则，我们就称它为RESTful架构。

REST本身并没有创造新的技术、组件或服务，而隐藏在RESTful背后的理念就是使用Web的现有特征和能力， 更好地使用现有Web标准中的一些准则和约束。虽然REST本身受Web技术的影响很深， 但是理论上REST架构风格并不是绑定在HTTP上，只不过目前HTTP是唯一与REST相关的实例。 所以我们这里描述的REST也是通过HTTP实现的REST。

web开发：实现所有功能

restful：软件设计风格---标准、简洁、层次、优雅，基于rest设计原则和约束的架构被称之为restFul。

**总结：**

*  Rest 词：没有更新的技术、组件、服务，但能让web请求能够利用web中的标准和能力更好的描述架构。
 *  RestFul: 是一种以网络为基础构架的一种架构风格， 符合Rest设计原则和约束的架构被称为RestFul。
 *  Restful 一种软件架构风格、设计风格，而**不是**标准，只是提供了一组设计原则和约束条件。它主要用于客户端和服务器交互类的软件。基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存等机制。

#### 1.2 URL定义 ####

*  资源：互联网所有的事物都可以被抽象为资源
    
     *  一首歌、一张图片、数据库一条记录等
 *  资源操作：使用POST(添加)、DELETE(删除)、PUT(修改)、GET(查询)，使用不同请求方法对资源进行操作。
    
     *  删除 delete
     *  查询 get
     *  添加 post
     *  修改 put (修改全部字段)| patch(更新部分字段)

#### 1.3 传统方式操作资源 ####

*  [http://127.0.0.1/item/queryUser.action?id=1][http_127.0.0.1_item_queryUser.action_id_1] 查询,GET
 *  [http://127.0.0.1/item/saveUser.action][http_127.0.0.1_item_saveUser.action] 新增,POST
 *  [http://127.0.0.1/item/updateUser.action][http_127.0.0.1_item_updateUser.action] 更新,PUT
 *  [http://127.0.0.1/item/deleteUser.action?id=1][http_127.0.0.1_item_deleteUser.action_id_1] 删除,DELETE

**注意：**传统的操作是没有问题的，但大神认为是有问题的，有什么问题呢？你每次请求的接口或者地址,都在做描述，例如查询的时候用了queryUser，新增的时候用了saveUser，修改的时候用了updateUser，其实完全没有这个必要，我使用了get请求就是查询、使用post请求就是新增的请求、PUT就是修改、delete就是删除，我的意图很明显，完全没有必要做描述，这就是为什么有了restful。

#### 1.4 使用RESTful操作资源 ####

*  【GET】 /users \# 查询用户信息列表
 *  【GET】 /users/1001 \# 查看某个用户信息

*  【POST】 /users \# 新建用户信息

*  【PUT】 /users/1001 \# 更新用户信息(全部字段)

*  【PATCH】 /users/1001 \# 更新用户信息(部分字段)

*  【DELETE】 /users/1001 \# 删除用户信息

#### 1.5 Rest API设计风格原则 ####

# 1.使用名词而不是动词
     - 不要使用：
         如:
         /getAllUsers    get          /users 、 get /users/002
         /createNewUser  post         /users
         /deleteAllUser  delete       /users 、delete /users/001
         /updateUser     put|patch    /users 、patch  /users/001
     
     # 2.Get方法和查询参数不应该涉及状态改变
     - 使用PUT,POST和DELETE方法 而不是GET方法来改变状态，不要使用GET进行状态改变
     
     # 3.使用复数名词
     - 不要混淆名词单数和复数，为了保持简单，只对所有资源使用复数，如:
         /cars     而不是 /car
         /users    而不是 /user
         /products 而不是 /product
         /settings 而不是 /setting
         /orders   而不是 /order
             
     # 4. 使用子资源表达关系
     - 如果一个资源与另外一个资源有关系，使用子资源，如:
         GET /cars/711/drivers/  返回 car 711的所有司机
         GET /cars/711/drivers/4 返回 car 711的4号司机
         GET /users/11/pets      返回 user 11的所有宠物
         GET /users/11/pets/2    返回 user 11的2号宠物
     
     # 5.使用Http头声明序列化格式
     - 在客户端和服务端双方都要知道通讯的格式，格式在HTTP-Header中指定，如:
         Content-Type：定义请求格式
         Accept：定义系列可接受的响应格式
     
     # 6.为集合提供过滤排序选择和分页等功能
     - Filtering过滤：使用唯一的查询参数进行
         GET /cars?color=red 返回红色的cars
         GET /cars?seats<=2 返回小于两座位的cars集合
     
     - Sorting排序：允许针对多个字段排序
         GET /cars?sort=-manufactorer,+model
         这是返回根据生产者降序和模型升序排列的car集合
     
     - Field selection
         移动端能够显示其中一些字段，它们其实不需要一个资源的所有字段，给API消费者一个选择字段的能力，这会降低网络流量，提高API可用性。
         GET /cars?fields=manufacturer,model,id,color
         
     - Paging分页
         使用limit和offset.实现分页，缺省时，limit=20和offset=0；
         GET /cars?offset=10&limit=5
         为了将总数发给客户端，使用订制的HTTP头： X-Total-Count.
         链接到下一页或上一页可以在HTTP头的link规定，遵循Link规定:
         Link: <https://blog.mwaysolutions.com/sample/api/v1/cars?offset=15&limit=5>; 
         rel="next",<https://blog.mwaysolutions.com/sample/api/v1/cars?offset=50&limit=3>; 
         rel="last",<https://blog.mwaysolutions.com/sample/api/v1/cars?offset=0&limit=5>; 
         rel="first",<https://blog.mwaysolutions.com/sample/api/v1/cars?offset=5&limit=5>; 
         rel="prev",
     
     # 7.版本化你的API  支付宝  v1  v2   v3
     - 使得API版本变得强制性，不要发布无版本的API，使用简单数字，避免小数点，如：2.5.
       一般在Url后面使用?v，如：/blog/api/v1
     
     # 8. 使用Http状态码处理错误
     - 如果你的API没有错误处理是很难的，只是返回500和出错堆栈不一定有用
     - Http状态码提供70个出错，我们只要使用10个左右：
       `200 – OK – 一切正常
       `201 – OK – 新的资源已经成功创建
       `204 – OK – 资源已经成功删除
       `304 – Not Modified – 客户端使用缓存数据
       `400 – Bad Request – 请求无效，需要附加细节解释如 "JSON无效"
       `401 – Unauthorized – 请求需要用户验证
       `403 – Forbidden – 服务器已经理解了请求，但是拒绝服务或这种请求的访问是不允许的。
       `404 – Not found – 没有发现该资源
       `422 – Unprocessable Entity – 只有服务器不能处理实体时使用，比如图像不能被格式化，或者重要字段丢失。
       `500 – Internal Server Error – API开发者应该避免这种错误。
     使用详细的错误包装错误：状态码、数据、header头信息
     {
       "errors": [
        {
         "userMessage": "Sorry, the requested resource does not exist",
         "internalMessage": "No car found in the database",
         "code": 34,
         "more info": "http://dev.mwaysolutions.com/blog/api/v1/errors/12345"
        }
       ]
     }

#### 1.6 Rest API案例 ####

新建Spring Initializr、引入Spring Web的项目spring-boot-day8

> 创建实体类User

package com.study.entity;
     
     import java.util.Date;
     
     /**
      * @ClassName User
      * @Description TODO
      * @Author Jiangnan Cui
      * @Date 2022/6/29 16:13
      * @Version 1.0
      */
     public class User {
         private Integer id;
         private String name;
         private Double salary;
         private Date birthday;
     
         public User() {
         }
     
         public User(Integer id, String name, Double salary, Date birthday) {
             this.id = id;
             this.name = name;
             this.salary = salary;
             this.birthday = birthday;
         }
     
         public Integer getId() {
             return id;
         }
     
         public void setId(Integer id) {
             this.id = id;
         }
     
         public String getName() {
             return name;
         }
     
         public void setName(String name) {
             this.name = name;
         }
     
         public Double getSalary() {
             return salary;
         }
     
         public void setSalary(Double salary) {
             this.salary = salary;
         }
     
         public Date getBirthday() {
             return birthday;
         }
     
         public void setBirthday(Date birthday) {
             this.birthday = birthday;
         }
     
         @Override
         public String toString() {
             return "User{" +
                     "id=" + id +
                     ", name='" + name + '\'' +
                     ", salary=" + salary +
                     ", birthday=" + birthday +
                     '}';
         }
     }

> 创建实体类Pet

package com.study.entity;
     
     /**
      * @ClassName Pet
      * @Description TODO
      * @Author Jiangnan Cui
      * @Date 2022/6/29 17:48
      * @Version 1.0
      */
     public class Pet {
         private Integer id;
         private String name;
         private Integer age;
     
         public Pet() {
         }
     
         public Pet(Integer id, String name, Integer age) {
             this.id = id;
             this.name = name;
             this.age = age;
         }
     
         public Integer getId() {
             return id;
         }
     
         public void setId(Integer id) {
             this.id = id;
         }
     
         public String getName() {
             return name;
         }
     
         public void setName(String name) {
             this.name = name;
         }
     
         public Integer getAge() {
             return age;
         }
     
         public void setAge(Integer age) {
             this.age = age;
         }
     
         @Override
         public String toString() {
             return "Pet{" +
                     "id=" + id +
                     ", name='" + name + '\'' +
                     ", age=" + age +
                     '}';
         }
     }

> 创建控制器UserController

package com.study.controller.v1;
     
     import com.study.entity.User;
     import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
     import org.springframework.web.bind.annotation.*;
     
     import java.util.Date;
     
     /**
      * @ClassName UserController
      * @Description TODO
      * @Author Jiangnan Cui
      * @Date 2022/6/29 16:16
      * @Version 1.0
      */
     @RestController //专用于restful风格的注解=@Controller + @ResponseBody
                     //@Controller：专用于传统开发的注解
     @RequestMapping("/v1/users") //符合使用名词复数形式
     public class UserController {
         
         //新建日志对象
         private static final Logger logger = LoggerFactory.getLogger(UserController.class);
     
         /**
          * @MethodName findUserById
          * @Description 根据id查询某个用户的详细信息
          * @param: id
          * @return: com.study.entity.User
          * @Author Jiangnan Cui
          * @Date 16:28 2022/6/29
          */
         //@RequestMapping(value = "/{id}",method = RequestMethod.GET) 此种方式太繁琐，推荐使用下面这种
         @GetMapping("/{id}") //@RequestMapping的子类注解，使用GetMapping时只能使用GET方式访问当前请求
         //@ResponseBody //将控制器方法返回值转换为json格式
         //@PathVariable：在路径中获取请求参数
         public User findUserById(@PathVariable("id") Integer id){
             logger.info("本次id：{}",id);
             return new User(id,"小崔",1234.56,new Date());
         }
     }

> 测试路径：[http://localhost:8080/v1/users/1][http_localhost_8080_v1_users_1]

![0634cd4f4bfd4ba9a4527712f94854a5.png][]

**配套视频：**[【编程不良人】2021年SpringBoot最新最全教程\_哔哩哔哩\_bilibili][2021_SpringBoot_bilibili 1]

> **安装Postman进行测试：**[Download Postman | Get Started for Free][Download Postman _ Get Started for Free] (访问官网后自动识别版本，下载后双击打开即安装完毕)

![6f38599f18484af9a8e61c1ccbda3ba9.png][]

package com.study.controller.v1;
     
     import com.study.entity.Pet;
     import com.study.entity.User;
     import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
     import org.springframework.web.bind.annotation.*;
     
     import java.util.ArrayList;
     import java.util.Arrays;
     import java.util.Date;
     import java.util.List;
     
     /**
      * @ClassName UserController
      * @Description TODO
      * @Author Jiangnan Cui
      * @Date 2022/6/29 16:16
      * @Version 1.0
      */
     @RestController //专用于restful风格的注解=@Controller + @ResponseBody
                     //@Controller：专用于传统开发的注解
     @RequestMapping("/v1/users") //符合使用名词复数形式
     public class UserController {
         //新建日志对象
         private static final Logger logger = LoggerFactory.getLogger(UserController.class);
     
         /**
          * @MethodName findUserById
          * @Description 根据id查询某个用户的详细信息
          * @param: id
          * @return: com.study.entity.User
          * @Author Jiangnan Cui
          * @Date 16:28 2022/6/29
          */
         //@RequestMapping(value = "/{id}",method = RequestMethod.GET) 此种方式太繁琐，推荐使用下面这种
         @GetMapping("/{id}") //@RequestMapping的子类注解，使用GetMapping时只能使用GET方式访问当前请求
         //@ResponseBody //将控制器方法返回值转换为json格式
         //@PathVariable：在路径中获取请求参数
         public User findUserById(@PathVariable("id") Integer id){
             logger.info("本次id：{}",id);
             return new User(id,"小崔",1234.56,new Date());
         }
     
         /**
          * @MethodName findAllUser
          * @Description 查询所有用户信息
          * @return: java.util.List<com.study.entity.User>
          * @Author Jiangnan Cui
          * @Date 17:24 2022/6/29
          */
         @GetMapping
         //@ResponseBody
         public List<User> findAllUser(){
             ArrayList<User> users = new ArrayList<>();
             users.add(new User(1,"张三",1000.00,new Date()));
             users.add(new User(2,"李四",2000.00,new Date()));
             users.add(new User(3,"王五",3000.00,new Date()));
             return users;
         }
     
         /**
          * @MethodName addUser
          * @Description 新增用户信息
          * @param: user
          * @Author Jiangnan Cui
          * @Date 17:28 2022/6/29
          */
         @PostMapping
         //@ResponseBody //将方法的返回值转化为json格式，并响应请求
         //@RequestBody: 接收请求的json格式数据，将json格式数据转化为对象
         public void addUser(@RequestBody User user){
             logger.info("name:{},salary:{},birthday:{}",user.getName(),user.getSalary(),user.getBirthday());
             //调用业务方法
     
         }
     
         /**
          * @MethodName updateUser
          * @Description 更新用户信息
          * @param: user
          * @Author Jiangnan Cui
          * @Date 17:30 2022/6/29
          */
         @PutMapping("/{id}")
         //@ResponseBody
         public void updateUser(@PathVariable("id") Integer id,@RequestBody User user){
             logger.info("id:{},name:{},salary:{},birthday:{}",id,user.getName(),user.getSalary(),user.getBirthday());
             //调用业务方法
     
         }
     
         /**
          * @MethodName deleteUser
          * @Description 删除用户信息
          * @param: id
          * @Author Jiangnan Cui
          * @Date 17:32 2022/6/29
          */
         @DeleteMapping("/{id}")
         @ResponseBody
         public void deleteUser(@PathVariable("id") Integer id){
             logger.info("本次删除用户的id：{}",id);
         }
     
         /**
          * @MethodName findPetById
          * @Description 根据宠物id查询主人的一个宠物
          * @param: id
          * @param: petId
          * @return: com.study.entity.Pet
          * @Author Jiangnan Cui
          * @Date 17:54 2022/6/29
          */
         @GetMapping("/{id}/pets/{petId}")
         public Pet findPetById(@PathVariable("id") Integer id,@PathVariable("petId") Integer petId){
             logger.info("宠物主人的id：{}",id);
             logger.info("宠物id：{}",petId);
             return new Pet(1,"小灰灰",5);
         }
     
         /**
          * @MethodName findAllPet
          * @Description 查询主人的所有宠物
          * @param: id
          * @return: java.util.List<com.study.entity.Pet>
          * @Author Jiangnan Cui
          * @Date 17:57 2022/6/29
          */
         @GetMapping("/{id}/pets")
         public List<Pet> findAllPet(@PathVariable("id") Integer id){
             logger.info("宠物主人的id：{}",id);
             List<Pet> pets = Arrays.asList(
                     new Pet(1,"熊大",20),
                     new Pet(2,"熊二",10),
                     new Pet(3,"光头强",50)
             );
             return pets;
         }
     
     }

**测试路径：**

（1）[http://localhost:8080/v1/users][http_localhost_8080_v1_users]

![d04d6ecff9144580b8df353a47dc46a9.png][]

（2）[http://localhost:8080/v1/users][http_localhost_8080_v1_users]

![e0abdb5decff428d94a6a951408e54b0.png][]

（3)[http://localhost:8080/v1/users/1][http_localhost_8080_v1_users_1]

![4a0ae9b5b72c407a9c4a0fb6f11fcda7.png][]

（4）[http://localhost:8080/v1/users/1][http_localhost_8080_v1_users_1]

![fded3e5e38674331bfab3d0f7ee89a0a.png][]

（5）[http://localhost:8080/v1/users/1/pets/1][http_localhost_8080_v1_users_1_pets_1]

![d4b61e18d21f4c19b544e95e0fca0b94.png][]

（6）[http://localhost:8080/v1/users/1/pets][http_localhost_8080_v1_users_1_pets]

![386aee30fff84a6c919e5d3880bb2e02.png][]

> **RestFul标准版：**利用RestFul响应类ResponseEntity和状态码HttpStatus优化UserController
> 
>  *  ResponseEntity：SpringMVC封装的一个专用于RestFul的响应类，这个类在响应时可以提供响应的状态码，同时还可以自定义响应头信息。
>  *  HttpStatus：SpringMVC封装的一个枚举类型，这个类中都是网络中状态码

package com.study.controller.v1;
     
     import com.study.entity.Pet;
     import com.study.entity.User;
     import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
     import org.springframework.http.HttpStatus;
     import org.springframework.http.ResponseEntity;
     import org.springframework.web.bind.annotation.*;
     
     import java.util.ArrayList;
     import java.util.Arrays;
     import java.util.Date;
     import java.util.List;
     
     /**
      * @ClassName UserController
      * @Description TODO
      * @Author Jiangnan Cui
      * @Date 2022/6/29 16:16
      * @Version 1.0
      */
     @RestController //专用于restful风格的注解=@Controller + @ResponseBody
                     //@Controller：专用于传统开发的注解
     @RequestMapping("/v1/users") //符合使用名词复数形式
     public class UserController {
         //新建日志对象
         private static final Logger logger = LoggerFactory.getLogger(UserController.class);
     
         /**
          * 补充：
          * 1.ResponseEntity：SpringMVC封装的一个专用于RestFul的响应类，这个类在响应时可以提供响应的状态码，
          *   同时还可以自定义响应头信息。
          * 2.HttpStatus：SpringMVC封装的一个枚举类型，这个类中都是网络中状态码
          */
     
         /**
          * @MethodName findUserById
          * @Description 根据id查询某个用户的详细信息
          * @param: id
          * @return: com.study.entity.User
          * @Author Jiangnan Cui
          * @Date 16:28 2022/6/29
          */
         //@RequestMapping(value = "/{id}",method = RequestMethod.GET) 此种方式太繁琐，推荐使用下面这种
         @GetMapping("/{id}") //@RequestMapping的子类注解，使用GetMapping时只能使用GET方式访问当前请求
         //@ResponseBody //将控制器方法返回值转换为json格式
         //@PathVariable：在路径中获取请求参数
         public ResponseEntity<User> findUserById(@PathVariable("id") Integer id){
             logger.info("本次id：{}",id);
             User user = new User(id, "小崔", 1234.56, new Date());
             return new ResponseEntity<>(user, HttpStatus.OK);
         }
     
         /**
          * @MethodName findAllUser
          * @Description 查询所有用户信息
          * @return: java.util.List<com.study.entity.User>
          * @Author Jiangnan Cui
          * @Date 17:24 2022/6/29
          */
         @GetMapping
         //@ResponseBody
         public ResponseEntity<List<User>> findAllUser(){
             ArrayList<User> users = new ArrayList<>();
             users.add(new User(1,"张三",1000.00,new Date()));
             users.add(new User(2,"李四",2000.00,new Date()));
             users.add(new User(3,"王五",3000.00,new Date()));
             return new ResponseEntity<>(users,HttpStatus.OK);
         }
     
         /**
          * @MethodName addUser
          * @Description 新增用户信息
          * @param: user
          * @Author Jiangnan Cui
          * @Date 17:28 2022/6/29
          */
         @PostMapping
         //@ResponseBody //将方法的返回值转化为json格式，并响应请求
         //@RequestBody: 接收请求的json格式数据，将json格式数据转化为对象
         public ResponseEntity<Void> addUser(@RequestBody User user){
             logger.info("name:{},salary:{},birthday:{}",user.getName(),user.getSalary(),user.getBirthday());
             //调用业务方法
             return new ResponseEntity<>(HttpStatus.NO_CONTENT);
         }
     
         /**
          * @MethodName updateUser
          * @Description 更新用户信息
          * @param: user
          * @Author Jiangnan Cui
          * @Date 17:30 2022/6/29
          */
         @PutMapping("/{id}")
         //@ResponseBody
         public ResponseEntity<Void> updateUser(@PathVariable("id") Integer id,@RequestBody User user){
             logger.info("id:{},name:{},salary:{},birthday:{}",id,user.getName(),user.getSalary(),user.getBirthday());
             //调用业务方法
             return new ResponseEntity<>(HttpStatus.NO_CONTENT);
         }
     
         /**
          * @MethodName deleteUser
          * @Description 删除用户信息
          * @param: id
          * @Author Jiangnan Cui
          * @Date 17:32 2022/6/29
          */
         @DeleteMapping("/{id}")
         @ResponseBody
         public void deleteUser(@PathVariable("id") Integer id){
             logger.info("本次删除用户的id：{}",id);
         }
     
         /**
          * @MethodName findPetById
          * @Description 根据宠物id查询主人的一个宠物
          * @param: id
          * @param: petId
          * @return: com.study.entity.Pet
          * @Author Jiangnan Cui
          * @Date 17:54 2022/6/29
          */
         @GetMapping("/{id}/pets/{petId}")
         public ResponseEntity<Pet> findPetById(@PathVariable("id") Integer id,@PathVariable("petId") Integer petId){
             logger.info("宠物主人的id：{}",id);
             logger.info("宠物id：{}",petId);
             Pet pet = new Pet(1, "小灰灰", 5);
             return new ResponseEntity<>(pet,HttpStatus.OK);
         }
     
         /**
          * @MethodName findAllPet
          * @Description 查询主人的所有宠物
          * @param: id
          * @return: java.util.List<com.study.entity.Pet>
          * @Author Jiangnan Cui
          * @Date 17:57 2022/6/29
          */
         @GetMapping("/{id}/pets")
         public ResponseEntity<List<Pet>> findAllPet(@PathVariable("id") Integer id){
             logger.info("宠物主人的id：{}",id);
             List<Pet> pets = Arrays.asList(
                     new Pet(1,"熊大",20),
                     new Pet(2,"熊二",10),
                     new Pet(3,"光头强",50)
             );
             return new ResponseEntity<>(pets,HttpStatus.OK);
         }
     }

> 再次启动服务，用Postman测试上面路径，从Postman中可以查看到相应状态码

![20b44708fe6b4a12b2699bba668597a7.png][]

#### 1.7 最终项目结构 ####

#### ![47886566572549e6b7e45ef3f2f63d7b.png][] ####

### 2. 异常处理 ###

#### 2.1 传统开发的异常处理 ####

**配套视频：**[【编程不良人】2021年SpringBoot最新最全教程\_哔哩哔哩\_bilibili][2021_SpringBoot_bilibili 2]

新建Spring Initializr、Spring Web项目

> pom.xml引入thymeleaf依赖

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

> 修改application.properties为application.yml，添加thymeleaf配置

# thymeleaf配置
     spring:
       thymeleaf:
         cache: false
         prefix: classpath:/templates/
         suffix: .html

> 新建hello.html

<!DOCTYPE html>
     <html lang="en">
     <head>
         <meta charset="UTF-8">
         <title>hello</title>
     </head>
     <body>
       <h1>Hello, SpringBoot!</h1>
     </body>
     </html>

> 新建MvcConfig配置类

package com.study.config;
     
     import org.springframework.context.annotation.Configuration;
     import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
     import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
     
     /**
      * @ClassName MvcConfig
      * @Description TODO
      * @Author Jiangnan Cui
      * @Date 2022/7/2 18:28
      * @Version 1.0
      */
     @Configuration //一定要添加此配置
     public class MvcConfig implements WebMvcConfigurer {
         @Override
         public void addViewControllers(ViewControllerRegistry registry) {
             //配置请求和页面视图映射，设置后可不经过页面直接访问html页面
             registry.addViewController("/hello")
                     .setViewName("hello");
         }
     }

> 新建DemoController

package com.study.controller;
     
     import com.study.exceptions.UserNameNotFoundException;
     import org.springframework.stereotype.Controller;
     import org.springframework.web.bind.annotation.RequestMapping;
     import org.springframework.web.bind.annotation.RestController;
     
     /**
      * @ClassName DemoController
      * @Description TODO
      * @Author Jiangnan Cui
      * @Date 2022/7/2 18:31
      * @Version 1.0
      */
     @Controller
     @RequestMapping("demo")
     public class DemoController {
         @RequestMapping("demo")
         public String demo(){
             System.out.println("demo ok...");
             int n = 1 / 0; //除零异常
             return "hello";
         }
     
         @RequestMapping("login")
         public String login(String username, String password){
             System.out.println("login...");
             System.out.println("username = " + username);
             System.out.println("password = " + password);
             if("xiaocui".equals(username) && "123456".equals(password)){
                 return "hello";
             }else{
                 throw new UserNameNotFoundException("用户名不正确！");
             }
         }
     
     }

> 新建500.html

<!DOCTYPE html>
     <html lang="en">
     <head>
         <meta charset="UTF-8">
         <title>500</title>
     </head>
     <body>
         <h1>系统内部错误，请稍后再试...</h1>
     </body>
     </html>

> 新建error.html

<!DOCTYPE html>
     <html lang="en">
     <head>
         <meta charset="UTF-8">
         <title>error</title>
     </head>
     <body>
       <h1>系统错误，用户名不正确！！！</h1>
     </body>
     </html>

> 自定义全局异常解析类GlobalExceptionResolver

package com.study.exceptions;
     
     import org.springframework.stereotype.Component;
     import org.springframework.web.servlet.HandlerExceptionResolver;
     import org.springframework.web.servlet.ModelAndView;
     
     import javax.servlet.http.HttpServletRequest;
     import javax.servlet.http.HttpServletResponse;
     
     /**
      * @ClassName GlobalExceptionResolver
      * @Description 全局异常解析类
      * @Author Jiangnan Cui
      * @Date 2022/7/2 18:59
      * @Version 1.0
      */
     @Component
     public class GlobalExceptionResolver implements HandlerExceptionResolver {
         /**
          * @MethodName resolveException
          * @Description 当控制器中任意一个方法出现异常时，如果该控制器的方法没有自己的异常处理（try-catch），
          *              则会进入当前方法
          * @param: request 当前请求对象
          * @param: response 当前响应对象
          * @param: handler 当前出现错误的方法对象
          * @param: ex 出现异常的异常对象
          * @return: org.springframework.web.servlet.ModelAndView 模型和视图
          * @Author Jiangnan Cui
          * @Date 19:00 2022/7/2
          */
         @Override
         public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
             System.out.println("这是全局异常处理...");
             System.out.println("当前异常为：" + ex);
             ModelAndView modelAndView = new ModelAndView();
     
             //针对不同异常类型跳转不同页面
             if(ex instanceof UserNameNotFoundException){
                 modelAndView.setViewName("error");
                 return modelAndView;
             }
             modelAndView.setViewName("500");
             return modelAndView;
         }
     }

> 自定义异常UserNameNotFoundException

package com.study.exceptions;
     
     /**
      * @ClassName UserNameNotFoundException
      * @Description 自定义异常：用户名不存在
      * @Author Jiangnan Cui
      * @Date 2022/7/2 18:54
      * @Version 1.0
      */
     public class UserNameNotFoundException extends RuntimeException{
         public UserNameNotFoundException(String message) {
             super(message);
         }
     }

> 测试路径：

（1）[http://localhost:8080/demo/demo][http_localhost_8080_demo_demo]

demo ok...
     这是全局异常处理...
     当前异常为：java.lang.ArithmeticException: / by zero

（2）[http://localhost:8080/demo/login?username=xiaozhu&password=123456][http_localhost_8080_demo_login_username_xiaozhu_password_123456]

login...
     username = xiaozhu
     password = 123456
     这是全局异常处理...
     当前异常为：com.study.exceptions.UserNameNotFoundException: 用户名不正确！

> 项目最终结构：

![fa1d1ca164be443db1e51c4a26186aee.png][]

#### 2.2 RestFul的异常处理 ####

**配套视频：**[【编程不良人】2021年SpringBoot最新最全教程\_哔哩哔哩\_bilibili][2021_SpringBoot_bilibili 3]

新建Spring Initializr、Spring Web项目spring-boot-day10

> pom.xml引入thymeleaf依赖

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

> application.properties重命名为application.yml，添加thymeleaf配置

spring:
       thymeleaf:
         prefix: classpath:/templates/
         suffix: .html
         cache: false

> 新建控制器DemoController

package com.study.controller;
     
     import com.study.exceptions.IllegalNumberException;
     import org.springframework.http.HttpStatus;
     import org.springframework.http.ResponseEntity;
     import org.springframework.web.bind.annotation.GetMapping;
     import org.springframework.web.bind.annotation.PathVariable;
     import org.springframework.web.bind.annotation.RequestMapping;
     import org.springframework.web.bind.annotation.RestController;
     
     /**
      * @ClassName DemoController
      * @Description TODO
      * @Author Jiangnan Cui
      * @Date 2022/7/2 22:06
      * @Version 1.0
      */
     @RestController
     @RequestMapping("demos")
     public class DemoController {
         /**
          * @MethodName demos
          * @Description 测试查询所有
          * @return: org.springframework.http.ResponseEntity<java.lang.String>
          * @Author Jiangnan Cui
          * @Date 22:08 2022/7/2
          */
         @GetMapping//测试路径：http://localhost:8080/demos
         public ResponseEntity<String> demos(){
             System.out.println("demo ok");
             return new ResponseEntity<>("demo ok", HttpStatus.OK);
         }
     
         /**
          * @MethodName demo
          * @Description 测试查询一个
          * @param: id
          * @return: org.springframework.http.ResponseEntity<java.lang.String>
          * @Author Jiangnan Cui
          * @Date 22:10 2022/7/2
          */
         @GetMapping("/{id}") //测试路径：http://localhost:8080/demos/1
         public ResponseEntity<String> demo(@PathVariable("id") Integer id){
             System.out.println("demo ok" + id);
             if(id<0)
                 throw new IllegalNumberException("无效id，请检查！");
             return new ResponseEntity<>("demo ok",HttpStatus.OK);
         }
     }

> 新建全局异常解析类GlobalExceptionResolver

package com.study.exceptions;
     
     import org.springframework.http.HttpStatus;
     import org.springframework.http.ResponseEntity;
     import org.springframework.web.bind.annotation.ControllerAdvice;
     import org.springframework.web.bind.annotation.ExceptionHandler;
     import org.springframework.web.bind.annotation.ResponseBody;
     
     /**
      * @ClassName GlobalExceptionResolver
      * @Description TODO
      * @Author Jiangnan Cui
      * @Date 2022/7/2 22:11
      * @Version 1.0
      */
     @ControllerAdvice
     public class GlobalExceptionResolver {
         //处理指定异常
         @ExceptionHandler(value = IllegalNumberException.class)
         @ResponseBody
         public ResponseEntity<String> IllegalNumberException(Exception ex){
             System.out.println("进入非法参数异常处理");
             return new ResponseEntity<>(ex.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
         }
     
         //处理Exception子类异常
         @ExceptionHandler(value = Exception.class)
         @ResponseBody
         public ResponseEntity<String> exceptionHandler(Exception ex){
             System.out.println("进入自定义异常处理");
             return new ResponseEntity<>(ex.getMessage(),HttpStatus.INTERNAL_SERVER_ERROR);
         }
     }

> 自定义异常IllegalNumberException

package com.study.exceptions;
     
     /**
      * @ClassName IllegalNumberException
      * @Description 自定义异常
      * @Author Jiangnan Cui
      * @Date 2022/7/2 22:17
      * @Version 1.0
      */
     public class IllegalNumberException extends RuntimeException{
         public IllegalNumberException(String message) {
             super(message);
         }
     }

> 测试路径：

（1）[http://localhost:8080/demos][http_localhost_8080_demos]

demo ok

![a8601aef820f4262b7cd262b36231dbc.png][]

（2）[http://localhost:8080/demos/1][http_localhost_8080_demos_1]

demo ok1

![f716e12905a547f390caba8cdfa3fc3a.png][]

（3）[http://localhost:8080/demos/0][http_localhost_8080_demos_0]

demo ok0

![6cc0d09fe36f488ea8bb485d605360c3.png][]

（4）[http://localhost:8080/demos/-1][http_localhost_8080_demos_-1]

demo ok-1
     进入非法参数异常处理

![827b93e93d534da7a71bf50c5fd2893c.png][]

> 项目结构

![617b986ee989432bab201da49bd3c16e.png][]

#### 2.3 总结 ####

1.开发方式演变
       a.传统方式开发 基于javaweb方式开发
         项目业务代码  +  view  写在一个项目中
         业务代码+view(jsp、thymeleaf、freemark)  
       b.前后端分离开发   前后端分离   天下
         前端系统(Vue)   
         ajax  异步请求
         后端系统(java) 接口  controller ===> 传统web方式 /user/findById?id=21 =====> GET POST PUT DELETE GET /users users/001(RestFul API)
     
     2.springboot异常处理
         异常处理: 
             当出现异常改如何处理====>当controller中方法在执行过程中如果出现异常,我们应该如何处理异常这种方式 称之为异常处理
         a.传统方式开发异常处理
             @Component
             public class GlobalExceptionResolver  implements HandlerExceptionResolver {
                 //resolveExcpetion: 当控制器中任意一个方法出现异常时,如果该控制器的方法没有自己异常处理(try...catch),则会进入当前方法
                 //注意:在异常处理这个方法中 完成自定义异常处理
                 //参数1: request 当前请求对象
                 //参数2: response 当前请求对应响应对象
                 //参数3: 当前出现错误的方法对象
                 //参数4: 出现异常的异常对象
                 //返回值: modelAndview 模型和视图
                 @Override
                 public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
                     System.out.println("这是全局异常处理....");
                     System.out.println("当前异常为: "+ex);
                     ModelAndView modelAndView = new ModelAndView();
     
                     //针对不同异常类型跳转不同页面
                     if(ex instanceof UserNameNotFoundException){
                         modelAndView.setViewName("error");
                         return modelAndView;
                     }
                     modelAndView.setViewName("500");
                     return modelAndView;
                 }
             }
     
         b.前后端分离开发异常处理
              ajax<------>controller
             @ControllerAdvice
             public class GlobalExceptionResolver {
                 //处理指定异常
                 @ExceptionHandler(value = IllegalNumberException.class)
                 @ResponseBody
                 public ResponseEntity<String> illegalNumberExceptionHandler(Exception ex) {
                     System.out.println("进入非法参数异常处理");
                     return new ResponseEntity<String>(ex.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
                 }
     
                 //处理exception子类异常
                 @ExceptionHandler(value = Exception.class) //用在方法上  作用:用来处理指定异常  value属性: 用来指定处理异常类型
                 @ResponseBody
                 public ResponseEntity<String> exceptionHandler(Exception ex) {
                     System.out.println("进入自定义异常处理");
                     return new ResponseEntity<>(ex.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
                 }
             }

### 3. CORS 跨域 ###

#### 3.1 CORS简介 ####

**配套视频：**[【编程不良人】2021年SpringBoot最新最全教程\_哔哩哔哩\_bilibili][2021_SpringBoot_bilibili 4]

**CORS**：`CORS是一个W3C标准，全称是"跨域资源共享"（Cross-origin resource sharing）`。它允许浏览器向跨源服务器，发出XMLHttpRequest(ajax)请求，从而克服了AJAX只能`同源使用的限制`。

**同源策略\[same origin policy\]**：是浏览器的一个安全功能，不同源的客户端脚本在没有明确授权的情况下，不能读写对方资源。同源策略是浏览器安全的基石。

**源\[origin\]**：就是协议、域名和端口号。例如：[百度一下，你就知道][Link 1]这个URL中：协议为http、域名为www.baidu.com、端口号为80。

**同源**：若地址里面的`协议、域名和端口号均相同`，则属于同源。

# 同源举例
     - 例如判断下面的URL是否与 http://www.a.com/test/index.html 同源
         http://www.a.com/dir/page.html --------->同源，协议、域名、端口号均相同
         http://www.child.a.com/test/index.html ->不同源，域名不相同
         https://www.a.com/test/index.html ------>不同源，协议不相同
         http://www.a.com:8080/test/index.html -->不同源，端口号不相同

**哪些操作不受同源限制：**

*  页面中的链接、重定向以及表单提交是不会受到同源策略限制的；
 *  跨域资源的引入是可以的，如嵌入到页面中的`<script src="..."></script>`，`<img>`，`<link>`，`<iframe>`等。

**哪些操作受到同源限制：**

*  在浏览器中发起一个AJAX请求，会受到同源策略限制，**`出现错误:Access-Control-Allow-Origin`**

![6608596fce474f208a987f92ba518523.png][]

**测试：**

> 新建cors.html

<!DOCTYPE html>
     <html lang="en">
     <head>
         <meta charset="UTF-8">
         <title>Title</title>
       <script>
         function test(){
           //1.创建xhr对象
           var xhr = new XMLHttpRequest();
     
           //1.5 处理结果
           xhr.onreadystatechange = function(){
             if(xhr.status==200 && xhr.readyState==4){
               console.log(xhr.responseText);
               document.getElementById("msg").innerText="返回结果为: "+xhr.responseText;
     
             }
           }
     
           //2.发送请求
           xhr.open("GET","http://localhost:8080/demos");
           xhr.send();
         }
       </script>
     </head>
     <body>
       <h1>cors跨域测试</h1>
       <input type="button" value="点我发送ajax请求" οnclick="test()">
       <h4 id="msg"></h4>
     </body>
     </html>

> 新建MvcConfig

package com.study.config;
     
     import org.springframework.context.annotation.Configuration;
     import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
     import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
     
     /**
      * @ClassName MvcConfig
      * @Description 配置后可不经过控制器直接访问html页面
      * @Author Jiangnan Cui
      * @Date 2022/7/3 10:08
      * @Version 1.0
      */
     @Configuration
     public class MvcConfig implements WebMvcConfigurer {
         @Override
         public void addViewControllers(ViewControllerRegistry registry) {
             registry.addViewController("/cors")
                     .setViewName("cors");
         }
     }

> 启动项目后，浏览器访问：[http://localhost:8080/cors][http_localhost_8080_cors]，可以正常访问，不存在跨域问题。

![190c0987afd24eba99fe4a53630497d4.png][]

> **使用IDEA内置的浏览器打开项目：**此时路径变成了[http://localhost:63342/spring-boot-day10/templates/cors.html?\_ijt=oru29oe9dkg5rkhii47uic36ig&\_ij\_reload=RELOAD\_ON\_SAVE][http_localhost_63342_spring-boot-day10_templates_cors.html_ijt_oru29oe9dkg5rkhii47uic36ig_ij_reload_RELOAD_ON_SAVE]，存在跨域问题。

![e9fd40127c954497ba7b5c51fbb020b7.png][]

####  ####

#### 3.2 Springboot中如何解决cors跨域问题 ####

**配套视频：**[【编程不良人】2021年SpringBoot最新最全教程\_哔哩哔哩\_bilibili][2021_SpringBoot_bilibili 5]

**以下两种方法使用其中一种即可：**

**（1）控制器类上添加@CrossOrigin注解**

package com.study.controller;
     
     import com.study.exceptions.IllegalNumberException;
     import org.springframework.http.HttpStatus;
     import org.springframework.http.ResponseEntity;
     import org.springframework.web.bind.annotation.*;
     
     /**
      * @ClassName DemoController
      * @Description TODO
      * @Author Jiangnan Cui
      * @Date 2022/7/2 22:06
      * @Version 1.0
      */
     @CrossOrigin //允许这个Controller中所有请求被其他域访问
     @RestController
     @RequestMapping("demos")
     public class DemoController {
         /**
          * @MethodName demos
          * @Description 测试查询所有
          * @return: org.springframework.http.ResponseEntity<java.lang.String>
          * @Author Jiangnan Cui
          * @Date 22:08 2022/7/2
          */
         @GetMapping//测试路径：http://localhost:8080/demos
         public ResponseEntity<String> demos(){
             System.out.println("demo ok");
             return new ResponseEntity<>("demo ok", HttpStatus.OK);
         }
     
         /**
          * @MethodName demo
          * @Description 测试查询一个
          * @param: id
          * @return: org.springframework.http.ResponseEntity<java.lang.String>
          * @Author Jiangnan Cui
          * @Date 22:10 2022/7/2
          */
         @GetMapping("/{id}") //测试路径：http://localhost:8080/demos/1
         public ResponseEntity<String> demo(@PathVariable("id") Integer id){
             System.out.println("demo ok" + id);
             if(id<0)
                 throw new IllegalNumberException("无效id，请检查！");
             return new ResponseEntity<>("demo ok",HttpStatus.OK);
         }
     }

**（2）全局解决跨域问题：编写cors全局配置类，对所有页面生效**

package com.study.config;
     
     import org.springframework.context.annotation.Bean;
     import org.springframework.context.annotation.Configuration;
     import org.springframework.web.cors.CorsConfiguration;
     import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
     import org.springframework.web.filter.CorsFilter;
     
     /**
      * @ClassName CorsConfig
      * @Description 全局配置解决跨域问题
      * @Author Jiangnan Cui
      * @Date 2022/7/3 10:35
      * @Version 1.0
      */
     @Configuration
     public class CorsConfig {
         @Bean
         public CorsFilter corsFilter(){
             UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
             CorsConfiguration corsConfiguration = new CorsConfiguration();
             corsConfiguration.addAllowedOrigin("*");//1.允许任何域名使用
             corsConfiguration.addAllowedHeader("*");//2.允许任何头使用
             corsConfiguration.addAllowedMethod("*");//3.允许任何方法使用(post、get等)
             source.registerCorsConfiguration("/**",corsConfiguration);//4.处理所有请求的跨域配置
             return new CorsFilter(source);
         }
     }

#### 3.3 总结 ####

1.什么是CORS
         定义: 跨域资源共享
     
     2.什么跨域资源共享
         结束: 允许浏览器可以从当前源服务器通过ajax访问另外一个源服务地址
     
     3.同源策略
         是浏览器的一个安全功能，不同源的客户端脚本在没有明确授权的情况下，不能读写对方资源。 同源策略是浏览器安全的基石   ajax请求
     
     4.什么是源 origin
         源[origin]就是协议、域名和端口号。例如：http://www.baidu.com:80这个URL。
         协议: http
         域名: www.baidu.com
         端口: 80
         url: http://www.baidu.com:80
         url: https://www.baidu.com:80 
         url: http://www.baizhiedu.com:80
         url: http://www.baidu.com:90
         测试:
             http://www.a.com/test/index.html
             1.http://www.a.com/dir/page.html            同源
             2.http://www.child.a.com/test/index.html    不同源
             3.https://www.a.com/test/index.html         不同源
             4.http://www.a.com:8080/test/index.html     不同源
     
     5.哪些操作不会受到同源限制
         1.<script src="..."></script>，<img>，<link>，<iframe>
     
     6.哪些操作会受到同源限制
         ajax
         出现跨域: Access-Control-Allow-Origin
     
     7.springboot中如何解决跨域问题?
         1.局部解决跨域
             @CrossOrigin: 这个注解用在类上  代表解决类中所有方法运行允许其他域中资源访问
         2.全局解决跨域
             @Configuration
             public class CorsConfig {
     
                 @Bean
                 public CorsFilter corsFilter() {
                     UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
                     CorsConfiguration corsConfiguration = new CorsConfiguration();
                     corsConfiguration.addAllowedOrigin("*"); // 1允许任何域名使用
                     corsConfiguration.addAllowedHeader("*"); // 2允许任何头
                     corsConfiguration.addAllowedMethod("*"); // 3允许任何方法（post、get等）
                     source.registerCorsConfiguration("/**", corsConfiguration);//4处理所有请求的跨域配置
                     return new CorsFilter(source);
                 }
             }

> 最终项目结构：

![8f3a60f91f294b6484b70bee9371f76d.png][]

### 4. Jasypt 加密 ###

**配套视频：**[【编程不良人】2021年SpringBoot最新最全教程\_哔哩哔哩\_bilibili][2021_SpringBoot_bilibili 6]

#### 4.1 引言 ####

Jasypt 也即Java Simplified Encryption是Sourceforge.net上的一个开源项目。在当地时间11月23号的通告中，Jasypt 1.4的新特征包括：加密属性文件（encryptable properties files）、Spring Framework集成、加密Hibernate数据源配置、新的命令行工具、URL加密的Apache wicket集成以及升级文档。

根据Jasypt文档，该技术可用于加密任务与应用程序，例如加密密码、敏感信息和数据通信、创建完整检查数据的sums. 其他性能包括高安全性、基于标准的加密技术、可同时单向和双向加密的加密密码、文本、数字和二进制文件。Jasypt也可以与Acegi Security整合也即Spring Security。Jasypt亦拥有加密应用配置的集成功能，而且提供一个开放的API从而任何一个Java Cryptography Extension都可以使用Jasypt。

Jasypt还符合RSA标准的基于密码的加密，并提供了无配置加密工具以及新的、高可配置标准的加密工具。

#### 4.2 SpringBoot整合Jasypt加密 ####

新建Spring Initializr、Spring Web的spring-boot-jasypt项目

*  **pom.xml引入依赖**

<dependency>
         <groupId>mysql</groupId>
         <artifactId>mysql-connector-java</artifactId>
         <version>5.1.38</version>
     </dependency>
     
     
     <dependency>
         <groupId>com.alibaba</groupId>
         <artifactId>druid</artifactId>
         <version>1.2.11</version>
     </dependency>
     
     
     <dependency>
         <groupId>org.mybatis.spring.boot</groupId>
         <artifactId>mybatis-spring-boot-starter</artifactId>
         <version>2.2.2</version>
     </dependency>
     
     
     <dependency>
         <groupId>com.github.ulisesbocchio</groupId>
         <artifactId>jasypt-spring-boot-starter</artifactId>
         <version>3.0.4</version>
     </dependency>

*  **修改application.properties为application.yml，编写如下配置：**

# 对主机名进行加密
     mysql:
       host: ENC(+Szc93CJDBbbOZShvgnUxeZiec3+Xc6BCKt2IFE9JdZy7kmy4NOk+xZAXcuT57So)
     
     # 数据库配置
     spring:
       datasource:
         type: com.alibaba.druid.pool.DruidDataSource
         driver-class-name: com.mysql.jdbc.Driver
         url: jdbc:mysql://${mysql.host}:3306/ems-thymeleaf?characterEncoding=UTF-8
         username: ENC(SAYP3WbR7jm0HYPlg3b9IWvMEZBBK+M8+rmDcFrwH8p+WNwxyYWkuZ1FvZztGELF)
         password: ENC(SAYP3WbR7jm0HYPlg3b9IWvMEZBBK+M8+rmDcFrwH8p+WNwxyYWkuZ1FvZztGELF)
     
     # mybatis配置
     mybatis:
       mapper-locations: classpath:com/study/mapper/*.xml
       type-aliases-package: com.study.entity
     
     # jasypt加密配置
     jasypt:
       encryptor:
         algorithm: PBEWITHHMACSHA512ANDAES_256 # 指定加密算法
         # password: 123456 # 指定秘钥，秘钥一般不能暴露在外面，需要单独设置 -Djasypt.encryptor.password=123456
                            # 打包运行时添加加密秘钥：nohuo java -jar -Djasypt.encryptor.password=123456 xxx.jar

*  **启动类添加注解扫描**

package com.study;
     
     import org.mybatis.spring.annotation.MapperScan;
     import org.springframework.boot.SpringApplication;
     import org.springframework.boot.autoconfigure.SpringBootApplication;
     
     @SpringBootApplication
     @MapperScan("com.study.dao")
     public class SpringBootJasyptApplication {
     
         public static void main(String[] args) {
             SpringApplication.run(SpringBootJasyptApplication.class, args);
         }
     
     }

*  **新建实体类User**

package com.study.entity;
     
     /**
      * @ClassName User
      * @Description TODO
      * @Author Jiangnan Cui
      * @Date 2022/7/3 11:43
      * @Version 1.0
      */
     public class User {
         private Integer id;
         private String username;
         private String realname;
         private String password;
         private Boolean gender;
     
         public User() {
         }
     
         public User(Integer id, String username, String realname, String password, Boolean gender) {
             this.id = id;
             this.username = username;
             this.realname = realname;
             this.password = password;
             this.gender = gender;
         }
     
         public Integer getId() {
             return id;
         }
     
         public void setId(Integer id) {
             this.id = id;
         }
     
         public String getUsername() {
             return username;
         }
     
         public void setUsername(String username) {
             this.username = username;
         }
     
         public String getRealname() {
             return realname;
         }
     
         public void setRealname(String realname) {
             this.realname = realname;
         }
     
         public String getPassword() {
             return password;
         }
     
         public void setPassword(String password) {
             this.password = password;
         }
     
         public Boolean getGender() {
             return gender;
         }
     
         public void setGender(Boolean gender) {
             this.gender = gender;
         }
     
         @Override
         public String toString() {
             return "User{" +
                     "id=" + id +
                     ", username='" + username + '\'' +
                     ", realname='" + realname + '\'' +
                     ", password='" + password + '\'' +
                     ", gender=" + gender +
                     '}';
         }
     }

*  **新建UserDAO**

package com.study.dao;
     
     import com.study.entity.User;
     
     import java.util.List;
     
     /**
      * @ClassName UserDAO
      * @Description TODO
      * @Author Jiangnan Cui
      * @Date 2022/7/3 11:45
      * @Version 1.0
      */
     public interface UserDAO {
         /**
          * @MethodName findAll
          * @Description 查询所有
          * @return: java.util.List<com.study.entity.User>
          * @Author Jiangnan Cui
          * @Date 11:45 2022/7/3
          */
         List<User> findAll();
     }

*  **新建UserDAOMapper**

<?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.study.dao.UserDAO">
       
       <select id="findAll" resultType="User">
         select
             id,username,realname,password,gender
         from `user`
       </select>
     </mapper>

*  **新建UserService**

package com.study.service;
     
     import com.study.entity.User;
     import org.springframework.stereotype.Service;
     
     import java.util.List;
     
     /**
      * @ClassName UserService
      * @Description TODO
      * @Author Jiangnan Cui
      * @Date 2022/7/3 11:47
      * @Version 1.0
      */
     public interface UserService {
         /**
          * @MethodName findAll
          * @Description 查询所有
          * @return: java.util.List<com.study.entity.User>
          * @Author Jiangnan Cui
          * @Date 11:48 2022/7/3
          */
         List<User> findAll();
     }

*  **新建UserServiceImpl**

package com.study.service;
     
     import com.study.dao.UserDAO;
     import com.study.entity.User;
     import org.springframework.beans.factory.annotation.Autowired;
     import org.springframework.stereotype.Service;
     import org.springframework.transaction.annotation.Transactional;
     
     import java.util.List;
     
     /**
      * @ClassName UserServiceImpl
      * @Description TODO
      * @Author Jiangnan Cui
      * @Date 2022/7/3 11:48
      * @Version 1.0
      */
     @Service
     @Transactional
     public class UserServiceImpl implements UserService{
         private UserDAO userDAO;
         @Autowired
         public UserServiceImpl(UserDAO userDAO) {
             this.userDAO = userDAO;
         }
     
         @Override
         public List<User> findAll() {
             return userDAO.findAll();
         }
     }

*  **新建UserController**

package com.study.controller;
     
     import com.study.entity.User;
     import com.study.service.UserService;
     import org.springframework.beans.factory.annotation.Autowired;
     import org.springframework.http.HttpStatus;
     import org.springframework.http.ResponseEntity;
     import org.springframework.web.bind.annotation.GetMapping;
     import org.springframework.web.bind.annotation.RequestMapping;
     import org.springframework.web.bind.annotation.RestController;
     
     import java.util.List;
     
     /**
      * @ClassName UserController
      * @Description TODO
      * @Author Jiangnan Cui
      * @Date 2022/7/3 11:50
      * @Version 1.0
      */
     @RestController
     @RequestMapping("/users")
     public class UserController {
         private UserService userService;
         @Autowired
         public UserController(UserService userService) {
             this.userService = userService;
         }
     
         @GetMapping
         public ResponseEntity<List<User>> users(){
             List<User> users = userService.findAll();
             return new ResponseEntity<>(users, HttpStatus.OK);
         }
     }

*  **测试Jasypt加密算法**

package com.study;
     
     import org.jasypt.encryption.StringEncryptor;
     import org.junit.jupiter.api.Test;
     import org.springframework.beans.factory.annotation.Autowired;
     import org.springframework.boot.test.context.SpringBootTest;
     
     /**
      * @ClassName JasyptTest
      * @Description TODO
      * @Author Jiangnan Cui
      * @Date 2022/7/3 11:59
      * @Version 1.0
      */
     @SpringBootTest
     public class JasyptTest {
         private StringEncryptor stringEncryptor;
         @Autowired
         public JasyptTest(StringEncryptor stringEncryptor) {
             this.stringEncryptor = stringEncryptor;
         }
     
         @Test
         public void test(){
             for (int i = 0; i < 10; i++) {
                 String root = stringEncryptor.encrypt("root");
                 System.out.println("root = " + root);
             }
         }
     
         @Test
         public void test1(){
             //加密
             String localhost = stringEncryptor.encrypt("localhost");
             System.out.println("localhost = " + localhost);
             //解密
             String decrypt = stringEncryptor.decrypt("+Szc93CJDBbbOZShvgnUxeZiec3+Xc6BCKt2IFE9JdZy7kmy4NOk+xZAXcuT57So");
             System.out.println("decrypt = " + decrypt);
         }
         
     }

**注意：**启动前配置好秘钥参数：-Djasypt.encryptor.password=123456

![6f150ab00d0946b4a1e486931327ff5e.png][]

*  **启动项目进行测试**：测试前配置传递秘钥参数，测试路径：[http://localhost:8080/users][http_localhost_8080_users]

![5a138e25a2134c53baa70f7d3357c22f.png][]

![6d483bfe80eb4c45bf68f96911286bc8.png][]

*  **最终项目结构：**

![c732ab670a6a40548029f8dfa59b1942.png][]

#### 4.3 总结 ####

1.原理
      引入jasypt依赖
    2.使用
      （1）类 =====> root + 秘钥(暴露) =====>    加密之后结果 每一次运行都会生成一个新的加密结果    每个加密结果都是可用
      （2）加密之后结果 ====> 类.方法 秘钥 =====> root

###  ###

### SpringBoot完结！ ###

[2021_SpringBoot_bilibili]: https://www.bilibili.com/video/BV1Cv411p7cQ?p=47
[acf6b372449b40988b2c3788bbd830db.png]: https://img-blog.csdnimg.cn/acf6b372449b40988b2c3788bbd830db.png
[http_127.0.0.1_item_queryUser.action_id_1]: http://127.0.0.1/item/queryUser.action?id=1
[http_127.0.0.1_item_saveUser.action]: http://127.0.0.1/item/saveUser.action
[http_127.0.0.1_item_updateUser.action]: http://127.0.0.1/item/updateUser.action
[http_127.0.0.1_item_deleteUser.action_id_1]: http://127.0.0.1/item/deleteUser.action?id=1
[http_localhost_8080_v1_users_1]: http://localhost:8080/v1/users/1
[0634cd4f4bfd4ba9a4527712f94854a5.png]: https://img-blog.csdnimg.cn/0634cd4f4bfd4ba9a4527712f94854a5.png
[2021_SpringBoot_bilibili 1]: https://www.bilibili.com/video/BV1Cv411p7cQ?p=48
[Download Postman _ Get Started for Free]: https://www.postman.com/downloads/
[6f38599f18484af9a8e61c1ccbda3ba9.png]: https://img-blog.csdnimg.cn/6f38599f18484af9a8e61c1ccbda3ba9.png
[http_localhost_8080_v1_users]: http://localhost:8080/v1/users
[d04d6ecff9144580b8df353a47dc46a9.png]: https://img-blog.csdnimg.cn/d04d6ecff9144580b8df353a47dc46a9.png
[e0abdb5decff428d94a6a951408e54b0.png]: https://img-blog.csdnimg.cn/e0abdb5decff428d94a6a951408e54b0.png
[4a0ae9b5b72c407a9c4a0fb6f11fcda7.png]: https://img-blog.csdnimg.cn/4a0ae9b5b72c407a9c4a0fb6f11fcda7.png
[fded3e5e38674331bfab3d0f7ee89a0a.png]: https://img-blog.csdnimg.cn/fded3e5e38674331bfab3d0f7ee89a0a.png
[http_localhost_8080_v1_users_1_pets_1]: http://localhost:8080/v1/users/1/pets/1
[d4b61e18d21f4c19b544e95e0fca0b94.png]: https://img-blog.csdnimg.cn/d4b61e18d21f4c19b544e95e0fca0b94.png
[http_localhost_8080_v1_users_1_pets]: http://localhost:8080/v1/users/1/pets
[386aee30fff84a6c919e5d3880bb2e02.png]: https://img-blog.csdnimg.cn/386aee30fff84a6c919e5d3880bb2e02.png
[20b44708fe6b4a12b2699bba668597a7.png]: https://img-blog.csdnimg.cn/20b44708fe6b4a12b2699bba668597a7.png
[47886566572549e6b7e45ef3f2f63d7b.png]: https://img-blog.csdnimg.cn/47886566572549e6b7e45ef3f2f63d7b.png
[2021_SpringBoot_bilibili 2]: https://www.bilibili.com/video/BV1Cv411p7cQ?p=49
[http_localhost_8080_demo_demo]: http://localhost:8080/demo/demo
[http_localhost_8080_demo_login_username_xiaozhu_password_123456]: http://localhost:8080/demo/login?username=xiaozhu&password=123456
[fa1d1ca164be443db1e51c4a26186aee.png]: https://img-blog.csdnimg.cn/fa1d1ca164be443db1e51c4a26186aee.png
[2021_SpringBoot_bilibili 3]: https://www.bilibili.com/video/BV1Cv411p7cQ?p=50
[http_localhost_8080_demos]: http://localhost:8080/demos
[a8601aef820f4262b7cd262b36231dbc.png]: https://img-blog.csdnimg.cn/a8601aef820f4262b7cd262b36231dbc.png
[http_localhost_8080_demos_1]: http://localhost:8080/demos/1
[f716e12905a547f390caba8cdfa3fc3a.png]: https://img-blog.csdnimg.cn/f716e12905a547f390caba8cdfa3fc3a.png
[http_localhost_8080_demos_0]: http://localhost:8080/demos/0
[6cc0d09fe36f488ea8bb485d605360c3.png]: https://img-blog.csdnimg.cn/6cc0d09fe36f488ea8bb485d605360c3.png
[http_localhost_8080_demos_-1]: http://localhost:8080/demos/-1
[827b93e93d534da7a71bf50c5fd2893c.png]: https://img-blog.csdnimg.cn/827b93e93d534da7a71bf50c5fd2893c.png
[617b986ee989432bab201da49bd3c16e.png]: https://img-blog.csdnimg.cn/617b986ee989432bab201da49bd3c16e.png
[2021_SpringBoot_bilibili 4]: https://www.bilibili.com/video/BV1Cv411p7cQ?p=51
[Link 1]: http://www.baidu.com
[6608596fce474f208a987f92ba518523.png]: https://img-blog.csdnimg.cn/6608596fce474f208a987f92ba518523.png
[http_localhost_8080_cors]: http://localhost:8080/cors
[190c0987afd24eba99fe4a53630497d4.png]: https://img-blog.csdnimg.cn/190c0987afd24eba99fe4a53630497d4.png
[http_localhost_63342_spring-boot-day10_templates_cors.html_ijt_oru29oe9dkg5rkhii47uic36ig_ij_reload_RELOAD_ON_SAVE]: http://localhost:63342/spring-boot-day10/templates/cors.html?_ijt=oru29oe9dkg5rkhii47uic36ig&_ij_reload=RELOAD_ON_SAVE
[e9fd40127c954497ba7b5c51fbb020b7.png]: https://img-blog.csdnimg.cn/e9fd40127c954497ba7b5c51fbb020b7.png
[2021_SpringBoot_bilibili 5]: https://www.bilibili.com/video/BV1Cv411p7cQ?p=52
[8f3a60f91f294b6484b70bee9371f76d.png]: https://img-blog.csdnimg.cn/8f3a60f91f294b6484b70bee9371f76d.png
[2021_SpringBoot_bilibili 6]: https://www.bilibili.com/video/BV1Cv411p7cQ?p=53
[6f150ab00d0946b4a1e486931327ff5e.png]: https://img-blog.csdnimg.cn/6f150ab00d0946b4a1e486931327ff5e.png
[http_localhost_8080_users]: http://localhost:8080/users
[5a138e25a2134c53baa70f7d3357c22f.png]: https://img-blog.csdnimg.cn/5a138e25a2134c53baa70f7d3357c22f.png
[6d483bfe80eb4c45bf68f96911286bc8.png]: https://img-blog.csdnimg.cn/6d483bfe80eb4c45bf68f96911286bc8.png
[c732ab670a6a40548029f8dfa59b1942.png]: https://img-blog.csdnimg.cn/c732ab670a6a40548029f8dfa59b1942.png