Spring Data JPA 入门

注解说明

  1. @Entity(name = "")类注解，用来注解该类是一个实体类并用来和数据库中的表建立关联关系。其中name表示该表的名称
  2. @Table(name = "") 类注解，跟@Entity(name = "")作用一致
  3. @Id属性注解，该注解表明该属性字段是一个主键，该属性必须具备，不可缺少
  4. @GeneratedValue(strategy = ,generator = "")和@Id主键注解一起使用，用来定义主键的呈现形式。其中strategy表示JPA通用的主键策略生成器，generator表示使用指定的主键生成器时，设置生成器的名称(即@GenericGenerator注解的name值)
    1. @GeneratedValue(strategy= GenerationType.IDENTITY) 该注解由数据库自动生成，主键自增型，在MySql数据库中使用最频繁，Oracle不支持
    2. @GeneratedValue(strategy= GenerationType.AUTO) 主键由程序控制，默认的主键生成策略，Oracle默认是序列化的方式，MySql默认是主键自增的方式
    3. @GeneratedValue(strategy= GenerationType.SEQUENCE) 根据底层数据库的序列来生成主键，条件是数据库支持序列，Oracle支持，MySql不支持
    4. @GeneratedValue(strategy= GenerationType.TABLE) 使用一个特定的数据库表格来保存主键，较少使用
  5. @GenericGenerator(name = "",strategy = "uuid") 自定义主键生成策略，其中name表示生成器的名称，strategy表示预定义的 Hibernate 策略或完全限定的类名
  6. @Column(name = "",nullable = ,columnDefinition = "") 类的属性注解，可以定义一个字段映射到数据库属性的具体特征(比如字段长度、非空、唯一、字段注释等)
  7. @Transient类的属性注解，该注解标注的字段不会被映射到数据库当中
  8. @JoinColum(name = "",referencedColumnName = "")保存表与表之间关系的字段，它要标注在实体属性上。一般修饰在主控方，用来定义一对一，一对多，多对多等关系。配合实体关系注解使用
    1. 关联的实体的主键一般是用来做外键的。但如果不想主键作为外键，则需要设置referencedColumnName属性
  9. @JoinTable(name = "", joinColumns = @JoinColumn(name = "",referencedColumnName = ""), inverseJoinColumns = @JoinColumn(name = "",referencedColumnName = ""))用于构建一对多，多对多时的连接表，默认会以主表加下划线加外键表为表名
    1. name中间表的表名称
    2. joinColumns = @JoinColumn(name = "",referencedColumnName = "")指明当前对象哪个列（referencedColumnName的值）和中间表哪个列（name的值）对应
    3. inverseJoinColumns = @JoinColumn(name = "",referencedColumnName = "")指明依赖对象哪个列（referencedColumnName的值）和中间表哪个列（name的值）对应

实体关系注解说明

  1. @OneToOne(cascade = {},fetch = {},mappedBy = "")实体间一对一的关系。实现的方式有外键关联和中间表保存关联关系

    1. cascade当前类对象操作了之后，级联对象的操作
      1. REMOVE级联删除操作。删除当前实体时，与它有映射关系的实体也会跟着被删除
      2. MEGER级联更新（合并）操作。当前对象中的数据改变，会相应地更新级联对象中的数据
      3. DETACH级联脱管/游离操作。如果要删除一个实体，但是它有外键无法删除，就需要这个级联权限了。它会撤销所有相关的外键关联
      4. REFRESH级联刷新操作。更新数据前先刷新对象和级联对象，再更新
      5. PERSIST级联持久化（保存）操作。持久保存拥有方实体时，也会持久保存该实体的所有相关数据
      6. ALL当前类增删改查改变之后，关联类跟着增删改查，拥有以上所有级联操作权
    2. fetch关联对象的立即加载和延迟加载
      1. FetchType.LAZY懒加载
      2. FetchType.EAGER立即加载
    3. mappedBy表示该类放弃外键的维护，是关系被维护端。其中mappedBy的值是被拥有类中的属性名

    一对一的关系实例如下：一个学生拥有一张书桌的，一张书桌属于一个学生的

    @Getter
@Setter
@Entity
@NoArgsConstructor
@Table(name = "desk")
public class Desk implements Serializable {

   @Id
   @GeneratedValue(strategy = GenerationType.IDENTITY)
   private Long id;

