Spring Data JPA--使用教程

ゝ一纸荒年。 2022-08-28 09:51 16阅读 0赞

原文网址：[Spring Data JPA--使用教程\_IT利刃出鞘的博客-CSDN博客][Spring Data JPA--_IT_-CSDN]

# 简介 #

**说明**

本文介绍如何使用JPA。

在SpringBoot项目中使用spring-boot-starter-data-jpa来引入Spring Data JPA。

**SpringBoot官网**

[Spring Data JPA - Reference Documentation][]

# 公共代码 #

## **依赖及配置** ##

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
 <modelVersion>4.0.0</modelVersion>
 <parent>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-parent</artifactId>
 <version>2.5.3</version>
 <relativePath/> 
 </parent>
 <groupId>com.example</groupId>
 <artifactId>demo_jpa</artifactId>
 <version>0.0.1-SNAPSHOT</version>
 <name>demo_jpa</name>
 <description>demo_jpa</description>
 <properties>
 <java.version>1.8</java.version>
 </properties>
 <dependencies>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-web</artifactId>
 </dependency>
 
 <dependency>
 <groupId>mysql</groupId>
 <artifactId>mysql-connector-java</artifactId>
 <scope>runtime</scope>
 </dependency>
 
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-data-jpa</artifactId>
 </dependency>
 <dependency>
 <groupId>org.hibernate.javax.persistence</groupId>
 <artifactId>hibernate-jpa-2.1-api</artifactId>
 <version>1.0.2.Final</version>
 </dependency>
 
 <dependency>
 <groupId>com.github.xiaoymin</groupId>
 <artifactId>knife4j-spring-boot-starter</artifactId>
 <version>3.0.2</version>
 </dependency>
 
 <dependency>
 <groupId>org.projectlombok</groupId>
 <artifactId>lombok</artifactId>
 <optional>true</optional>
 </dependency>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-test</artifactId>
 <scope>test</scope>
 </dependency>
 </dependencies>
 
 <build>
 <plugins>
 <plugin>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-maven-plugin</artifactId>
 <configuration>
 <excludes>
 <exclude>
 <groupId>org.projectlombok</groupId>
 <artifactId>lombok</artifactId>
 </exclude>
 </excludes>
 </configuration>
 </plugin>
 </plugins>
 </build>
 
 </project>

application.yml

spring:
      datasource:
        driver-class-name: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://127.0.0.1:3306/jpa?characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
        username: root
        password: 222333
    
      jpa:
        # 打印sql
        show-sql: true
        # 关闭属性的延时加载
        open-in-view: false
    #    hibernate:
    #      # 是否开启自动更新数据库表结构。生产中不要开启。
    #      #   有以下几个值供选择。常用：update、none
    #      #   create：每次加载hibernate时都删除上次生成的表，再根据你的model类生成新表。即使两次没有改变也这样执行，可能导致表数据丢失。
    #      #   create-drop：每次加载hibernate时，先删除已存在的表结构再重新生成，sessionFactory一关闭，表就自动删除。
    #      #   update：第一次加载hibernate时根据model类自动建立表结构，以后加载hibernate时根据model类自动更新表结构。
    #      #           即使表结构变了但表中的行仍然存在不会删除以前的行。
    #      #           部署到服务器后，表结构是不会被马上建立起来的，是要等应用第一次运行起来后才会。
    #      #   validate：每次加载hibernate时，验证创建数据库表结构，只会和数据库中的表进行比较，不会创建新表，但是会插入新值。
    #      #   none：关闭自动更新
    #      ddl-auto: none
    #
    #      # hibernate5及之后的命名策略配置。
    #      naming:
    #        # 负责模型对象层次的处理，将对象模型处理为逻辑名称
    #        #   有以下5个值供选择：
    #        #     ImplicitNamingStrategyJpaCompliantImpl（默认值）后四者均继承自它。
    #        #     ImplicitNamingStrategyComponentPathImpl
    #        #     ImplicitNamingStrategyLegacyHbmImpl
    #        #     ImplicitNamingStrategyLegacyJpaImpl
    #        #     SpringImplicitNamingStrategy
    #        implicit-strategy: org.hibernate.boot.model.naming.ImplicitNamingStrategyJpaCompliantImpl
    #
    #        # 映射成真实的数据名称的处理，将逻辑名称处理为物理名称。
    #        #   有以下2个值供选择：
    #        #     PhysicalNamingStrategyStandardImpl：直接映射，若有@Column则以其为准。等同于之前的DefaultNamingStrategy
    #        #     SpringPhysicalNamingStrategy（默认值）：字段为小写，当有大写字母的时候会转换为分隔符号“_”。等同于之前的ImprovedNamingStrategy
    #        physical-strategy: org.springframework.boot.orm.jpa.hibernate.SpringPhysicalNamingStrategy
    #
    #        # hibernate5之前的命名策略配置。
    #        #   有以下2个值供选择：
    #        #     DefaultNamingStrategy（默认值）：直接映射，若有@Column则以其为准。
    #        #     ImprovedNamingStrategy：字段为小写，当有大写字母的时候会转换为分隔符号“_”。
    #        # naming-strategy: org.hibernate.cfg.ImprovedNamingStrategy

