SpringBoot中使用Spring Data JPA

Springboot 中如何集成spring data jpa

一 什么是ORM？

ORM即Object-Relationl Mapping，它的作用是在关系型数据库和对象之间作一个映射，这样，我们在具体的操作数据库的时候，就不需要再去和复杂的SQL语句打交道，只要像平时操作对象一样操作它就可以了 。

在ORM出现之前，我们是用jdbc来操作数据库，但jdbc没有封装，对于大项目来说，使用复杂，也难以实现MVC的概念，所以人们就开发了ORM框架来解决这些问题。比如Hibernate，Mybatis，不过Hibernate是完全的ORM框架，mybatis是半ORM框架，因为它需要手动建表和自己写sql。

ORM的优点： 提高了开发效率。由于ORM可以自动对Entity对象与数据库中的Table进行字段与属性的映射，能够像操作对象一样从数据库获取数据。

ORM的缺点 ：ORM的缺点是会牺牲程序的执行效率，因为是自动生成sql,所以实现复杂查询比较麻烦。

二 什么是JPA？

ORM 框架很多，大家各自搞自己的，为了统一下规范，就出现了 JPA。

JPA全称Java Persistence API，可以通过注解或者XML描述【对象-关系表】之间的映射关系，并将实体对象持

久化到数据库中。

JPA为我们提供了：

1）ORM映射元数据：JPA支持XML和注解两种元数据的形式，元数据描述对象和表之间的映射关系，框架据此将实体对象持久化到数据库表中；

如：@Entity、@Table、@Column、@Transient等注解。

2）API：用来操作实体对象，执行CRUD操作，框架在后台替我们完成所有的事情，开发者从繁琐的JDBC和SQL代码中解脱出来。

如：entityManager.merge(T t)；

3）JPQL查询语言：通过面向对象而非面向数据库的查询语言查询数据，避免程序的SQL语句紧密耦合。

如：from Student s where s.name = ?

但是：

JPA仅仅是一种规范，也就是说JPA仅仅定义了一些接口，而接口是需要实现才能工作的。所以底层需要某种实现，而Hibernate就是实现了JPA接口的ORM框架。

三 什么是Spring Data Jpa？

实现Jpa中的接口需要写大量的代码，包括简单的增删改查，那可不可以由框架将这些写好呢，于是spring data jpa出现了。

spirng data jpa是spring提供的一套简化JPA开发的框架，不仅有接口，也有实现类，只要按照约定好的【方法命名规则】写dao层接口，就可以在不写接口实现的情况下，实现对数据库的访问和操作。同时提供了很多除了CRUD之外的功能，如分页、排序、复杂查询等等。

Spring Data JPA 可以理解为 JPA 规范的再次封装抽象，底层还是使用了 Hibernate 的 JPA 技术实现。

四 Spring Data JPA和Mybatis对比

关于在开发中到底应该使用JPA还是Mybatis争论不休，总体来说，国外用JPA的多，国内用Mybatis的多。

Spring Data JPA是面向对象的思想，一个对象就是一个表，强化的是你对这个表的控制。spring data jpa实现了jpa（java persistence api）功能，即可以实现pojo转换为关系型数据库记录的功能，通俗来讲就是可以不写任何的建表sql语句了。jpa是spring data jpa功能的一个子集。

Mybatis则是面向sql，你的结果完全来源于sql，而对象这个东西只是用来接收sql带来的结果集。你的一切操作都是围绕sql，包括动态根据条件决定sql语句等。mybatis并不那么注重对象的概念。只要能接收到数据就好。

各自优缺点：

面向sql就更利于优化，因为sql可以优化的点太多了。对于并发用户多，追求性能的，Mybatis更有优势。

面向对象就更利于移植，可维护性，因为数据对象不依赖于数据源。比如从mysql换成oracle，JPA更方便。

最终用哪个，看你们老板的要求。

五 Springboot 中如何集成spring data jpa

Spring Boot 中使用的 Jpa 实际上是 Spring Data Jpa，在 Spring Data 中，只要你的方法名称符合规范，它就知道你想干嘛，不需要自己再去写 SQL。本章带领大家学习如何在Springboot中如何集成spring data jpa

