SpringBoot 中 JPA 的使用

详细连接 简书https://www.jianshu.com/p/c14640b63653

新建项目，增加依赖

根据本样例的需求，我们要添加下面三个依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>6.0.6</version>                      引入的依赖尤其是这个依赖更加的重要你连接的数据库驱动就需要它

</dependency>

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver   

准备数据库环境

为这个项目，我们专门新建一个 springboot_jpa 的数据库，并且给 springboot 用户授权

create database springboot_jpa;  如果你用的是不是mysql的root 可以使用这个语句进行授权  如果是root那也可以不用进行授权
grant all privileges on springboot_jpa.* to 'springboot'@'%' identified by 'springboot';
flush privileges;

项目配置

但是数据库要自己创建
#通用数据源配置
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://10.110.2.56:3306/dbjpa?charset=utf8mb4&useSSL=false&serverTimezone=UTC //有时这个也是很必要的.

 spring.datasource.username=springboot spring.datasource.password=springboot 
# Hikari 数据源专用配置
 spring.datasource.hikari.maximum-pool-size= spring.datasource.hikari.minimum-idle=5

 # JPA 相关配置 
spring.jpa.database-platform=org.hibernate.dialect.MySQL5InnoDBDialect
 spring.jpa.show-sql=true //配置在日志中打印出执行的 SQL 语句信息。

 spring.jpa.hibernate.ddl-auto=update 每次都会更新你的表首次访问会进行创建

1. spring.jpa.hibernate.ddl-auto=create 配置指明在程序启动的时候要删除并且创建实体类对应的表。这个参数很危险，因为他会把对应的表删除掉然后重建。所以千万不要在生成环境中使用。只有在测试环境中，一开始初始化数据库结构的时候才能使用一次。
2. spring.jpa.database-platform=org.hibernate.dialect.MySQL5InnoDBDialect 。在 SrpingBoot 2.0 版本中，Hibernate 创建数据表的时候，默认的数据库存储引擎选择的是 MyISAM （之前好像是 InnoDB，这点比较诡异）。这个参数是在建表的时候，将默认的存储引擎切换为 InnoDB 用的。

建立第一个数据实体类

数据库实体类是一个 POJO Bean 对象。这里我们先建立一个 数据库实体。数据库实体的源码如下

package cn.edu.aynu.entities;

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;

import javax.persistence.*;

/**
 * Description: 164804116zln
 * Created by lenovo on 2019/5/6 13:23
 */
@Data
@NoArgsConstructor
@Entity(name = "employee") //@Entity 是一个必选的注解，声明这个类对应了一个数据库表
@JsonIgnoreProperties(value = {"handler","hibernateLazyInitializer","fieldHandler"})  //下面解释

public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    @Column
    private String name;
    @Column
    private String address;

    public Employee(String name, String address) {
        this.name = name;
        this.address = address;
    }

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

在hibernate查询数据,并将数据转化为json的时候报错,原因是hibernate在配置表A与表B之间的映射时，会在类A中引用类B，在类B中引用类A。当其中一个对象用jackson转成json时，会造成他们之间的无限引用，直到报错. 
解决办法:

在引用类及被引用类上加上注解

@JsonIgnoreProperties(value = {"handler","hibernateLazyInitializer","fieldHandler"})

但是，我就只建立了一个表居然还报错是不是很搞笑

其中：

@Table(name = "AUTH_USER") 是一个可选的注解。声明了数据库实体对应的表信息。包括表名称、索引信息等。这里声明这个实体类对应的表名是 AUTH_USER。如果没有指定，则表名和实体的名称保持一致。

1. @Id 注解声明了实体唯一标识对应的属性。
2. @Column(length = 32) 用来声明实体属性的表字段的定义。默认的实体每个属性都对应了表的一个字段。字段的名称默认和属性名称保持一致（并不一定相等）。字段的类型根据实体属性类型自动推断。这里主要是声明了字符字段的长度。如果不这么声明，则系统会采用 255 作为该字段的长度

 @GeneratedValue(strategy = GenerationType.IDENTITY) 
（https://www.cnblogs.com/sandea/p/8252809.html）这是一个很详细的注解解释上面的例子

实现一个持久层服务

在 Spring Data JPA 的世界里，实现一个持久层的服务是一个非常简单的事情。我只需要声明一个接口，这个接口继承
org.springframework.data.repository.Repository<T, ID> 接口或者他的子接口就行。这里为了功能的完备，我们继承了 org.springframework.data.jpa.repository.JpaRepository<T, ID> 接口。其中 T 是数据库实体类，ID 是数据库实体类的主键。
然后再简单的在这个接口上增加一个 @Repository 注解就结束了。其实不加也可以