## 表结构及数据 ##

t\_user.sql

DROP TABLE IF EXISTS t_user;
    
    CREATE TABLE `t_user`
    (
        `id`   bigint(0) NOT NULL AUTO_INCREMENT,
        `user_name` varchar(32) NULL DEFAULT NULL,
        `age`  int(10) NULL DEFAULT NULL,
        PRIMARY KEY (id)
    ) ENGINE = InnoDB;
    
    INSERT INTO `t_user`(user_name, age) values ('Tony1', 21);
    INSERT INTO `t_user`(user_name, age) values ('Tony2', 22);
    INSERT INTO `t_user`(user_name, age) values ('Tony3', 23);
    INSERT INTO `t_user`(user_name, age) values ('Tony3', 24);

## 其他 ##

**entity**

package com.example.demo.user.entity;
    
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    import javax.persistence.*;
    
    @Data
    @NoArgsConstructor
    @Entity
    @Table(name = "t_user")
    public class User {
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private Long id;
    
        private String userName;
    
        private Integer age;
    }

# 已有方法（CrudRepository） #

**接口的继承**

继承关系如下，所以JpaRepository有CrudRepository的所有方法。

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTliKnliIPlh7rpnpg_size_18_color_FFFFFF_t_70_g_se_x_16][]

**所有方法**

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTliKnliIPlh7rpnpg_size_14_color_FFFFFF_t_70_g_se_x_16][]

**实例**

package com.example.demo.user.controller;
    
    import com.example.demo.user.entity.User;
    import com.example.demo.user.repository.UserRepository;
    import io.swagger.annotations.Api;
    import io.swagger.annotations.ApiOperation;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.domain.Page;
    import org.springframework.data.domain.PageRequest;
    import org.springframework.data.domain.Sort;
    import org.springframework.web.bind.annotation.PostMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.util.List;
    
    @Api(tags = "简单功能")
    @RestController
    @RequestMapping("/simple")
    public class SimpleController {
        @Autowired
        private UserRepository userRepository;
    
        @ApiOperation("已有方法")
        @PostMapping("intrinsic")
        public void intrinsic() {
            User user = new User();
            user.setUserName("Tony");
    
            User save          = userRepository.save(user);// id会被回写到user对象中
            boolean existsById = userRepository.existsById(user.getId());
            User findById      = userRepository.findById(user.getId()).get();
            // userRepository.deleteById(user.getId());
            // userRepository.delete(user);
            // userRepository.deleteAll();
    
            System.out.println("----------------------------------------------------------");
            System.out.println("user       : " + user);
            System.out.println("save       : " + save);
            System.out.println("existsById : " + existsById);
            System.out.println("findById   : " + findById);
        }
    }

