1. 对于一般应用中各类简单的增删查改，spring data提供了根据名字直接查询的代理方法，啥都不需要做，唯一需要编写接口，命名方法，这部分实在是太方便了，而且简单查询解决了差不多80%的问题。这部分相对简单，不再赘述，参考用法大全部分。

2. 对于复杂但又相对固定的查询，可以使用JPQL和Native Sql，即@Query直接写JPQL语句的方式。这部分也不难，简单给个例子，需要注意的是返回结果如果是多个值并且返回多组，那应该以Object[][]表示

@Query(value = "SELECT su.id, su.name_CN, avg(s.rate), count(b.id), count(concat(b.key, '@', s.admin)) "

+ "FROM " + CommonConstants.SCHEMA_PREFIX + "Submarket su, " + CommonConstants.SCHEMA_PREFIX + "Building b, " + CommonConstants.SCHEMA_PREFIX + "Space s, " + CommonConstants.SCHEMA_PREFIX + "Market m, " + CommonConstants.SCHEMA_PREFIX + "City c "

+ "where b.submarket_id = su.id and s.building_id = b.id and su.market_id = m.id and m.city_id = c.id and c.country_id = ?1 group by su.id", nativeQuery=true)

Object[][] findAreaInfoByCountryId(int parentId);

3. 对于复杂且动态的查询，使用Criteria。对于criteria的用法，那就有相当多的内容了。需要使用到criteria的场景通常是界面上有各种过滤和条件选项。

Criteria由于需要使用类的方式将整个复杂sql语句组织起来，因此有不少类，我们先来理解下这些类的含义。

3.1大多数情况下，搜索返回的结果是一个数据库中的实体对象，对于这种情况，实际上可以直接使用spring data jpa提供的toPredicate方法，该方法定义如下

public interface Specification<T> {

Predicate toPredicate(Root<T> root, CriteriaQuery<?> query, CriteriaBuilder cb);

}

实际使用时只需要把预定义好的Repository对象继承JpaSpecificationExecutor对象即可

@Repository