   @Column(name = "identifier", length = 20)
   private String identifier;

   /**
    * mappedBy = "desk" 表明该实体表放弃外键的维护。其中 mappedBy 的值是 Student 类中的属性
    */
   @OneToOne(mappedBy = "desk")
   private Student student;
}

@Getter
@Setter
@Entity
@NoArgsConstructor
@Table(name = "student")
public class Student implements Serializable {

   @Id
   @GeneratedValue(strategy = GenerationType.IDENTITY)
   private Long id;

   @Column(name = "name", length = 100)
   private String name;

   /**
    * name = "desk_id" 设置外键在表中的字段名
    * nullable = false 说明该外键的值在表中不允许为 null
    */
   @OneToOne(fetch = FetchType.EAGER)
   @JoinColumn(nullable = false, name = "desk_id")
   private Desk desk;
}

  2. @OneToMany和@ManyToOne实体一对多和多对一的双向关系。一端(One)使用@OneToMany，多端(Many)使用@ManyToOne

    1. 在JPA规范中，一对多的双向关系由多端(Many)来维护，即多端(Many)负责关系的CRUD
    2. 一端(One)则为关系被维护端，不能维护关系，使用@OneToMany的mappedBy属性表明是关系的被维护端，值是被拥有类中的属性名
    3. 多端(Many)使用@ManyToOne表明是多端，使用@JoinColum设置在表中关联的字段(外键)

    一对多和多对一的双向关系实例如下：多个学生属于一间教室，一间教室属于多名学生

    @Getter
@Setter
@Entity
@NoArgsConstructor
@Entity
@Table(name = "student")
public class Student implements Serializable {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "name",length = 100)
    private String name;

    /**
     * name = "class_room_id" 设置外键在表中的字段名
     * nullable = false 说明该外键的值在表中不允许为 null
     */
    @ManyToOne
    @JoinColumn(nullable = false,name = "class_room_id",referencedColumnName = "class_no")
    private ClassRoom classRoom;
}

@Getter
@Setter
@Entity
@NoArgsConstructor
@Entity
@Table(name = "class_room")
public class ClassRoom implements Serializable {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "class_no")
    private String classNo;

    /**
     * mappedBy = "classRoom" 表明该实体表放弃外键的维护。其中 mappedBy 的值是 Student 类中的属性
     */
    @OneToMany(mappedBy = "classRoom")
    private Set<Student> students;
}

  3. @ManyToMany实体间多对多的关系。由一个中间表来维护关系，表名默认为 主表名_从表名

    1. 多对多关系中一般不设置级联保存、级联删除、级联更新等操作
    2. 使用@JoinTable注解，中间表会按照注解指定的方式生成

    多对多的关系实例如下：一个教师有多名学生，一个学生有多个教师

    @Getter
@Setter
@Entity
@NoArgsConstructor
@Entity
@Table(name = "student")
public class Student implements Serializable {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "name",length = 100)
    private String name;

    /**
     * 在多对多的关系中，需要使用中间表来维护双方的关系，通过@JoinTable定义中间表
     *  name = "student_teacher" 中间表的表名称
     *  joinColumns = @JoinColumn(name = "student_id",referencedColumnName = "id") 指明当前对象哪个列（referencedColumnName的值）和中间表哪个列（name的值）对应
     *  inverseJoinColumns = @JoinColumn(name = "teacher_id",referencedColumnName = "id") 指明依赖对象哪个列（referencedColumnName的值）和中间表哪个列（name的值）对应
     */
    @ManyToMany
    @JoinTable(name = "student_teacher",
            joinColumns = @JoinColumn(name = "student_id",referencedColumnName = "id"),
            inverseJoinColumns = @JoinColumn(name = "teacher_id",referencedColumnName = "id"))
    private Set<Teacher> teachers;
}

@Getter
@Setter
@Entity
@NoArgsConstructor
@Table(name = "teacher")
public class Teacher implements Serializable {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "name",length = 100)
    private String name;

    /**
     * mappedBy = "teacher" 表明该实体表放弃外键的维护。其中 mappedBy 的值是 Student 类中的属性
     */
    @ManyToMany(mappedBy = "teachers")
    private Set<Student> students;
}

级联操作

