Spring Boot简明教程之数据访问（二）：JPA(超详细)

超、凢脫俗 2022-05-10 09:38 293阅读 0赞

# Spring Boot简明教程之数据访问（二）：JPA(超详细) #

### 文章目录 ###

*  Spring Boot简明教程之数据访问（二）：JPA(超详细)
 *   *  创建项目
     *  Spring Data简介
     *  JPA简介
     *  Spring Data 与JPA
     *  使用Spring Data JPA的基本流程
     *   *  创建实体类（entity）
         *  创建Dao层（Repository）
         *  编写配置文件
         *  创建Controller
     *  JPA常用注解说明
     *  自定义查询
     *   *  关键字查询
         *  自定义SQL语句
         *   *  原生SQL
             *  JPQL查询
     *  复杂查询
     *   *  分页查询
         *  限制查询
     *  常见问题及其解决方案：
     *  总结
     *  源码地址
     *  联系作者

## 创建项目 ##

创建的过程和我们的第一篇文章：[SpringBoot简明教程之快速创建第一个SpringBoot应用][SpringBoot_SpringBoot]大致相同，差别只是我们在挑选所需要的组件时，除了Web组件外，我们需要添加如下三个组件：`JPA、MySQL、JDBC`

![在这里插入图片描述][70]

或者，我们按照第一次创建完成后，手动在pom.xml文件中加入以下配置：

<dependency>
    	<groupId>org.springframework.boot</groupId>
    	<artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
    	<groupId>org.springframework.boot</groupId>
    	<artifactId>spring-boot-starter-jdbc</artifactId>
    </dependency>
    <dependency>
    <dependency>
    	<groupId>mysql</groupId>
    	<artifactId>mysql-connector-java</artifactId>
    	<scope>runtime</scope>
    </dependency>

我们发现，与我们直接使用JDBC template不同的是，这次我们引入了一个新的包：`spring-boot-starter-data-jpa`,我们进一步查看，就会发现，其主要是引入了一个`spring-data-jpa`的包。

![在这里插入图片描述][70 1]

## Spring Data简介 ##

Spring Data是为了简化构建基于 Spring 框架应用的数据访问技术，包括关系、非关系数据库、  
云数据服务等等。SpringData为我们提供使用统一的API来对数据访问层进行操作，让我们在使用关系型或者非关系型数据访问技术时都基于Spring提供的统一标准，标准包含了CRUD（创建、获取、更新、删除）、查询、  
排序和分页的相关操作，同时为我们提供了统一的数据访问类的模板，例如：MongoTemplate、RedisTemplate等。

## JPA简介 ##

JPA（Java Persistence API）定义了一系列对象持久化的标准，它的出现主要是为了简化现有的持久化开发工作和整合 ORM 技术，目前实现了这一规范的有 Hibernate、TopLink、JDO 等 ORM 框架。

## Spring Data 与JPA ##

我们可以将Spring-data-jpa理解为Spring Boot对于JPA的再次封装，使得我们通过Spring-data-jpa即实现常用的数据库操作：

*  JpaRepository实现基本功能: 编写接口继承JpaRepository既有crud及分页等基本功能
 *  定义符合规范的方法命名: 在接口中只需要声明符合规范的方法，即拥有对应的功能
 *  支持自定义查询： @Query自定义查询，定制查询SQL
 *  Specifications查询（Spring Data JPA支持JPA2.0的Criteria查询）

## 使用Spring Data JPA的基本流程 ##

### 创建实体类（entity） ###

package cn.newtol.springboot07.entity;
    import javax.persistence.*;
    
    /**
     * @Author: 公众号：Newtol
     * @Description:  JPA使用示例:使用JPA注解配置映射关系
     * @Date: Created in 18:45 2018/9/24
     */
    
    @Entity   //表示一个实体类，和数据表进行映射
    @Table(name = "t_user")   //所映射的表的名字，可省略，默认为实体类名
    public class User {
        
    
    
        @Id //设置为主键
        @GeneratedValue(strategy = GenerationType.IDENTITY) //定义为自增主键
        private Integer id;
    
        @Column(name = "t_name",nullable = false)  //设置该字段在数据表中的列名,并设置该字段设置为不可为空
        private String name;
    
        @Column     //默认则字段名就为属性名
        private Integer phone;
    
        @Transient   //增加该注解，则在数据表中不会进行映射
        private String address;
        
        // //省略getter settet方法、构造方法，创建时自行补上
    }