1.创建工程

创建工程，添加 Web、Spring Data Jpa 、 MySQL 驱动依赖、lombok依赖。

默认Mysql驱动时8.X，如果本机安装的Mysql是5.X，需要手动修改版本

<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>
        <version>5.1.45</version>  <!-- 手动添加版本号-->
        <scope>runtime</scope>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-tomcat</artifactId>
        <scope>provided</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

2.添加 Druid连接池依赖

springboot默认的连接池是HiKari，但国内用druid的也很多，所以本章中我们也用一下druid。

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.1.10</version>
</dependency>

常见的数据库连接池主要有c3p0，dbcp，tomcat-jdbc-pool，druid，HiKariCP。

c3p0：不提供对数据库的监控。使用时是单线程的。

dbcp：不提供数据库的监控。使用时是单线程的。

tomcat jdbc pool：它兼容dbcp。但是比dbcp性能更高。

druid：  是阿里巴巴开源的数据库连接池，提供对数据库的监控，就是为监控而生。它的功能最为全面，可扩展性好，具有sql拦截的功能。

HiKariCP：  是数据库连接池里面的后起之秀，出来的比较晚，但是性能很好。

总的来说：性能方面HiKariCP>druid>tomcat jdbc pool>dbcp>c3p0。

3.配置数据库连接信息和Jpa信息。

# 数据库的基本配置
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.url=jdbc:mysql://localhost:3306/boot?characterEncoding=utf8&serverTimezone=GMT%2B8

#配置连接池
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource

# JPA配置
spring.jpa.database=mysql

# 是否在控制台打印SQL
spring.jpa.show-sql=true

# 每次启动项目时，数据库初始化策略
#ddl-auto:create----每次运行该程序，没有表格会新建表格，表内有数据会清空
#ddl-auto:create-drop----每次程序结束的时候会清空表
#ddl-auto:update----每次运行程序，没有表格会新建表格，表内有数据不会清空，只会更新
#ddl-auto:validate----运行程序会校验数据与数据库的字段类型是否相同，不同会报错

spring.jpa.hibernate.ddl-auto=update

# 指定默认的存储引擎为InnoDB，默认情况下，自动创建表的时候会使用 MyISAM 做表的引擎，
# 如果配置了数据库方言为 MySQL57Dialect，则使用 InnoDB 做表的引擎。
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL57Dialect

4.Spring Data Jpa应用。

4.1 入门案例

先准备数据库表:

创建对应的实体类，添加相应注解：

package com.test.jpa.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.beans.factory.annotation.Value;

import javax.persistence.*;


@Entity(name = "users")
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Users {

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

    @Column(name="user_name")
    private String userName;

    private int age;
}

编写Dao接口：

package com.test.jpa.dao;

import com.test.jpa.pojo.Users;
import org.springframework.data.jpa.repository.JpaRepository;


public interface UsersRepository extends JpaRepository<Users,Integer> {
}

测试：

编写web层测试:

总结:

通过入门案例我们可以发现，dao层只需要继承JpaRepository接口，我们不需要写sql语句就可以查询出数据。这就是Jpa的方便之处。

4.2 Spring Data JPA核心接口

1 Repository接口

提供了方法名称命名查询方式
 提供了基于@Query注解查询与更新

需要自定义方法名,如下所示:

import java.util.List;


public interface UsersRepository extends Repository<Users,Integer> {
    
    List<Users> findAll();

}

测试:

这里省掉了service层，直接在控制层测试

2 CrudRepository接口

CrudRepository接口继承了Repository接口

CrudRepository提供了基本的增删改查，不再需要我们自定义。

import com.bjsxt.pojo.Users;
import org.springframework.data.repository.CrudRepository;

public interface UsersRepositoryCrudRepository extends CrudRepository<Users,Integer> {
}

3 PagingAndSortingRepository接口

该接口继承了CrudRepository接口

该接口提供了分页与排序的操作， 也就是该接口不用自己定义增删改查方法和分页排序方法