级联在关系映射注解中指主动方对象执行操作(增删改)时，被关联对象(关系被维护段)是否同步执行统一操作
四个关系注解 @OneToMany ，@ManyToOne ，@OneToOne ，@ManyToMany 中都有一个属性cascade，通过该属性维护级联关系(默认值是default不存在级联操作)：

  1. CascadeType.PERSIST级联是级联保存

    @Builder
@Getter
@Setter
@AllArgsConstructor
@Entity
@Table(name = "student")
public class Student implements Serializable {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    /**
     * @JoinColumn(nullable = false,name = "desk_id")
     *  name = "desk_id" 设置外键在表中的字段名
     *  nullable = false 说明该外键的值在表中不允许为 null
     *
     * @OneToOne(fetch = FetchType.LAZY,cascade = CascadeType.PERSIST)
     *  fetch = FetchType.LAZY 采用懒加载方式
     *  cascade = CascadeType.PERSIST 级联保存，当保存学生实体时，会同步保存课桌实体
     */
    @OneToOne(fetch = FetchType.LAZY,cascade = CascadeType.PERSIST)
    @JoinColumn(nullable = false,name = "desk_id")
    private Desk desk;
    
    @Tolerate
    public Student() { }
}

@Builder
@Getter
@Setter
@Entity
@Table(name = "desk")
public class Desk implements Serializable {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "identifier",length = 20)
    private String identifier;

    /**
     * mappedBy = "desk" 表明该实体表放弃外键的维护。其中 mappedBy 的值是 Student 类中的属性
     */
    @OneToOne(mappedBy = "desk")
    private Student student;

    @Tolerate
    public Desk() { }
}

/***级联保存实例保存student对象同时保存desk对象*/
@Test
@Transactional
public void saveStudent(){
  Student student = Student.builder().name("wen").age(23).birthday(LocalDate.now()).build();
  Desk desk = Desk.builder().identifier("456").build();
  student.setDesk(desk);
  studentRepository.save(student);
}

/***单纯保存desk不影响student*/
@Test
public void saveDesk(){
  Desk desk = Desk.builder().identifier("123").build();
  deskRepository.save(desk);
}

  2. CascadeType.MERGE 级联更新

    @Builder
@Getter
@Setter
@AllArgsConstructor
@Entity
@Table(name = "student")
public class Student implements Serializable {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    /**
     * @JoinColumn(nullable = false,name = "desk_id")
     *  name = "desk_id" 设置外键在表中的字段名
     *  nullable = false 说明该外键的值在表中不允许为 null
     *
     * @OneToOne(fetch = FetchType.LAZY,cascade = CascadeType.MERGE)
     *  fetch = FetchType.LAZY 采用懒加载方式
     *  cascade = CascadeType.MERGE 级联更新，当保存更新的学生实体中又对Desk对象修改时，会同步保存课桌实体
     */
    @OneToOne(fetch = FetchType.LAZY,cascade = CascadeType.MERGE)
    @JoinColumn(nullable = false,name = "desk_id")
    private Desk desk;
    
    @Tolerate
    public Student() { }
}

@Builder
@Getter
@Setter
@Entity
@Table(name = "desk")
public class Desk implements Serializable {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "identifier",length = 20)
    private String identifier;

    /**
     * mappedBy = "desk" 表明该实体表放弃外键的维护。其中 mappedBy 的值是 Student 类中的属性
     */
    @OneToOne(mappedBy = "desk")
    private Student student;

    @Tolerate
    public Desk() { }
}

/***级联更新实例student对象同时更新desk对象*/
@Test
@Transactional
@Commit
public void updateStudent() {
  Optional<Student> student = studentRepository.findById(1L);
  student.ifPresent(stu->{
      stu.setName("cheng");
      Desk desk = stu.getDesk();
      desk.setIdentifier("1001-11");
      studentRepository.save(stu);
  });
}

  3. CascadeType.REMOVE 级联删除

    @Builder
@Getter
@Setter
@AllArgsConstructor
@Entity
@Table(name = "student")
public class Student implements Serializable {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    /**
     * @JoinColumn(nullable = false,name = "desk_id")
     *  name = "desk_id" 设置外键在表中的字段名
     *  nullable = false 说明该外键的值在表中不允许为 null
     *
     * @OneToOne(fetch = FetchType.LAZY,cascade = CascadeType.REMOVE)
     *  fetch = FetchType.LAZY 采用懒加载方式
     *  cascade = CascadeType.REMOVE 级联删除，当删除学生实体时，会同步删除课桌实体
     */
    @OneToOne(fetch = FetchType.LAZY,cascade = CascadeType.REMOVE)
    @JoinColumn(nullable = false,name = "desk_id")
    private Desk desk;
    