public interface CityDao extends JpaSpecificationExecutor<City>{

｝

真正调用时只需要传递如下回调方法，spring会自动帮你完成分页

Page<City> page = cityDao.findAll(new Specification<City>() {

@Override

public Predicate toPredicate(Root<City> root, CriteriaQuery<?> query, CriteriaBuilder cb) {

root = query.from(City.class);

Path<String> nameExp = root.get("name");

return cb.like(nameExp, "%北京%");

}

}, new PageRequest(1, 5, new Sort(Direction.DESC, new String[] { "id" })));

对于这种情况，虽然动态查询比较复杂，但是要庆幸是其中相当简单的类型了。

3.2 我们来看boss升级难度以后的情况。假如此时你的查询中不是一个简单实体类型，而是一个复杂的聚合对象，有一堆聚合查询，有一堆a对象的属性，一堆b对象的属性。可能你还试图用toPredicate方法继续，但实际上Page只允许你传递已定义好的数据库中的实体对象，因为其root中定义的泛型实际上限制了后续的行为，比如想在root上join，如果root不是一个数据库实体则编译就报错了。另外由此引发的query.multiselect自定义查询结果无效，因为结果默认就是你定义好的那个实体。这时候的解决办法就是自定义dao实现类。首先，定义一个自定义实现接口

@NoRepositoryBean

public interface SearchJpaRepositoryCustom {

public Page<Tuple> searchListing(final ListingSearchContext searchContext, Pageable pageable);

}

其次，dao接口得继承该自定义接口

public interface BuildingRepository extends PagingAndSortingRepository<Building, Integer>, SearchJpaRepositoryCustom

然后，真正的dao模型实现类如下，需要注意，自定义的实现类必须实现自定义接口，并且，名字是BuildingRepository+impl，注意这里踩过坑

public class BuildingRepositoryImpl extends PagableRepository implements SearchJpaRepositoryCustom {

@PersistenceContext

private EntityManager em;

private Join<Space, ?> getSearchExpression(final CriteriaBuilder cb, final ListingSearchContext searchContext,

final Root<Space> root, final Predicate predicate) {

List<Expression<Boolean>> expressions = predicate.getExpressions();

// 只搜索版本为0的(即当前版本)

expressions.add(cb.equal(root.<String> get("ver"), 0));

if (searchContext.getSpaceId() > 0) {

expressions.add(cb.equal(root.<Integer> get("id"), searchContext.getSpaceId())); // id

}

if (null != searchContext.getMinRate()) {

expressions.add(cb.greaterThanOrEqualTo(root.<BigDecimal> get("rate"), searchContext.getMinRate())); // 价格

}

if (null != searchContext.getMaxRate()) {

expressions.add(cb.lessThanOrEqualTo(root.<BigDecimal> get("rate"), searchContext.getMaxRate())); // 价格

}

if (null != searchContext.getLCD()) {

expressions.add(cb.lessThanOrEqualTo(root.<Date> get("dateAvailable"), searchContext.getLCD())); // 可用日期

}

// spaceTypeId

if (searchContext.getSpaceTypeId() > 0) {

expressions.add(cb.equal(root.<String> get("spaceType").get("id"), searchContext.getSpaceTypeId()));

}

// buildingGrade&submarket

Join<Space, ?> buildingJoin = root.join(root.getModel().getSingularAttribute("building"), JoinType.INNER);

if (searchContext.getBuildingGradeId() > 0) {

expressions.add(cb.equal(buildingJoin.get("buildingGrade").get("id"), searchContext.getBuildingGradeId()));

}

if (searchContext.getSubmarketId() > 0) {

expressions.add(cb.equal(buildingJoin.get("submarket").get("id"), searchContext.getSubmarketId()));

}

if (StringUtils.isNotEmpty(searchContext.getKeyword())) {

Predicate like1 = cb.like(buildingJoin.<String> get("buildingNameCn"),

"%" + searchContext.getKeyword() + "%");

Predicate like2 = cb.like(buildingJoin.<String> get("addressCn"), "%" + searchContext.getKeyword() + "%");

expressions.add(cb.or(like1, like2)); // 关键字

}

return buildingJoin;

}

@Override

public Page<Tuple> searchListing(final ListingSearchContext searchContext, Pageable pageable) {

final CriteriaBuilder cb = em.getCriteriaBuilder();

final CriteriaQuery<Tuple> query = cb.createTupleQuery();

final Root<Space> root = query.from(Space.class);

Predicate predicate = cb.conjunction();

Join<Space, ?> buildingJoin = getSearchExpression(cb, searchContext, root, predicate);

Join<Space, ?> spaceTypeJoin = root.join(root.getModel().getSingularAttribute("spaceType"), JoinType.INNER);

Join<Space, ?> contiguousJoin = root.join(root.getModel().getSingularAttribute("contiguous"), JoinType.INNER);

Join<Building, ?> assetJoin = buildingJoin.join("asset", JoinType.INNER);

Join<BuildingGrade, ?> buildingGradeJoin = buildingJoin.join("buildingGrade", JoinType.INNER);

SetJoin<Asset, ?> mediaJoin = assetJoin.joinSet("medias");

mediaJoin.on(cb.and(cb.equal(mediaJoin.get("type"), "photo"), cb.equal(mediaJoin.get("subtype"), "main")));

Expression<BigDecimal> maxConExp = cb.max(contiguousJoin.<BigDecimal> get("maxContiguous"));

Expression<BigDecimal> totalConExp = cb.sum(root.<BigDecimal> get("size"));

query.multiselect(cb.count(root.<Integer> get("id")), root.<Integer> get("userByAdmin").get("id"), totalConExp,

maxConExp, cb.min(root.<BigDecimal> get("minDivisible")), root.<Integer> get("building"),

cb.max(root.<Integer> get("stage")), cb.min(root.<Integer> get("lcd")),

cb.min(root.<Integer> get("led")), cb.min(root.<Integer> get("floor")),

cb.max(root.<Integer> get("floor")), mediaJoin.get("path"), spaceTypeJoin.get("nameEn"),

buildingGradeJoin.get("nameEn"));

query.where(predicate);

query.orderBy(cb.desc(root.get("gmtCreate").as(Date.class)));

query.groupBy(root.<Integer> get("building").get("id"), root.<String> get("userByAdmin").get("id"));

Predicate minExp = null;

Predicate maxExp = null;

Predicate minMaxResultExp = null;

if (null != searchContext.getMinSize()) {

minExp = cb.greaterThanOrEqualTo(cb.min(root.<BigDecimal> get("minDivisible")), searchContext.getMinSize()); // 最小面积

minMaxResultExp = minExp;

}

if (null != searchContext.getMaxSize()) {

maxExp = cb.lessThanOrEqualTo(searchContext.isContiguous() ? maxConExp : totalConExp,

searchContext.getMaxSize()); // 最大面积

minMaxResultExp = maxExp;

}

if (null != searchContext.getMinSize() && null != searchContext.getMaxSize()) {

minMaxResultExp = cb.or(minExp, maxExp);

}

if (null != minMaxResultExp) {

query.having(minMaxResultExp);

}

TypedQuery<Tuple> pagableQuery = em.createQuery(query);

return pageable == null ? new PageImpl<Tuple>(pagableQuery.getResultList())

: readPage(pagableQuery, pageable);

}

}

3.3 难度又升级了，解决了上面的问题以后，面临新的问题：分页。使用toPredicate时，spring已经实现了分页，而自定义实现类后，分页也需要自己实现。

首当其冲的问题就是count，如果在3.2中用了group by这种操作，而此处分页时候又想统计分页结果，那么实际上就是想count 分组数。常见做法是：

select count(*) from

(select ... group by ...)

但是实际上jpa不支持这种类型的子查询，本人这里试了很久各种方法，实际上都行不通。参考文末“特殊情况的count写法”

最终使用了将 criteria还原为hql，通过translator组装成native的sql，附加上参数，最终执行的方式，通过后的参考代码如下

protected Long executeCountQuery(final ListingSearchContext searchContext, TypedQuery<Tuple> query) {

String hqlString = query.unwrap(Query.class).getQueryString();

QueryTranslatorFactory translatorFactory = new ASTQueryTranslatorFactory();

Query hibernateQuery = ((HibernateQuery)query).getHibernateQuery();

QueryImpl hImpl = (QueryImpl)hibernateQuery;

Map<String, TypedValue> paramMap = (Map<String, TypedValue>)ReflectionUtils.getFieldValue(hImpl,"namedParameters");

QueryTranslator translator = translatorFactory.createQueryTranslator(hqlString, hqlString, paramMap,

(SessionFactoryImplementor) emf.unwrap(SessionFactory.class), null);

translator.compile(paramMap, false);

javax.persistence.Query nativeQuery = em

.createNativeQuery("select count(*) from (" + translator.getSQLString() + ") x");

ParameterTranslations parameterTranslations = translator.getParameterTranslations();

for(String name : paramMap.keySet()){

for (int position : parameterTranslations.getNamedParameterSqlLocations(name)) {

nativeQuery.setParameter(position + 1, paramMap.get(name).getValue());

}

}

Long cnt = ((Number) nativeQuery.getSingleResult()).longValue();

return cnt;

}

通过利用已有的分页类，实现自定义的分页

protected Page<Tuple> readPage(final ListingSearchContext searchContext, TypedQuery<Tuple> query, Pageable pageable) {

query.setFirstResult(pageable.getOffset());

query.setMaxResults(pageable.getPageSize());

Long total = executeCountQuery(searchContext, query);

List<Tuple> content = total > pageable.getOffset() ? query.getResultList() : Collections.<Tuple> emptyList();

return new PageImpl<Tuple>(content, pageable, total);

}

4. 复杂sql的简化。对于一些明显复杂的sql（比如需要经过多次嵌套子查询的sql），建议将该查询简化，简化的方式无非是修改模型，增加适应简化查询的的新方法。

Spring 框架对 JPA 的支持

Spring 框架对 JPA 提供的支持主要体现在如下几个方面：

• 首先，它使得 JPA 配置变得更加灵活。JPA 规范要求，配置文件必须命名为 persistence.xml，并存在于类路径下的 META-INF 目录中。该文件通常包含了初始化 JPA 引擎所需的全部信息。Spring 提供的 LocalContainerEntityManagerFactoryBean 提供了非常灵活的配置，persistence.xml 中的信息都可以在此以属性注入的方式提供。
• 其次，Spring 实现了部分在 EJB 容器环境下才具有的功能，比如对 @PersistenceContext、@PersistenceUnit 的容器注入支持。
• 第三，也是最具意义的，Spring 将 EntityManager 的创建与销毁、事务管理等代码抽取出来，并由其统一管理，开发者不需要关心这些，业务方法中只剩下操作领域对象的代码，事务管理和 EntityManager 创建、销毁的代码都不再需要开发者关心了。

Spring Data JPA 更简洁

Spring Data JPA 框架，主要针对的就是 Spring 唯一没有简化到的业务逻辑代码，至此，开发者连仅剩的实现持久层业务逻辑的工作都省了，唯一要做的，就只是声明持久层的接口，其他都交给 Spring Data JPA 来帮你完成！

下面就来了解Spring Data JPA。

1.下载需要的包。

需要先 下载Spring Data JPA 的发布包（需要同时下载 Spring Data Commons 和 Spring Data JPA 两个发布包，Commons 是 Spring Data 的公共基础包），并把相关的依赖 JAR 文件加入到 CLASSPATH 中。

2.让持久层接口 Dao（以UserDao） 继承 Repository 接口。

该接口使用了泛型，需要为其提供两个类型：第一个为该接口处理的域对象类型，第二个为该域对象的主键类型。

总结

以 上就是我对Java开发深入了解spring data jpa 问题及其优化总结，分享给大家，觉得收获的话可以点个关注收藏转发一波喔，谢谢大佬们支持！

最后，每一位读到这里的网友，感谢你们能耐心地看完。希望在成为一名更优秀的Java程序员的道路上，我们可以一起学习、一起进步！都能赢取白富美，走向架构师的人生巅峰!

进阶地址:https://ke.qq.com/course/230866?flowToken=1000327

想了解学习Java方面的技术内容以及Java技术视频的内容可加群：722040762 验证码：头条（06 必过）欢迎大家的加入哟！