springDataJpa最佳實踐

時間  2020-01-14
標籤 springdatajpa 最佳 實踐 简体版
原文   原文鏈接

前言

Spring Data Jpa框架的目標是顯著減小實現各類持久性存儲的數據訪問層所需的樣板代碼量。Spring Data Jpa存儲庫抽象中的中央接口是Repository。它須要領域實體類以及領域實體ID類型做爲類型參數來進行管理。該接口主要用做標記接口，以捕獲要使用的類型並幫助您發現擴展該接口的接口。CrudRepository、JpaRepository是更具體的數據操做抽象，通常咱們在項目中使用的時候定義咱們的領域接口而後繼承CrudRepository或JpaRepository便可實現實現基礎的CURD方法了，可是這種用法有侷限性，不能處理超複雜的查詢，並且稍微複雜的查詢代碼寫起來也不是很優雅，因此下面看看怎麼最優雅的解決這個問題。html

擴展接口用法

/**
 * @author: kl @kailing.pub
 * @date: 2019/11/11
 */
@Repository
public interface SendLogRepository extends JpaRepository<SendLog,Integer> {

    /**
     * 派生的經過解析方法名稱的查詢
     * @param templateName
     * @return
     */
    List<SendLog> findSendLogByTemplateName(String templateName);

    /**
     * HQL
     * @param templateName
     * @return
     */
    @Query(value ="select SendLog from  SendLog s where s.templateName = :templateName")
    List<SendLog> findByTempLateName(String templateName);

    /**
     * 原生sql
     * @param templateName
     * @return
     */
    @Query(value ="select s.* from  sms_sendlog s where s.templateName = :templateName",nativeQuery = true)
    List<SendLog> findByTempLateNameNative(String templateName);
}

優勢：mysql

  • 一、這種擴展接口的方式是最多見的用法，繼承JpaRepository接口後，立馬擁有基礎的CURD功能
  • 二、還能夠經過特定的方法名作解析查詢，這個能夠算spring Data Jpa的最特殊的特性了。並且主流的IDE對這種使用方式都有比較好的自動化支持，在輸入要解析的方法名時會給出提示。
  • 三、能夠很是方便的以註解的形式支持HQL和原生SQL

缺陷：spring

  • 一、複雜的分頁查詢支持很差

缺陷就一條，這種擴展接口的方式要實現複雜的分頁查詢，有兩種方式,並且這兩種方式代碼寫起來都不怎麼優雅，並且會把大量的條件拼接邏輯寫在調用查詢的service層。sql

第一種實例查詢(Example Query)方式: 
public void testExampleQuery() {
        SendLog log = new SendLog();
        log.setTemplateName("kl");
        /*
         * 注意：withMatcher方法的propertyPath參數值填寫領域對象的字段值，而不是實際的表字段
         */
        ExampleMatcher matcher = ExampleMatcher.matching()
                .withMatcher("templateName", match -> match.contains());
        Example example = Example.of(log, matcher);

        Pageable pageable = PageRequest.of(0, 10);
        Page<SendLog> logPage = repository.findAll(example, pageable);
    }

上面代碼實現的語義是模糊查詢templateName等於"kl"的記錄並分頁，乍一看這個代碼還過得去哈，其實當查詢的條件多一點，這種代碼就會變得又臭又長，並且只支持基礎的字符串類型的字段查詢，若是查詢條件有時間篩選的話就不支持了，在複雜點多表關聯的話就更GG了，因此這種方式不合格直接上黑名單了。express

第二種繼承JpaSpecificationExecutor方式：

JPA 2引入了一個標準API，您可使用它來以編程方式構建查詢。Spring Data JPA提供了使用JPA標準API定義此類規範的API。這種方式首先須要繼承JpaSpecificationExecutor接口，下面咱們用這種方式實現和上面相同語義的查詢：編程

public void testJpaSpecificationQuery() {
        String templateName = "kk";
        Specification specification = (Specification) (root, query, criteriaBuilder) -> {
            Predicate predicate = criteriaBuilder.like(root.get("templateName"),templateName);
            query.where(predicate);
            return predicate;
        };

        Pageable pageable = PageRequest.of(0, 2);
        Page<SendLog> logPage = sendLogRepository.findAll(specification, pageable);
    }