    @Tolerate
    public Student() { }
}

@Builder
@Getter
@Setter
@Entity
@Table(name = "desk")
public class Desk implements Serializable {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "identifier",length = 20)
    private String identifier;

    /**
     * mappedBy = "desk" 表明该实体表放弃外键的维护。其中 mappedBy 的值是 Student 类中的属性
     */
    @OneToOne(mappedBy = "desk")
    private Student student;

    @Tolerate
    public Desk() { }
}

/***级联删除实例student对象同时删除desk对象*/
@Test
@Transactional
@Commit
public void deleteStudent() {
  studentRepository.deleteById(1L);
}

  4. CascadeType.REFRESH 级联刷新

  5. CascadeType.DETACH 级联托管

  6. CascadeType.ALL 具有上述五个级联的功能

    注意点：@OneToOne和@OneToMany中存在一个orphanRemoval属性，表示当关联关系被删除的时候，是否级联删除

    @Builder
@Getter
@Setter
@AllArgsConstructor
@Entity
@Table(name = "student")
public class Student implements Serializable {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "name",length = 100)
    private String name;

    /**
     * name = "class_room_id" 设置外键在表中的字段名
     * nullable = false 说明该外键的值在表中不允许为 null
     */
    @ManyToOne(cascade = CascadeType.ALL)
    @JoinColumn(nullable = false,name = "class_room_id",referencedColumnName = "class_no")
    private ClassRoom classRoom;

    @Tolerate
    public Student() {

    }
}

@Getter
@Setter
@Builder
@Entity
@Table(name = "class_room")
public class ClassRoom implements Serializable {

   @Id
   @GeneratedValue(strategy = GenerationType.IDENTITY)
   private Long id;

   @Column(name = "class_no")
   private String classNo;

   /**
    * mappedBy = "classRoom" 表明该实体表放弃外键的维护。其中 mappedBy 的值是 Student 类中的属性
    * orphanRemoval = true 表示删除ClassRoom对象前先将Student对象删除后再删除ClassRoom对象
    */
   @OneToMany(mappedBy = "classRoom",orphanRemoval = true)
   private Set<Student> students;

   @Tolerate
   public ClassRoom() {

   }
}

/***级联删除实例ClassRoom对象前先删除外键引用的Student对象*/
@Test
@Transactional
@Commit
public void deleteClassRoom() {
   classRoomRepository.deleteById(8L);
}

使用JPA关键字进行CRUD操作

使用JPA进行CRUD操作时，基本不用写简单的SQL语句，通过JPA提供的JpaRepository类即可完成简单的CRUD

Spring Data JPA提供了JpaRepository，该接口继承PagingAndSortingRepository和QueryByExampleExecutor接口

  1. PagingAndSortingRepository接口继承CrudRepository，提供了排序和分页的方法。CrudRepository接口定义了简单的CRUD方法，而JpaRepository接口对该接口进行增强操作
  2. QueryByExampleExecutor接口提供了⼀种⽤户友好的查询技术，具有简单的接⼝，它允许动态查询创建，并且不需要编写包含字段名称的查询

简单CRUD入门操作

  1. 定义DAO层，不需要写@Repository注解
    public interface StudentRepository extends JpaRepository<Student,Long> { }
  2. 使用JPA提供的find和get关键字完成常规的查询操作，使用delete关键字完成删除，使用count关键字完成统计等，通过跟By关键字进行字段绑定
    public interface StudentRepository extends JpaRepository<Student,Long> {
    /**根据名称获取实体*/
    Student findByName(String name);

    /**根据age获取实体*/
    Student getByAge(Integer age);

    /**根据id和名称获取实体*/
    List<Student> findByIdAndName(Long id, String name);

    /**删除list中包含的实体并返回影响的行数*/
    Long deleteByIdIn(List<Long> ids);

    /**查询统计name包含关键字的个数*/
    Long countByNameContains(String key);
}
  3. 如果要对某个对象进行修改操作，需要先查询出给实体后使用save方法进行更新，或者自定义SQL的方式进行更新操作

