6.4 SpringData JPA的使用

引言：该文档是参考尚硅谷的关于springboot教学视屏后整理而来。当然后面还加入了一些自己从网上收集整理而来的案例！

一、SpringData JPA初步使用

1. springdata简介

2. springboot整合springdata jpa（这是一个最简单的集成案例）

pom.xml引入架包依赖：

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.atguigu</groupId>
    <artifactId>spring-boot-06-data-jpa</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>spring-boot-06-data-jpa</name>
    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.10.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <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-jdbc</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-web</artifactId>
        </dependency>

        <!--lombok插件-->
        <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>

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

</project>

application.yml中配置如下：

spring:
  datasource:
    url: jdbc:mysql://192.168.15.22/jpa
    username: root
    password: 123456
    driver-class-name: com.mysql.jdbc.Driver
  jpa:
    hibernate:
#     更新或者创建数据表结构
      ddl-auto: update
#    控制台显示SQL
    show-sql: true

建表sql:

/*
 Navicat Premium Data Transfer

 Source Server         : 47.98.202.86
 Source Server Type    : MySQL
 Source Server Version : 50721
 Source Host           : 47.98.202.86:3306
 Source Schema         : springboot

 Target Server Type    : MySQL
 Target Server Version : 50721
 File Encoding         : 65001

 Date: 09/04/2019 23:51:27
*/

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for tbl_user
-- ----------------------------
DROP TABLE IF EXISTS `tbl_user`;
CREATE TABLE `tbl_user`  (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `last_name` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `email` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 4 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of tbl_user
-- ----------------------------
INSERT INTO `tbl_user` VALUES (1, '刘亦菲', '123@qq.com');
INSERT INTO `tbl_user` VALUES (2, '唐嫣', '123@qq.com');
INSERT INTO `tbl_user` VALUES (3, '??', 'aa');

SET FOREIGN_KEY_CHECKS = 1;

实体类User:

package com.atguigu.springboot.entity;

import lombok.Data;

import javax.persistence.*;

//使用JPA注解配置映射关系
@Entity //告诉JPA这是一个实体类（和数据表映射的类）
@Table(name = "tbl_user") //@Table来指定和哪个数据表对应;如果省略默认表名就是user；
@Data
public class User {

    @Id //这是一个主键
    @GeneratedValue(strategy = GenerationType.IDENTITY)//自增主键
    private Integer id;

    @Column(name = "last_name",length = 50) //这是和数据表对应的一个列
    private String lastName;
    @Column //省略默认列名就是属性名
    private String email;

}

数据层接口UserRepository：

package com.atguigu.springboot.repository;

import com.atguigu.springboot.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;

//继承JpaRepository来完成对数据库的操作
public interface UserRepository extends JpaRepository<User,Integer> {
}

Controller层UserController：这里省略了service，主要是为了测试集成springdata jpa

package com.atguigu.springboot.controller;

import com.atguigu.springboot.entity.User;
import com.atguigu.springboot.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {

    @Autowired
    UserRepository userRepository;

    @GetMapping("/user/{id}")
    public User getUser(@PathVariable("id") Integer id){
        User user = userRepository.findOne(id);
        return user;
    }

    @GetMapping("/user")
    public User insertUser(User user){
        User save = userRepository.save(user);
        return save;
    }

}

测试（这里只是通过get请求简单的测试）：

　　查询用户id=2的员工，访问网址：http://localhost:8080/user/2

　　　　　　返回结果：{"id":2,"lastName":"唐嫣","email":"123@qq.com"}

　　增加一个用户，访问网址：http://localhost:8080/user?lastName=王菲&email=aa

　　　　　　返回结果为：{"id":3,"lastName":"王菲","email":"aa"}

二、springdata jpa 详解

1. springdata jpa 中的接口

　先参考【Spring Data JPA--接口方法】，后期在自己整理！

2. 实现复杂查询  参考：https://www.cnblogs.com/zjfjava/p/8456771.html

（1）基于方法名解析的概念

JpaRepository支持接口规范方法名查询。意思是如果在接口中定义的查询方法符合它的命名规则，就可以不用写实现。
  spring-data-jpa会根据方法的名字来自动生成sql语句，我们只需要按照方法定义的规则即可;

例如：findByName(String name): 这个方法表示从数据库中查询Name这个属性等于XXX的所有记录
   　　  类似于SQL语句：select * from xxTable where name=xxx这种形式

这段话有两个重点：方法名需要在接口中设定; 必须符合一定的命名规范;

（2）方法名构造方法

      find+全局修饰+By+实体的属性名称+限定词   + 连接词+ ...(其它实体属性)+OrderBy+排序属性+排序方向
例如：find Distinct By FirstName      IgnoreCase And         LastName OrderBy      Age      Desc(String firstName,String lastName);
      findDistinctByFirstNameIgnoreCaseAndLastNameOrderByAgeDesc(String firstName,String lastName)
其中：
      Distinct是全局修饰（非必须），
      FirstName和LastName是实体的属性名，
      And是连接词，
      IgnoreCase是限定词，
      Age是排序属性，
      Desc是排序方向，限定词和连接词统称为“关键词”。
spring-data-jpa规定，在属性后面接关键字.

（3）目前支持的关键词
  全局修饰：Distinct，Top，First
  排序方向：Asc，Desc

关键字：

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)