import com.bjsxt.pojo.Users;
import org.springframework.data.repository.PagingAndSortingRepository;
public interface UsersRepositoryPagingAndSorting extends PagingAndSortingRepository<Users,Integer> {
}

4 JpaRepository接口

该接口继承了PagingAndSortingRepository

对继承的父接口中方法的返回值进行适配，也就是该接口不用自己定义增删改查方法和分页排序方法，并且让分页查询更简单。

5 JPASpecificationExecutor接口

该接口主要是提供了多条件查询的支持，并且可以在查询中添加排序与分页。注意JPASpecificationExecutor是单独存在的。不继承上述接口。

可以看出来，因为JpaRepository继承了前面几个接口，所以我们重点来研究JpaRepository和JPASpecificationExecutor就可以了。

4.3 JpaRepository接口应用

1. 基本增删改查

dao层：

package com.test.jpa.dao;

import com.test.jpa.pojo.Users;
import org.springframework.data.jpa.repository.JpaRepository;


public interface UsersJpaRepository extends JpaRepository<Users,Integer> {
}

web层测试:

package com.test.jpa.controller;

import com.test.jpa.dao.UsersJpaRepository;
import com.test.jpa.pojo.Users;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;


@RestController
@RequestMapping("/users")
public class UsersController {

    @Autowired
    private UsersJpaRepository usersJpaRepository;

    @RequestMapping("/select")
    public List<Users> select()
    {
        return usersJpaRepository.findAll();
    }

    @RequestMapping("/add")
    public void addUser()
    {
        Users user=new Users();
        user.setAge(19);
        user.setUserName("cc");
        usersJpaRepository.save(user);
    }

    @RequestMapping("/update")
    public void updateUser()
    {
        Users user=usersJpaRepository.getOne(3);
        user.setAge(19);
        user.setUserName("ddd");
        usersJpaRepository.save(user);
    }

    @RequestMapping("/delete")
    public void deleteUserById()
    {
         int id=1;
        usersJpaRepository.deleteById(id);
    }

    @RequestMapping("/selectById")
    public Users selectById()
    {
        return usersJpaRepository.findById(3).get();//
        // 2.x版本后需要.get()才能得到实体对象， id未查询到对应实体时会报错
    }

}

2.分页和排序

//分页查询
 @RequestMapping("/selectByPage")
 public List<Users> selectByPage() {      
        PageRequest pageable = PageRequest.of(0, 2);
        Page<Users> page = usersJpaRepository.findAll(pageable);
        List<Users> usersList=page.getContent();
        //数据的总条数：page.getTotalElements();
        //总页数：page.getTotalPages();
        return usersList;
    }

其中：

PageRequest:封装了分页的参数，当前页，每页显示的条数。注意：它的当前页是从0开始

Page ：是spring data jpa 的分页模型。包含的属性信息如下:

{
"content": [{}], // 数据列表
"last": true, // 是否最后一页
"totalPages": 1, // 总页数
"totalElements": 1, // 数据总数
"sort": null, // 排序
"first": true, // 是否首页
"numberOfElements": 1, // 本页数据条数
"size": 10, // 每页长度
"number": 0 // 当前页序号
}

分页并排序:

//分页查询并排序
@RequestMapping("/selectByPageByOrder")
public List<Users> selectByPageByOrder() {

    //按照id降序排
    PageRequest pageable = PageRequest.of(0, 2,Sort.Direction.DESC, "id");
    Page<Users> page = usersJpaRepository.findAll(pageable);
    List<Users> usersList=page.getContent();
    //数据的总条数：page.getTotalElements();
    //总页数：page.getTotalPages();
    return usersList;
}

3.自定义方法

JpaRepository 提供了一些基本的数据操作方法，例如保存，更新，删除，分页查询等，开发者也可以在接口中自己声明相关的方法，只需要方法名称符合规范即可，在 Spring Data 中，只要按照既定的规范命名方法，Spring Data Jpa 就知道你想干嘛，这样就不用写 SQL 了，那么规范是什么呢？参考下图：

• 按照 Spring Data 的规范，查询方法以 find | read | get 开头
• 涉及条件查询时，条件的属性用条件关键字连接，要注意的是：条件属性以首字母大写