自定义SQL语句

自定义SQL在JPA中有两种呈现形式

  1. JPQL形式的SQL语句，from 后面是以类名呈现的,?1 代表是的是方法中的第一个参数
    public interface DeskRepository extends JpaRepository<Desk,Long> {
    @Query(value = "select desk from Desk desk where desk.id in ?1")
    List<Desk> findByIdIn(List<Long> ids);
}
  2. 原生的SQL语句，需要使用nativeQuery = true指定使用原生SQL，:name是通过@Param注解去绑定的
    public interface DeskRepository extends JpaRepository<Desk,Long> {
    @Query(value = "select * from desk where identifier = :identifier",nativeQuery = true)
    Desk findByIdentifier(@Param("identifier") String identifier);
}
  3. 自定义SQL更新数据。@Query注解中编写JPQL实现DELETE和UPDATE操作的时候必须加上@Modifying注解，以通知Spring Data 这是一个DELETE或UPDATE操作，同时接口的返回值表示影响的行数
    @Modifying
@Query(value = "update student set age = :age where name = :name",nativeQuery = true)
int updateStudentAgeByName(@Param("name") String name,@Param("age") Integer age);

备注：

  1. SQL 中的参数传递也有两种形式：
    1. 使用问号 ?，紧跟数字序列，数字序列从1开始
    2. 使用冒号 :，紧跟参数名，参数名是通过@Param注解来绑定
  2. 注意JPQL不支持INSERT操作
  3. UPDATE或者DELETE操作需要使用事务，此时需要 定义Service层，在Service层的方法上添加事务操作

动态创建查询

QueryByExampleExecutor接口提供了⼀种⽤户友好的查询技术，具有简单的接⼝，它允许动态查询创建，并且不需要编写包含字段名称的查询

QueryByExampleExecutor使用场景：使用一组静态或动态约束来查询数据存、频繁重构域对象，而不用担心破坏现有查询、简单的查询的使用场景

public interface QueryByExampleExecutor<T> {
    // 根据实例查找一个对象
    <S extends T> Optional<S> findOne(Example<S> example);
    // 根据实例查找一批对象
    <S extends T> Iterable<S> findAll(Example<S> example);
    // 根据实例查找一批对象，且排序
    <S extends T> Iterable<S> findAll(Example<S> example, Sort sort);
    // 根据实例查找一批对象，且排序和分页
    <S extends T> Page<S> findAll(Example<S> example, Pageable pageable);
    // 根据实例查找，返回符合条件的对象个数
    <S extends T> long count(Example<S> example);
    // 根据实例查找，返回符合条件的对象
    <S extends T> boolean exists(Example<S> example);
}

public interface Example<T> {

   static <T> Example<T> of(T probe) {
      return new TypedExample<>(probe, ExampleMatcher.matching());
   }

   static <T> Example<T> of(T probe, ExampleMatcher matcher) {
      return new TypedExample<>(probe, matcher);
   }

   T getProbe();

   ExampleMatcher getMatcher();

   @SuppressWarnings("unchecked")
   default Class<T> getProbeType() {
      return (Class<T>) ProxyUtils.getUserClass(getProbe().getClass());
   }
}

从源码中可以看出 Example 主要包含三部分内容。

  1. Probe：这是具有填充字段的域对象的实际实体类，即查询条件的封装类（又可以理解为：查询条件参数），必填。
  2. ExampleMatcher：ExampleMatcher 有关于如何匹配特定字段的匹配规则，它可以重复使用在多个示例，必填；如果不填，用默认的（又可以理解为参数的匹配规则）
  3. Example：Example 由 Probe 探针和 ExampleMatcher 组成，它用于创建查询，即组合查询参数和参数的匹配规则
//创建查询条件数据对象
Student student = new Student();
student.setName("i-");
student.setAge(22);

//创建匹配器，即如何使用查询条件
ExampleMatcher matcher = ExampleMatcher.matching()
       ////name采用“开始匹配”的方式查询
       .withMatcher("name", ExampleMatcher.GenericPropertyMatchers.startsWith())
       //忽略属性age
       .withIgnorePaths("age");