這種方式顯然更對味口了吧，並且也支持複雜的查詢條件拼接，好比日期等。惟一的缺憾是領域對象的屬性字符串須要手寫了，並且接口只會提供findAll(@Nullable Specification<T> spec, Pageable pageable)方法，各類複雜查詢邏輯拼接都要寫在service層。對於架構分層思想流行了這麼多年外增強迫症的人來講實在是不能忍，若是單獨封裝一個Dao類編寫複雜的查詢又顯的有點多餘和臃腫架構

Spring Data Jpa最佳實踐

在詳細介紹最佳實踐前，先思考和了解一個東西，Spring Data Jpa是怎麼作到繼承一個接口就能實現各類複雜查詢的呢？這裏實際上是一個典型的代理模式的應用，只要繼承了最底層的Repository接口，在應用啓動時就會幫你生成一個代理實例，而真正的目標類纔是最終執行查詢的類，這個類就是:SimpleJpaRepository,它實現了JpaRepository、JpaSpecificationExecutor的全部接口，因此只要基於SimpleJpaRepository定製Repository基類，就能擁有繼承接口同樣的查詢功能，並且能夠在實現類裏編寫複雜的查詢方法了。app

1、繼承SimpleJpaRepository實現類

/**
 * @author: kl @kailing.pub
 * @date: 2019/11/8
 */
public abstract class BaseJpaRepository<T, ID> extends SimpleJpaRepository<T, ID> {

    public EntityManager em;

    BaseJpaRepository(Class<T> domainClass, EntityManager em) {
        super(domainClass, em);
        this.em = em;
    }
}

構造一個SimpleJpaRepository實例，只須要一個領域對象的類型，和EntityManager 實例便可，EntityManager在Spring的上下文中已經有了，會自動注入。領域對象類型在具體的實現類中注入便可。如：框架

/**
 * @author: kl @kailing.pub
 * @date: 2019/11/11
 */
@Repository
public class SendLogJpaRepository extends BaseJpaRepository<SendLog,Integer> {
    
    public SendLogJpaRepository(EntityManager em) {
        super(SendLog.class, em);
    }
    /**
     * 原生查詢
     * @param templateName
     * @return
     */
    public SendLog findByTemplateName(String templateName){
        String sql = "select * from send_log where templateName = :templateName";
        Query query =em.createNativeQuery(sql);
        query.setParameter("templateName",templateName);
        return (SendLog) query.getSingleResult();
    }

    /**
     * hql查詢
     * @param templateName
     * @return
     */
    public SendLog findByTemplateNameNative(String templateName){
        String hql = "from SendLog where templateName = :templateName";
        TypedQuery<SendLog> query =em.createQuery(hql,SendLog.class);
        query.setParameter("templateName",templateName);
       return query.getSingleResult();
    }

    /**
     *  JPASpecification 實現複雜分頁查詢
     * @param logDto
     * @param pageable
     * @return
     */
    public Page<SendLog> findAll(SendLogDto logDto,Pageable pageable) {
        Specification specification = (Specification) (root, query, criteriaBuilder) -> {
            Predicate predicate = criteriaBuilder.conjunction();
            if(!StringUtils.isEmpty(logDto.getTemplateName())){
                predicate.getExpressions().add( criteriaBuilder.like(root.get("templateName"),logDto.getTemplateName()));
            }
            if(logDto.getStartTime() !=null){
                predicate.getExpressions().add(criteriaBuilder.greaterThanOrEqualTo(root.get("createTime").as(Timestamp.class),logDto.getStartTime()));
            }
            query.where(predicate);
            return predicate;
        };
        return  findAll(specification, pageable);
    }
}

經過繼承BaseJpaRepository，使SendLogJpaRepository擁有了JpaRepository、JpaSpecificationExecutor接口中定義的全部方法功能。並且基於抽象基類中EntityManager實例，也能夠很是方便的編寫HQL和原生SQL查詢等。最賞心悅目的是不只擁有了最基本的CURD等功能，並且超複雜的分頁查詢也不分家了。只是JpaSpecification查詢方式還不是特別出彩，下面繼續最佳實踐dom

2、集成QueryDsl結構化查詢