在UsersJpaRepository接口中添加自定义方法:

List<Users> findByUserName(String userName);
List<Users> findByUserNameLike(String userName);

测试:

4.@Query 注解

有的时候，Spring Data规范里提供的查询关键字并不能满足我们的查询需求，这个时候就可以使用 @Query 关键字，来自定义查询 SQL。

1.例如查询 id 最大的 User：

@Query(value="select * from users  where id=(select max(id) from users)",nativeQuery = true)
Users getMaxIdUser();

nativeQuery：代表本地查询，就是使用原生的sql语句。

5.@Param注解

用来注入参数

@Query(value = "select * from users where user_name like %:userName%",nativeQuery = true)
List<Users> findByNameMatch(@Param("userName") String userName);

4.4复杂查询

Spring Data JPA中也有一对一、一对多、多对多映射。这些映射还分单向关联和双向关联，在双向关联时还需要考虑对象序列化为JSON字符串时的死循环问题。

单向关联和双向关联

• 单向关联 单向关联指的是实体类A中有一个实体类B变量，但是实体类B中没有实体类A变量，即为单向关联。
• 双向关联 双向关联指的是实体类A中有一个实体类B变量，而实体类B中也含有一个实体类A变量，即为双向关联。

1. 一对一

一对一映射需要@OneToOne注解和@JoinColumn注解配合使用

准备两张表users和cards:

创建实体类：

Cards：

package com.test.jpa.pojo;

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

import javax.persistence.*;


@Entity(name = "cards")
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Cards {

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

    @Column(name = "card_type")
    private String cardType;

}

Users：

每个用户对应一张会员卡，所以每个users对象中包含一个card对象。

package com.test.jpa.pojo;

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.beans.factory.annotation.Value;

import javax.persistence.*;
import java.io.Serializable;


@Entity(name = "users")
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Users {

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

    @Column(name="user_name")
    private String userName;

    private int age;

    //@JoinColumn注解中的name元素为当前实体类中对应的属性id，即users表中的card_id
    // 而referencedColumnName则为关联对象的id,即cards表中的主键id
    @JoinColumn(name = "card_id",referencedColumnName = "id")
    @OneToOne(cascade = {CascadeType.ALL})
    private Cards card;

}

注意：

@JoinColumn 是指表与表之间关系的字段 

@OneToOne是一对一关系映射。其中CascadeType是级联类型。

CascadeType.PERSIST

级联新增，保存父对象时会新建其中包含的子对象 

CascadeType.MERGE

级联修改，保存父对象时会更新其中所包含的子对象数据 

CascadeType.REMOVE

级联删除，当删除关联关系时会将子对象的数据删除 

CascadeType.REFRESH

级联刷新，保存关联关系时会更新子对象和数据库中一致(意思是你在父对象中添加一个只包含ID的子对象，也可以保存进去) 

CascadeType.ALL

包含上述所有操作

测试:

2.一对多

新增address表

这里一个用户对应多个地址，是一对多的关系。

描述一对多关系中需要用到@OneToMany和@ManyToOne

首先创建Address实体类:

package com.test.jpa.pojo;

import com.fasterxml.jackson.annotation.JsonBackReference;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;

import javax.persistence.*;
import javax.xml.soap.Detail;


@Data
//jpa中使用lombok时，需排除关联表属性，否则会报错
@EqualsAndHashCode(exclude="user")
@NoArgsConstructor
@AllArgsConstructor
@Entity(name = "address")
public class Address {

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

    private String detail;

    @ManyToOne(cascade = CascadeType.ALL,optional=false)////可选属性optional=false,表示user不能为空。删除地址，不影响用户
    @JoinColumn(name="user_id")
    @JsonBackReference //防止json序列化出现死循环
    private Users user;

}

注意：此实体类中添加了三个新注解

@EqualsAndHashCode(exclude="user") 是指 jpa中使用lombok时，需排除关联表属性，否则会报错。

@ManyToOne（）代表多对一的关系

@JsonBackReference   防止json序列化出现死循环

在Users表中添加address集合

package com.test.jpa.pojo;

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.beans.factory.annotation.Value;