（4）嵌套实体方法命名规则

构词法：主实体中子实体的名称+ _ +子实体的属性名称

例如：
    List<Person> findByAddress_ZipCode(ZipCode zipCode)
    表示查询所有 Address（地址）的zipCode（邮编）为指定值的所有Person(人员)

//查询需求： 从数据库中查询电话号码(phone)以指定字符串开始(例如：136)的，并且地址(address)中包含指定字符串（例如：路）的记录;   提取前两条，降序排列
//select * from user where phone like '136%' and address like '%路%' order by phone desc limit 0,2
List<User> findTop2ByPhoneStartingWithAndAddressContainingOrderByPhoneDesc(String phone,String address);
List<User> findTop2ByPhoneStartingWithAndAddressContaining(String phone,String address,Sort sort);
//分页要用到Pageable接口
Page<User> findByPhoneStartingWithAndAddressContaining(String phone,String address,Pageable pageable);

 三、Criteria（条件）查询

转载：SpringDataJpa的Specification查询   Specification动态构建多表查询

相应的接口是JpaSpecificationExecutor，这个接口基本是围绕着Specification接口来定义的， Specification接口(JPA)中只定义了如下一个方法：

Predicate toPredicate(Root<T> root, CriteriaQuery<?> query, CriteriaBuilder cb); 这个方法的参数和返回值都是JPA标准里面定义的对象。

1、Criteria（条件）查询基本概念：

Root接口：代表Criteria查询的根对象，Criteria查询的查询根定义了实体类型，能为将来导航获得想要的结果，它与SQL查询中的FROM子句类似；

　　(1) Root实例是类型化的，且定义了查询的FROM子句中能够出现的类型;

　　(2) 查询根实例能通过传入一个实体类型给 AbstractQuery.from方法获得;

　　(3) Criteria查询，可以有多个查询根;

　　(4) AbstractQuery是CriteriaQuery 接口的父类，它提供得到查询根的方法;

CriteriaQuery接口：代表一个specific的顶层查询对象，它包含着查询的各个部分，比如：select 、from、where、group by、order by等；

　　　注意：CriteriaQuery对象只对实体类型或嵌入式类型的Criteria查询起作用；

CriteriaBuilder接口：用来构建CritiaQuery的构建器对象Predicate：一个简单或复杂的谓词类型，其实就相当于条件或者是条件组合；

2. Criteria查询基本对象的构建

(1) 通过EntityManager的getCriteriaBuilder或EntityManagerFactory的getCriteriaBuilder方法可以得到CriteriaBuilder对象；（可以构建查询条件对象）

(2) 通过调用CriteriaBuilder的createQuery或createTupleQuery方法可以得到CriteriaQuery对象；（执行查询条件对象）

(3) 通过调用CriteriaQuery的from方法可以获得Root实例过滤条件；

a. 过滤条件会被应用到SQL语句的FROM子句中。在criteria 查询中，查询条件通过Predicate或Expression实例应用到CriteriaQuery对象上；

b. 这些条件使用 CriteriaQuery .where 方法应用到CriteriaQuery 对象上；（查询条件怎么应用到顶层查询对象上）

c. CriteriaBuilder也作为Predicate实例的工厂，通过调用CriteriaBuilder 的条件方（ equal，notEqual， gt， ge，lt， le，between，like等）创建Predicate对象。

d. 复合的Predicate 语句可以使用CriteriaBuilder的and, or and not 方法构建。

构建简单的Predicate示例：

Predicate p1=cb.like(root.get(“name”).as(String.class), “%”+uqm.getName()+“%”);

Predicate p2=cb.equal(root.get("uuid").as(Integer.class), uqm.getUuid());

Predicate p3=cb.gt(root.get("age").as(Integer.class), uqm.getAge());

