Spring Data套装基础之JPA

最新推荐文章于 2022-06-28 22:59:18 发布
最新推荐文章于 2022-06-28 22:59:18 发布
阅读量195 收藏
点赞数
分类专栏： Spring 文章标签： jpa Spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/trayvontang/article/details/111718315
版权

文章目录

1. 简介

在Spring Data套装基础之Repositories中我们介绍了Spring Data最核心和公共的部分，这里我们简单介绍一下Spring Data JPA。

Spring Data JPA主要是针对关系数据库的，Spring Data Repository的东西都能使用，在查询方面肯定更加强大。

2. JPA 与 Spring Data JPA

JPA(Java Persistence API)Java持久化API，JDK1.5开始支持Java持久化规范(JSR 338)，即javax.persistence包相关接口。

JPA主要是为了规范ORM(对象关系映射技术，如Hibernate、TopLink、JDO等)，统一抽象层，面向接口编程，这样更容易切换、维护、重构。

JPA主要包括：

  1. ORM(Object Relational Metadata)元数据的映射
  2. 实体对象来执行CRUD操作相关API
  3. JPQL(Java Persistence Query Language)，面向对象查询语言，避免程序的SQL语句紧密耦合

JPA是ORM规范，Hibernate实现了JPA，Spring Data JPA在JPA之上添加另一层抽象，通过Repository简化了数据持久化的工作量。

3. Spring Data JPA 与 MyBatis

如果业务逻辑比较简单Spring Data JPA可能要好一些，因为很多时候不用自己写SQL。

如果业务逻辑比较复杂，MyBatis可能要更好一些，可以专注于SQL，方便统一管理，有问题好定位。

4. 接口与实现类

Repository接口：

  1. Repository：只要名字按规范，接口就可以直接使用，不需要写SQL
  2. CrudRepository：继承了Repository，添加了增删改查相关功能
  3. PagingAndSortingRepository：继承了CrudRepository，添加了了排序分页相关
  4. JpaRepository：继承了PagingAndSortingRepository，添加了更多增删改查的功能
  5. QueryByExampleExecutor：更底层的接口，JpaRepository继承了QueryByExampleExecutor，一些方法接受Example参数
  6. Specification：JPA中Root、CriteriaQuery、CriteriaBuilder的封装，用于构建过滤条件
  7. JpaSpecificationExecutor：更加灵活的查询方式，主要是为了更好的实现一些自定义的查询
  8. QueryDslPredicateExecutor：基于ORM、SQL等构建的通用查询API

实现类：

  1. SimpleJpaRepository：Spring Data JPA在处理Repository、UserCrudRepository、PagingAndSortingRepository、JpaRepository等接口使用的就是这个类
  2. QueryDslJpaRepository(弃用了，使用QuerydslJpaPredicateExecutor)
  3. QuerydslJpaPredicateExecutor：QueryDslPredicateExecutor实现类

5. 主键

@GenericGenerator：Hibernate主键生成策略注解
@GeneratedValue：Java注解，可以通过generator属性引用其他生成策略

也可以通过GenerationType指定，如@GeneratedValue(strategy = GenerationType.IDENTITY)

  1. AUTO：主键由程序控制，也是GenerationType的默认值
  2. TABLE：使用一个特定的数据库表格来保存主键
  3. SEQUENCE：根据底层数据库的序列来生成主键，条件是数据库支持序列
  4. IDENTITY：主键由数据库自动生成

6. @Query

@Query可以直接指定SQL语句，只需要将nativeQuery设置为true

@Query(value = "select * from user where username like ?1",nativeQuery = true)
List<User> queryByUsername(String username);

在SQL语句中使用?1,?2…?n这样的占位符和方法参数对应。

默认，@Query是JPQL：

@Query("select u from User u where u.username like %?1%")
List<User> getByUsernameLike(String username);

注意：在JPQL查询使用的是类名User而不是表名user

当然，还可以使用@param方式的参数

@Query("select u from User u where u.id = :id")
User getById(@Param("id") String userId);

还可以使用@Modifying执行更新操作：

@Transactional()
@Modifying
@Query("update User set username = ?1 where id = ?2")
int updateUsernameById(Integer id, String username);

排序与分页：

