spring data jpa 之增删改查

熟悉了mybatis的灵活，可能你对他的动态查询很喜欢，表示各种sql都能胜任。初步接触jpa时，你会各种吐槽，不如mybatis来的方便。其实jpa也能帮你完成你的各种需求，至于编写的复杂度，那可能就仁者见仁智者见智了。习惯了，其实也一样了。

代码放github和码云了：spring-data/github spring-data/码云

save操作(含merge操作，即update也在save里)
  • save方法会预检查该entity是否持久化，isNew会判断该对象的Id类型 是否实现Persistable或EntityInformation进行重写isNew方法，如果Id是Number类型，直接判断value==0 true 执行entityManager.persist 否则执行entityManager.merge()
  /**
   * save方法会预检查该entity是否持久化，isNew会判断该对象的Id类型 是否实现Persistable或EntityInformation进行
   * 重写isNew方法，如果Id是Number类型，直接判断value==0 true 执行entityManager.persist 否则执行entityManager.merge()
   */
  @Test
  public void insert() {
    Customer customer = new Customer();
    customer.setName("lk");
    customer.setEmail("spring.jpa@163.com");
    customer.setAddress("Shanghai PuDong Area XueYe Road");
    customer.setPhone("13699999999");
    //这里保存以后customer的id会被填充为保存后entity的id
    Customer savedEntity = customerRepository.save(customer);
    //保存并立即刷新数据库，由于customer以及提供id，会执行merge方法进行保存
//    Customer savedAndFlush = customerRepository.saveAndFlush(customer);
    List<Customer> batchCustomers = Arrays.asList(new Customer(), new Customer());
    //批量保存,saveAll是循环单挑插入，并不是batch操作，数据较大使用时请注意性能
//    List<Customer> batchSaves = customerRepository.saveAll(batchCustomers);
  }
delete操作
  • delte操作会先执行查询(除了batch操作)，在执行删除，若查询不到结果，抛出异常(EmptyResultDataAccessException)不执行删除
  /**
   * 删除操作，除了batch操作，其他方法均先查询后删除
   */
  @Test
  public void delete() {
    //select * from customer where id=?;delete from customer where id=?;
    //同delete(entity)
    customerRepository.deleteById(38L);
    //select * from customer;循环遍历id单个删除...delete from customer where id=?...
    customerRepository.deleteAll();
    Customer customer = new Customer();
    customer.setId(Long.valueOf(42L));
    Customer customerOther = new Customer();
    customerOther.setId(41L);
    List<Customer> deleteAll = Arrays.asList(customer,customerOther);
    //循环执行delete(entity)
    customerRepository.deleteAll(deleteAll);
    //不查询直接：delete from customer;(风险较大清空表)
    customerRepository.deleteAllInBatch();
    //不查询直接：delete from customer where id=? or id=?
    customerRepository.deleteInBatch(deleteAll);
  }

最常用的query操作

jpa 官方查询关键字
KeywordSampleJPQL snippet
And findByLastnameAndFirstname … where x.lastname = ?1 and x.firstname = ?2
Or findByLastnameOrFirstname … where x.lastname = ?1 or x.firstname = ?2
Is,Equals findByFirstname,findByFirstnameIs,findByFirstnameEquals … where x.firstname = ?1
Between findByStartDateBetween … where x.startDate between ?1 and ?2
LessThan findByAgeLessThan … where x.age < ?1
LessThanEqual findByAgeLessThanEqual … where x.age <= ?1
GreaterThan findByAgeGreaterThan … where x.age > ?1
GreaterThanEqual findByAgeGreaterThanEqual … where x.age >= ?1
After findByStartDateAfter … where x.startDate > ?1
Before findByStartDateBefore … where x.startDate < ?1
IsNull findByAgeIsNull … where x.age is null
IsNotNull,NotNull findByAge(Is)NotNull … where x.age not null
Like findByFirstnameLike … where x.firstname like ?1
NotLike findByFirstnameNotLike … where x.firstname not like ?1
StartingWith findByFirstnameStartingWith … where x.firstname like ?1 (parameter bound with appended %)
EndingWith findByFirstnameEndingWith … where x.firstname like ?1 (parameter bound with prepended %)
Containing findByFirstnameContaining … where x.firstname like ?1 (parameter bound wrapped in %)
OrderBy findByAgeOrderByLastnameDesc … where x.age = ?1 order by x.lastname desc
Not findByLastnameNot … where x.lastname <> ?1
In findByAgeIn(Collection<Age> ages) … where x.age in ?1
NotIn findByAgeNotIn(Collection<Age> ages) … where x.age not in ?1
True findByActiveTrue() … where x.active = true
False findByActiveFalse() … where x.active = false
IgnoreCase findByFirstnameIgnoreCase … where UPPER(x.firstame) = UPPER(?1)
单表字段查询
    //select * from customer;
    customerRepository.findAll();
    //select * from customer where id = 1;
    customerRepository.findById(1L);
    //select * from customer where address = "address";
    customerRepository.findCustomerByAddress("address");
    //select * from customer where name = "lk" and phone = "133";
    customerRepository.findCustomersNameAndPhone("133", "lk");
    //select * from customer where name like '%k';
    customerRepository.findCustomersNameLike("k");
    //select * from customer where name like 'k'; 如果需要模糊查询需要手动拼接 % 连接符
    customerRepository.findCustomersByNameLike("k");
    //select * from customer where name like "%l";
    customerRepository.findCustomersByNameStartingWith("l");
    //select * from customer where name like "%k%";
    customerRepository.findCustomersByNameContains("k");
    / /.....还有很多，不再一一列举......