@Repository
public interface UserDao extends JpaRepository<employee, Long> {
}

那么你就有了操纵数据库的基本功能,我使用的是postman进行测试的

package cn.edu.aynu.controller;

import cn.edu.aynu.dao.EmployeeDao;
import cn.edu.aynu.entities.Employee;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * Description: 164804116zln
 * Created by lenovo on 2019/5/6 13:31
 */
@RestController
public class EmployeeHandler {

    @Autowired
    EmployeeDao employeeDao;

    @PostMapping(path = "/add")
    public void add(@RequestBody Employee employee){
        employeeDao.save(employee);

    }
    @GetMapping("/emp/{id}")

    public Employee get(@PathVariable("id") Integer id){
        System.out.println(id);
        Employee employee = employeeDao.getOne(id);

        return  employee;
    }

    @GetMapping("/emps")
    public List<Employee> getAll(){
        List<Employee> employees = employeeDao.findAll();
        return employees;
    }

}

Controller

数据库记录

我们还可以通过测试用例验证通过标识查找对象功能，查询所有数据功能的正确性，查询功能甚至可以进行排序和分页

    @Test
    public void testLocate() {
        Optional<UserDO> userDOOptional = userDao.findById(1L);
        if (userDOOptional.isPresent()) {
            UserDO userDO = userDOOptional.get();
            System.out.println("name = " + userDO.getName());
            System.out.println("account = " + userDO.getAccount());
        }
    }

    @Test
    public void testFindAll() {
        List<UserDO> userDOList = userDao.findAll(new Sort(Sort.Direction.DESC,"account"));
        for (UserDO userDO : userDOList) {
            System.out.println("name = " + userDO.getName());
            System.out.println("account = " + userDO.getAccount());
        }
    }

controller

可以看到，我们所做的全部事情仅仅是在 SpingBoot 工程里面增加数据库配置信息，声明一个 UserDO 的数据库实体对象，然后声明了一个持久层的接口，改接口继承自 org.springframework.data.jpa.repository.JpaRepository<T, ID> 接口。然后，系统就自动拥有了丰富的增加、删除、修改、查询功能。查询功能甚至还拥有了排序和分页的功能。

这就是 JPA 的强大之处。除了这些接口外，用户还会有其他的一些需求， JPA 也一样可以满足你的需求。

扩展查询

很多我们想要的查询功能还没有。不过放心。JPA 有非常方便和优雅的方式来解决

根据属性来查询

如果想要根据实体的某个属性来进行查询我们可以在

@Repository
public interface EmployeeDao extends JpaRepository<Employee,Integer> {

 UserDO findByAccount(String account);

}

接口中进行接口声明。例如，如果我们想根据实体的 account 这个属性来进行查询（在登录功能的时候可能会用到）。我们在 com.yanggaochao.springboot.learn.springbootjpalearn.security.dao.UserDao 中增加一个接口声明就可以了

然后增加一个测试用例

@Test
    public void testFindByAccount() {
        UserDO userDO = userDao.findByAccount("wentian");
        if (userDO != null) {
            System.out.println("name = " + userDO.getName());
            System.out.println("account = " + userDO.getAccount());
        }
    }

这种方式非常强大，不经能够支持单个属性，还能支持多个属性组合。例如如果我们想查找账号和密码同时满足查询条件的接口。那么我们在 UserDao 接口中声明

UserDO findByAccountAndPwd(String account, String pwd);

再例如，我们要查询 id 大于某个条件的用户列表，则可以声明如下的接口

List<UserDO> findAllByIdGreaterThan(Long id);

这个语句结构可以用下面的表来说明

 

JPA 关键字说明

自定义查询

如果上述的情况还无法满足需要。那么我们就可以通过通过 import org.springframework.data.jpa.repository.Query 注解来解决这个问题。例如我们想查询名称等于某两个名字的所有用户列表，则声明如下的接口即可

@Query("SELECT O FROM UserDO O WHERE O.name = :name1  OR O.name = :name2 ")
List<UserDO> findTwoName(@Param("name1") String name1, @Param("name2") String name2);

这里是用 PQL 的语法来定义一个查询。其中两个参数名字有语句中的 : 后面的支付来决定

如果你习惯编写 SQL 语句来完成查询，还可以在用下面的方式实现

@Query(nativeQuery = true, value = "SELECT * FROM AUTH_USER WHERE name = :name1  OR name = :name2 ")
List<UserDO> findSQL(@Param("name1") String name1, @Param("name2") String name2);

这里在 @Query 注解中增加一个 nativeQuery = true 的属性，就可以采用原生 SQL 语句的方式来编写查询。

联合主键