import javax.persistence.*;
import java.io.Serializable;
import java.util.List;


@Entity(name = "users")
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Users {

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

    @Column(name="user_name")
    private String userName;

    private int age;

    //@JoinColumn注解中的name元素为当前实体类中对应的属性id，即users表中的card_id
    // 而referencedColumnName则为关联对象的id,即cards表中的主键id
    @JoinColumn(name = "card_id",referencedColumnName = "id")
    @OneToOne(cascade = {CascadeType.ALL})
    private Cards card;


    @OneToMany(mappedBy = "user")
    private List<Address> addressList;

}

注意:这里新增了一个注解

@OneToMany(mappedBy = "user") 代表一对多的关系

其中属性mappedBy的意思是:

1.只有OneToOne，OneToMany，ManyToMany上才有mappedBy属性，ManyToOne不存在该属性,在@OneToMany里加入mappedBy属性可以避免生成一张中间表。

2.mappedBy标签一定是定义在被拥有方的，他指向拥有方； 表示声明自己不是一对多的关系维护端，由对方来维护，是在一的一方进行声明的。mappedBy的值应该为一的一方的表名

3.mappedBy的含义，应该理解为，拥有方能够自动维护跟被拥有方的关系，当然，如果从被拥有方，通过手工强行来维护拥有方的关系也是可以做到的；

4.mappedBy跟joinColumn/JoinTable总是处于互斥的一方，可以理解为正是由于拥有方的关联被拥有方的字段存在，拥有方才拥有了被拥有方。mappedBy这方定义JoinColumn/JoinTable总是失效的，不会建立对应的字段或者表。

测试：

3.多对多

准备任务表和用户和任务的关系表，一个用户对应多个任务，一个任务对应多个用户，形成多对多的关系.

创建实体类:Tasks

package com.test.jpa.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;


@Data
@NoArgsConstructor
@AllArgsConstructor
@Entity(name = "tasks")
public class Tasks {

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

    private String content;
}

修改Users实体类，添加多对多关系

package com.test.jpa.pojo;

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.beans.factory.annotation.Value;

import javax.persistence.*;
import java.io.Serializable;
import java.util.List;
import java.util.Set;


@Entity(name = "users")
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Users {

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

    @Column(name="user_name")
    private String userName;

    private int age;

    //@JoinColumn注解中的name元素为当前实体类中对应的属性id，即users表中的card_id
    // 而referencedColumnName则为关联对象的id,即cards表中的主键id
    @JoinColumn(name = "card_id",referencedColumnName = "id")
    @OneToOne(cascade = {CascadeType.ALL})
    private Cards card;


    @OneToMany(mappedBy = "user")
    private List<Address> addressList;

    @ManyToMany
    @JoinTable(name = "user_task",joinColumns = @JoinColumn(name = "user_id"),
            inverseJoinColumns = @JoinColumn(name = "task_id"))
    private List<Tasks> tasksList;

}

注意:这里新增了两个注解

 @ManyToMany 代表多对多的关系

 @JoinTable 存放的是两个实体间的多对多关系表,name中存放的是关系表表名, joinColumns存放的当前实体类在关心表中的id名，inverseJoinColumns存放的是关联的实体表在关系表中的id名.

测试：

4.5 JPASpecificationExecutor接口

该接口主要是提供了多条件查询的支持，并且可以在查询中添加排序与分页。它是独立存在的。

多条件查询示例:

添加dao层

package com.test.jpa.dao;

import com.test.jpa.pojo.Users;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;


public interface UsersSpecificationExecutor extends JpaRepository<Users,Integer>,JpaSpecificationExecutor<Users> {


}

控制层测试:

package com.test.jpa.controller;

import com.test.jpa.dao.UsersSpecificationExecutor;
import com.test.jpa.pojo.Users;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import javax.swing.text.html.HTMLDocument;
import java.util.ArrayList;
import java.util.List;


@RestController
@RequestMapping("/specification")
public class TestSpecificationExecutor {

     @Autowired
     private UsersSpecificationExecutor usersSpecificationExecutor;