分页，排序
    //select * from customer order by name desc;
    customerRepository.findAll(Sort.by(Direction.DESC, "name"));
    //select * from customer limit 0,10;
    customerRepository.findAll(PageRequest.of(0, 10));
example查询（场景较少）
    Customer customer = new Customer();
    customer.setAddress("address");
    //select * from customer where address ="address";
    customerRepository.findAll(Example.of(customer));
    customer.setName("lk");
    customer.setPhone("133");
    ExampleMatcher matcher = ExampleMatcher.matching()
        .withMatcher("name", match -> match.contains())
        .withMatcher("phone", match -> match.startsWith());
    //select * from customer where name like '%lk%" and phone like '133%' and address = "address";
    customerRepository.findOne(Example.of(customer, matcher));
namedQuery 也是自定义的@Query的一种
//entity
@Entity(name = "Customer")
@NamedQuery(name = "Customer.findByNameNQ", query = "select c from Customer c where name =?1")
public class Customer {}

//repository定义方法findByNameNQ
List<Customer> findByNameNQ(String name);

//test
//namedQuery:select * from customer where name = "lk";
customerRepository.findByNameNQ("lk");
@Query自定义JQL语句查询，语法跟sql类似，但注意基于entity的命名，如果属性nativeQuery为ture则，必须用原生sql语句
  @Query("select c from Customer c where name like %?1")
  List<Customer> findCustomersNameLike(String name);

  @Query("select c from Customer c where name = :name and phone = :phone")
  List<Customer> findCustomersNameAndPhone(@Param("phone") String phone,
      @Param("name") String name);

  @Query(value = "select * from customer where name =?1",nativeQuery = true)
  List<Customer> findByNameSql(String name);
@Modify 配合 @Query实现 修改部分字段
  @Modifying
  @Query("update Customer c set c.name = :name where c.id = :id")
  int modifyByPhone(@Param("name") String name,@Param("id") Long id);

  @Modifying
  @Query("delete from Customer c  where c.id = ?1")
  int deleteCustomer(Long id);

自定义返回值，基于JQL语法，在拼装返回结果集时，是根据构造函数进行组装的，可以基于接口或者类，要保证属性是entity内的属性。也可以借助@Query，使用 new map()返回map，或者new Class返回想要的结果。

  //repository

  List<NameOnlyI> findCustomersByName(String name);

  List<NameOnly> findByName(String name);

  @Query("select new com.spring.jpa.beans.NameOnly(name,address) from Customer where name = ?1")
  List<NameOnly> findByName4Obj(String name);

  @Query("select new map(name as myname,address as myaddress) from Customer where name = :name")
  List<Map<String, Object>> findByName4Map(@Param("name") String name);

//test

    //基于接口的返回值
    List<NameOnlyI> interfaces = customerRepository.findCustomersByName("lk1");
    //基于类的返回值，如果有两个构造函数会报错，无法解析转换
    List<NameOnly> nameOnlies = customerRepository.findByName("lk1");
    //基于类的返回值，@Query显式声明返回bean
    List<NameOnly> objs = customerRepository.findByName4Obj("lk1");
    //@Query返回map 用as做key，不用as默认key是0，1，2...
    List<Map<String, Object>> maps = customerRepository.findByName4Map("lk1");

复杂关联关系查询 @OneToOne @ManyToMany @ManyToOne @OneToMany

customer 顾客表，和customer_group 多对一
customer_group 顾客分组表
book 书籍表，customer是多对多。
book_detail 书籍详细表，和book是一对一

  • 四张表没任何业务，假象出来的，单纯为了验证jpa查询方式