### 创建Dao层（Repository） ###

package cn.newtol.springboot07.repository;
    
    import cn.newtol.springboot07.entity.User;
    import org.springframework.data.jpa.repository.JpaRepository;
    
    /**
     * @Author: 公众号：Newtol
     * @Description:
     * @Date: Created in 19:35 2018/9/24
     */
    //定义为接口
    public interface UserRepository extends JpaRepository<User,Integer>{
        
    	//直接继承即可，不用编写任何方法
    }

### 编写配置文件 ###

spring:
      datasource:
        driver-class-name: com.mysql.jdbc.Driver
        url: jdbc:mysql://localhost:3306/springboot?useSSL=false
        username: root
        password:
    
      jpa:
        hibernate:
          ddl-auto: create
        show-sql: true

### 创建Controller ###

package cn.newtol.springboot07.controller;
    
    import cn.newtol.springboot07.entity.User;
    import cn.newtol.springboot07.repository.UserRepository;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RestController;
    import java.util.Optional;
    
    /**
     * @Author: 公众号：Newtol
     * @Description:
     * @Date: Created in 19:37 2018/9/24
     */
    
    
    @RestController
    public class UserController {
        
    
        @Autowired
        UserRepository userRepository;
    
        //根据Id查询用户
        @GetMapping("/user/{id}")
        public User getUser(@PathVariable("id") Integer id){
        
            User user = userRepository.getOne(id);
            return user;
        }
    
        //插入用户
        @GetMapping("/user")
        public User addUser(User user){
        
            userRepository.save(user);
            return user;   //返回插入的对象及其自增ID
        }
    }

直接启动项目，看到Spring Boot自动帮我们在数据库中自动创建了t\_user表：

![在这里插入图片描述][70 2]

并且因为我们之前对`address`属相使用了@Transient注解，不进行映射，所以我们看到表中没有`address`字段。现在我们将@Transient注释后，再次启动项目：

![在这里插入图片描述][70 3]

`address`就也被成功的创建。

接着，我们尝试着往数据库中插入一条数据，我们在浏览器中输入：`localhost:8080/user?name=zhangsan&phone=123&address=beijing`

![在这里插入图片描述][70 4]

再到数据库中进行查看：

![在这里插入图片描述][70 5]  
插入成功。

现在我们来查询刚刚插入的数据,浏览器输入：`http://localhost:8080/user/1`

![在这里插入图片描述][70 6]

成功查询到刚才插入的数据,并且我们可以在控制台看到Spring Boot为我们打印的刚才执行的查询语句：

![在这里插入图片描述][70 7]

## JPA常用注解说明 ##

虽然我们在上面的示例中已经使用了常用了的注解，但是为了方便和理解，我们在这个地方归纳一下关于JPA的一些常用的注解及其对应的参数。