@Query("select u from User u where u.username like %?1%")
Page<User> findByUsernameLikePageable(String username, Pageable pageable);

@Query("select u from User where username like %?1%")
List<User> findByUsernameAndSort(String username, Sort sort);

7. JpaSpecificationExecutor

Spring data JPA不会扫描JpaSpecificationExecutor，想要直接使用，需要继承一个Repository接口。

JpaSpecificationExecutor接受Specification做为参数，方面我们自定义查询。

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.domain.Sort;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.test.context.junit4.SpringRunner;
import vip.mycollege.mysql.jpa.entity.User;

import javax.annotation.Resource;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import java.util.ArrayList;
import java.util.List;

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserJpaSpecificationExecutorTest {

    @Resource
    private UserJpaSpecificationExecutor userJpaSpecificationExecutor;

    @Test
    public void testJpaSpecificationExecutor1() {
        Specification<User> specification = new Specification<User>() {
            @Override
            public Predicate toPredicate(Root<User> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
                Predicate predicate = criteriaBuilder.equal(root.get("username"), "tim");
                return predicate;
            }
        };
        List<User> list = userJpaSpecificationExecutor.findAll(specification);
        for (User users : list) {
            System.out.println(users);
        }
    }

    @Test
    public void combin() {
        Specification<User> specification = new Specification<User>() {
            @Override
            public Predicate toPredicate(Root<User> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
                List<Predicate> list = new ArrayList<>();
                list.add(criteriaBuilder.equal(root.get("username"), "tim"));
                list.add(criteriaBuilder.equal(root.get("age"), 20));
                Predicate[] arr = new Predicate[list.size()];
                return criteriaBuilder.and(list.toArray(arr));
            }
        };
        List<User> list = userJpaSpecificationExecutor.findAll(specification);
        for (User users : list) {
            System.out.println(users);
        }
    }

    @Test
    public void orAnd() {
        Specification<User> specification = new Specification<User>() {
            @Override
            public Predicate toPredicate(Root<User> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
                Predicate namePredicate = criteriaBuilder.equal(root.get("username"), "tim");
                Predicate agePredicate = criteriaBuilder.equal(root.get("age"), 20);
                Predicate nameAndAgePredicate = criteriaBuilder.and(namePredicate, agePredicate);
                Predicate idPredicate = criteriaBuilder.equal(root.get("id"), 1);
                return criteriaBuilder.or(nameAndAgePredicate, idPredicate);
            }
        };
        Sort sort = Sort.by(Sort.Direction.DESC, "id");
        List<User> list = userJpaSpecificationExecutor.findAll(specification, sort);
        for (User users : list) {
            System.out.println(users);
        }
    }

    @Test
    public void gt() {
        Specification<User> specification = new Specification<User>() {
            @Override
            public Predicate toPredicate(Root<User> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
                return criteriaBuilder.gt(root.get("id").as(Integer.class), 2);
            }
        };
        Sort sort = Sort.by(Sort.Direction.DESC, "id");
        List<User> list = userJpaSpecificationExecutor.findAll(specification, sort);
        for (User users : list) {
            System.out.println(users);
        }
    }

    @Test
    public void lt() {
        Specification<User> specification = new Specification<User>() {
            @Override
            public Predicate toPredicate(Root<User> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
                return criteriaBuilder.lt(root.get("id").as(Integer.class), 2);
            }
        };
        Sort sort = Sort.by(Sort.Direction.DESC, "id");
        List<User> list = userJpaSpecificationExecutor.findAll(specification, sort);
        for (User users : list) {
            System.out.println(users);
        }
    }

    @Test
    public void between() {
        Specification<User> specification = new Specification<User>() {
            @Override
            public Predicate toPredicate(Root<User> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
                return criteriaBuilder.between(root.get("id").as(Integer.class), 2,10);
            }
        };
        Sort sort = Sort.by(Sort.Direction.DESC, "id");
        List<User> list = userJpaSpecificationExecutor.findAll(specification, sort);
        for (User users : list) {
            System.out.println(users);
        }
    }
}

8. 映射关系

8.1 @OneToMany

一对多的关系，例如，一个专业Speciality有多个User。

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import java.util.Set;

