Spring Data JPA (二)
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开头:代表查询
对象中属性的名称(首字母大写)
含义:根据属性名称进行查询
案例
1)、引入pom.xml
<properties>
<spring.version>5.0.2.RELEASE</spring.version>
<hibernate.version>5.0.7.Final</hibernate.version>
<slf4j.version>1.6.6</slf4j.version>
<log4j.version>1.2.12</log4j.version>
<c3p0.version>0.9.1.2</c3p0.version>
<mysql.version>5.1.6</mysql.version>
</properties>
<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
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:aop="http://www.springframework.org/schema/aop" xmlns:jpa="http://www.springframework.org/schema/data/jpa"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx https://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa.xsd">
<!--spring 和 spring data jpa 的配置-->
<!--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>
<!-- <tx:advice id="txAdvice" transaction-manager="transactionManager" >-->
<!-- <tx:attributes>-->
<!-- <tx:method name="save" propagation="REQUIRED"/>-->
<!-- <tx:method name="insert" propagation="REQUIRED"/>-->
<!-- <tx:method name="update" propagation="REQUIRED"/>-->
<!-- <tx:method name="delete" propagation="REQUIRED"/>-->
<!-- <tx:method name="get" read-only="true"/>-->
<!-- <tx:method name="find" read-only="true"/>-->
<!-- <tx:method name="*" propagation="REQUIRED"/>-->
<!-- </tx:attributes>-->
<!-- </tx:advice>-->
<!-- -->
<!-- <!–5.aop–>-->
<!-- <aop:config>-->
<!-- <aop:pointcut id="pointcut" expression="execution(* com.rzk.server.*.*(..))"/>-->
<!-- <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut"/>-->
<!-- </aop:config>-->
<!--6、配置包扫描-->
<context:component-scan base-package="com.rzk"></context:component-scan>
</beans>
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 {
/**
* @Id:声明主键配置
* @GeneratedValue:配置主键的生成策略
* GenerationType.IDENTITY:自增
* @Column:配置属性和字段的映射关系
* 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<Customer> {
/**
* 案例:根据客户名称查询客户
* 使用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<Customer> {
/**
* 案例:根据客户名称查询客户
* 使用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<T> var1);
//查询列表
List<T> findAll(Specification<T> var1);
//查询全部,分页
//Pageable:分页参数
//返回值:分页pageBean(page:是SpringDataJpa提供的)
Page<T> findAll(Specification<T> var1, Pageable var2);
//查询列表
//Sort:排序参数
List<T> findAll(Specification<T> var1, Sort var2);
//统计查询
long count(Specification<T> var1);
Specification :查询条件
自定义我们自己的Specification 实现类
实现
Root:查询的根对象(查询的任何属性都可以从根对象中获取
CriteriaQuery:顶层查询对象,自定义查询方式
CriteriaBuilder:查询的构造器,封装了很多的查询条件
applicationContext.xml
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:aop="http://www.springframework.org/schema/aop" xmlns:jpa="http://www.springframework.org/schema/data/jpa"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx https://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa.xsd">
<!--spring 和 spring data jpa 的配置-->
<!--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>
<!-- <tx:advice id="txAdvice" transaction-manager="transactionManager" >-->
<!-- <tx:attributes>-->
<!-- <tx:method name="save" propagation="REQUIRED"/>-->
<!-- <tx:method name="insert" propagation="REQUIRED"/>-->
<!-- <tx:method name="update" propagation="REQUIRED"/>-->
<!-- <tx:method name="delete" propagation="REQUIRED"/>-->
<!-- <tx:method name="get" read-only="true"/>-->
<!-- <tx:method name="find" read-only="true"/>-->
<!-- <tx:method name="*" propagation="REQUIRED"/>-->
<!-- </tx:attributes>-->
<!-- </tx:advice>-->
<!-- -->
<!-- <!–5.aop–>-->
<!-- <aop:config>-->
<!-- <aop:pointcut id="pointcut" expression="execution(* com.rzk.server.*.*(..))"/>-->
<!-- <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut"/>-->
<!-- </aop:config>-->
<!--6、配置包扫描-->
<context:component-scan base-package="com.rzk"></context:component-scan>
</beans>
实体类
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 {
/**
* @Id:声明主键配置
* @GeneratedValue:配置主键的生成策略
* GenerationType.IDENTITY:自增
* @Column:配置属性和字段的映射关系
* 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<T> var1, CriteriaQuery<?> var2, CriteriaBuilder var3);//封装查询条件
多表之间的关系和操作多表的操作步骤
测试
根据客户名称查询,查询客户名为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);
}
```java
这个异常是说明数据库中的数据本应该是唯一的 但是是重复了 是数据的问题不是代码问题
查询的数据库的条数有两条或以上就会报错
#### 完成根据客户名称得到模糊匹配,返回客户列表
```java
/**
* 案例:完成根据客户名称得到模糊匹配,返回客户列表
* 客户名称 r 开头
*
* equal:直接到path对象(属性),然后进行比较即可
* gt , lt , ge , le , like : 根据path指定比较的参数类型 再去比较
* 指定参数类型: path.as(类型得到字节码对象)
*
*/
@Test
public void likeSpec(){
//构造查询条件
Specification<Customer> spec = new Specification<Customer>() {
@Override
public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
Path<Object> custName = root.get("custName");
Predicate rz = criteriaBuilder.like(custName.as(String.class), "r%");
return rz;
}
};
List<Customer> daoAll = customerDao.findAll(spec);
for (Customer customer : daoAll) {
System.out.println(customer);
}
}
排序
@Test
public void DESEASCSpec(){
//构造查询条件
Specification<Customer> spec = new Specification<Customer>() {
@Override
public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
Path<Object> custName = root.get("custName");
Predicate rz = criteriaBuilder.like(custName.as(String.class), "r%");
return rz;
}
};
//添加排序
//创建排序 sort 对象,需要构造方法实例化sort对象
//第一个参数 : 排序的顺序(倒序,正序)
//第二个参数 : 排序的属性名称
// Sort.Direction.DESC :倒序
// Sort.Direction.ASE :升序
//第二个参数 : 排序的属性名称
Sort sort = new Sort(Sort.Direction.ASC,"custId");
List<Customer> daoAll = customerDao.findAll(spec, sort);
for (Customer customer : daoAll) {
System.out.println(customer);
}
}
可以看到已经按降序排序了
分页查询
- 分页查询
- Specification:查询条件
- Pageable:分页参数
- 分页参数:查询的页码,每页查询的条数
- findAll(Specification,Pageable);带有条件的分页
- findAll(Pageable):没有条件的分页
- 返回:Page(SpringDateJpa为我们封装好的pageBean对象,数据列表,总条数)
/**
* 分页查询
* Specification:查询条件
* Pageable:分页参数
* 分页参数:查询的页码,每页查询的条数
* findAll(Specification,Pageable);带有条件的分页
* findAll(Pageable):没有条件的分页
* 返回:Page(SpringDateJpa为我们封装好的pageBean对象,数据列表,总条数)
*
*/
@Test
public void limitSpec(){
Specification<Customer> spec = new Specification<Customer>() {
@Override
public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
Path<Object> custName = root.get("custName");
Predicate predicate = criteriaBuilder.equal(custName, "rui");
return predicate;
}
};
//PageRequest对象时Pageable接口的实现类
/**
* 创建PageRequest的过程中,需要调用它的构造方法闯入两个参数
* 第一个参数:当前查询的页数(从0开始)
* 第二个参数:每页查询的数量
*/
Pageable pageable = new PageRequest(0,3);
//分页查询
Page<Customer> page = customerDao.findAll(spec, pageable);
for (Customer customer : page) {
System.out.println(customer);
}
System.out.println(page.getContent());//得到数据集合列表
System.out.println(page.getTotalElements());//得到总条数
System.out.println(page.getTotalPages());//得到总页数
}
完成多表操作
一对多操作
多对多操作