本篇内容
1. SpringDataJpa的概述
2. SpringDataJpa的入门操作
3. SpringDataJpa的运行过程和原理剖析
4. 复杂查询SpringDataJpa的概述
1. 概述：
* Spring Data JPA 是 Spring 基于 ORM 框架、JPA 规范的基础上封装的一套 JPA 应用框架，可使开发者用极简的代码即可实现对数据库的访问和操作。它提供了包括增删改查等在内的常用功能，且易于扩展！学习并使用 Spring Data JPA 可以极大提高开发效率！
2. 作用：
* Spring Data JPA 让我们解脱了 DAO 层的操作，基本上所有 CRUD 都可以依赖于它来实现,在实际的工作工程中，推荐使用 Spring Data JPA + ORM（如：hibernate）完成操作，这样在切换不同的 ORM框架时提供了极大的方便，同时也使数据库层操作更加简单，方便解耦
3. Spring Data JPA 与 与 JPA 和 和hibernate之间的关系 [它是对jpa规范的封装...]
4. 关系：
1. JPA 是一套规范，内部是有接口和抽象类组成的。hibernate 是一套成熟的 ORM 框架，而且Hibernate 实现了 JPA 规范，所以也可以称 hibernate 为 JPA 的一种实现方式，我们使用 JPA的 API 编程，意味着站在更高的角度上看待问题（面向接口编程）
2. Spring Data JPA 是 Spring 提供的一套对 JPA 操作更加高级的封装，是在 JPA 规范下的专门用来进行数据持久化的解决方案。
5. 我们昨天学习的是JPA的规范，今天学的是SpringData JPA ，它是对JPA的封装，减少了一些重复性代码，提高了生产效率；入门操作：
1. 案例：
* 客户的基本CRUD
2. 搭建环境
1. 创建工程导入坐标
2. 配置Spring的配置文件（配置Spring Data jpa的整合）
3. 编写实体类（Customer），使用jpa注解配置映射关系
3. 编写：
1. 编写一个符合SpringDataJpa的dao层接口
* 只需要编写dao层接口，不需要编写dao层接口的实现类
* dao层接口规范
1. 需要继承两个接口（JpaRepository,JpaSpecificationExecutor）
2. 需要提供相应的泛型
* 第一个是实体类类型和主键类型
* 第二个是实体类类型
2. 语句：
1. findOne(id): 根据id查询
2. save(customer): 保存或者更新（依据：传递的实体类对象中，是否包含id属性）
3. delete(id): 根据id删除
4. findAll() 查询全部源码分析
1. 分析图： 接口为什么能实现这些方法呢？
2. 底层原理解析
![]()
3. SpringDataJpa的运行过程和原理解析
1. 通过JdkDynamicAopProxy的invoke方法创建了一个动态代理对象
2. SimpleJpaRepository当中封装了JPA的操作（借助JPA的api完成数据库的CRUD）
3. 通过hibernate完成数据库操作（封装了jdbc）
4. xml配置文件中配置的扫描包，就能自动的创建一个相应的实体类dao操作实现类；复杂查询
1. 借助接口中定义好的方法完成查询
* findOne(id): 根据id查询
2. jpql的查询方式 【sql查询做补充，jpql一定更要掌握，它是一种面向对象的查询方式】
1. jpql： jpa query language（jpql查询语言）
2. 特点：
* 语法或关键字和sql语句类似
* 查询的是类和类中的属性
3. 方式：
* 需要将JPQL语句配置到接口方法上
1. 特有的查询：需要在dao接口上配置方法
2. 在新添加的方法上，使用注解的形式配置jpql查询语句
3. 注解： @Query
3. sql语句的查询
1. 特有的查询：需要在dao接口上配置方法
2. 在新添加的方法上，使用注解的形式配置sql查询语句
3. 注解：@Query
* value: jpql语句 | sql 语句
* nativeQuery: false (使用jpql查询) | true(使用本地查询：sql查询)
- 是否使用本地查询
4. 方法名称规则查询 【建议使用，清晰易懂】
1. 是对jpql查询更加深入的一层封装
2. 我们只需要按照SpringDataJpa提供的方法名称规则定义方法，不需要再去配置jpql语句，完成查询
3. 用法：
1. findBy开头: 代表查询
* 对象中属性的名称(首字母大写)
2. 含义：根据属性名称进行查询
4. 查询举例： -- 里面添加参数的时候顺序不能弄反，必须与方法名保持一致
1. findBy + 属性名称
2. findBy + 属性名称 + 查询方式
3. findBy + 属性名称 + 查询方式 +and| or + 属性名+ 查询方式...四种查询方法
1. 使用 Spring Data JPA 中接口定义的方法进行查询
* 在继承 JpaRepository，和 JpaRepository 接口后,我们就可以使用接口中定义的方法进行查询
2. 使用 JPQL 的方式查询
* 使用 Spring Data JPA 提供的查询方法已经可以解决大部分的应用场景，但是对于某些业务来说，我们还需要灵活的构造查询条件，这时就可以使用@Query 注解，结合 JPQL 的语句方式完成查询
* @Query 注解的使用非常简单，只需在方法上面标注该注解，同时提供一个 JPQL 查询语句即可
* 此外，也可以通过使用 @Query 来执行一个更新操作，为此，我们需要在使用 @Query 的同时，用 @Modifying 来将该操作标识为修改查询，这样框架最终会生成一个更新的操作，而非查询
3. 使用 SQL 语句查询
* @Query(value="select * from cst_customer",nativeQuery=true)
4. 方法命名规则查询
* 方法命名规则查询就是根据方法的名字，就能创建查询。只需要按照 Spring Data JPA提供的方法命名规则定义方法的名称，就可以完成查询工作。Spring Data JPA 在程序执行的时候会根据方法名称进行解析，并自动生成查询语句进行查询
* 按照 Spring Data JPA 定义的规则，查询方法以 findBy 开头，涉及条件查询时，条件的属性用条件关键字连接，要注意的是：条件属性首字母需大写。框架在进行方法名解析时，会先把方法名多余的前缀截取掉，然后对剩下部分进行解析。
* 使用关键字生成的查询语句表：
代码演示[Maven工程]
pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>cn.itcast</groupId>
<artifactId>jpa-day2</artifactId>
<version>1.0-SNAPSHOT</version>
<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>
<!-- junit单元测试 -->
<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>
<!--Spring 对orm 框架的支持包-->
<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>
<!-- spring end -->
<!-- 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</groupId>
<artifactId>hibernate-validator</artifactId>
<version>5.2.1.Final</version>
</dependency>
<!-- hibernate end -->
<!-- c3p0 beg -->
<dependency>
<groupId>c3p0</groupId>
<artifactId>c3p0</artifactId>
<version>${c3p0.version}</version>
</dependency>
<!-- c3p0 end -->
<!-- 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>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql.version}</version>
</dependency>
<!--SpringDataJpa 的坐标-->
<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>
<!-- el beg 使用spring data jpa 必须引入 -->
<dependency>
<groupId>javax.el</groupId>
<artifactId>javax.el-api</artifactId>
<version>2.2.4</version>
</dependency>
<dependency>
<groupId>org.glassfish.web</groupId>
<artifactId>javax.el</artifactId>
<version>2.2.4</version>
</dependency>
<!-- el end -->
</dependencies>
</project>resources/applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:jdbc="http://www.springframework.org/schema/jdbc"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:jpa="http://www.springframework.org/schema/data/jpa"
xmlns:task="http://www.springframework.org/schema/task"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/jdbc
http://www.springframework.org/schema/jdbc/spring-jdbc.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.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="cn.itcast.domain"/>
<!--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">
<!--这里是jpa实现了hibernate，所以SpringData jpa默认也继承了hibernate 的一些高级特性，如一级缓存二级缓存等..-->
<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="root"></property>
<property name="jdbcUrl" value="jdbc:mysql:///jpa"></property>
<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
</bean>
<!--3. 整合spring data jpa-->
<jpa:repositories base-package="cn.itcast.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>
<!--5. 声明式事务-->
<!--6. 配置包扫描-->
<context:component-scan base-package="cn.itcast"></context:component-scan>
</beans>domain/customer.java
package cn.itcast.domain;
import javax.persistence.*;
/**
* Customer
* hasee
* 2018/12/17
* 10:18
*
* @Version 1.0
**/
/*
* 1. 实体类和表的映射关系
* @Eitity:声明实体类
* @Table:表名实体类和表映射关系
* 2. 类中属性和表中资源的映射关系
* @Id： 配置主键
* @GenerateValue ： 指定主键的生成策略
* @Column： 实体类属性和表中属性的对应关系
*
* */
@Entity
@Table(name = "cst_customer")
public class Customer {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "cust_id")
private Long custId;
@Column(name = "cust_address")
private String custAddress;
@Column(name = "cust_industry")
private String custIndustry;
@Column(name = "cust_level")
private String custLevel;
@Column(name = "cust_name")
private String custName;
@Column(name = "cust_phone")
private String custPhone;
@Column(name = "cust_source")
private String custSource;
public Long getCustId() {
return custId;
}
public void setCustId(Long custId) {
this.custId=custId;
}
public String getCustAddress() {
return custAddress;
}
public void setCustAddress(String custAddress) {
this.custAddress=custAddress;
}
public String getCustIndustry() {
return custIndustry;
}
public void setCustIndustry(String custIndustry) {
this.custIndustry=custIndustry;
}
public String getCustLevel() {
return custLevel;
}
public void setCustLevel(String custLevel) {
this.custLevel=custLevel;
}
public String getCustName() {
return custName;
}
public void setCustName(String custName) {
this.custName=custName;
}
public String getCustPhone() {
return custPhone;
}
public void setCustPhone(String custPhone) {
this.custPhone=custPhone;
}
public String getCustSource() {
return custSource;
}
public void setCustSource(String custSource) {
this.custSource=custSource;
}
@Override
public String toString() {
return "Customer{" +
"custId=" + custId +
", custAddress='" + custAddress + '\'' +
", custIndustry='" + custIndustry + '\'' +
", custLevel='" + custLevel + '\'' +
", custName='" + custName + '\'' +
", custPhone='" + custPhone + '\'' +
", custSource='" + custSource + '\'' +
'}';
}
}dao/CustomerDao
package cn.itcast.domain;
import javax.persistence.*;
/**
* Customer
* hasee
* 2018/12/17
* 10:18
*
* @Version 1.0
**/
/*
* 1. 实体类和表的映射关系
* @Eitity:声明实体类
* @Table:表名实体类和表映射关系
* 2. 类中属性和表中资源的映射关系
* @Id： 配置主键
* @GenerateValue ： 指定主键的生成策略
* @Column： 实体类属性和表中属性的对应关系
*
* */
@Entity
@Table(name = "cst_customer")
public class Customer {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "cust_id")
private Long custId;
@Column(name = "cust_address")
private String custAddress;
@Column(name = "cust_industry")
private String custIndustry;
@Column(name = "cust_level")
private String custLevel;
@Column(name = "cust_name")
private String custName;
@Column(name = "cust_phone")
private String custPhone;
@Column(name = "cust_source")
private String custSource;
public Long getCustId() {
return custId;
}
public void setCustId(Long custId) {
this.custId=custId;
}
public String getCustAddress() {
return custAddress;
}
public void setCustAddress(String custAddress) {
this.custAddress=custAddress;
}
public String getCustIndustry() {
return custIndustry;
}
public void setCustIndustry(String custIndustry) {
this.custIndustry=custIndustry;
}
public String getCustLevel() {
return custLevel;
}
public void setCustLevel(String custLevel) {
this.custLevel=custLevel;
}
public String getCustName() {
return custName;
}
public void setCustName(String custName) {
this.custName=custName;
}
public String getCustPhone() {
return custPhone;
}
public void setCustPhone(String custPhone) {
this.custPhone=custPhone;
}
public String getCustSource() {
return custSource;
}
public void setCustSource(String custSource) {
this.custSource=custSource;
}
@Override
public String toString() {
return "Customer{" +
"custId=" + custId +
", custAddress='" + custAddress + '\'' +
", custIndustry='" + custIndustry + '\'' +
", custLevel='" + custLevel + '\'' +
", custName='" + custName + '\'' +
", custPhone='" + custPhone + '\'' +
", custSource='" + custSource + '\'' +
'}';
}
}test/CustomerDaoTest.java
package cn.itcast.test;
import cn.itcast.dao.CustomerDao;
import cn.itcast.domain.Customer;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
/**
* CustomerDaoTest
* hasee
* 2018/12/17
* 10:41
*
* @Version 1.0
**/
@RunWith(SpringJUnit4ClassRunner.class) //声明spring提供的单元测试环境
@ContextConfiguration(locations = "classpath:applicationContext.xml") //指定spring容器的配置信息
public class CustomerDaoTest {
//从容器中获取一个dao对象操作
@Autowired
private CustomerDao customerDao;
/*
*
* 根据id查询
* */
@Test
public void TestFindOne(){
Customer one=customerDao.findOne((long)2);
System.out.println(one);
}
/*
*
* save：保存或者更新
* 1. 根据传递的对象是否存在主键id，
* * 如果没有id主键属性： 保存
* * 存在id主键属性，根据id查询数据，更新数据
* 2. 传入的id值为long类型，所以有两种给值方法：
* * (long)值
* * 值l
* 3. 它的原理是先对数据库该条数据的主键id值进行判断，如果已有id值则为update，删除之前的所有内容，如果没有id则为save；
* */
/*
* 保存
* */
@Test
public void TestSave(){
//创建一个实体类
Customer customer=new Customer();
//为实体类赋值
customer.setCustName("张碧晨");
customer.setCustId((long)5);
//调用customerDao进行保存操作
customerDao.save(customer);
//调用customerDao查询是否已经保存成功
Customer one=customerDao.findOne(5l);
System.out.println(one);
}
/*
* 更新
* */
@Test
public void testUpdate(){
//创建实体类并给值
Customer customer=new Customer();
customer.setCustId(5l);
customer.setCustLevel("最高等级");
//调用save操作，判断数据库该id是否存在，存在则进行修改，删除原该id值行的所有内容
customerDao.save(customer);
//调用查询方法检查数据是否已修改
Customer one=customerDao.findOne(5l);
System.out.println(one);
}
/*
*
* 删除
*
* 注意：
* 1. 删除的原理，它先进行查询该id所对应的是否有数据
* * 如果有则进行删除操作
* * 如果没有所对应的id值则抛出异常，删除失败；
* 2. 删除成功后再查询会返回null，则可以进行判断；
* */
@Test
public void testDelete(){
//执行删除操作
customerDao.delete(4l);
//执行查询操作
Customer one=customerDao.findOne(5l);
if (one==null){
System.out.println("您已成功删除");
}
}
/*
*
* 查询所有
* */
@Test
public void testFindAll(){
List<Customer> list=customerDao.findAll();
for (Customer customer : list) {
System.out.println(customer);
}
}
/*
*
* count： 统计
* */
@Test
public void testCount(){
long count=customerDao.count();
System.out.println(count);
}
/*
* 测试：判断id为4的客户是否存在
* 1. 可以查询以下id为4的客户
* * 如果值为空，代表不存在
* * 如果不为空，代表存在
*
* 2. 判断数据库中id为4的客户的数量
* * 如果数量为0，代表不存在
* * 如果数量大于0，代表存在
*
* 3. 我们SpringData JPA使用的是判断数量；
* */
@Test
public void testExists(){
boolean exists=customerDao.exists(10l);
if ((exists+"").equals("true")){
System.out.println("存在");
}else {
System.out.println("不存在");
}
}
/*
* 根据id从数据库中查询 :需要添加注解@Transactional(保证程序正常运行)，否则会报错；
* 1. findOne：
* em.find(); 立即加载
* 2. getOne：
* em.getReference 延迟加载
* * 返回的是一个客户的动态代理对象
* * 什么时候用，什么时候查询
*
*
* */
@Test
@Transactional
public void testGetOne(){
Customer one=customerDao.getOne(2l);
System.out.println(one);
}
}test/JpqlTest.java
package cn.itcast.test;
import cn.itcast.dao.CustomerDao;
import cn.itcast.domain.Customer;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;
/**
* JpqlTest
* hasee
* 2018/12/17
* 14:41
*
* @Version 1.0
**/
@RunWith(SpringJUnit4ClassRunner.class) //声明spring提供的单元测试环境
@ContextConfiguration(locations = "classpath:applicationContext.xml") //指定spring容器的配置信息
public class JpqlTest {
@Autowired
private CustomerDao customerDao;
/*
*
* 根据名称查询
* */
@Test
public void testFindJPQL(){
Customer customer=customerDao.findjpql("暗余大神");
System.out.println(customer);
}
/*
*
* 根据名称和id值进行查询
*
* 1. 对于多个占位符参数
* * 赋值的时候，默认的情况下，占位符的位置需要和方法参数中的位置保持一致
* * 举例：
* 1. test：
* Customer customer=customerDao.findCustNameAndId("暗余大神",2l);
System.out.println(customer);
2. interface：
@Query(value = "from Customer where custName = ? and custId = ? ")
public Customer findCustNameAndId(String name,Long id);
* 2. 可以指定占位符参数的位置
* * ？索引的方式，指定此占位的取值来源
* * 举例：
* 1. test：
* Customer customer=customerDao.findCustNameAndId(2l,"暗余大神");
System.out.println(customer);
* 2. interface：
@Query(value = "from Customer where custName = ?2 and custId = ?1 ")
public Customer findCustNameAndId(Long id,String name);
*
* */
@Test
public void testFindCustNameAndId(){
Customer customer=customerDao.findCustNameAndId("暗余大神",2l);
System.out.println(customer);
}
/*
* 更新
* springDataJpa中使用jpql完成 更新/删除操作
* * 需要手动添加事务的支持
* * 默认会执行结束后，回滚事务
* * 这里的更新操作不会先清除原有的内容，而是覆盖指定的内容，之前存在的没被修改的依然存在；
* @Rollback: 设置是否自动回滚
* false/ true
* */
@Test
@Transactional //添加事务的支持
@Rollback(false)
public void testUpdateCustomer(){
customerDao.updateCustomer(4l,"程序员");
}
}test/sqlTest.java
package cn.itcast.test;
import cn.itcast.dao.CustomerDao;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.List;
/**
* SqlTest
* hasee
* 2018/12/17
* 15:46
*
* @Version 1.0
**/
@RunWith(SpringJUnit4ClassRunner.class) //声明spring提供的单元测试环境
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class SqlTest {
@Autowired
private CustomerDao customerDao;
/*
*
* 使用sql查询全部数据
*
* */
@Test
public void testFindSql(){
List<Object[]> sql=customerDao.findSql();
for (Object[] obj : sql) {
System.out.println(Arrays.toString(obj));
}
}
/*
*
* 模糊查询
* */
@Test
public void testFindNameBySql(){
List<Object[]> list=customerDao.findNameBySql("暗%");
for (Object[] objects : list) {
System.out.println(Arrays.toString(objects));
}
}
}test/methodTest.java
package cn.itcast.test;
import cn.itcast.dao.CustomerDao;
import cn.itcast.domain.Customer;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import java.util.List;
/**
* methodTest
* hasee
* 2018/12/17
* 16:09
*
* @Version 1.0
**/
/*
*
* 方法命名规则查询
* */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class methodTest {
@Autowired
private CustomerDao customerDao;
/*
*
* 它的接口方法名为：findBy+属性名（首字母大写）
* 使用此种方式查询可以不用在接口写@Query等...
* */
@Test
public void testFindCustName(){
Customer customer=customerDao.findByCustName("暗余大神");
System.out.println(customer);
}
/*
*
* 模糊查询
* */
@Test
public void testFindCustNameLike(){
List<Customer> list=customerDao.findByCustNameLike("暗余%");
for (Customer customer : list) {
System.out.println(customer);
}
}
/*
*
* 模糊查询+精准查询
* */
@Test
public void testfindByCustNameLikeAndCustIndustry(){
Customer customer=customerDao.findByCustNameLikeAndCustIndustry("暗余%", "荣耀王者100星");
System.out.println(customer);
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