//创建实例
Example<Student> example = Example.of(student, matcher);
List<Student> studentList = studentRepository.findAll(example);
for (Student stu : studentList) {
   System.out.println(stu);
}

QueryByExampleExecutor的特点及约束：

  1. 支持动态查询，输入字段为null则忽略这个条件
  2. 不支持过滤条件分组，即不支持过滤条件用 or（或）来连接，所有的过滤条件都是简单一层的用 and（并且）连接，如 name = ?1 or (email = ?2 and email = ?3)
  3. 支持字符串的开始、包含、结束、正则匹配和其他属性类型的精确匹配，如针对于“name”的过滤也只有这么一个存储过滤值的位置，没办法同时传入两个过滤值

ExampleMatcher说明：

  1. nullHandler：Null值处理方式，枚举类型，有两个可选值，INCLUDE（包括）、IGNORE（忽略）
    1. 标识作为条件的实体对象中，一个属性值（条件值）为 Null 时，是否参与过滤
    2. 当该选项值是 INCLUDE 时，表示仍参与过滤，会匹配数据库表中该字段值是 Null 的记录
    3. 若为 IGNORE 值，表示不参与过滤
  2. defaultStringMatcher：默认字符串匹配方式，枚举类型，有 6 个可选值。该配置对所有字符串属性过滤有效，除非该属性在 propertySpecifiers 中单独定义自己的匹配方式
    1. DEFAULT（默认，效果同 EXACT）
    2. EXACT（相等）
    3. STARTING（开始匹配）
    4. ENDING（结束匹配）
    5. CONTAINING（包含，模糊匹配）
    6. REGEX（正则表达式）
  3. defaultIgnoreCase：默认大小写忽略方式，布尔型，当值为false时，即不忽略，大小写不相等
    1. 该配置对所有字符串属性过滤有效，除非该属性在 propertySpecifiers 中单独定义自己的忽略大小写方式
  4. ignoredPaths：忽略属性列表，忽略的属性不参与查询过滤
  5. propertySpecifiers: 各属性自定义查询方式包含：属性名、字符串匹配方式、大小写忽略方式、属性转换器

QueryByExampleExecutor实际中需要考虑的因素
查询条件表示有两部分: 一是条件值，二是查询方式，条件值使用实体对象存储，页面传入值按值进行过滤，未传入值则忽略

  1. null值的处理，是否需要匹配数据库中字段值为null的记录
  2. 基本类型的处理，比如int的默认值是0，为了避免不传值时，使用默认值进行查询，避免使用基本类型，采用包装类型
  3. 忽略某些属性值，实体类中的所有属性是否都需要参与查询
  4. 不同的过滤方式，查询条件判断不一样
  5. 大小写匹配

排序实现

JPA提供了一个Sort类来定义排序，排序实现方式如下

  1. 使用原生SQL来写
    public interface DeskRepository extends JpaRepository<Desk,Long> {
    @Query(value = "select * from desk where identifier = :identifier order by id desc",nativeQuery = true)
    Desk findByIdentifier(@Param("identifier") String identifier);
}
  2. 使用JPQL来写
    public interface DeskRepository extends JpaRepository<Desk,Long> {
    @Query(value = "select desk from Desk desk where desk.id in ?1 order by id asc")
    List<Desk> findByIdIn(List<Long> ids);
}
  3. Sort作为参数传递给方法
    public interface DeskRepository extends JpaRepository<Desk,Long> {
    @Query(value = "select desk from Desk desk where desk.id in ?1")
    List<Desk> findByIdIn(List<Long> ids,Sort sort);
}

//单字段排序
List<Desk> desks = deskRepository.findByIdIn(List.of(3L,4L,5L), Sort.by(Sort.Direction.DESC,"id"));
System.out.println(desks);

//多字段排序
Sort.Order order1 = new Sort.Order(Sort.Direction.DESC, "id");
Sort.Order order2 = new Sort.Order(Sort.Direction.DESC, "identifier");
List<Sort.Order> orders = List.of(order1, order2);
Sort sort = Sort.by(orders);
List<Desk> deskList = deskRepository.findByIdIn(List.of(3L,4L,5L), sort);
System.out.println(deskList);
  4. 基于特殊参数的排序
    public interface DeskRepository extends JpaRepository<Desk,Long> { 
     List<Desk> findAllByOrderByIdDesc();
}