构建组合的Predicate示例：

Predicate p = cb.and(p3,cb.or(p1,p2));

使用实例：

（1）当然也可以形如前面动态拼接查询语句的方式，比如：

/**
     * 测试条件查询
     * @return
     */
    @GetMapping("/user/list")
    public List<User> getList(){

        //假设这是前端传过来的条件
        User user = new User();
        user.setLastName("fei");
        user.setId(1);

        Specification<User> spec = new Specification<User>() {
            public Predicate toPredicate(Root<User> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
                //用于暂时存放查询条件的集合
                List<Predicate> list = new ArrayList<Predicate>();
                //------------------- 查询条件示例 -------------------------
                //like示例
                if (user.getLastName() != null && user.getLastName().trim().length() > 0){
//                    Predicate lastNamePredicate = cb.like(root.get("lastName").as(String.class), "%"+user.getLastName()+"%");
                    Predicate lastNamePredicate = cb.like(root.get("lastName"), '%'+user.getLastName()+'%');//和上面一句等效
                    list.add(lastNamePredicate);
                }
                //equal示例
                if(user.getId() >0){
//                    Predicate idPredicate = cb.equal(root.get("id"), user.getId());
                    Predicate idPredicate = cb.equal(root.get("id").as(Integer.class), user.getId());
                    list.add(idPredicate);
                }

                //between示例()  以下注释的部分，自己参照修改
//                if (birthday != null) {
//                    Predicate birthdayPredicate = cb.between(root.get("birthday"), birthday, new Date());
//                    predicatesList.add(birthdayPredicate);
//                }
                //排序示例(先根据学号升序排序，后根据姓名升序排序)
//                query.orderBy(cb.asc(root.get("studentNumber")),cb.asc(root.get("name")));

                //最终将查询条件拼好然后return
                    Predicate[] p = new Predicate[list.size()];
                return cb.and(list.toArray(p));
            }
        };

        List<User> users = userRepository.findAll(spec);
        users.forEach(System.out::println);
        return users;
    }

说明：以下是上面sql的打印结果，打印的应该是预编译的sql，至于为啥主键id的值被替换了？以后再做探讨，如果有大神了解，补充上！

Hibernate: select user0_.id as id1_2_, user0_.email as email2_2_, user0_.last_name as last_nam3_2_ from tbl_user user0_ where (user0_.last_name like ?) and user0_.id=1；
User(id=1, lastName=liuyifei, email=123@qq.com)；

注意：此处记录下我遇到的坑，由于我只是做简单的动态条件查询测试，所以就没有考虑编码的问题，原来我在数据库中存的是中文的用户名，但是这就导致我在以上测试的时候，

　　   尽快代码没有问题，但是死活查不出结果，我一直在纠结我预编译的那个sql，还以为是我代码或者是yml中jpa配置的有问题，导致花了很长时间，后来我将数据库中的用户 名改为英文的就可以了！（编码问题是所有中国程序员都要考虑的问题）

（2）使用CriteriaQuery来得到最后的Predicate

/**
     * 测试条件查询
     * @return
     */
    @GetMapping("/user/list1")
    public List<User> getList1(){
        User user = new User();
        user.setId(1);
        user.setLastName("fei");
        user.setEmail("123@qq.com");

        Specification<User> spec = new Specification<User>() {
            public Predicate toPredicate(Root<User> root, CriteriaQuery<?> query, CriteriaBuilder cb) {

                Predicate p1 = cb.like(root.get("lastName").as(String.class), "%"+user.getLastName()+"%");
                Predicate p2 = cb.equal(root.get("email").as(String.class), user.getEmail());
                Predicate p3 = cb.gt(root.get("id").as(Integer.class), user.getId());
                //把Predicate应用到CriteriaQuery中去,因为还可以给CriteriaQuery添加其他的功能，比如排序、分组啥的
                query.where(cb.and(p3,cb.or(p1,p2)));
                //添加排序的功能
                query.orderBy(cb.desc(root.get("id").as(Integer.class)));

                return query.getRestriction();
            }
        };

        List<User> users = userRepository.findAll(spec);
        users.forEach(System.out::println);
        return users;

//   sql: select user0_.id as id1_2_, user0_.email as email2_2_, user0_.last_name as last_nam3_2_ from tbl_user user0_
//        where user0_.id>1 and (user0_.last_name like ? or user0_.email=?) order by user0_.id desc
//        User(id=2, lastName=tanying, email=123@qq.com)
    }

综上所述，我们可以用Specification的toPredicate方法构建更多更复杂的查询方法。