springboot中使用Spring Data Jpa

news2024/11/13 9:24:48

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操作。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/60620.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

图论期末复习（《图论机器应用》——朴月华）

图论期末复习（《图论机器应用》——朴月华）

文章目录一、图的基本概念二、图的连通性三、树四、E 图与 H 图五、对集与独立集六、平面图与网络流一、图的基本概念 1、基本概念2、顶点的度 概念&#xff0c;有关定理及推论&#xff08;握手定理&#xff09;&#xff0c;度序列的概念及相关结论&#xff0c;根据度序列画图…
阅读更多...
【星球】【slam】 研讨会（5）VINS：Mono+Fusion 重点提炼

【星球】【slam】 研讨会（5）VINS：Mono+Fusion 重点提炼

VINSFusion重点梳理 A重点梳理和回顾 1传感器前端 视觉前端 特征点提取 opencv接口 goodfeaturestotrack 光流追踪 opencv接口 calcOptical 异常点剔除 光流剔除的异常点 本质矩阵的校验(不符合本质矩阵的点筛除) 特征点去畸变 “逐渐逼近式”的计算方式 特征点性质的计算 IM…
阅读更多...
常用算法-Java

常用算法-Java

基础概念 程序 数据结构 算法 算法特性&#xff1a;输入、输出、有穷性、确定性、可靠性 算法目标&#xff1a;正确性、可读性、健壮性、运行时间少、内存空间小 时间复杂度 时间复杂度是用来估计算法运行时间的一个单位。 一般来说&#xff0c;时间复杂度高的算法比时…
阅读更多...
【高并发基础】理解 MVCC 及提炼实现思想

【高并发基础】理解 MVCC 及提炼实现思想

文章目录1. 前言2. MVCC 概念2.1 MVCC 版本链2.2 MVCC trx_id2.3 MVCC Read View3. 提出问题4. 解决问题4.1 不读未提交的数据4.1.1 一般的并发情况4.1.2 特殊的并发情况4.1.3 剩下的并发情况4.2 如果自己修改了数据&#xff0c;要第一时间读到5. MySQL RC 使用 MVCC5.1 MVCC D…
阅读更多...
Git使用学习记录（一、前置知识）

Git使用学习记录（一、前置知识）

Git使用学习记录&#xff08;一、前置知识&#xff09; Git简介 Git 是什么&#xff1f; Git 是目前为止最为先进的分布式版本控制系统&#xff08;分布式版本控制系统没有“中央服务器”&#xff0c;每个⼈的电脑上都是⼀个完整的版本库&#xff0c;⼯作时不需要联网&#xff…
阅读更多...
Dynamics 365 Environment Variables（环境变量）的应用

Dynamics 365 Environment Variables（环境变量）的应用

环境变量这个功能很早就有了&#xff0c;但最近才关注到&#xff0c;是个不错的功能&#xff0c;所以写篇介绍下它的应用。 项目里都会有配置实体这么个东西&#xff0c;用于存储各种常量或者与其他系统集成时的各种配置参数&#xff0c;以往我们都是自定义一个实体用来存放&am…
阅读更多...
PyTorch 2.0发布了，一行代码提速76%

PyTorch 2.0发布了，一行代码提速76%

PyTorch 官方&#xff1a;我们这次的新特性太好用了&#xff0c;所以就直接叫 2.0 了。 前段时间&#xff0c;PyTorch 团队在官方博客宣布 Pytorch 1.13 发布&#xff0c;包含 BetterTransformer 稳定版等多项更新。在体验新特性的同时&#xff0c;不少人也在期待下一个版本的推…
阅读更多...
Mysql进阶学习（十）存储过程和函数流程控制结构

Mysql进阶学习（十）存储过程和函数流程控制结构

Mysql进阶学习&#xff08;十&#xff09;存储过程和函数&流程控制结构存储过程和函数1. 存储过程1.1 创建语法1.2 调用语法1.3 删除存储过程1.4 查看存储过程的信息2. 函数2.1 创建语法2.2 调用语法2.3 查看函数2.4 删除函数3. 存储过程/函数案例4. 流程控制结构4.1. 分支…
阅读更多...
心肺运动试验----各类参数分析笔记

心肺运动试验----各类参数分析笔记

1&#xff1a;定义 什么是心肺运动试验&#xff1f; 心肺运动试验(CPET)是一种可以使研究者同时观察患者的心血管系统和呼吸系统对同一种运动应激的反应情况的临床试验。因为&#xff0c;呼吸道的气体交换与循环相关联&#xff0c;可以同时反映心排血量、肺血流以及外周O2的摄…
阅读更多...
详解设计模式：命令模式

详解设计模式：命令模式

命令模式&#xff08;Command Pattern&#xff09;也被称为行动模式&#xff08;Action Pattern&#xff09;、事物模式&#xff08;Transaction Pattern&#xff09;&#xff0c;是在 GoF 23 种设计模式中定义了的行为型模式。 命令模式 是一种数据驱动的设计模式。请求以命令…
阅读更多...
序列类型（元组（）、列表[]、字符串““）、集合类型（{}、set()）

