Spring Data Jpa介绍

JPA（Java persisten API），全称为Java持久化API，是JAVAEE中的一套规范API。它推出的目的是对ORM框架进行大统一，它提供一套接口，让厂商们（如hibernate）对JPA提供实现。JPA与hibernate的关系就像JDBC与Mysql驱动、Oracle驱动一样的关系，只是它更加高度抽象，可以称之为ORM框架的接口。
Spring Data JPA 是 Spring 基于 Spring Data 框架、在JPA 规范的基础上开发的一个框架，使用 Spring Data JPA 可以极大地简化JPA 的写法，可以在几乎不用写实现的情况下实现对数据库的访问和操作，除了CRUD外，还包括分页和排序等一些常用的功能。

Spring Data Jpa实战

• 创建项目

maven依赖详情如下

<?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.2.0.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>training.springboot</groupId>
    <artifactId>jpa</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>jpa</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <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-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

配置文件详情如下

# 数据库相关配置
spring.datasource.username=root
spring.datasource.password=yzhroot
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8&serverTimezone=CTT

# JPA相关配置
# 数据库类型
spring.jpa.database=mysql
# 日志输出sql
spring.jpa.show-sql=true
# 建表语句设置
spring.jpa.hibernate.ddl-auto=update
# 解决spring-mvc与hibernate事务问题
spring.jpa.open-in-view=true

• 实战场景

这次练习主要涉及到三个实体，用户，部门以及角色，其中用户和部门是多对一，用户和角色是多对多关系。

• 编写实体类

/**
 * 用户实体类
 */
@Entity(name = "user")
public class User {

    //设置id为主键，生成策略是自增
    @Id
    @GeneratedValue(strategy= GenerationType.IDENTITY)
    private Long id;
    private String username;

    //设置数据库列名是create_date，格式为 yyyy-MM-dd
    @Temporal(value = TemporalType.DATE)
    @Column(name = "create_date")
    private Date createDate;

    //防止JSON序列化时循环引用
    @ManyToOne(cascade = CascadeType.ALL)
    @JoinColumn(name = "department_id")
    @JsonBackReference
    private Department department;

    //多对多
    @ManyToMany(fetch = FetchType.EAGER)
    @JoinTable(name = "user_and_role",
            joinColumns = {@JoinColumn(name = "user_id",referencedColumnName = "id")},
            inverseJoinColumns = {@JoinColumn(name = "role_id",referencedColumnName = "id")})
    private List<Role> roles;

    public Long getId() {
        return id;
    }

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

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public Date getCreateDate() {
        return createDate;
    }

    public void setCreateDate(Date createDate) {
        this.createDate = createDate;
    }

    public Department getDepartment() {
        return department;
    }

    public void setDepartment(Department department) {
        this.department = department;
    }

    public List<Role> getRoles() {
        return roles;
    }

    public void setRoles(List<Role> roles) {
        this.roles = roles;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", createDate=" + createDate +
                ", department=" + department +
                ", roles=" + roles +
                '}';
    }
}

/**
 * 角色实体类
 */
@Entity(name = "role")
public class Role {

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

    @ManyToMany
    @JoinTable(name = "user_and_role",
            joinColumns = {@JoinColumn(name = "role_id",referencedColumnName = "id")},
            inverseJoinColumns = {@JoinColumn(name = "user_id",referencedColumnName = "id")})
    @JsonBackReference
    private List<User> users;

    public Long getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public List<User> getUsers() {
        return users;
    }

    public void setUsers(List<User> users) {
        this.users = users;
    }
}

/**
 * 部门实体类
 */
@Entity(name = "department")
public class Department {

    @Id
    @GeneratedValue(strategy= GenerationType.IDENTITY)
    private Long id;
    private String name;
    //设置一对多的映射表
    @OneToMany(mappedBy="department",cascade = CascadeType.ALL)
    private List<User> users;

    public Long getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public List<User> getUsers() {
        return users;
    }

    public void setUsers(List<User> users) {
        this.users = users;
    }
}

创建实体时涉及到了几个Jpa的常用注解，下面来简单解释一下。

• @Entity：表明这是一个实体类，name属性的值代表与这个实体类映射的数据库表。

• @Id：表明这个属性是数据库中的主键。

• @GeneratedValue：用来声明主键是自动生成的，strategy的常见的值有四个；分别是TABLE、AUTO、IDENTITY、SEQUENCE。

  • TABLE：使用一个特定的数据库表格来保存主键。
  • AUTO：主键由程序控制，是默认值。
  • IDENTITY：主键由数据库自动生成（主要是支持自动增长的数据库，如mysql）
  • SEQUENCE：根据底层数据库的序列来生成主键，条件是数据库支持序列。 这个值要与generator一起使用，generator 指定生成主键使用的生成器（可能是orcale中自己编写的序列）。

• @OneToMany：用于标识一对多关系，mappedBy属性是One方的属性名称，cascade 属性是代表着级联操作。