      @RequestMapping("/select")
      public List<Users> select()
      {
             Specification<Users> usersSpecification=new Specification<Users>(){
              //CriteriaBuilder是一个工厂类，用来创建安全查询的criteriaQuery对象和拼接的查询条件
              //Root根对象对应于from后面的表
              //Predicate用于查询条件的拼接，对应于where后面的表达式。
              @Override
              public Predicate toPredicate(Root<Users> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {

                  List<Predicate> list=new ArrayList<>();
                  list.add(criteriaBuilder.equal(root.get("userName"),"aa"));
                  list.add(criteriaBuilder.equal(root.get("age"),11));
                  Predicate[] arr=new Predicate[list.size()];
                  return criteriaBuilder.and(list.toArray(arr));
              }
          };

          List<Users> list=this.usersSpecificationExecutor.findAll(usersSpecification);

          return list;

      }
}

4.6 JPQL查询语言

1.什么是 JPQL

JPQL全称Java Persistence Query Language。中文意思是Java持久化查询语言。

是一种可移植的查询语言，旨在以面向对象表达式语言的表达式，将SQL语法和简单查询语义绑定在一起·使用 这种语言编写的查询是可移植的，可以被编译成所有主流数据库服务器上的SQL。

其特征与原生SQL语句类似，并且完全面向对象，通过类名和属性访问，而不是表名和表的属性。

2.JPQL提供的查询语法

查询用的 SELECT 语法

比如：SELECT u FROM Users u WHERE u.userName = :userName

对应sql： select * from users where user_name=参数

解析: 这里的Users是指实体 u是别名。u.userName是实体对象中的userName属性。:userName是传递的参数。

更新用的 UPDATE 语法

比如：UPDATE Users u SET u.userName = :userName where u.id = :id

删除用的 DELETE 语法

比如: delete from Users u where u.id=:id

注意：JPQL中没有insert添加语句

3.JPQL的使用

创建接口UsersDao3,添加查询方法.

package com.test.springdatajpa.dao;

import com.test.springdatajpa.pojo.Users;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;


public interface UsersDao3 extends JpaRepository<Users,Integer> {

    //查询
    @Query("SELECT u FROM users u WHERE u.userName = :userName")
    //简化写法
    //@Query(" FROM users u WHERE u.userName = :userName")
    public List<Users> getUsers(@Param("userName") String userName);
   
}

注意:

@Query(“SELECT u FROM users u WHERE u.userName = :userName”) 中的users是实体名,而实体名用哪个有两种情况：

情况1：在实体类中直接用@Entity（name=“users”） 不用@Table ，则表示此实体对应的表名是users，同时实体名也设置为users。如下：

情况2：在实体类中用

@Entity

@Table（name=“users”） 两个注解，则表示此实体对应的表名是users，实体名为类名。如下：

调用dao层方法测试:

在UsersDao3中添加修改和删除：

package com.test.springdatajpa.dao;

import com.test.springdatajpa.pojo.Users;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;


public interface UsersDao3 extends JpaRepository<Users,Integer> {

    //查询
    //@Query("SELECT u FROM users u WHERE u.userName = :userName")
    @Query(" FROM users u WHERE u.userName = :userName")
    public List<Users> getUsers(@Param("userName") String userName);

    //修改
    //SpringData 的每个方法上有事务， 但都是一个只读事务。 他们不能完成修改操作,所以需要手动添加@Transactional
    @Transactional
    @Query( "UPDATE users u SET u.userName = :userName where u.id = :id")
    @Modifying
    public void updateUsers(@Param("id") int id, @Param("userName") String userName);

    //删除
    @Transactional
    @Query( "delete from users u where u.id=:id")
    @Modifying
    public void deleteUsers(@Param("id") int id);


}

注意:

在使用修改和删除语句的时候。需要加@Modifying和@Transactional注解

@Transactional：是因为SpringData 的每个方法上有事务， 但都是一个只读事务。 他们不能完成修改操作,所以需要手动添加

@Modifying：JPQL实现DELETE和UPDATE操作的时候必须加上@modifying注解，以通知Spring Data 这是一个DELETE或UPDATE操作。