从 org.springframework.data.jpa.repository.JpaRepository<T, ID> 接口定义来看，数据实体的主键是一个单独的对象，那么如果一个数据库的表的主键是两个或者两个以上字段联合组成的怎么解决呢。

我们扩充一下前面的场景。假如我们有一个角色 Role 对象，有两个属性 一个 id ，一个 name ，对应了 auth_role 数据表，同时有一个角色用户关系对象 RoleUser，说明角色和用户对应关系，有两个属性 roleId,userId 对应 auth_role_user 表。那么我们需要声明一个 RoleDO 对象如下

package com.yanggaochao.springboot.learn.springbootjpalearn.security.domain.dao;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table(name = "AUTH_ROLE")
public class RoleDO {
    @Id
    private Long id;
    @Column(length = )
    private String name;
    @Column(length = )
    private String note;

    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 String getNote() {
        return note;
    }

    public void setNote(String note) {
        this.note = note;
    }
}

bean

对于有多个属性作为联合主键的情况，我们一般要新建一个单独的主键类，他的属性和数据库实体主键的字段一样，要实现 java.io.Serializable 接口，类声明如下

package com.yanggaochao.springboot.learn.springbootjpalearn.security.domain.dao;

import java.io.Serializable;

public class RoleUserId implements Serializable {
    private Long roleId;
    private Long userId;
}

同样的，我们声明一个 RoleUserDO 对象如下

package com.yanggaochao.springboot.learn.springbootjpalearn.security.domain.dao;

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.IdClass;
import javax.persistence.Table;
import java.io.Serializable;

@Entity
@IdClass(RoleUserId.class)
@Table(name = "AUTH_ROLE_USER")
public class RoleUserDO  {
    @Id
    private Long roleId;
    @Id
    private Long userId;

    public Long getRoleId() {
        return roleId;
    }

    public void setRoleId(Long roleId) {
        this.roleId = roleId;
    }

    public Long getUserId() {
        return userId;
    }

    public void setUserId(Long userId) {
        this.userId = userId;
    }
}

这里因为数据实体类和数据实体主键类的属性一样，所以我们可以删除掉这个数据实体主键类，然后将数据实体类的主键类声明为自己即可。当然，自己也要实现 java.io.Serializable 接口。

这样，我们如果要查询某个角色下的所有用户列表，就可以声明如下的接口

@Query("SELECT U FROM UserDO U ,RoleUserDO RU WHERE U.id = RU.userId AND RU.roleId = :roleId")
List<UserDO> findUsersByRole(@Param("roleId") Long roleId);

================================================

下面我放上一个完整的操纵jpa的例子,注意数据库需要自己创建

package cn.edu.aynu.controller;

import cn.edu.aynu.dao.EmployeeDao;
import cn.edu.aynu.entities.Employee;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * Description: 164804116zln
 * Created by lenovo on 2019/5/6 13:31
 */
@RestController
public class EmployeeHandler {

    @Autowired
    EmployeeDao employeeDao;

    @PostMapping(path = "/add")
    public void add(@RequestBody Employee employee){
        employeeDao.save(employee);

    }
    @GetMapping("/emp/{id}")

    public Employee get(@PathVariable("id") Integer id){
        System.out.println(id);
        Employee employee = employeeDao.getOne(id);

        return  employee;
    }

    @GetMapping("/emps")
    public List<Employee> getAll(){
        List<Employee> employees = employeeDao.findAll();
        return employees;
    }

}

Controller

package cn.edu.aynu.dao;

import cn.edu.aynu.entities.Employee;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

/**
 * Description: 164804116zln
 * Created by lenovo on 2019/5/6 13:31
 */
@Repository
public interface EmployeeDao extends JpaRepository<Employee,Integer> {

}

EmployeeDao

package cn.edu.aynu.entities;

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;

import javax.persistence.*;

/**
 * Description: 164804116zln
 * Created by lenovo on 2019/5/6 13:23
 */
@Data
@NoArgsConstructor
@Entity(name = "employee")
@JsonIgnoreProperties(value = {"handler","hibernateLazyInitializer","fieldHandler"})
public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    @Column
    private String name;
    @Column
    private String address;

    public Employee(String name, String address) {
        this.name = name;
        this.address = address;
    }

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

bean

 <dependencies>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>6.0.</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.0.</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

pom

#通用数据源配置
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/dbjpa?charset=utf8mb4&useSSL=false&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=root
# Hikari 数据源专用配置
spring.datasource.hikari.maximum-pool-size=
spring.datasource.hikari.minimum-idle=
# JPA 相关配置
spring.jpa.database-platform=org.hibernate.dialect.MySQL5InnoDBDialect
spring.jpa.show-sql=true
spring.jpa.hibernate.ddl-auto=update

application.properties