*  @Entity：表示该类是一个的实体类。@Entity标注是必需的 ，name属性为可选；需要注意的是：@Entity标注的实体类至少需要有一个无参的构造方法。
 *  @Table：表示该实体类所映射的数据表信息，需要标注在类名前，不能标注在方法或属性前。参数如下：
    
    <table> 
     <thead> 
      <tr> 
       <th>参数</th> 
       <th>说明</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td>name</td> 
       <td>实体所对应表的名称，默认表名为实体名</td> 
      </tr> 
      <tr> 
       <td>catalog</td> 
       <td>实体指定的目录名</td> 
      </tr> 
      <tr> 
       <td>schema</td> 
       <td>表示实体指定的数据库名</td> 
      </tr> 
      <tr> 
       <td>uniqueConstraints</td> 
       <td>该实体所关联的唯一约束条件，一个实体可以有多个唯一的约束，默认没有约束条件。创建方式：uniqueConstraints = {@uniqueConstraint（columnNames = {“name”,“phone”}）}</td> 
      </tr> 
      <tr> 
       <td>indexes</td> 
       <td>该实体所关联的索引。创建方式：indexes = { @Index(name = “index_name”, columnList = “t_name”)}</td> 
      </tr> 
     </tbody> 
    </table>
 *  @Column：表示该属性所映射的字段，此标记可以标注在Getter方法或属性前。它有如下参数：
    
    <table> 
     <thead> 
      <tr> 
       <th>参数</th> 
       <th>说明</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td>unique</td> 
       <td>字段是否为唯一标识，默认为false</td> 
      </tr> 
      <tr> 
       <td>nullable</td> 
       <td>字段是否可以为null值，默认为true</td> 
      </tr> 
      <tr> 
       <td>insertable</td> 
       <td>使用“INSERT” SQL语脚本插入数据时，是否需要插入该字段的值。</td> 
      </tr> 
      <tr> 
       <td>updatable</td> 
       <td>使用“UPDATE”脚本插入数据时，是否需要更新该字段的值</td> 
      </tr> 
      <tr> 
       <td>table</td> 
       <td>当映射多个表时，指定表中的字段。默认值为主表的表名。</td> 
      </tr> 
      <tr> 
       <td>length</td> 
       <td>当字段的类型为varchar时的字段的长度，默认为255个字符。</td> 
      </tr> 
      <tr> 
       <td>precision</td> 
       <td>用于表示精度，数值的总长度</td> 
      </tr> 
      <tr> 
       <td>scale</td> 
       <td>用于表示精度，小数点后的位数。</td> 
      </tr> 
      <tr> 
       <td>columnDefinition</td> 
       <td>用于创建表时添加该字段所需要另外执行的SQL语句</td> 
      </tr> 
     </tbody> 
    </table>
 *  @Id：表示该属性为主键，每一个实体类至少要有一个主键（Primary key）。
    
    <table> 
     <thead> 
      <tr> 
       <th>参数</th> 
       <th>说明</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td>strategy</td> 
       <td>表示生成主键的策略 ，有4种类型：GenerationType.TABLE 、 GenerationType.SEQUENCE 、 GenerationType.IDENTITY 、 GenerationType.AUTO 默认为：AUTO，表示自动生成。</td> 
      </tr> 
      <tr> 
       <td>generator</td> 
       <td>生成规则名，不同的策略有不同的配置</td> 
      </tr> 
     </tbody> 
    </table>
 *  @Basic： 实体属性设置加载方式为惰性加载
    
    <table> 
     <thead> 
      <tr> 
       <th>参数</th> 
       <th>说明</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td>fetch</td> 
       <td>表示获取值的方式，它的值定义的枚举型，可选值为LAZY（惰性加载）、EAGER（即时加载），默认为即时加载。</td> 
      </tr> 
      <tr> 
       <td>optional</td> 
       <td>属性是否可以为null，不能用于java基本数据型（ byte、int、short、long、boolean、char、float、double ）</td> 
      </tr> 
     </tbody> 
    </table>

## 自定义查询 ##

我们刚刚在上面使用的是JPA已经封装好的一些默认的查询方式，但是我们在实际的项目中，可能需要自定义一些符合实际需求的查询，那么我们就需要用到**自定义查询**。

### 关键字查询 ###

JPA已经帮我们做好了关键字，我们只需要将这些关键字组成方法名，就可以实现相对应的查询。