• ManyToMany：用于标识多对多关系。

• @JoinTable：用于标识中间表，并需要制定另一个joinColumns标识本表主键在中间表的名称，inverseJoinColumns标识另一个Many方的主键在中间表的名称。

• @JsonBackReference：防止Json转换后循环调用。

• @Temporal：标明属性在数据库中是date类型，TemporalType的值有三种；

  • TemporalType.DATE：实体类会封装成日期“yyyy-MM-dd”的 Date类型。
  • TemporalType.TIME：实体类会封装成时间“hh-MM-ss”的 Date类型。
  • TemporalType.TIMESTAMP：实体类会封装成完整的时间“yyyy-MM-dd hh:MM:ss”的 Date类型。

• 编写实体类的CRUD

/**
 * 部门实体类的CRUD操作
 */
@Repository
public interface DepartmentDao extends JpaRepository<Department,Long> {
}

/**
 * 角色实体类的CRUD操作
 */
@Repository
public interface RoleDao extends JpaRepository<Role,Long> {
}

/**
 * 用户实体类的CRUD操作
 */
@Repository
public interface UserDao extends JpaRepository<User,Long> {
}

可以看到我们只需编写一个接口继承JpaRepository接口便可以基本的CRUD操作，下面来简单介绍下原理。
JpaRepository继承自PagingAndSortingRepository和QueryByExampleExecutor，而
PagingAndSortingRepository继承自CrudRepository。

• CrudRepository

public interface CrudRepository<T, ID> extends Repository<T, ID> {
    <S extends T> S save(S var1); //插入或更新一条记录

    <S extends T> Iterable<S> saveAll(Iterable<S> var1);//插入或更新多条记录

    Optional<T> findById(ID var1);//根据ID查询一个实体

    boolean existsById(ID var1);//根据ID判断一个实体是否存在

    Iterable<T> findAll();//查询所有实体

    Iterable<T> findAllById(Iterable<ID> var1);//根据ID批量查询实体

    long count();//查询所有实体的数量

    void deleteById(ID var1);    //根据ID删除一个实体

    void delete(T var1);//根据一个实体的信息，删除这个实体

    void deleteAll(Iterable<? extends T> var1);  //批量删除实体

    void deleteAll();    //删除全部实体
}

• PagingAndSortingRepository

public interface PagingAndSortingRepository<T, ID> extends CrudRepository<T, ID> {
    Iterable<T> findAll(Sort var1);//根据规则排序

    Page<T> findAll(Pageable var1);//分页查询
}

• JpaRepository

public interface JpaRepository<T, ID> extends PagingAndSortingRepository<T, ID>, QueryByExampleExecutor<T> {
    List<T> findAll(); // 查询所有实体
 
    List<T> findAll(Sort sort); // 查询所有实体并排序
 
    List<T> findAll(Iterable<ID> ids); // 根据ID集合查询实体
 
    <S extends T> List<S> save(Iterable<S> entities); // 保存并返回（修改后的）实体集合
 
    void flush(); // 提交事务
 
    <S extends T> S saveAndFlush(S entity); // 保存实体并立即提交事务
 
    void deleteInBatch(Iterable<T> entities); // 批量删除实体集合
 
    void deleteAllInBatch();// 批量删除所有实体
 
    T getOne(ID id); // 根据ID查询实体
 
    @Override
    <S extends T> List<S> findAll(Example<S> example); // 查询与指定Example匹配的所有实体
 
    @Override
    <S extends T> List<S> findAll(Example<S> example, Sort sort);// 查询与指定Example匹配的所有实体并排序
}

简单来说，SpringDataJpa在运行时，会以动态代理的形式生成实现这些方法的代理对象，然后就可以实现我们的增删改查功能了。
另外，JPA还支持约定命名法，以下是约定规则（下图来自https://blog.csdn.net/Phapha1996/article/details/78712597
）：

Jpa约定规则

• 测试

由于篇幅有限，只简单写出几种测试，完整代码见底部链接

@SpringBootTest
class JpaApplicationTests {

    @Autowired
    private UserDao userDao;

    @Autowired
    private DepartmentDao departmentDao;

    //添加一个USER
    @Test
    public void testAddUser(){
        User user = new User();
        user.setCreateDate(new Date());
        user.setUsername("小明");
        userDao.save(user);
    }

    //添加一个部门，级联操作
    @Test
    public void testAddDepartment(){
        Department department = new Department();
        department.setName("研发部");
        department.setId((long) 1);

        User user = new User();
        user.setId((long) 2);
        user.setUsername("小红2");
        user.setCreateDate(new Date());

        List<User> users = new ArrayList<>();
        users.add(user);
        department.setUsers(users);
        departmentDao.save(department);
    }

    //查询所有USER
    @Test
    public void testQueryAllUser(){
        System.out.println(userDao.findAll());
    }

}

完整的工程代码链接：https://github.com/youzhihua/springboot-training