Ⅳ 复杂查询（JPQL）
1.1 使用Spring Data JPA中接口定义的方法进行查询
继承JpaRepository后的方法列表
继承JpaSpecificationExecutor的方法列表
1.2 使用JPQL的方式查询
使用Spring Data JPA提供的查询方法已经可以解决大部分的应用场景，但是对于某些业务来说，我们还需要灵活的构造查询条件，这时就可以使用 @Query 注解，结合JPQL的语句方式完成查询
@Query 注解的使用非常简单，只需在方法上面标注该注解，同时提供一个JPQL查询语句即可
package cn.ys.jpa.dao;
import cn.ys.jpa.domain.Customer;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
/**
* 符合SpringDataJpa的dao层接口规范
* JpaRepository<操作的实体类类型，实体类中主键属性的类型>
* * 封装了基本CRUD操作
* JpaSpecificationExecutor<操作的实体类类型>
* * 封装了复杂查询（分页）
*/
public interface CustomerDao extends JpaRepository<Customer, Long>, JpaSpecificationExecutor<Customer> {
/**
* 案例：根据客户名称查询客户
* 使用jpql的形式查询
* jpql：from Customer where custName = ?1
*
* 配置jpql语句，使用的@Query注解
*/
//@Query 使用jpql的方式查询。?1代表参数的占位符，其中1对应方法中的参数索引
@Query(value = "from Customer where custName = ?1")
public List<Customer> findJpql(String custName);
/**
* 案例：根据客户名称和客户id查询客户
* jpql： from Customer where custName = ? and custId = ?
*
* 对于多个占位符参数
* 赋值的时候，默认的情况下，占位符的位置需要和方法参数中的位置保持一致
*
* 可以指定占位符参数的位置
* ? 索引的方式，指定此占位的取值来源
*/
@Query(value = "from Customer where custName = ?2 and custId = ?1")
public Customer findCustNameAndId(Long id, String name);
/**
* 使用jpql完成更新操作
* 案例 ： 根据id更新，客户的名称
* 更新4号客户的名称，将名称改为“黑马程序员”
*
* sql ：update cst_customer set cust_name = ? 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);
}
此外，也可以通过使用 @Query 来执行一个更新操作，为此，我们需要在使用 @Query 的同时，用 @Modifying 来将该操作标识为修改查询，这样框架最终会生成一个更新的操作，而非查询
测试
package cn.ys.jpa;
import cn.ys.jpa.dao.CustomerDao;
import cn.ys.jpa.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;
import java.util.List;
@RunWith(SpringJUnit4ClassRunner.class) //声明spring提供的单元测试环境
@ContextConfiguration(locations = "classpath:applicationContext.xml")//指定spring容器的配置信息
public class JpqlTest {
@Autowired
private CustomerDao customerDao;
@Test
public void testFindJPQL() {
List<Customer> customers = customerDao.findJpql("友邦");
System.out.println(customers);
}
@Test
public void testFindCustNameAndId() {
Customer customer = customerDao.findCustNameAndId(1l,"友邦");
System.out.println(customer);
}
/**
* 测试jpql的更新操作
* * springDataJpa中使用jpql完成 更新/删除操作
* * 需要手动添加事务的支持
* * 默认会执行结束之后，回滚事务
* @Rollback : 设置是否自动回滚
* false | true
*/
@Test
@Transactional //添加事务的支持
@Rollback(value = false)
public void testUpdateCustomer() {
customerDao.updateCustomer(4l,"友邦");
}
}
1.3 使用SQL语句查询
Spring Data JPA同样也支持sql语句的查询，如下：
package cn.ys.jpa.dao;
import cn.ys.jpa.domain.Customer;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Query;
import java.util.List;
/**
* 符合SpringDataJpa的dao层接口规范
* JpaRepository<操作的实体类类型，实体类中主键属性的类型>
* * 封装了基本CRUD操作
* JpaSpecificationExecutor<操作的实体类类型>
* * 封装了复杂查询（分页）
*/
public interface CustomerDao extends JpaRepository<Customer, Long>, JpaSpecificationExecutor<Customer> {
/**
* 使用sql的形式查询：
* 查询全部的客户
* sql ： select * from cst_customer;
* Query : 配置sql查询
* value ： sql语句
* nativeQuery ： 查询方式
* true ： sql查询
* false：jpql查询
*
*/
//@Query(value = " select * from cst_customer" ,nativeQuery = true)
@Query(value="select * from cst_customer where cust_name like ?1", nativeQuery = true)
public List<Object [] > findSql(String name);
}
测试
package cn.ys.jpa;
import cn.ys.jpa.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.util.Arrays;
import java.util.List;
@RunWith(SpringJUnit4ClassRunner.class) //声明spring提供的单元测试环境
@ContextConfiguration(locations = "classpath:applicationContext.xml")//指定spring容器的配置信息
public class JpqlTest {
@Autowired
private CustomerDao customerDao;
//测试sql查询
@Test
public void testFindSql() {
List<Object[]> list = customerDao.findSql("友%");
for(Object [] obj : list) {
System.out.println(Arrays.toString(obj));
}
}
}
1.4 方法命名规则查询
顾名思义，方法命名规则查询就是根据方法的名字，就能创建查询。只需要按照Spring Data JPA提供的方法命名规则定义方法的名称，就可以完成查询工作。Spring Data JPA在程序执行的时候会根据方法名称进行解析，并自动生成查询语句进行查询。
按照Spring Data JPA 定义的规则，查询方法以findBy开头，涉及条件查询时，条件的属性用条件关键字连接，要注意的是：条件属性首字母需大写。框架在进行方法名解析时，会先把方法名多余的前缀截取掉，然后对剩下部分进行解析。
package cn.ys.jpa.dao;
import cn.ys.jpa.domain.Customer;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import java.util.List;
/**
* 符合SpringDataJpa的dao层接口规范
* JpaRepository<操作的实体类类型，实体类中主键属性的类型>
* * 封装了基本CRUD操作
* JpaSpecificationExecutor<操作的实体类类型>
* * 封装了复杂查询（分页）
*/
public interface CustomerDao extends JpaRepository<Customer, Long>, JpaSpecificationExecutor<Customer> {
/**
* 方法名的约定：
* findBy : 查询
* 对象中的属性名（首字母大写） ： 查询的条件
* CustName
* * 默认情况 ： 使用 等于的方式查询
* 特殊的查询方式
*
* findByCustName -- 根据客户名称查询
*
* 再springdataJpa的运行阶段
* 会根据方法名称进行解析 findBy from xxx(实体类)
* 属性名称 where custName =
*
* 1.findBy + 属性名称 （根据属性名称进行完成匹配的查询=）
* 2.findBy + 属性名称 + “查询方式（Like | isnull）”
* findByCustNameLike
* 3.多条件查询
* findBy + 属性名 + “查询方式” + “多条件的连接符（and|or）” + 属性名 + “查询方式”
*/
public List<Customer> findByCustName(String custName);
public List<Customer> findByCustNameLike(String custName);
//使用客户名称模糊匹配和客户所属行业精准匹配的查询
public List<Customer> findByCustNameLikeAndCustIndustry(String custName,String custIndustry);
}
测试
package cn.ys.jpa;
import cn.ys.jpa.dao.CustomerDao;
import cn.ys.jpa.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;
@RunWith(SpringJUnit4ClassRunner.class) //声明spring提供的单元测试环境
@ContextConfiguration(locations = "classpath:applicationContext.xml")//指定spring容器的配置信息
public class JpqlTest {
@Autowired
private CustomerDao customerDao;
//测试方法命名规则的查询
@Test
public void testNaming() {
List<Customer> customers = customerDao.findByCustName("友邦");
System.out.println(customers);
}
//测试方法命名规则的查询
@Test
public void testFindByCustNameLike() {
List<Customer> list = customerDao.findByCustNameLike("友%");
for (Customer customer : list) {
System.out.println(customer);
}
}
//测试方法命名规则的查询
@Test
public void testFindByCustNameLikeAndCustIndustry() {
List<Customer> customers = customerDao.findByCustNameLikeAndCustIndustry("友%", "保险");
System.out.println(customers);
}
}
具体的关键字，使用方法和生产成SQL如下表所示
| Keyword | Sample | JPQL |
|---|---|---|
And |
findByLastnameAndFirstname | … where x.lastname = ?1 and x.firstname = ?2 |
Or |
findByLastnameOrFirstname | … where x.lastname = ?1 or x.firstname = ?2 |
Is,Equals |
findByFirstnameIs,findByFirstnameEquals | … where x.firstname = ?1 |
Between |
findByStartDateBetween | … where x.startDate between ?1 and ?2 |
LessThan |
findByAgeLessThan | … where x.age < ?1 |
LessThanEqual |
findByAgeLessThanEqual | … where x.age ⇐ ?1 |
GreaterThan |
findByAgeGreaterThan | … where x.age > ?1 |
GreaterThanEqual |
findByAgeGreaterThanEqual | … where x.age >= ?1 |
After |
findByStartDateAfter | … where x.startDate > ?1 |
Before |
findByStartDateBefore | … where x.startDate < ?1 |
IsNull |
findByAgeIsNull | … where x.age is null |
IsNotNull,NotNull |
findByAge(Is)NotNull | … where x.age not null |
Like |
findByFirstnameLike | … where x.firstname like ?1 |
NotLike |
findByFirstnameNotLike | … where x.firstname not like ?1 |
StartingWith |
findByFirstnameStartingWith | … where x.firstname like ?1 (parameter bound with appended %) |
EndingWith |
findByFirstnameEndingWith | … where x.firstname like ?1 (parameter bound with prepended %) |
Containing |
findByFirstnameContaining | … where x.firstname like ?1 (parameter bound wrapped in %) |
OrderBy |
findByAgeOrderByLastnameDesc | … where x.age = ?1 order by x.lastname desc |
Not |
findByLastnameNot | … where x.lastname <> ?1 |
In |
findByAgeIn(Collection ages) | … where x.age in ?1 |
NotIn |
findByAgeNotIn(Collection age) | … where x.age not in ?1 |
TRUE |
findByActiveTrue() | … where x.active = true |
FALSE |
findByActiveFalse() | … where x.active = false |
IgnoreCase |
findByFirstnameIgnoreCase | … where UPPER(x.firstame) = UPPER(?1) |