<table> 
 <thead> 
  <tr> 
   <th>关键字</th> 
   <th>示例</th> 
   <th>同功能JPQL</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>And</code></td> 
   <td><code>findByLastnameAndFirstname</code></td> 
   <td><code>where x.lastname = ?1 and x.firstname = ?2</code></td> 
  </tr> 
  <tr> 
   <td><code>Or</code></td> 
   <td><code>findByLastnameOrFirstname</code></td> 
   <td><code>where x.lastname = ?1 or x.firstname = ?2</code></td> 
  </tr> 
  <tr> 
   <td><code>Is,Equals</code></td> 
   <td><code>findByFirstname,findByFirstnameIs,findByFirstnameEquals</code></td> 
   <td><code>where x.firstname = 1?</code></td> 
  </tr> 
  <tr> 
   <td><code>Between</code></td> 
   <td><code>findByStartDateBetween</code></td> 
   <td><code>where x.startDate between 1? and ?2</code></td> 
  </tr> 
  <tr> 
   <td><code>LessThan</code></td> 
   <td><code>findByAgeLessThan</code></td> 
   <td><code>where x.age &lt; ?1</code></td> 
  </tr> 
  <tr> 
   <td><code>LessThanEqual</code></td> 
   <td><code>findByAgeLessThanEqual</code></td> 
   <td><code>where x.age &lt;= ?1</code></td> 
  </tr> 
  <tr> 
   <td><code>GreaterThan</code></td> 
   <td><code>findByAgeGreaterThan</code></td> 
   <td><code>where x.age &gt; ?1</code></td> 
  </tr> 
  <tr> 
   <td><code>GreaterThanEqual</code></td> 
   <td><code>findByAgeGreaterThanEqual</code></td> 
   <td><code>where x.age &gt;= ?1</code></td> 
  </tr> 
  <tr> 
   <td><code>After</code></td> 
   <td><code>findByStartDateAfter</code></td> 
   <td><code>where x.startDate &gt; ?1</code></td> 
  </tr> 
  <tr> 
   <td><code>Before</code></td> 
   <td><code>findByStartDateBefore</code></td> 
   <td><code>where x.startDate &lt; ?1</code></td> 
  </tr> 
  <tr> 
   <td><code>IsNull</code></td> 
   <td><code>findByAgeIsNull</code></td> 
   <td><code>where x.age is null</code></td> 
  </tr> 
  <tr> 
   <td><code>IsNotNull,NotNull</code></td> 
   <td><code>findByAge(Is)NotNull</code></td> 
   <td><code>where x.age not null</code></td> 
  </tr> 
  <tr> 
   <td><code>Like</code></td> 
   <td><code>findByFirstnameLike</code></td> 
   <td><code>where x.firstname like ?1</code></td> 
  </tr> 
  <tr> 
   <td><code>NotLike</code></td> 
   <td><code>findByFirstnameNotLike</code></td> 
   <td><code>where x.firstname not like ?1</code></td> 
  </tr> 
  <tr> 
   <td><code>StartingWith</code></td> 
   <td><code>findByFirstnameStartingWith</code></td> 
   <td><code>where x.firstname like ?1</code> (参数前面加 %)</td> 
  </tr> 
  <tr> 
   <td><code>EndingWith</code></td> 
   <td><code>findByFirstnameEndingWith</code></td> 
   <td><code>where x.firstname like ?1</code> (参数后面加 %)</td> 
  </tr> 
  <tr> 
   <td><code>Containing</code></td> 
   <td><code>findByFirstnameContaining</code></td> 
   <td><code>where x.firstname like ?1</code> (参数两边加 %)</td> 
  </tr> 
  <tr> 
   <td><code>OrderBy</code></td> 
   <td><code>findByAgeOrderByLastnameDesc</code></td> 
   <td><code>where x.age = ?1 order by x.lastname desc</code></td> 
  </tr> 
  <tr> 
   <td><code>Not</code></td> 
   <td><code>findByLastnameNot</code></td> 
   <td><code>where x.lastname &lt;&gt; ?1</code></td> 
  </tr> 
  <tr> 
   <td><code>In</code></td> 
   <td><code>findByAgeIn(Collection&lt;Age&gt; ages)</code></td> 
   <td><code>where x.age in ?1</code></td> 
  </tr> 
  <tr> 
   <td><code>NotIn</code></td> 
   <td><code>findByAgeNotIn(Collection&lt;Age&gt; age)</code></td> 
   <td><code>where x.age not in ?1</code></td> 
  </tr> 
  <tr> 
   <td><code>True</code></td> 
   <td><code>findByActiveTrue()</code></td> 
   <td><code>where x.active = true</code></td> 
  </tr> 
  <tr> 
   <td><code>False</code></td> 
   <td><code>findByActiveFalse()</code></td> 
   <td><code>where x.active = false</code></td> 
  </tr> 
  <tr> 
   <td><code>IgnoreCase</code></td> 
   <td><code>findByFirstnameIgnoreCase</code></td> 
   <td><code>where UPPER(x.firstame) = UPPER(?1)</code></td> 
  </tr> 
 </tbody> 
</table>

我们除了使用`find`关键字以外，还可以使用`count`、`delete`、`get`等。

例如，我们在Controller中加入如下方法得：

/**
     * @Author: 公众号：Newtol
     * @Description: 自定义关键字查询
     * @Date: Created in 19:37 2018/9/24
     */
    @GetMapping("/test/{address}/{phone}")
    public List<User> getUserByAddressAndPhone (@PathVariable("address") String address, @PathVariable("phone") Integer phone){
        
    	return userRepository.findByAddressEqualsAndPhoneNot(address,phone);
    }