**执行结果**

Hibernate: insert into t_user (age, user_name) values (?, ?)
    Hibernate: select count(*) as col_0_0_ from t_user user0_ where user0_.id=?
    Hibernate: select user0_.id as id1_0_0_, user0_.age as age2_0_0_, user0_.user_name as user_nam3_0_0_ from t_user user0_ where user0_.id=?
    ----------------------------------------------------------
    user       : User(id=5, userName=Tony, age=null)
    save       : User(id=5, userName=Tony, age=null)
    existsById : true
    findById   : User(id=5, userName=Tony, age=null)

# 自定义方法（JpaRepository） #

**简介**

自定义方法即根据方法名来自动生成SQL，主要语法有以下几种（后面跟属性名）：

*  查询：findXXBy、readXXBy、queryXXBy、getXXBy（这几个等价）
 *  数量：countXXBy
 *  存在：existsXXBy
 *  删除：deleteXXBy、removeXXBy（这几个等价）

举例

1.  假设对应实体为User，里边有userName、age。语法可以是：
    
    1.  findBy、findUserBy、findUsersBy、findAllBy、findFirstBy、findTopBy、findDistinctBy、findDistinctFirstBy、findDistinctUserNameFirstBy、findDinstinctTopBy

## **语法大全** ##

<table> 
 <tbody> 
 <tr> 
 <td> Keyword </td> 
 <td> Sample </td> 
 <td> JPQL snippet </td> 
 </tr> 
 <tr> 
 <td> And </td> 
 <td> findByLastnameAndFirstname </td> 
 <td> … where x.lastname = ?1 and x.firstname = ?2 </td> 
 </tr> 
 <tr> 
 <td> Or </td> 
 <td> findByLastnameOrFirstname </td> 
 <td> … where x.lastname = ?1 or x.firstname = ?2 </td> 
 </tr> 
 <tr> 
 <td> Is,Equals </td> 
 <td> findByFirstnameIs,findByFirstnameEquals </td> 
 <td> … where x.firstname = ?1 </td> 
 </tr> 
 <tr> 
 <td> Between </td> 
 <td> findByStartDateBetween </td> 
 <td> … where x.startDate between ?1 and ?2 </td> 
 </tr> 
 <tr> 
 <td> LessThan </td> 
 <td> findByAgeLessThan </td> 
 <td> … where x.age &lt; ?1 </td> 
 </tr> 
 <tr> 
 <td> LessThanEqual </td> 
 <td> findByAgeLessThanEqual </td> 
 <td> … where x.age ⇐ ?1 </td> 
 </tr> 
 <tr> 
 <td> GreaterThan </td> 
 <td> findByAgeGreaterThan </td> 
 <td> … where x.age &gt; ?1 </td> 
 </tr> 
 <tr> 
 <td> GreaterThanEqual </td> 
 <td> findByAgeGreaterThanEqual </td> 
 <td> … where x.age &gt;= ?1 </td> 
 </tr> 
 <tr> 
 <td> After </td> 
 <td> findByStartDateAfter </td> 
 <td> … where x.startDate &gt; ?1 </td> 
 </tr> 
 <tr> 
 <td> Before </td> 
 <td> findByStartDateBefore </td> 
 <td> … where x.startDate &lt; ?1 </td> 
 </tr> 
 <tr> 
 <td> IsNull </td> 
 <td> findByAgeIsNull </td> 
 <td> … where x.age is null </td> 
 </tr> 
 <tr> 
 <td> IsNotNull,NotNull </td> 
 <td> findByAge(Is)NotNull </td> 
 <td> … where x.age not null </td> 
 </tr> 
 <tr> 
 <td> Like </td> 
 <td> findByFirstnameLike </td> 
 <td> … where x.firstname like ?1 </td> 
 </tr> 
 <tr> 
 <td> NotLike </td> 
 <td> findByFirstnameNotLike </td> 
 <td> … where x.firstname not like ?1 </td> 
 </tr> 
 <tr> 
 <td> StartingWith </td> 
 <td> findByFirstnameStartingWith </td> 
 <td> … where x.firstname like ?1&nbsp;(parameter bound with appended&nbsp;%) </td> 
 </tr> 
 <tr> 
 <td> EndingWith </td> 
 <td> findByFirstnameEndingWith </td> 
 <td> … where x.firstname like ?1&nbsp;(parameter bound with prepended&nbsp;%) </td> 
 </tr> 
 <tr> 
 <td> Containing </td> 
 <td> findByFirstnameContaining </td> 
 <td> … where x.firstname like ?1&nbsp;(parameter bound wrapped in&nbsp;%) </td> 
 </tr> 
 <tr> 
 <td> OrderBy </td> 
 <td> findByAgeOrderByLastnameDesc </td> 
 <td> … where x.age = ?1 order by x.lastname desc </td> 
 </tr> 
 <tr> 
 <td> Not </td> 
 <td> findByLastnameNot </td> 
 <td> … where x.lastname &lt;&gt; ?1 </td> 
 </tr> 
 <tr> 
 <td> In </td> 
 <td> findByAgeIn(Collection ages) </td> 
 <td> … where x.age in ?1 </td> 
 </tr> 
 <tr> 
 <td> NotIn </td> 
 <td> findByAgeNotIn(Collection age) </td> 
 <td> … where x.age not in ?1 </td> 
 </tr> 
 <tr> 
 <td> TRUE </td> 
 <td> findByActiveTrue() </td> 
 <td> … where x.active = true </td> 
 </tr> 
 <tr> 
 <td> FALSE </td> 
 <td> findByActiveFalse() </td> 
 <td> … where x.active = false </td> 
 </tr> 
 <tr> 
 <td> IgnoreCase </td> 
 <td> findByFirstnameIgnoreCase </td> 
 <td> … where UPPER(x.firstame) = UPPER(?1) </td> 
 </tr> 
 </tbody> 