表关系注解参数（@OneToOne @ManyToMany @ManyToOne @OneToMany ）
Cascade级联操作
CascadeType. PERSIST 级联持久化 ( 保存 ) 操作
CascadeType. MERGE 级联更新 ( 合并 ) 操作
CascadeType. REFRESH 级联刷新操作，只会查询获取操作
CascadeType. REMOVE 级联删除操作
CascadeType. ALL 级联以上全部操作
  • Fetch
    抓取是否延迟加载，默认情况一的方为立即加载，多的一方为延迟加载，可以手动指定Fetch.EAGER/Fetch.LAZY
  • mappedBy
    关联关系由此方属性维护，可以理解成一对注解使用mappedBy的一方由另一方维护，且必须是注解作用下的属性名。
可以根据关联表的属性作为条件查询，结果同样是根据两次sql查询出来的。通过关联表的属性进行查询时，使用关联 entityName_columnName方式，或者直接使用 _columnName进行查询。如果不想级联查询时，在一方不适用注解即可。

@OneToOne

一对一关联关系，有三种形式存在：

  • 两张表共享主键pk，使用@PrimaryKeyJoinColumn来建立关联关系
@Entity
public class A {
  @Id
  private Long id;
  @OneToOne(cascade = CascadeType.ALL)
  @PrimaryKeyJoinColumn
  private B b;
}

@Entity
public class B {
  @Id
  private Long id;
}
  • 通过中间表建立关联关系，使用@JoinTable注解，joinColumns指定本表和关联表的外键，inverseJoinColumns指定关联关系另一方和关联表的外键
@Entity
public class A {
  @Id
  private Long id;
  @OneToOne(cascade = CascadeType.ALL)
  joinColumns = @JoinColumn(name="a_fk"),
  inverseJoinColumns = @JoinColumn(name="b_fk")
  private B b;
}

@Entity
public class B {
  @Id
  private Long id;
  @OneToOne(mappedBy="b")
  private A a;
}
  • 通过外键，唯一约束指定关联关系，使用@JoinColumn注解，如果不写该注解，默认会在此表中自动创建连接列：主表属性_关联表主键名称
@Entity(name = "book")
public class Book {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;

  private String name;
  private Integer count;

  @OneToOne(cascade = CascadeType.ALL)
  @JoinColumn(name = "detail_id",referencedColumnName = "id")
//referencedColumnName 不写默认是主键，当不是主键是可以用此声明，但必须保证连接键在连接表是唯一约束的
  private BookDetail bookDetail;

//setter getter
}

@Entity(name = "book_detail")
public class BookDetail {

  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;
  private String size;
//不需要依赖book可以不写关联属性

//setter getter
}

public interface BookRepository extends JpaRepository<Book, Long> {

  //可以查出关联表的实体，结果是根据两次sql查询出来的，即select * from book where name = ?;->查出detail_id->select * from book_detail where id = ?;
  List<Book> findByName(String name);
  //可以根据关联表的属性作为条件查询，结果同样是根据两次sql查询出来的。通过关联表的属性进行查询时，使用关联 entityName_columnName方式，或者直接使用 _columnName进行查询。
  List<Book> findByNameAndBookDetail_Id(String name, Long id);

  //自定义返回值，一次查询返回结果
  @Query("select new com.spring.jpa.beans.BookResult(b.id as id,b.name as name ,d.size as size) from Book as b left join BookDetail as d on b.bookDetail = d.id")
  List<BookResult> findResults();

}
@ManyToMany
  • 通过@ManyToMany 注解定义多对多关系，同时通过 @JoinTable 注解描述关联表和关联条件。
// 维护端注解
@Entity
public class A {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;
  @ManyToMany (cascade = CascadeType.REFRESH)
  @JoinTable (
           name =  "a_b" , //关联表名
           inverseJoinColumns =  @JoinColumn (name =  "a_id" ),//被维护端外键
           joinColumns =  @JoinColumn (name =  "b_id" ))//维护端外键被维护端注解
   private B b;

//setter getter
}

@Entity
public class B {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;
  @ManyToMany(cascade = CascadeType.REFRESH,
            mappedBy = "b",//通过维护端的属性关联
            fetch = FetchType.LAZY)
// 关系维护端删除时，如果中间表存在些纪录的关联信息，则会删除该关联信息;
// 关系被维护端删除时，如果中间表存在些纪录的关联信息，则会删除失败 .
  private A a;

//setter getter
}
  • 默认joinColumn值：关联表名：主表表名 + 下划线 + 从表表名；关联表到主表的外键：主表表名 + 下划线 + 主表中主键列名；关联表到从表的外键名：主表中用于关联的属性名+ 下划线 + 从表的主键列名