Querydsl是一個框架，可經過其流暢的API來構造靜態類型的相似SQL的查詢。這是Spring Data Jpa文檔中對QueryDsl的描述。Spring Data Jpa對QueryDsl的擴展支持的比較好，基本能夠無縫集成使用。Querydsl定義了一套和JpaSpecification相似的接口，使用方式上也相似，因爲QueryDsl多了一個maven插件，能夠在編譯期間生成領域對象操做實體，因此在拼接複雜的查詢條件時相比較JpaSpecification顯的更靈活好用，特別在關聯到多表查詢的時候。下面看下怎麼集成：

一、快速集成

由於以前有寫過最簡單的QueryDsl集成方式，因此這裏就不在贅述了，具體參見《Querydsl結構化查詢之jpa》,

二、豐富BaseJpaRepository基類

/**
 * @author: kl @kailing.pub
 * @date: 2019/11/8
 */
public abstract class BaseJpaRepository<T, ID> extends SimpleJpaRepository<T, ID> {

    public EntityManager em;
    protected final QuerydslJpaPredicateExecutor<T> jpaPredicateExecutor;

    BaseJpaRepository(Class<T> domainClass, EntityManager em) {
        super(domainClass, em);
        this.em = em;
        this.jpaPredicateExecutor = new QuerydslJpaPredicateExecutor<>(JpaEntityInformationSupport.getEntityInformation(domainClass, em), em, SimpleEntityPathResolver.INSTANCE, getRepositoryMethodMetadata());
    }
}

在BaseJpaRepository基類中新增了QuerydslJpaPredicateExecutor實例，它是Spring Data Jpa基於QueryDsl的一個實現。用來執行QueryDsl的Predicate相關查詢。集成QueryDsl後，複雜分頁查詢的畫風就變的更加清爽了，如：

/**
     * QSendLog實體是QueryDsl插件自動生成的，插件會自動掃描加了@Entity的實體，生成一個用於查詢的EntityPath類
     */
    private  final  static QSendLog sendLog = QSendLog.sendLog;

    public Page<SendLog> findAll(SendLogDto logDto, Pageable pageable) {
        BooleanExpression expression = sendLog.isNotNull();
        if (logDto.getStartTime() != null) {
            expression = expression.and(sendLog.createTime.gt(logDto.getStartTime()));
        }
        if (!StringUtils.isEmpty(logDto.getTemplateName())) {
            expression = expression.and(sendLog.templateName.like("%"+logDto.getTemplateName()+"%"));
        }
        return jpaPredicateExecutor.findAll(expression, pageable);
    }

到目前爲止，實現相同的複雜分頁查詢，代碼已經很是的清爽和優雅了，在複雜的查詢在這種模式下也變的很是的清晰。可是，這還不是十分完美的。還有兩個問題須要解決下：

  • QuerydslJpaPredicateExecutor實現的方法不支持分頁查詢同時又有字段排序。下面是它的接口定義，能夠看到，要麼分頁查詢一步到位可是沒有排序，要麼排序查詢返回List列表本身封裝分頁。
public interface QuerydslPredicateExecutor<T> {
    Optional<T> findOne(Predicate predicate);
    Iterable<T> findAll(Predicate predicate);
    Iterable<T> findAll(Predicate predicate, Sort sort);
    Iterable<T> findAll(Predicate predicate, OrderSpecifier<?>... orders);
    Iterable<T> findAll(OrderSpecifier<?>... orders);
    Page<T> findAll(Predicate predicate, Pageable pageable);
    long count(Predicate predicate);
    boolean exists(Predicate predicate);
}
  • 複雜的多表關聯查詢QuerydslJpaPredicateExecutor不支持

三、最終的BaseJpaRepository形態

Spring Data Jpa對QuerDsl的支持畢竟有限，可是QueryDsl是有這種功能的，像上面的場景就須要特別處理了。最終改造的BaseJpaRepository以下：

/**
 * @author: kl @kailing.pub
 * @date: 2019/11/8
 */
public abstract class BaseJpaRepository<T, ID> extends SimpleJpaRepository<T, ID> {

    protected final JPAQueryFactory jpaQueryFactory;
    protected final QuerydslJpaPredicateExecutor<T> jpaPredicateExecutor;
    protected final EntityManager em;
    private final EntityPath<T> path;
    protected final Querydsl querydsl;
    