</table>

## 实例 ##

**Repository**

package com.example.demo.user.repository;
 
 import com.example.demo.user.entity.User;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.stereotype.Repository;
 
 import java.util.List;
 
 @Repository
 public interface UserRepository extends JpaRepository<User, Long> {
 //通过名字获得列表
 List<User> findByUserName(String userName);
 
 //通过名字获得分页
 Page<User> queryByUserNameLike(String userName, Pageable pageable);
 
 //通过名字和年龄获得列表
 List<User> findByUserNameAndAge(String userName, Integer age);
 
 //通过名字获得第一个
 User findFirstByUserName(String userName);
 
 //通过名字获得前5个
 List<User> findFirst5ByUserName(String userName);
 
 //通过名字获得数量
 int countByUserName(String userName);
 
 }

**Controller**

package com.example.demo.user.controller;
 
 import com.example.demo.user.entity.User;
 import com.example.demo.user.repository.UserRepository;
 import io.swagger.annotations.Api;
 import io.swagger.annotations.ApiOperation;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.PageRequest;
 import org.springframework.data.domain.Sort;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 
 import java.util.List;
 
 @Api(tags = "简单功能")
 @RestController
 @RequestMapping("/simple")
 public class SimpleController {
 @Autowired
 private UserRepository userRepository;
 
 @ApiOperation("自定义方法")
 @PostMapping("custom")
 public void custom() {
 List<User> byUserName = userRepository.findByUserName("Tony3");
 List<User> byUserNameAndAge = userRepository.findByUserNameAndAge("Tony3", 23);
 User firstByUserName = userRepository.findFirstByUserName("Tony3");
 List<User> first5ByUserName = userRepository.findFirst5ByUserName("Tony3");
 int count = userRepository.countByUserName("Tony3");
 Page<User> page = userRepository.queryByUserNameLike("%Tony%",
 PageRequest.of(0, 2, Sort.by(Sort.Direction.DESC, "id")));
 
 System.out.println("----------------------------------------------------------");
 System.out.println("byUserName : " + byUserName);
 System.out.println("byUserNameAndAge : " + byUserNameAndAge);
 System.out.println("firstByUserName : " + firstByUserName);
 System.out.println("first5ByUserName : " + first5ByUserName);
 System.out.println("count : " + count);
 System.out.println("page : " + page.getContent());
 }
 }