@ManyToOne @OneToMany
  • 注解和上面都差不多，无非就是谁关联谁
@Entity
@NamedQuery(name = "Customer.findByNameNQ", query = "select c from Customer c where name =?1")
public class Customer {

  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;
  private String name;
  private String email;
  private String address;
  private String phone;

//  //targetEntity 默认是关联实体，若使用接口作为关联实体时，应指明targetEntity的实现类，且接口应继承Serializable，否则无法被解析
//  @ManyToOne(fetch = FetchType.EAGER,targetEntity = CustomerGroup.class)
//  @JoinColumn(name = "group_type",referencedColumnName = "type")
//  private CustomerGroupInterface customerGroup;

  //manyToOne 单向关联或 oneToMany双向关联
//  //这里使用非主键作为外键关联，type在customer_group表中唯一约束，也可以使用@JoinTable 处理关联表做连接这里不再演示
  @ManyToOne(fetch = FetchType.EAGER,cascade = CascadeType.ALL)
  @JoinColumn(name = "group_type",referencedColumnName = "type")
  private CustomerGroup customerGroup;

  //customerGroup为一的一方，单向关联customer（多方）
//  @Column(name = "group_type")
//  private String type;

//setter getter
}

@Entity
@Table(name = "customer_group")
public class CustomerGroup implements CustomerGroupInterface {

  private static final long serialVersionUID = -6956725658881048590L;
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;
  @Column(unique = true)
  private String type;
  private String name;
  private Integer level;

  //oneToMany 单向关联，customer中无需注解，注意joinColumn是table中的name
//  @OneToMany(fetch = FetchType.EAGER)
//  @JoinColumn(name = "group_type")

  //oneToMany 双向关联，customer中无需注解,mappedBy必须指向entity中的属性名，即标有@ManyToOne的属性名，且此处不可再使用@JoinColumn。
  @OneToMany(fetch = FetchType.EAGER, mappedBy = "customerGroup")
  private List<Customer> customers;

//setter getter
}
其他注解
注解解释
@Entity 声明一个类为实体Bean。
@Table 说明此实体类映射的表名，目录，schema的名字。
@Id 声明此表的主键。
@GeneratedValue 定义主键的增长策略。我这里一般交给底层数据库处理，所以调用了名叫generator的增长方式，由下边的@GenericGenerator实现。
@GenericGenerator hibernate内部的主键增长方式。
@Version 注解用于支持乐观锁版本控制。一般可以用 数字 或者 timestamp 类型来支持 version.
@Column name 可选，列名(默认值是属性名); unique 可选，是否在该列上设置唯一约束(默认值false);nullable 可选，是否设置该列的值可以为空(默认值true); insertable 可选，该列是否作为生成的insert语句中的一个列(默认值true);updatable 可选，该列是否作为生成的update语句中的一个列(默认值true); columnDefinition 可选，为这个特定列覆盖SQL DDL片段 (这可能导致无法在不同数据库间移植); table 可选，定义对应的表(默认为主表);length 可选，列长度(默认值255);precision 可选，列十进制精度(decimal precision)(默认值0);scale 可选，如果列十进制数值范围(decimal scale)可用,在此设置(默认值0)
@Index 某一字段加索引 @Table(name = "customer", indexes = {@Index(columnList = "name")})，给name字段加上索引
@Transient 被注解成 @Transient 的 getter 方法或属性，将不会被持久化（自己测试，只有放在getter方法内才起作用）
@Basic 所有没有定义注解的属性，等价于在其上面添加了 @Basic注解可以声明属性的获取策略 ( fetch strategy ),fetch:抓取策略,延时加载与立即加载，optional:指定在生成数据库结构时字段是否允许为 null.
@Temporal 在核心的 Java API 中并没有定义时间精度 ( temporal precision )。因此处理时间类型数据时，你还需要定义将其存储在数据库中所预期的精度。
@Enumerated 枚举类型成员属性映射,EnumType.STRING指定属性映射为字符串,EnumType.ORDINAL指定属性映射为数据序
@Lob 用于标注字段类型为Clob和Blob类型，Clob(Character Large Ojects)类型是长字符串类型,实体的类型可为char[]、Character[]、或者String类型，Blob(Binary Large Objects)类型是字节类型,实体的类型可为byte[]、Byte[]、或者实现了Serializable接口的类。通常使用惰性加载的方式,@Basic(fetch=FetchType.LAZY)
@SecondaryTable （@javax.persistence.SecondaryTable）将一个实体映射到多个数据库表中


作者：打不开的回忆
链接：https://www.jianshu.com/p/de122a0c3fd2
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/hanzeng1993/p/11926597.html