JPA分页实现

PagingAndSortingRepository接口继承自CrudRepository接口提供的分页和排序方法

@NoRepositoryBean
public interface PagingAndSortingRepository<T, ID> extends CrudRepository<T, ID> {
    //排序功能。它按照Sort制定的排序返回数据
	Iterable<T> findAll(Sort sort);
    //分页查询（含排序功能）
	Page<T> findAll(Pageable pageable);
}

Pageable接口用于构造分页查询，返回Page对象。Page从0开始分页。实例化Pageable方式如下

//方式一，不排序
Pageable pageable = PageRequest.of(page, size);

//方式二，自定义字段排序
Pageable pageable = PageRequest.of(page, size, sort);

//方式三，自定义多个字段相同的排序
Pageable pageable = PageRequest.of(page, size, direction,properties);

实现方式如下：

@Query(value = "select * from desk where id in (:ids)",nativeQuery = true)
Page<Desk> findAllDeskPageById(@Param("ids") List<Long> ids, Pageable pageable);

@Query(value = "from Desk where id in (:ids)")
Page<Desk> getDeskPageById(@Param("ids") List<Long> ids, Pageable pageable);

//当前页码（注意：第一页是从0开始）
int pageIndex = 0;
//分页大小
int pageSize = 10;
Sort sort = Sort.by(Sort.Order.desc("id"));
PageRequest pageRequest = PageRequest.of(pageIndex, pageSize, sort);

//查询所有
Page<Desk> desks = deskRepository.findAll(pageRequest);
//使用原生SQL语句
Page<Desk> desks = deskRepository.findAllDeskPageById(List.of(3L,4L),pageRequest);        
//使用JPQL语句
Page<Desk> desks = deskRepository.getDeskPageById(List.of(3L,4L),pageRequest);       


System.out.println(String.join("","当前页码数：", String.valueOf(desks.getNumber() + 1)," 页"));
System.out.println(String.join("","总页数：", String.valueOf(desks.getTotalPages())," 页"));
System.out.println(String.join("","总记录数：", String.valueOf(desks.getTotalElements())," 条"));
System.out.println(String.join("","每页的条数：", String.valueOf(desks.getSize())," 条"));
System.out.println(String.join("","数据列表：", String.valueOf(desks.getContent())));

JpaSpecificationExecutor 接口

可以用于动态生成Query来满足业务中的各种复杂场景

public interface DeskRepository extends JpaRepository<Desk,Long>, JpaSpecificationExecutor<Desk> { }

@Test
@Transactional
@Commit
public void StudentByName(){

  Desk desk = Desk.builder().identifier("5").id(4L).build();

  //排序 ：第一个参数是排序的规则(DESC/ASC)  后面参数是排序的字符
   Sort sort = Sort.by(Sort.Order.desc("id"));
   PageRequest pageRequest = PageRequest.of(0, 2, sort);

  /***
   * root:代表了可以查询和操作的实体对象的根，可以通过它的 Path<Y> get(String attributeName); 这个方法拿到要操作的字段
   *      注意:只可以拿到对应的T的字段(Employee)
   * criteriaQuery:代表一个specific的顶层查询对象,包含查询的各个部分,比如select,from,where,group by ,order by 等
   *      简单理解 就是它提供 了查询ROOT的方法(where,select,having)
   * criteriaBuilder:用来构建CriteriaQuery的构建器对象(相当于条件或者说条件组合),构造好后以Predicate的形式返回  
   */
  Page<Desk> desks = deskRepository.findAll((root, criteriaQuery, criteriaBuilder) -> {

      List<Predicate> predicateList = new ArrayList<>();
      if (StringUtils.hasText(desk.getIdentifier())) {
          predicateList.add(criteriaBuilder.equal(root.get("identifier"),desk.getIdentifier()));
      }

      if (desk.getId() != null) {
          predicateList.add(criteriaBuilder.equal(root.get("id"),desk.getId()));
      }

      return criteriaQuery.where(predicateList.toArray(new Predicate[0])).groupBy(root.get("id")).getRestriction();
  },pageRequest);

  System.out.println(desks.getContent());
}

参考 https://zhuanlan.zhihu.com/p/110024146

posted @ 2023-05-28 22:51  伊文小哥  阅读(200)  评论(0)  编辑  收藏  举报