**请求结果**

Hibernate: select user0_.id as id1_0_, user0_.age as age2_0_, user0_.user_name as user_nam3_0_ from t_user user0_ where user0_.user_name=?
    Hibernate: select user0_.id as id1_0_, user0_.age as age2_0_, user0_.user_name as user_nam3_0_ from t_user user0_ where user0_.user_name=? and user0_.age=?
    Hibernate: select user0_.id as id1_0_, user0_.age as age2_0_, user0_.user_name as user_nam3_0_ from t_user user0_ where user0_.user_name=? limit ?
    Hibernate: select user0_.id as id1_0_, user0_.age as age2_0_, user0_.user_name as user_nam3_0_ from t_user user0_ where user0_.user_name=? limit ?
    Hibernate: select count(user0_.id) as col_0_0_ from t_user user0_ where user0_.user_name=?
    Hibernate: select user0_.id as id1_0_, user0_.age as age2_0_, user0_.user_name as user_nam3_0_ from t_user user0_ where user0_.user_name like ? escape ? order by user0_.id desc limit ?
    Hibernate: select count(user0_.id) as col_0_0_ from t_user user0_ where user0_.user_name like ? escape ?
    ----------------------------------------------------------
    byUserName       : [User(id=3, userName=Tony3, age=23), User(id=4, userName=Tony3, age=24)]
    byUserNameAndAge : [User(id=3, userName=Tony3, age=23)]
    firstByUserName  : User(id=3, userName=Tony3, age=23)
    first5ByUserName : [User(id=3, userName=Tony3, age=23), User(id=4, userName=Tony3, age=24)]
    count            : 2
    page             : [User(id=4, userName=Tony3, age=24), User(id=3, userName=Tony3, age=23)]

# 样例查询（QueryByExampleExecutor） #

这个属于动态查询，见：[JPA--动态查询--Example\_IT利刃出鞘的博客-CSDN博客][JPA--_--Example_IT_-CSDN]

# 其他 #

**PagingAndSortingRepository**

PagingAndSortingRepository继承于CrudRepository，除了具有CrudRepository接口的能力外，还新增了分页和排序的功能。不过，对于分页，只能传Pageable，对于排序，只能传Sort，实际基本不会用到。

接口定义如下。：

package org.springframework.data.repository;
 
 import java.io.Serializable;
 
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.domain.Sort;
 
 @NoRepositoryBean
 public interface PagingAndSortingRepository<T, ID extends Serializable> extends CrudRepository<T, ID> {
 
 	Iterable<T> findAll(Sort sort); // 查询所有实体并排序
 
 	Page<T> findAll(Pageable pageable); // 分页查询实体
 }

# **其他网址** #

[SpringBoot重点详解--使用JPA操作数据库\_pengjunlee的博客-CSDN博客\_jpa使用][SpringBoot_--_JPA_pengjunlee_-CSDN_jpa]

[Spring Data JPA--_IT_-CSDN]: https://knife.blog.csdn.net/article/details/120631751
[Spring Data JPA - Reference Documentation]: https://docs.spring.io/spring-data/jpa/docs/current/reference/html/#repositories
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTliKnliIPlh7rpnpg_size_18_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/30aedea69a974481b265cb7bfacb436f.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTliKnliIPlh7rpnpg_size_14_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/a745c831d2b74ac9a4b6a7e51b5514ca.png
[JPA--_--Example_IT_-CSDN]: https://knife.blog.csdn.net/article/details/119987868
[SpringBoot_--_JPA_pengjunlee_-CSDN_jpa]: https://blog.csdn.net/pengjunlee/article/details/80038677