序列类型（元组（）、列表[]、字符串““）、集合类型（{}、set()）

序列类型 组合数据类型能够将多个同类型或不同类型的数据组织起来 &#xff0c;通过单一的表示使数据操作更有序更容易。根据数据之间的 关系&#xff0c;组合数据类型可以分为三类&#xff1a; 序列类型、集合类型和映射类型。 • 序列类型是一个元素向量&#xff0c;元素之间…
阅读更多...
Centos8安装CDH解决不兼容问题

Centos8安装CDH解决不兼容问题

问题 我的配置 系统&#xff1a; centos8 安装包&#xff1a; CDH-5.16.1-1.cdh5.16.1.p0.3-el7.parcel CDH-5.16.1-1.cdh5.16.1.p0.3-el7.parcel.sha cloudera-manager-centos7-cm5.16.1_x86_64.tar.gz manifest.json 在 http://192.168.1.1:7180/ 上通过web分配percel时分配…
阅读更多...
Python实现基于内容的协同过滤推荐算法构建电影推荐系统

Python实现基于内容的协同过滤推荐算法构建电影推荐系统

说明&#xff1a;这是一个机器学习实战项目&#xff08;附带数据代码文档视频讲解&#xff09;&#xff0c;如需数据代码文档视频讲解可以直接到文章最后获取。 1.项目背景 基于内容(Content Based,CB)的推荐算法&#xff0c;根据用户过去是一段时间内喜欢的物品&#xff0c;由…
阅读更多...
DHTMLX Spreadsheet JavaScript Pro 5.0

DHTMLX Spreadsheet JavaScript Pro 5.0

Spreadsheet — Web-Based Spreadsheet Solution 破解版DHTMLX Spreadsheet is a framework-agnostic JavaScript solution that allows you to quickly add an editable Excel-like spreadsheet on a web page. Unlike online services, DHTMLX Spreadsheet allows you to st…
阅读更多...
Windows x64隐藏可执行内存

Windows x64隐藏可执行内存

文章目录实现效果实现原理VAD内存什么是VAD内存查看VAD内存VAD属性VAD内存可利用的点x64分页机制W7 x64下任意地址PDT PTE算法W10 x64定位随机化页表基址实现隐藏可执行内存隐藏内存对抗实现效果 驱动程序在Test进程中申请一块内存地址并打印&#xff0c;然后控制台程序在接收到…
阅读更多...
Web中的Bias（更新中）

Web中的Bias（更新中）

目录前言数据偏见对人们的影响衡量偏见活跃偏差或少数人的智慧数据偏见其他参考文献前言 本文参考Ricardo Baeza-Yates 2018年发表在《Communications of the ACM》的论文Bias on the Web&#xff0c;论文旨在提高人们对网络使用和内容中存在的偏见对我们所有人造成的潜在影响…
阅读更多...
Methyltetrazine-PEG4-NHS ester,甲基四嗪PEG4琥珀酰亚胺酯

Methyltetrazine-PEG4-NHS ester,甲基四嗪PEG4琥珀酰亚胺酯

一&#xff1a;产品描述 1、名称 英文&#xff1a;Methyltetrazine-PEG4-NHS ester 中文&#xff1a;甲基四嗪-四聚乙二醇-琥珀酰亚胺酯 2、CAS编号&#xff1a;1802907-92-1 3、所属分类&#xff1a;Tetrazine 4、分子量&#xff1a;533.54 5、分子式&#xff1a;C24H3…
阅读更多...
qt单线程实现顺序事件的处理不卡顿技巧（IDE开发）

qt单线程实现顺序事件的处理不卡顿技巧（IDE开发）

需求&#xff1a; 我现在是这样的需求&#xff0c;我正在开发一款嵌入式IDE中&#xff0c;编辑器中光标改变&#xff0c;右侧的符号大纲能对应的改变选中项。 这里的过程是这样的&#xff0c;鼠标位置改变事件函数里&#xff0c;通过光标行号&#xff0c;计算得到当前处于的符…
阅读更多...
通过私钥连接腾讯云，实现免密远程登录

通过私钥连接腾讯云，实现免密远程登录

一、创建 SSH 密钥 系统提示不会保存私钥&#xff0c;要求用户在 10 分钟之内自行下载私钥&#xff0c;要保存在本地电脑和邮箱里面备用。 二、绑定密钥到云服务器 勾选刚才创建的 SSH 密钥&#xff0c;点击上面的绑定云主机&#xff0c;弹窗中要先找到你云主机的地域&#x…
阅读更多...
【计算机毕业设计】74.家教平台系统源码

【计算机毕业设计】74.家教平台系统源码

一、系统截图&#xff08;需要演示视频可以私聊&#xff09; 摘 要 21世纪的今天&#xff0c;随着社会的不断发展与进步&#xff0c;人们对于信息科学化的认识&#xff0c;已由低层次向高层次发展&#xff0c;由原来的感性认识向理性认识提高&#xff0c;管理工作的重要性已逐…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023