在userRepository中鸡加入如下方法：

/**
     * @Author: 公众号：Newtol
     * @Description:
     * @Date: Created in 19:35 2018/9/24
     */
    public interface UserRepository extends JpaRepository<User,Integer>{
        
        public List<User> findByAddressEqualsAndPhoneNot (String address, Integer phone);
    }

在数据库中插入下面两条数据：

INSERT INTO `t_user` VALUES ('2', 'beijing', 'zhangsi', '456');
    INSERT INTO `t_user` VALUES ('3', 'beijing', 'wangwu', '123');

在浏览器输入：`http://localhost:8080/test/beijing/456`

我们就可以看到返回了如下数据，查询成功。

![在这里插入图片描述][70 8]

### 自定义SQL语句 ###

通常如果使用JPA提供给我们的关键字组成的查询方法仍然无法满足需求，那么我们就可以使用`@Query`来实现自定的SQL语句。

#### 原生SQL ####

JPA中支持使用原生的SQL语句，例如：

在userRepository中加入下面的方法：

//自定义SQL查询
        @Query(value = "select * from t_user WHERE phone = ? " ,nativeQuery = true)
        List<User> getAllUser (Integer phone);

在controller中加入以下方法：

//自定义SQL查询
        @GetMapping("/test/{phone}")
        public List<User> getAllUser(@PathVariable("phone") Integer phone){
        
            return userRepository.getAllUser(phone);
        }

在浏览器中输入：`http://localhost:8080/test/123`

返回数据，查询成功。![在这里插入图片描述][70 9]

但是，如果我们需要执行`UPDATE`、`DELETE`操作时，除了使用`@Query`外，还需要使用`@Modifying`、  
`@Transactional`两个注解。

例如：

在userRepository中加入下面的方法：

//自定义SQL删除
        @Query(value = "delete from t_user WHERE phone = ? ",nativeQuery = true)
        @Modifying
        @Transactional
        void deleteUser(Integer phone);

在controller中加入以下方法：

//自定义SQL删除
        @GetMapping("/del/{phone}")
        public void deleteUser(@PathVariable("phone") Integer phone){
        
           userRepository.deleteUser(phone);
        }

在浏览器中输入：`http://localhost:8080/del/456`,我们就会发现数据库中phone为456的数据就已经被删除了。

#### JPQL查询 ####

在userRepository中加入下面的方法：

//JPQL查询
        @Query("select u from User u where u.name = ?1")
        User getUserByName(String name);

在controller中加入以下方法：

//JPQL查询
        @GetMapping("/get/{name}")
        public User getUserByName(@PathVariable("name") String name){
        
            return userRepository.getUserByName(name);
        }

浏览器输入：`http://localhost:8080/get/zhangsan`,数据返回，查询成功：

![在这里插入图片描述][70 10]

## 复杂查询 ##

### 分页查询 ###

我们经常会遇到进行分页查询的情况，而JPA就很好的替我们解决了这一个问题。只需要几行代码就可以解决：

例如：在controller中加入以下方法：

//分页查询
    @GetMapping("/userList/{page}/{size}")
    public Page<User> getUserList(@PathVariable("page") Integer page, @PathVariable("size") Integer size) {
        
    	Sort sort = new Sort(Sort.Direction.DESC,"id");
        PageRequest pageRequest = PageRequest.of(page,size,sort);
        return  userRepository.findAll(pageRequest);
     }

浏览器输入：`http://localhost:8080/userList/0/3`

返回的数据格式为：

{
        
        "content": [
            {
        
                "id": 3, 
                "name": "wangwu", 
                "phone": 123, 
                "address": "beijing"
            }, 
            {
        
                "id": 2, 
                "name": "lisi", 
                "phone": 789, 
                "address": "shanghai"
            }, 
            {
        
                "id": 1, 
                "name": "zhangsan", 
                "phone": 123, 
                "address": "beijing"
            }
        ], 
        "pageable": {
        
            "sort": {
        
                "sorted": true, 
                "unsorted": false
            }, 
            "offset": 0, 
            "pageSize": 3, 
            "pageNumber": 0, 
            "paged": true, 
            "unpaged": false
        }, 
        "totalPages": 1, 
        "last": true, 
        "totalElements": 3, 
        "number": 0, 
        "size": 3, 
        "sort": {
        
            "sorted": true, 
            "unsorted": false
        }, 
        "numberOfElements": 3, 
        "first": true
    }

