Spring Data JPA 与JPA和hibernate之间的关系
Spring Data JPA的特性??
（一）、JPA是一套规范，内部是有接口和抽象类组成。hibernate 是一套成熟的ORM框架
SpringData Jpa极大简化了数据库访问层代码，如何简化的？使用了SpringDataJpa 我们的dao层中字需要写接口，就自动具有了增删改查、分页查询等方法
（二）、java代码-->SpringData Jpa(把jpa的规范又封装了一层) --->Jpa规范(封装hibernate) --- >hibernate ---> 查询数据库
java代码写的是SpringData Jpa提供的规范，但SpringData Jpa内部封装了一层jpa规范的操作逻辑，但真正执行的是jpa规范内部的hibernate,hibernate封装了jdbc
（三）、springDataJpa的运行过程和原理剖析
1）、通过JdkDynamicAopProxy的invoke 方法创建了一个动态代理对象
2）、SimpleJpaRepository当中封装了JPA的操作（借助JPA的api完成数据库的CRUD）
3）、通过hibernate完成数据库操作（封装了jdbc）
（四）、复杂查询
1）、借助接口中的定义好的方法完成查询
? findOne(id):根据id查询
2）、jpql的查询方式
? jpql：jpa query language （jpa查询语言）
? 特点：语法或关键字和sql语句类似
? 查询的是类和类中的属性
需要将JPQL语句语句配置到接口方法上
1）、特有的查询：需要在dao接口上配置方法
2）、在新添加的方法上，使用注解的形式配置jpql查询语句
3）、注解：@query
3）、sql语句的查询
1）、特有的查询：需要在dao接口上配置方法
2）、在新添加的方法上，使用注解的形式配置sql查询语句
3）、注解： @Query
value：jpql语句 | sql语句
nativeQuery：false （使用jpql查询） | true（使用本地查询 ：sql查询）
是否使用本地查询
4）、方法名称规则查询
是对jpql查询，更加深入的一层封装
我们只需要按照SpringDataJpa提供的方法名称规则定义方法，不需要再去配置jpql语句，
findBy开头：代表查询
对象中属性的名称（首字母大写）
含义：根据属性名称进行查询
img
案例
1）、引入pom.xml
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<!--spring beg-->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.6.8</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-orm</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${spring.version}</version>
</dependency>
<!--hibernate beg-->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>${hibernate.version}</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-entitymanager</artifactId>
<version>${hibernate.version}</version>
</dependency>
<dependency>
<groupId>org.hibernate.validator</groupId>
<artifactId>hibernate-validator</artifactId>
<version>6.0.9.Final</version>
</dependency>
<!--c3p0 beg-->
<dependency>
<groupId>c3p0</groupId>
<artifactId>c3p0</artifactId>
<version>${c3p0.version}</version>
</dependency>
<!--log end-->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>${log4j.version}</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>${slf4j.version}</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>${slf4j.version}</version>
</dependency>
<!--log end-->
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-jpa</artifactId>
<version>1.9.0.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jcl</artifactId>
<version>${spring.version}</version>
</dependency>
<!--el beg使用spring data jpa 必须引入-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql.version}</version>
</dependency>
<dependency>
<groupId>javax.el</groupId>
<artifactId>javax.el-api</artifactId>
<version>3.0.0</version>
</dependency>
<dependency>
<groupId>org.glassfish.web</groupId>
<artifactId>javax.el</artifactId>
<version>2.2.4</version>
</dependency>
</dependencies>
2）、编写一个applicationContext.xml
<!--1、創建entityManagerFactory 对象交给spring容器管理-->
<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
<property name="dataSource" ref="dataSource"/>
<!--实体类所在的包-->
<property name="packagesToScan" value="com.rzk.pojo"/>
<!--jpa的供应商适配器-->
<property name="persistenceProvider">
<bean class="org.hibernate.jpa.HibernatePersistenceProvider"/>
</property>
<!--jpa的供应商适配器-->
<property name="jpaVendorAdapter">
<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
<!--配置是否自动创建数据库表-->
<property name="generateDdl" value="false"/>
<!--指定数据类型-->
<property name="database" value="MYSQL"/>
<!--数据库方言，支持特有语法-->
<property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect"/>
<!--是否显示sql-->
<property name="showSql" value="true"/>
</bean>
</property>
<!--jpa的方言：高级特性-->
<property name="jpaDialect">
<bean class="org.springframework.orm.jpa.vendor.HibernateJpaDialect"/>
</property>
</bean>
<!--2、创建数据库连接池-->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="user" value="root"></property>
<property name="password" value="123456"></property>
<property name="jdbcUrl" value="jdbc:mysql://127.0.0.1:3306/jap"></property>
<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
</bean>
<!--3、整合spring dataJpa-->
<jpa:repositories base-package="com.rzk.dao" transaction-manager-ref="transactionManager"
entity-manager-factory-ref="entityManagerFactory"></jpa:repositories>
<!--4、配置事务管理器-->
<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory" ref="entityManagerFactory"></property>
</bean>
<!--6、配置包扫描-->
<context:component-scan base-package="com.rzk"></context:component-scan>
3)、dao层
JpaRepository<实体类,你这个类主键的属性>
public interface CustomerDao extends JpaRepository<Customer,Long>, JpaSpecificationExecutor
}
4)、pojo
DROP TABLE IF EXISTS cst_customer;
CREATE TABLE cst_customer (
cust_id bigint(20) NOT NULL AUTO_INCREMENT,
cust_address varchar(255) DEFAULT NULL,
cust_industry varchar(255) DEFAULT NULL,
cust_level varchar(255) DEFAULT NULL,
cust_name varchar(255) DEFAULT NULL,
cust_phone varchar(255) DEFAULT NULL,
cust_source varchar(255) DEFAULT NULL,
PRIMARY KEY (cust_id)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=gbk;
/**
fileName:Customer
description:
author:rzk
createTime:2020/8/5 20:43
versioni:1.0.0
1、实体类和表的映射关系
@Entity
@Table
2、类中属性和表中字段的映射关系
@Id
@GeneratedValue
@Column
/
@Entity
@Table(name = "cst_customer")
public class Customer {
/*
GenerationType.IDENTITY:自增
name：数据库表中字段的名称
*/
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "cust_id")
private Long custId;//客户主键
@Column(name = "cust_name")
private String custName;//客户名称
@Column(name = "cust_source")
private String custSource;//客户来源
@Column(name = "cust_level")
private String custLevel;//客户级别
@Column(name = "cust_industry")
private String custIndustry;//客户所属行业
@Column(name = "cust_phone")
private String custPhone;//客户的联系方式
@Column(name = "cust_address")
private String custAddress;//客户地址
public Long getCustId() {
return custId;
}
public void setCustId(Long custId) {
this.custId = custId;
}
public String getCustName() {
return custName;
}
public void setCustName(String custName) {
this.custName = custName;
}
public String getCustSource() {
return custSource;
}
public void setCustSource(String custSource) {
this.custSource = custSource;
}
public String getCustLevel() {
return custLevel;
}
public void setCustLevel(String custLevel) {
this.custLevel = custLevel;
}
public String getCustIndustry() {
return custIndustry;
}
public void setCustIndustry(String custIndustry) {
this.custIndustry = custIndustry;
}
public String getCustPhone() {
return custPhone;
}
public void setCustPhone(String custPhone) {
this.custPhone = custPhone;
}
public String getCustAddress() {
return custAddress;
}
public void setCustAddress(String custAddress) {
this.custAddress = custAddress;
}
@Override
public String toString() {
return "Customer{" +
"custId=" + custId +
", custName=‘" + custName + ‘‘‘ +
", custSource=‘" + custSource + ‘‘‘ +
", custLevel=‘" + custLevel + ‘‘‘ +
", custIndustry=‘" + custIndustry + ‘‘‘ +
", custPhone=‘" + custPhone + ‘‘‘ +
", custAddress=‘" + custAddress + ‘‘‘ +
‘}‘;
}
}
5)、测试类
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class SpeTest {
@Autowired
private CustomerDao customerDao;
@Test
public void testSpec(){
List<Customer> all = customerDao.findAll();
for (Customer customer : all) {
System.out.println(customer);
}
}
/**
* save: 保存或者更新
* 根据传递的对象是否存在主键Id，如果没有id主键属性：
* 保存id主键属性，根据id查询数据，更新数据
*/
@Test
public void testSave(){
Customer customer = new Customer();
customer.setCustName("lisi");
customerDao.save(customer);
}
/**
* 如果Id有值，就是修改，但是如果其他字段没有传入进来，会把原有的字段清空
*/
@Test
public void testUpdate(){
Customer customer = new Customer();
customer.setCustId(1l);
customer.setCustName("lisi");
customerDao.save(customer);
}
/**
* 删除
*/
@Test
public void testDelete(){
customerDao.delete(3l);
}
/**
* 查询所有
*/
public void testOne(){
Customer one = customerDao.findOne(1l);
System.out.println(one);
}
}
使用JPQL完成查询方法
@Query: 代表是进行查询
? 此方法是用来进行更新操作
@Modifying :当前执行时一个更新操作
public interface CustomerDao extends JpaRepository<Customer,Long>, JpaSpecificationExecutor
/**
* 案例：根据客户名称查询客户
* 使用jpql的形式查询
* jpql：from Customer where custName = ？
*
*
* 配置jpql语句，使用@Query注解
*/
@Query(value = "from Customer where custName = ?")
public Customer findJpql(String custName);
/**
*
* 使用jpql 完成更新操作
* 案例：根据id更新，客户的名称
* 更新4号客户的名称，将名称改为 hello
* sql ： update cut_customer set cust_address=? where cust_id=?
* jpql: update Customer set custName = ? where custId = ?
*
* @Query : 代表是进行查询
* 此方法是用来进行更新操作
* @Modifying
* 当前执行时一个更新操作
/
@Query(value = "update Customer set custName = ?2 where custId = ?1")
@Modifying /如果要执行修改或删除需要添加事务*/
public void updateCustomer(long custId,String custName
/**
* jpql模糊查询
*
* @param name
* @return
*/
@Query(value = "from Customer where custName like ?")
public List<Object []> customerLike(String name);
}
测试
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class JpqlTest {
@Autowired
private CustomerDao customerDao;
@Test
public void testFindJPQL(){
Customer kzr = customerDao.findJpql("rzk");
System.out.println(kzr);
}
/**
* 测试jpql的更新操作
* springDataJpa 中使用jpql完成 更新/删除操作
* 需要手动添加事务的支持
* 默认会执行结束之后，回滚事务
*
* @Rollback:设置是否自动回滚
* false | true
*
*/
@Test
@Transactional // 添加事务的支持
@Rollback(value = false)
public void testUpdateCustomer(){
customerDao.updateCustomer(4l,"zhangsan");
}
/**
* jpql 模糊查询
*/
@Test
public void customerLike(){
List<Object[]> customerLike = customerDao.customerLike("z%");
System.out.println(customerLike);
}
}
TransactionRequiredException: Executing an update/delete query
添加或删除出现的错误
需要添加事务
使用sql完成查询+模糊查询
dao 层
public interface CustomerDao extends JpaRepository<Customer,Long>, JpaSpecificationExecutor
/**
* 案例：根据客户名称查询客户
* 使用jpql的形式查询
* jpql：from Customer where custName = ？
*
*
* 配置jpql语句，使用@Query注解
*/
@Query(value = "from Customer where custName = ?")
public Customer findJpql(String custName);
/**
*
* @param name
* @param id
* @return
*
* 案例：根据用户名称和用户id查询
* jpql ： from Customer where cusstName = ? and custId = ?
*
* 对于多个占位符参数
* 赋值的时候，默认的情况下，占位符的位置需要和方法参数中位置保持一致
*
* 可以指定占位符的位置
* ？索引的方式，指定此占位符的取值来源
*/
@Query(value = "from Customer where custName = ?2 and custId = ?1")
public Customer findCustNameAndId(Long id,String name);
/**
*
* 使用jpql 完成更新操作
* 案例：根据id更新，客户的名称
* 更新4号客户的名称，将名称改为 hello
* sql ： update cut_customer set cust_address=? where cust_id=?
* jpql: update Customer set custName = ? where custId = ?
*
* @Query : 代表是进行查询
* 此方法是用来进行更新操作
* @Modifying
* 当前执行时一个更新操作
*/
@Query(value = "update Customer set custName = ?2 where custId = ?1")
@Modifying /*如果要执行修改或删除需要添加事务*/
public void updateCustomer(long custId,String custName);
/**
* 使用sql的形式查询
* 查询全部的客户
* sql ： select * from cst_customer;
* Query:配置sql查询
* value ： sql语句
* naiveQuery：查询方式
* true：sql查询
* false：jpql查询
*
*/
@Query(value = "select * from cst_customer",nativeQuery = true)
public List<Object []> findSql();
/**
* 根据用户名 模糊查询
*
*/
@Query(value = "select * from cst_customer where cust_name like ?",nativeQuery = true)
public List<Object []> findSqlLike(String name);
}
测试
@Test
@Transactional // 添加事务的支持
@Rollback(value = false)
public void testFindSql(){
List<Object[]> list = customerDao.findSql();
for (Object[] obj : list) {
System.out.println(Arrays.toString(obj));
}
}
@Test
public void testFindLike(){
List<Object[]> sqlLike = customerDao.findSqlLike("r%");
for (Object[] objects : sqlLike) {
System.out.println(Arrays.toString(objects));
}
}
方法名称规则查询+ 模糊查询
是对jpql查询，更加深入的一层封装
我们只需按照SpringDataJpa 提供的方法名称规则定义方法，不需要再去配置jpql语句，完成查询
findBy开头 ： 代表查询
对象中属性名称（首字母大写）
1）、findBy + 属性名称（根据属性名称进行完成匹配的查询 = ）
2）、findby + 属性名称 + “查询方式”（Like | isnull）
findByCustNameLike
3）、多条件查询
findBy + 属性名 + 查询方式 + 多条件的连接符 （and | or）
/**
* 方法名的约定
* findBy :查询
* 对象中的属性名（首字母大写） 查询条件
* CustName
*
* findByCustName 根据客户名称查询
*
* 在springdataJpa的运行阶段
* 会根据方法名称进行解析 findBy from *** (实体类)
* 属性名称 where custName
*
*/
public Customer findByCustName(String custName);
测试
//测试方法名规则的查询
@Test
public void TestName(){
Customer customer = customerDao.findByCustName("zhukai");
System.out.println(customer);
}
回顾
SpringDataJpa，jpa规范，hibernate三者之间的关系
code ---> springDatajpa ---> jpa规范的API --->hibernate
符合SpringDataJpa规范的dao层接口的编写规则
需要实现两个接口（jpaRepository，JpaSpecificationExecutor）
提供响应的泛型
运行过程
动态代理的方式：动态代理对象
查询
多表查询
SpecificationExecutor动态查询
方法列表
//查询单个对象
T findOne(Specification
//查询列表
List
//查询全部，分页
//Pageable:分页参数
//返回值:分页pageBean(page:是SpringDataJpa提供的)
Page
//查询列表
//Sort:排序参数
List
//统计查询
long count(Specification
Specification :查询条件
自定义我们自己的Specification 实现类
实现
Root:查询的根对象(查询的任何属性都可以从根对象中获取
CriteriaQuery:顶层查询对象,自定义查询方式
CriteriaBuilder:查询的构造器,封装了很多的查询条件
applicationContext.xml
<!--1、創建entityManagerFactory 对象交给spring容器管理-->
<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
<property name="dataSource" ref="dataSource"/>
<!--实体类所在的包-->
<property name="packagesToScan" value="com.rzk.pojo"/>
<!--jpa的供应商适配器-->
<property name="persistenceProvider">
<bean class="org.hibernate.jpa.HibernatePersistenceProvider"/>
</property>
<!--jpa的供应商适配器-->
<property name="jpaVendorAdapter">
<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
<!--配置是否自动创建数据库表-->
<property name="generateDdl" value="false"/>
<!--指定数据类型-->
<property name="database" value="MYSQL"/>
<!--数据库方言，支持特有语法-->
<property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect"/>
<!--是否显示sql-->
<property name="showSql" value="true"/>
</bean>
</property>
<!--jpa的方言：高级特性-->
<property name="jpaDialect">
<bean class="org.springframework.orm.jpa.vendor.HibernateJpaDialect"/>
</property>
</bean>
<!--2、创建数据库连接池-->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="user" value="root"></property>
<property name="password" value="123456"></property>
<property name="jdbcUrl" value="jdbc:mysql://127.0.0.1:3306/jap"></property>
<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
</bean>
<!--3、整合spring dataJpa-->
<jpa:repositories base-package="com.rzk.dao" transaction-manager-ref="transactionManager"
entity-manager-factory-ref="entityManagerFactory"></jpa:repositories>
<!--4、配置事务管理器-->
<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory" ref="entityManagerFactory"></property>
</bean>
<!--6、配置包扫描-->
<context:component-scan base-package="com.rzk"></context:component-scan>
实体类
import javax.persistence.*;
/**
fileName:Customer
description:
author:rzk
createTime:2020/8/5 20:43
versioni:1.0.0
1、实体类和表的映射关系
@Entity
@Table
2、类中属性和表中字段的映射关系
@Id
@GeneratedValue
@Column
/
@Entity
@Table(name = "cst_customer")
public class Customer {
/*
GenerationType.IDENTITY:自增
name：数据库表中字段的名称
*/
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "cust_id")
private Long custId;//客户主键
@Column(name = "cust_name")
private String custName;//客户名称
@Column(name = "cust_source")
private String custSource;//客户来源
@Column(name = "cust_level")
private String custLevel;//客户级别
@Column(name = "cust_industry")
private String custIndustry;//客户所属行业
@Column(name = "cust_phone")
private String custPhone;//客户的联系方式
@Column(name = "cust_address")
private String custAddress;//客户地址
public Long getCustId() {
return custId;
}
public void setCustId(Long custId) {
this.custId = custId;
}
public String getCustName() {
return custName;
}
public void setCustName(String custName) {
this.custName = custName;
}
public String getCustSource() {
return custSource;
}
public void setCustSource(String custSource) {
this.custSource = custSource;
}
public String getCustLevel() {
return custLevel;
}
public void setCustLevel(String custLevel) {
this.custLevel = custLevel;
}
public String getCustIndustry() {
return custIndustry;
}
public void setCustIndustry(String custIndustry) {
this.custIndustry = custIndustry;
}
public String getCustPhone() {
return custPhone;
}
public void setCustPhone(String custPhone) {
this.custPhone = custPhone;
}
public String getCustAddress() {
return custAddress;
}
public void setCustAddress(String custAddress) {
this.custAddress = custAddress;
}
@Override
public String toString() {
return "Customer{" +
"custId=" + custId +
", custName=‘" + custName + ‘‘‘ +
", custSource=‘" + custSource + ‘‘‘ +
", custLevel=‘" + custLevel + ‘‘‘ +
", custIndustry=‘" + custIndustry + ‘‘‘ +
", custPhone=‘" + custPhone + ‘‘‘ +
", custAddress=‘" + custAddress + ‘‘‘ +
‘}‘;
}
}
dao层
Predicate toPredicate(Root
多表之间的关系和操作多表的操作步骤
测试
根据客户名称查询,查询客户名为rzk的客户
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class SpecTest {
@Autowired
private CustomerDao customerDao;
/**
* 查詢单个
*/
@Test
public void findOneSpec(){
//匿名内部类
/**
* 自定义查询条件
* 1.实现Specification接口(提供泛型:查询的对象类型)
* 2.实现toPredicate方法(构造查询条件)
* 3.需要借助方法参数中的两个参数(
* root:获取需要查询的对象属性)
* CriteriaBuilder:够着查询条件的,内部封装了很多的查询条件(模糊查询)
*
* 案例:根据客户名称查询,查询客户名为rzk的客户
* 查询条件:
* 1.查询方式
* cb对象
* 2.比较的属性名称
* root对象
*/
Specification<Customer> spec = new Specification<Customer>() {
@Override
public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
//1.获取比较的属性
Path<Object> custName = root.get("custName");
//2.构造查询条件 ----> select * from cst_customer where cust_name = "rzk"
/**
* 第一个参数： 需要比较的属性（path对象）
* 第二个参数：当前需要比较的取值
*/
Predicate rzk = criteriaBuilder.equal(custName, "rzk");//进行精准的匹配 (比较的属性,比较的属性的取值)
return rzk;
}
};
Customer one = customerDao.findOne(spec);
System.out.println(one);
}
错误
如果报错这个错
org.springframework.dao.IncorrectResultSizeDataAccessException: result returns more than one elements; nested exception is javax.persistence.NonUniqueResultException: result returns more than one elements
根据客户名（rzk）和客户所属行业查询 多条件查询
/**
* 多条件查询
* 案例：根据客户名（传智播客）和客户所属行业查询
*
*/
@Test
public void findAllSpec(){
/**
* root:获取属性
* 客户名
* 所属行业
* CriteriaBuilder：构造查询
* 1.构造客户名的精准匹配查询
* 2.构造所属行业的精准匹配查询
* 3.将以上两个查询联系起来
*
*/
Specification<Customer> spec = new Specification<Customer>() {
@Override
public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
Path<Object> custName = root.get("custName");//客户名
Path<Object> custIndustry = root.get("custIndustry");//所属行业
//构造查询
//1.构造客户名的精准匹配查询
Predicate p1 = criteriaBuilder.equal(custName, "rui");//第一个参数,path(属性),第二个参数,属性的取值
//2.构造客户名的精准匹配查询
Predicate p2 = criteriaBuilder.equal(custIndustry, "student");
//3.将多个查询条件组合到一起:组合(满足条件一并且满足条件二,与关系 ,满足条件一或满足条件二,或关系)
Predicate predicate = criteriaBuilder.and(p1, p2);
return predicate;
}
};
Customer one = customerDao.findOne(spec);
System.out.println(one);
List<Customer> daoAll = customerDao.findAll(spec);
for (Customer customer : daoAll) {
System.out.println(customer);
}
这个异常是说明数据库中的数据本应该是唯一的 但是是重复了 是数据的问题不是代码问题
查询的数据库的条数有两条或以上就会报错
完成多表操作
一对多操作
多对多操作
原文：https://www.cnblogs.com/rzkwz/p/13497687.html