系列文章
spring-data-jpa 入门
spring-data-jpa 入门二:常用技术使用之关联关系查询配置
前面基本上将spirng-data-jpa常用查询写清楚了,一般如果不是复杂的查询基本上都能满足了,而且我们并没有做太多的事情,花费时间大多是在entity层实体的配置。现在我们将介绍下在复杂情况下的查询方法的使用:
前面说过dao层spring-data-jpa会默认解析以findBy开头方法命自动组装成sql,虽然这种方式使用快捷便利,但是难免会出现一些复杂跨多张表的情况,而且多表之间没有关联的情况,为此我们可以直接使用sql查询。
在spring-data-jpa中 用@Query表示dao层方法自己实现。
/**
* 用户信息dao
* Created by hsh on 18/08/30.
*/
public interface UserInfoRepository extends
JpaRepository,
JpaSpecificationExecutor {
@Query("select u from UserInfo u where u.id=?1 ")
UserInfo findById(Integer id);
/**
* 原生分页 查询条件不能为空
*/
Page findByUNameContainingAndUNumberEqualsAndIdEquals
(String uName, String uNumber, Integer id, Pageable pageable);
}
这是我们原先的dao层,在此基础之上我们用上@Query注解,至于括号里面的则是JPQL 语句,属性hql应该对JPQL
不默认,这里就不延伸了,后文会介绍下JPQL。
至于 where u.id=?1
?1 则表示的是第一个参数,这里面则是Integer id,如果有多个参数话,依次类推?2、?3等,而且使用的时候没有顺序的,例如:
@Query("select u from UserInfo u where u.password=?2 and u.UName=?1 ")
UserInfo findByUserNameAndAndPassword(String userName,String password);
当然@Query是支持原生sql的,例如:
@Query(value = "select * from user_info where id=:id",nativeQuery = true)
UserInfo findById(Integer id);
nativeQuery 意思是本地化查询,也就是原生sql查询。
顺道补充下,在@Query中,参数占位符的使用方式:
1. 如上面我们给的例子,使用 ?1 这种形式。
2. 使用 :参数名称 的形式,例如第二个例子
3. 使用 @Param注解的形式,例如:
@Query(value = "select * from user_info where id=:id1",nativeQuery = true)
UserInfo findById(@Param("id1")Integer id);
其实总结下来只是一种机制:如果有注解,则用注解,没有注解默认为参数名称,使用时候可以直接名称或者用坐标表示。mybatis其实也是种形式。
接下来是重点了,mybatis非常流行,有一定原因是因为它的丰富的动态标签。当然spirng-data-jpa也是支持动态查询的,一共两种方式:
1. 通过JPA的Criteria(标准) API实现
2. dao层接口继承JpaSpecificationExecutor
只是简单的说下怎么使用Criteria API 查询:
举个列子:
public class UserInfoDaoImpl {
@PersistenceContext(unitName = "entityManagerFactory")
EntityManager em;
public List getUserInfo(UserInfo userInfo) {
CriteriaBuilder builder = em.getCriteriaBuilder();
CriteriaQuery< UserInfo> query = builder.createQuery(UserInfo.class);
Root< UserInfo> root = query.from(UserInfo.class);
Predicate p1 = builder.like(root.< String> get("uName"), "%" + userInfo.getName() + "%");
Predicate p2 = builder.equal(root.< String> get("password"), userInfo.getPassword());
query.where(p1, p2);
List userInfos = em.createQuery(query).getResultList();
return userInfos;
}
}
解释下:
1. 这是个 dao层实现类,在前面配置的时候,我们制定了实现类是以Impl结尾,默认且必须与dao接口在同一个文件夹。
2. @PersistenceContext 表示的是 持久化单元上下文
3. unitName与LocalContainerEntityManagerFactoryBean类的容器对象的名称一致
4. builder.like 与builder.equal 就相当于构建了两个where 条件 name like = ? and password = ?
的形式
5. query.where(p1,p2) 就相当于拼接sql 将 select * from user_info
与 where name like = ? and password = ?
拼装在一起
6. getSingleResult或者getResultList返回结果,这里jpa的单个查询如果为空的话会报异常
代码虽然简单明了,且步骤清晰,总结就是四步 :创建builder => 创建Query => 构造条件 => 查询,但是其实除了第三步,其他对我们来说完全是一模一样的模板,所以 spring-data-jpa 给我做了这些事情。
dao层接口继承JpaSpecificationExecutor
我们先将上面的代码用第二种方式写出了,在具体分析:
@Service
public class UserInfoServiceImpl implements UserInfoService {
@Resource
private UserInfoRepository userInfoRepository;
@Override
public List getUserInfoList(final UserInfo userInfo) {
return userInfoRepository.findAll(new Specification() {
public Predicate toPredicate(Root root, CriteriaQuery criteriaQuery, CriteriaBuilder criteriaBuilder) {
List predicates = new ArrayList();
if (userInfo != null && userInfo.getUName() != null)
predicates.add(criteriaBuilder.like(root.get("uName"), "%" + userInfo.getUName() + "%"));
if (userInfo != null && userInfo.getPassword() != null)
predicates.add(criteriaBuilder.equal(root.get("password"), userInfo.getPassword()));
if (predicates.size() > 0)
return criteriaQuery.where(predicates.toArray(new Predicate[predicates.size()])).getRestriction();
return null;
}
});
}
}
首先我们调用了userInfoRepository.findAll(new Specification< UserInfo>() {});方法,来自于JpaSpecificationExecutor< T> 接口,他是这么定义的:
public interface JpaSpecificationExecutor<T> {
T findOne(Specification<T> var1);
List<T> findAll(Specification<T> var1);
Page<T> findAll(Specification<T> var1, Pageable var2);
List<T> findAll(Specification<T> var1, Sort var2);
long count(Specification<T> var1);
}
而 Specification 是个接口,内部是这么定义的
public interface Specification {
Predicate toPredicate(Root var1, CriteriaQuery var2, CriteriaBuilder var3);
}
到此我们知道原来Specification这个接口其实就是返回一个Predicate 对象,前面说了Predicate 其实就是在组装where条件语句。那么 JpaSpecificationExecutor 接口下面的定义的方法,其实就是采用策略模式,接口参数为Specification,前面也说了框架内部会自动实现,而且这个实现就是SimpleJpaRepository ,我们所有的Dao层接口默认实现类都是他
public class SimpleJpaRepository<T, ID extends Serializable>
implements JpaRepository<T, ID>, JpaSpecificationExecutor< T> {
我们看下SimpleJpaRepository中 List< T> findAll(Specification< T> var1)的实现:
public List findAll(Specification spec) {
return this.getQuery(spec, (Sort)null).getResultList();
}
这里自己调用getQuery 方法,而getQuery是这样的:
protected TypedQuery getQuery(Specification spec, Sort sort) {
return this.getQuery(spec, this.getDomainClass(), sort);
}
其中getDomainClass() 返回类型是Class< T> 也就是说返回的是一个类型,
那么getQuery(spec, this.getDomainClass(), sort) 的代码如下:
protected TypedQuery getQuery(Specification spec, Class domainClass, Sort sort) {
CriteriaBuilder builder = this.em.getCriteriaBuilder();
CriteriaQuery query = builder.createQuery(domainClass);
Root root = this.applySpecificationToCriteria(spec, domainClass, query);
query.select(root);
if(sort != null) {
query.orderBy(QueryUtils.toOrders(sort, root, builder));
}
return this.applyRepositoryMethodMetadata(this.em.createQuery(query));
}
到这一觉都恍然大悟,原来它做的事情还是一开始我们写的Criteria API的写法啊,问题就在这句话里面了
Root root = this.applySpecificationToCriteria(spec, domainClass, query);
applySpecificationToCriteria方法实现:
private Root applySpecificationToCriteria
(Specification spec, Class domainClass, CriteriaQuery query) {
Assert.notNull(domainClass, "Domain class must not be null!");
Assert.notNull(query, "CriteriaQuery must not be null!");
Root root = query.from(domainClass);
if(spec == null) {
return root;
} else {
CriteriaBuilder builder = this.em.getCriteriaBuilder();
Predicate predicate = spec.toPredicate(root, query, builder);
if(predicate != null) {
query.where(predicate);
}
return root;
}
}
看到Predicate predicate = spec.toPredicate(root, query, builder);
这句话没有,不就是在调用我们在接口里面写的匿名内部类的实现嘛。
所以一开始就说了 继承JpaSpecificationExecutor接口与Criteria API 写法是一致的,就是封装了一下,就和我们平时写JDBC时候,都会封装一个工具类差不多,只不过这是人家Spring封装的。
上面我们大致了解到Spring-data-jpa 两种动态查询的写法,并且着重的分析了下 继承JpaSpecificationExecutor接口的实现以及原理。下面就要来点复杂的东西了,来看看 如果多表多条件查询改怎么做。
前面我们做过关联关系查询配置,并且配置了一对一,一对多,多对多的配置。通过配置我们能查到关联实体的信息,现在我们用 findAll(Specification
来实验下:
public Page findUserInfo(final UserInfoVo userInfo, PageRequest request) throws Exception {
return userInfoRepository.findAll(new Specification() {
public Predicate toPredicate(Root root, CriteriaQuery query, CriteriaBuilder cb) {
List predicates = new ArrayList();
if (userInfo != null && userInfo.getIds() != null) {
predicates.add(cb.equal(root.get("id"), userInfo.getId()));
}
if (userInfo != null && userInfo.getUName() != null)
predicates.add(cb.like(root.get("uName"), "%" + userInfo.getUName() + "%"));
if (userInfo != null && userInfo.getUNumber() != null)
predicates.add(cb.equal(root.get("uNumber"), userInfo.getUNumber()));
if (userInfo != null && userInfo.getAddress() != null)
//查询用户详情信息
predicates.add(cb.like(
root.get("userDetails").get("address"),
"%" + userInfo.getAddress() + "%"));
if (predicates.size() > 0)
return query.where(
predicates.toArray(new Predicate[predicates.size()])
).getRestriction();
return null;
}
}, request);
}
PageRequest 前面也说过它是一个分页对象,例如下面就是一个 请求第一页,每页数量为10,并且以Id 降序的分页条件
new PageRequest(0,10, new Sort(Sort.Direction.DESC, new String[]{"id"}))
其实能明白 上面的例子之后,Spring-data-jpa 可以说已经揭开神秘的面纱了,后面的无非是补充一些常用的知识点而已,哈哈,还是通过上面的例子我补充下In和join的用法感觉这两个还是比较常用:
public Predicate toPredicate(Root root, CriteriaQuery query, CriteriaBuilder cb) {
List predicates = new ArrayList();
if (userInfo != null && userInfo.getIds() != null) {
String[] ids = userInfo.getIds().split(",");
//①
CriteriaBuilder.In in = cb.in(root.get("id"));
for (String id : ids) {
in.value(Integer.valueOf(id));
}
predicates.add(in);
}
if (userInfo != null && userInfo.getUName() != null)
predicates.add(cb.like(root.get("uName"), "%" + userInfo.getUName() + "%"));
if (userInfo != null && userInfo.getUNumber() != null)
predicates.add(cb.equal(root.get("uNumber"), userInfo.getUNumber()));
if (userInfo != null && userInfo.getAddress() != null)
Join userDetails = root.join("userDetails", JoinType.LEFT);
//②
predicates.add(cb.like(userDetails.get("address"), "%" + userInfo.getAddress() + "%"));
//③
// predicates.add(cb.like(
// root.get("userDetails").get("address"),
// "%" + userInfo.getAddress() + "%"));
if (predicates.size() > 0)
return query.where(predicates.toArray(new Predicate[predicates.size()])).getRestriction();
return null;
}
public interface In<T> extends Predicate {
Expression getExpression();
CriteriaBuilder.In value(T var1);
CriteriaBuilder.In value(Expression extends T> var1);
}
其实还是个Predicate ,所以在value()完所以Id之后直接predicates.add(in)
了;
到这基本上将动态查询说清楚了,Spring-data-jpa对于我们来说应该不是那么陌生了,后面的话还将继续探讨一些问题: