SpringBoot基础教程(四) | JPA篇

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