@Entity
@Table(name = "speciality")
public class Speciality {

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

@OneToMany(targetEntity = User.class, cascade = CascadeType.DETACH, fetch = FetchType.EAGER)
@JoinColumn(name = "speciality_id")
private Set<User> Users;

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

public Integer getId() {
return id;
}

public void setId(Integer id) {
this.id = id;
}

public Set<User> getUsers() {
return Users;
}

public void setUsers(Set<User> users) {
Users = users;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

@Override
public String toString() {
return "Speciality{" +
"id=" + id +
", Users=" + Users +
", name='" + name + '\'' +
'}';
}
}

然后，我们查询Speciality的时候就可以把关联的User都查出来。

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import vip.mycollege.mysql.jpa.entity.Speciality;

import javax.annotation.Resource;
import java.util.Iterator;


@RunWith(SpringRunner.class)
@SpringBootTest
public class SpecialityCrudRepositoryTest {

@Resource
private SpecialityCrudRepository specialityCrudRepository;

@Test
public void findAll(){
Iterator<Speciality> iterator = specialityCrudRepository.findAll().iterator();
while (iterator.hasNext()){
Speciality speciality = iterator.next();
System.out.println(speciality);
}
}
}

8.2 其他

除了最常用的@OneToMany，还有@ManyToMany、@ManyToOne、@OneToOne

OneToOne、OneToMany和ManyToMany可以设置mappedBy

在属于拥有关系中，没有mappedBy属性的实体是拥有者

两个实体中都又@ManyToMany，如果都没有设置mappedBy,则默认将生成两个实体表和两个连接表

8.3 CascadeType

选项说明
CascadeType.ALL包含下面四种
CascadeType.MERGE级联合并，若A属性修改了，那么关联对象B保存时同时修改A对象
CascadeType.REMOVE级联删除，A对象删除，那么关联对象B中的对象也会删除
CascadeType.PERSIST级联新增，A对象保存时，关联对象B中的对象也会保存
CascadeType.REFRESH级联刷新，获取A对象里也同时，也重新获取最新的关联对象B

9. hibernate表处理策略

spring.jpa.hibernate.ddl-auto=update

参数说明
none禁用DDL处理，默认值
create每次运行程序时，都会重新创建表，故而数据会丢失
upadte每次运行程序，没有表时会创建表，如果对象发生改变会更新表结构，原有数据不会清空，只会更新
validate运行程序会校验数据与数据库的字段类型是否相同，字段不同会报错
create-drop每次运行程序时会先创建表结构，然后待程序结束时清空表

10. 注解

注解说明
@Id指定表主键
@Lob将属性映射成数据库支持的大对象类型
@Table声明表名
@Basic指定非约束明确的各个字段
@Entity声明类为实体
@Column持久字段属性
@IdClass联合主键
@OrderBy排序
@Embedded指定类或它的值是一个可嵌入的类的实例的实体的属性
@OneToOne定义了连接表之间有一个一对一的关系
@Transient表示该属性并非一个到数据库表的字段的映射，JPA将忽略该属性
@EmbeddedId可嵌入式联合主键
@Enumerated映射enum枚举类型的字段
@AccessTypeFIELD直接访问字段，PROPERTY通过getter、setter方法字段
@JoinColumn连接字段
@ManyToOne定义连接表之间多对一关系
@OneToMany定义连接表之间一对多关系
@ManyToMany定义连接表之间多对多关系
@NamedQuery在实体类上，声明JPQL配置方法
@JoinColumns里面有多个@JoinColumn
@EntityGraph为了提高查询效率。解决N+1条SQL的问题
@ColumnResult字段返回值
@EntityResult实体返回值
@NamedQueries在实体类上，声明式JPQL配置方法
@GeneratedValue指定主键生成方式
@TableGenerator指定主键生成器
@NamedNativeQuery在实体类上，声明原始SQL配置
@NamedEntityGraph为了提高查询效率，解决N+1条SQL的问题
@UniqueConstraint指定的字段和用于主要或辅助表的唯一约束
@TemporalType.DATE映射只有日期的date
@TemporalType.TIME映射只有时间的time
@SequenceGenerator指定在@GeneratedValue注解中指定的属性的值。它创建了- -个序列
@SqlResultSetMapping字段属性映射
@SqlResultSetMappings多个@SqlResultSetMapping
@TemporalType.TIMESTAMP映射为日期datetime

11. 文档资料

Spring Data JPA文档
Spring Data JPA
querydsl

trayvontang
关注
专栏目录
JPA之Specification多条件搜索
li_tiantian的博客
08-22 2159
import javax.persistence.criteria.CriteriaBuilder; import javax.persistence.criteria.CriteriaQuery; import javax.persistence.criteria.Predicate; import javax.persistence.criteria.Root; import org.spr...
herbinate的基本属性总结
qq_18593653的博客
06-08 2862
1. @Id 声明属性为主键 2. @GeneratedValue表示主键是自动生成策略，一般该注释和 @Id 一起使用 3. @Entity 任何?hibernte 映射对象都要有次注释 4. @Table(name = “tablename”) 类声明此对象映射到哪个表 5. @Column(name = “Name”,nullable=false,le
springDataJpa使用2021-06-29
weixin_43681813的博客
07-01 191
实体类注解： @Data 用途：可自己生成getset方法（本地使用需要使用下载lombok插件） @Entity 用途：表名这是一个Entity类 @Table(name = “数据库表名”) 用途：对应数据库表名 属性字段注解： @Id 用途：声明这是主键id @GeneratedValue(stratefy=GenerationType.IDENTITY) 用途：设置自增策略为自动 @Column 用途：包含长短、表结构中对应的列名等等。 使用方法： 1.创建repository.StudentRep
Spring Data Jpa提供的findAll(Specification,Page)接口，查询不显示数据，显示条数
weixin_43854540的博客
10-26 3227
关于Spring Data Jpa提供的findAll(Specification,Page)接口，查询不显示数据，显示条数。 因为接口中的Page中的PageIndex是从0开始的，所有前端请求数据中的当前页要 -1才能出来结果。
SpringDataJPA之Specification复杂查询
热门推荐
★【World Of Moshow 郑锴】★
05-14 5万+
前言 继上次SpringData-JPA之ExampleMatcher实例查询使用一会之后发现ExampleMatcher对日期的查询特别糟糕，所以才有了Specification查询的研究。 实现 对应的Repository需要实现JpaSpecificationExecutor接口 public interface EventRepository extends JpaReposito...
spring注解+spring data jpa文档+JPA文档.rar
04-05
Spring框架的核心特性包括依赖注入（DI）和面向切面编程（AOP），并且它还提供了对数据库操作的支持，这主要通过Spring Data JPA和Java Persistence API（JPA）实现。 Spring注解是Spring框架中的一大特色，它极大...
Spring Data JPA API（Spring Data JPA 开发文档）.CHM
08-31
Spring Data JPA API。 Spring Data JPA 开发文档。 官网 Spring Data JPA API。
Spring Data JPA中文文档[1.4.3]_springdatajpa_erlang_waitxpf_
10-02
1. **Repository Abstraction**：这是 Spring Data JPA 的核心特性之一。它提供了一种声明式的数据访问接口，允许开发者定义自定义的查询方法，而不需要手动编写 SQL 或者 HQL（Hibernate Query Language）。例如，...
详解Spring Data JPA系列之投影（Projection）的用法
08-29
Spring Data JPA 投影（Projection）的用法 Spring Data JPA 系列中的投影（Projection）是一种非常有用的功能，它允许开发者自定义查询结果的结构和内容，从而满足不同的业务需求。在本文中，我们将详细介绍 ...
spring-gis:Spring Data JPA、Hibernate Spatial、Postgis
06-08
开发者只需要定义Repository接口，Spring Data JPA就能自动实现基础的数据库交互功能，如查询、保存和删除。 【Hibernate Spatial】 Hibernate Spatial是Hibernate ORM的一个扩展，用于处理空间数据。它为JPA提供了...
使用Spring Data Jpa为我们提供的@EntityGraph.docx
06-26
在很多情况下，我们使用Spring-Data- Jpa，一些简单的查询，我们都喜欢用定义方法查询，而不是写JPQL。JPA为我们提供了一组注解：使用Spring-Data- Jpa为我们提供的@EntityGraph，或@EntityGraph和@NamedEntityGraph进行解决。 @NamedEntityGraphs、@NamedEntityGraph、@EntityGraph @NamedEntityGraphs：用于对@NamedEntityGraph注解进行分组。 @NamedEntityGraph：用于指定查找操作或查询的路径和边界。 属性name：(可选) 实体图的名称。 默认为根实体的实体名。 属性attributeNodes：(可选) 包含在该图中的实体属性列表。 属性：includeAllAttributes：(可选)将注释实体类的所有属性作为属性节点包含在NamedEntityGraph中，而无需显式列出它们。包含的属性仍然可以由引用子图的属性节点完全指定。默认为false。一般不需要设置。 属性subgraphs：(可选)包含在实体图中的子图列表。这些是从
specification-with-projection:使用Spring Data JPA的JpaSpecificationExecutor.findAll（Specification，Pageable）支持投影
05-15
投影规格 使用Spring Data JPA的JpaSpecificationExecutor.findAll(Specification,Pageable)支持投影 适用于Spring Data JPA 2.x（Spring Boot 2.x）的2.xx版本 版本1.xx Spring Data JPA 1.x 如何使用 添加对pom的依赖 <!-- for Spring Data 2.x --> < dependency> < groupId>th.co.geniustree.springdata.jpa</ groupId> < artifactId>specification-with-projections</ artifactId> < version>2.0.1</ version> </ dependency> <!-- for
JPA中Specification方法
qq_34157673的博客
10-30 3331
jpa自定义findAll 步骤一：继承JpaRepository @Repository public interface ProjectDao extends JpaRepository<Project, String> { int countByProjectNameAndIdNot(String projectName, String id); Page<Project> findAll(Specification<Project> speci
find_all可以连续使用_使用Spring Data JPA的Specification构建数据库查询
weixin_26720479的博客
11-26 285
Spring Data JPA最为优秀的特性就是可以通过自定义方法名称生成查询来轻松创建查询SQL。Spring Data JPA提供了一个Repository编程模型，最简单的方式就是通过扩展JpaRepository，我们获得了一堆通用的CRUD方法，例如save，findAll，delete等。并且使用这些关键字可以构建很多的数据库单表查询接口：public interface Custom...
JPA 实现 增删改查
qq_36367462的博客
03-25 1041
一 ：使用JPA提供的基础CRUD操作 1.继承JPA提供的JpaRepository<T, ID>接口 /** * @Description * @data 2019-03-30 10:28 */ @Repository public interface PlayerRepository extends JpaRepository<Player,Integer> { } JpaRepository<T, ID>接口提供了基本的crud操作，可以直接调用
QueryDSL和Spring Data JPA动态查询实践
qq_40664458的博客
06-28 7294
QueryDSL和Spring Data JPA动态查询实践
Spring Data JPA Specification（规范）实现复杂查询(H2数据库)
蚩尤后裔-汪茂雄
04-28 2万+
目录 持久化 API 接口概述 JpaSpecificationExecutor 常用 API 编码示例 持久化 API 接口概述 1、JPA 持久化 API 接口主要如下： public interface PagingAndSortingRepository<T, ID> extends CrudRepository<T, ID> public inte......
Spring Data Jpa|利用Specification实现多表查询+动态查询
weixin_44217002的博客
02-28 1741
Spring Data Jpa 利用Specification实现多表查询+动态查询
Spring-Data-JPA中使用Specification实现动态查询
Wetsion的博客
04-12 2万+
      最近项目技术选型db框架选择了使用JPA，刚开始时，使用jpa进行一些单表简单的查询非常轻松，大家写的不亦乐乎，后来在遇到多条件动态查询的业务场景时，发现现有的JpaRepository提供的方法和自己写@Query已经满足了不了需求，难不成要对所有的条件和字段进行判断，再写很多个dao方法？后面查到jpa提供了围绕Specification这个类的一系列类，来用于实现动态查询。   ...
Spring Boot深度整合Spring Data JPA实战
"这篇文档是关于如何在Spring Boot项目中集成Spring Data JPA的教程，主要面向Spring Boot的高级用户。文档首先介绍了Spring Data JPA，这是一个基于Java Persistence API (JPA) 的Spring框架模块，旨在简化数据访问...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值