### 限制查询 ###

除了限制查询以外，对于排行榜类的数据，或许我们只需要取出前面几名即可，Jpa也对这种情况做了很好的支持：

例如：在userRepository中加入下面的方法：

//限制查询 
        List<User> findFirst2ByAddressOrderByIdDesc (String address);

在controller中加入以下方法：

@GetMapping("/top/{address}")
    public List<User> getTop2User(@PathVariable("address") String address){
        
    	return userRepository.findFirst2ByAddressOrderByIdDesc(address);
     }

在浏览器输入：`http://localhost:8080/top/beijing`

返回的数据为：

[{
        "id":3,"name":"wangwu","phone":123,"address":"beijing"},{
        "id":1,"name":"zhangsan","phone":123,"address":"beijing"}]

## 常见问题及其解决方案： ##

1.  如果提示：No identifier specified for entity: xxx
    
    解决方案：这是因为在创建实体类时，导入的jar包错误导致的。我们将`import org.springframework.data.annotation.*;`更改为：`import javax.persistence.*;`即可
2.  如果提示： No default constructor for entity: :
    
    解决方案：这是因为在实体类中创建了含参数的构造方法造成的，这是因为在使用类反射机制 Class.newInstance()方法创建实例时，需要有一个默认的无参数构造方法，否则会执出实例化异常（InstantiationException）,所以将构造方法更改为无参数即可。
3.  如果提示：Caused by: org.springframework.dao.InvalidDataAccessApiUsageException: Executing an update/delete query; nested exception is javax.persistence.TransactionRequiredException: Executing an update/delete query
    
    解决方案：这是因为在JPA中执行DELETE/UPDATE操作时，需要使用`@Modifying`、  
    `@Transactional`两个注解，补上即可。
4.  如果提示：Can not issue data manipulation statements with executeQuery()。
    
    解决方案：如果提示这个错误，就需要查询检查自己的SQL语句是否书写正确，如果正确，检查是否加上`@Modifying`、`@Transactional`两个注解
5.  如果提示：Ambiguous handler methods mapped for HTTP path
    
    解决方案：这是由于URL映射重复引起的，将你所请求的URL重新进行定义即可。
6.  如果在使用PageRequest方法显示过期
    
    解决方案：将构造方法更改为：PageRequest.of即可。在2.0版本以后，就使用of(…) 方法代替 PageRequest(…)构造器。

## 总结 ##

我们首先介绍了`spring Data`，然后演示了一遍使用JPA的基本流程，最后详细的介绍了我们主要使用的几个注解、注意事项等；以及除了使用默认的查询方式外，如何去使用自定义查询和复杂查询。

## 源码地址 ##

[源码地址][Link 1]

## 联系作者 ##

有关转载、错误指正、问题咨询等事宜请扫码关注个人公众号进行联系，更有大量视频学习资源分享 ![70 11][]

[SpringBoot_SpringBoot]: https://blog.csdn.net/m0_37888031/article/details/81807433
[70]: /images/20220510/bff04caea66040df9f726c2c50ad7121.png
[70 1]: /images/20220510/e84a1475c3a842fc8e65e2ca8c7fcade.png
[70 2]: /images/20220510/7d4b493ab2ea41da89efc203134cc08f.png
[70 3]: /images/20220510/1b9e7bccba4549c9b8d472a9309eb948.png
[70 4]: /images/20220510/8688a0400c7d4a1390f68498d3de3405.png
[70 5]: /images/20220510/71c85e7f23a8499c958695654b1510ca.png
[70 6]: /images/20220510/85b50d8563804353a98c85736fd8ff17.png
[70 7]: /images/20220510/3c5046d73a4b4a0b94821b4d9a6da3a8.png
[70 8]: /images/20220510/fa0392ea24bc4030aea61e13a3362a01.png
[70 9]: /images/20220510/569fab6f80e34c7d981378ee47cbb9c8.png
[70 10]: /images/20220510/4d918fad244b41ec8e242e900b94938e.png
[Link 1]: https://github.com/cquptrhw/Spring-boot-learning
[70 11]: /images/20220510/1ccce9579e17456fb6008d7adc48731e.png