    BaseJpaRepository(Class<T> domainClass, EntityManager em) {
        super(domainClass, em);
        this.em = em;
        this.jpaPredicateExecutor = new QuerydslJpaPredicateExecutor<>(JpaEntityInformationSupport.getEntityInformation(domainClass, em), em, SimpleEntityPathResolver.INSTANCE, getRepositoryMethodMetadata());
        this.jpaQueryFactory = new JPAQueryFactory(em);
        this.path = SimpleEntityPathResolver.INSTANCE.createPath(domainClass);
        this.querydsl = new Querydsl(em, new PathBuilder<T>(path.getType(), path.getMetadata()));
    }
    
    protected Page<T> findAll(Predicate predicate, Pageable pageable, OrderSpecifier<?>... orders) {
        final JPAQuery countQuery = jpaQueryFactory.selectFrom(path);
        countQuery.where(predicate);
        JPQLQuery<T> query = querydsl.applyPagination(pageable, countQuery);
        query.orderBy(orders);
        return PageableExecutionUtils.getPage(query.fetch(), pageable, countQuery::fetchCount);
    }
}

新增了findAll(Predicate predicate, Pageable pageable, OrderSpecifier<?>... orders)方法，用於支持複雜分頁查詢的同時又有字段排序的查詢場景。其次的改動是引入了JPAQueryFactory實例，用於多表關聯的複雜查詢。使用方式以下：

/**
     * QSendLog實體是QueryDsl插件自動生成的，插件會自動掃描加了@Entity的實體，生成一個用於查詢的EntityPath類
     */
    private  final  static QSendLog qSendLog = QSendLog.sendLog;
    private  final static QTemplate qTemplate = QTemplate.template;

    public Page<SendLog> findAll(SendLogDto logDto, Template template, Pageable pageable) {
        JPAQuery  countQuery = jpaQueryFactory.selectFrom(qSendLog).leftJoin(qTemplate);
        countQuery.where(qSendLog.templateCode.eq(qTemplate.code));
        if(!StringUtils.isEmpty(template.getName())){
            countQuery.where(qTemplate.name.eq(template.getName()));
        }
        JPQLQuery query = querydsl.applyPagination(pageable, countQuery);
        return PageableExecutionUtils.getPage(query.fetch(), pageable, countQuery::fetchCount);
    }

3、集成p6spy打印執行的sql

上面的功能以及十分完美了，可是談到最佳實踐彷佛少了一個打印SQL的功能。在使用Jpa的結構化語義構建複雜查詢時，常常會由於各類緣由致使查詢的結果集不是本身想要的，可是又無法排查，由於不知道最終執行的sql是怎麼樣的。Spring Data Jpa也有打印sql的功能，可是比較雞肋，它打印的是沒有替換查詢參數的sql，無法直接複製執行。因此這裏推薦一個工具p6spy，p6spy是一個打印最終執行sql的工具，並且能夠記錄sql的執行耗時。使用起來也比較方便，簡單三步集成：

一、引入依賴 
<dependency>
                <groupId>p6spy</groupId>
                <artifactId>p6spy</artifactId>
                <version>${p6spy.version}</version>
            </dependency>
二、修改數據源連接字符串 
jdbc:mysql://127.0.0.1:3306 改爲 jdbc:p6spy:mysql://127.0.0.1:3306
三、添加配置spy.propertis配置 
appender=com.p6spy.engine.spy.appender.Slf4JLogger
logMessageFormat=com.p6spy.engine.spy.appender.CustomLineFormat
customLogMessageFormat = executionTime:%(executionTime)| sql:%(sqlSingleLine)

這個是最簡化的自定義打印的配置，更多配置可參考：https://p6spy.readthedocs.io/...

結語

最後的BaseJpaRepository功能上基本知足了全部的查詢需求，又作了基礎查詢和複雜查詢的不分離，不至於把大量的複雜查詢拼接邏輯寫到service層，或者是新建的複雜查詢類裏。完全解決了文首提出的那些問題。基於QueryDsl的複雜查詢代碼邏輯清晰，結構優雅，極力推薦使用。最後，在安利下p6spy，一個很是實用的打印sql的工具，能夠幫助排查分析JPA最終生成執行的sql語句,其打印的sql語句能夠直接複製到mysql管理工具中執行的。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程