本篇進(jìn)行Spring-data-jpa的介紹，幾乎涵蓋該框架的所有方面，在日常的開發(fā)當(dāng)中，基本上能滿足所有需求。這里不講解JPA和Spring-data-jpa單獨(dú)使用，所有的內(nèi)容都是在和Spring整合的環(huán)境中實(shí)現(xiàn)。如果需要了解該框架的入門，百度一下，很多入門的介紹。在這篇文章的接下來(lái)一篇，會(huì)有一個(gè)系列來(lái)講解mybatis，這個(gè)系列從mybatis的入門開始，到基本使用，和spring整合，和第三方插件整合，緩存，插件，最后會(huì)持續(xù)到mybatis的架構(gòu)，源碼解釋，重點(diǎn)會(huì)介紹幾個(gè)重要的設(shè)計(jì)模式，這樣一個(gè)體系?；旧现v完之后，mybatis在你面前就沒(méi)有了秘密，你能解決mybatis的幾乎所有問(wèn)題，并且在開發(fā)過(guò)程中相當(dāng)?shù)姆奖?#xff0c;駕輕就熟。

這篇文章由于介紹的類容很全，因此很長(zhǎng)，如果你需要，那么可以耐心的看完，本人經(jīng)歷了很長(zhǎng)時(shí)間的學(xué)識(shí)，使用，研究的心血濃縮成為這么短短的一篇博客。

大致整理一個(gè)提綱：

　　1、Spring-data-jpa的基本介紹；

　　2、和Spring整合；

　　3、基本的使用方式；

　　4、復(fù)雜查詢，包括多表關(guān)聯(lián)，分頁(yè)，排序等；

現(xiàn)在開始：

　　1、Spring-data-jpa的基本介紹：JPA誕生的緣由是為了整合第三方ORM框架，建立一種標(biāo)準(zhǔn)的方式，百度百科說(shuō)是JDK為了實(shí)現(xiàn)ORM的天下歸一，目前也是在按照這個(gè)方向發(fā)展，但是還沒(méi)能完全實(shí)現(xiàn)。在ORM框架中，Hibernate是一支很大的部隊(duì)，使用很廣泛，也很方便，能力也很強(qiáng)，同時(shí)Hibernate也是和JPA整合的比較良好，我們可以認(rèn)為JPA是標(biāo)準(zhǔn)，事實(shí)上也是，JPA幾乎都是接口，實(shí)現(xiàn)都是Hibernate在做，宏觀上面看，在JPA的統(tǒng)一之下Hibernate很良好的運(yùn)行。

　　上面闡述了JPA和Hibernate的關(guān)系，那么Spring-data-jpa又是個(gè)什么東西呢？這地方需要稍微解釋一下，我們做Java開發(fā)的都知道Spring的強(qiáng)大，到目前為止，企業(yè)級(jí)應(yīng)用Spring幾乎是無(wú)所不能，無(wú)所不在，已經(jīng)是事實(shí)上的標(biāo)準(zhǔn)了，企業(yè)級(jí)應(yīng)用不使用Spring的幾乎沒(méi)有，這樣說(shuō)沒(méi)錯(cuò)吧。而Spring整合第三方框架的能力又很強(qiáng)，他要做的不僅僅是個(gè)最早的IOC容器這么簡(jiǎn)單一回事，現(xiàn)在Spring涉及的方面太廣，主要是體現(xiàn)在和第三方工具的整合上。而在與第三方整合這方面，Spring做了持久化這一塊的工作，我個(gè)人的感覺(jué)是Spring希望把持久化這塊內(nèi)容也拿下。于是就有了Spring-data-**這一系列包。包括，Spring-data-jpa,Spring-data-template,Spring-data-mongodb,Spring-data-redis，還有個(gè)民間產(chǎn)品，mybatis-spring，和前面類似，這是和mybatis整合的第三方包，這些都是干的持久化工具干的事兒。

　　這里介紹Spring-data-jpa，表示與jpa的整合。

　　2、我們都知道，在使用持久化工具的時(shí)候，一般都有一個(gè)對(duì)象來(lái)操作數(shù)據(jù)庫(kù)，在原生的Hibernate中叫做Session，在JPA中叫做EntityManager，在MyBatis中叫做SqlSession，通過(guò)這個(gè)對(duì)象來(lái)操作數(shù)據(jù)庫(kù)。我們一般按照三層結(jié)構(gòu)來(lái)看的話，Service層做業(yè)務(wù)邏輯處理，Dao層和數(shù)據(jù)庫(kù)打交道，在Dao中，就存在著上面的對(duì)象。那么ORM框架本身提供的功能有什么呢？答案是基本的CRUD，所有的基礎(chǔ)CRUD框架都提供，我們使用起來(lái)感覺(jué)很方便，很給力，業(yè)務(wù)邏輯層面的處理ORM是沒(méi)有提供的，如果使用原生的框架，業(yè)務(wù)邏輯代碼我們一般會(huì)自定義，會(huì)自己去寫SQL語(yǔ)句，然后執(zhí)行。在這個(gè)時(shí)候，Spring-data-jpa的威力就體現(xiàn)出來(lái)了，ORM提供的能力他都提供，ORM框架沒(méi)有提供的業(yè)務(wù)邏輯功能Spring-data-jpa也提供，全方位的解決用戶的需求。使用Spring-data-jpa進(jìn)行開發(fā)的過(guò)程中，常用的功能，我們幾乎不需要寫一條sql語(yǔ)句，至少在我看來(lái)，企業(yè)級(jí)應(yīng)用基本上可以不用寫任何一條sql，當(dāng)然spring-data-jpa也提供自己寫sql的方式，這個(gè)就看個(gè)人怎么選擇，都可以。我覺(jué)得都行。

　　2.1與Spring整合我們從spring配置文件開始，為了節(jié)省篇幅，這里我只寫出配置文件的結(jié)構(gòu)。

<?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:p="http://www.springframework.org/schema/p" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context" xmlns:mongo="http://www.springframework.org/schema/data/mongo"xmlns:jpa="http://www.springframework.org/schema/data/jpa"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsdhttp://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd http://www.springframework.org/schema/txhttp://www.springframework.org/schema/tx/spring-tx-3.0.xsdhttp://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsdhttp://www.springframework.org/schema/data/mongohttp://www.springframework.org/schema/data/mongo/spring-mongo-1.0.xsdhttp://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa.xsd"><!-- 數(shù)據(jù)庫(kù)連接 --><context:property-placeholder location="classpath:your-config.properties" ignore-unresolvable="true" /><!-- service包 --><context:component-scan base-package="your service package" /><!-- 使用cglib進(jìn)行動(dòng)態(tài)代理 --><aop:aspectj-autoproxy proxy-target-class="true" /><!-- 支持注解方式聲明式事務(wù) --><tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true" /><!-- dao --><jpa:repositories base-package="your dao package" repository-impl-postfix="Impl" entity-manager-factory-ref="entityManagerFactory" transaction-manager-ref="transactionManager" /><!-- 實(shí)體管理器 --><bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean"><property name="dataSource" ref="dataSource" /><property name="packagesToScan" value="your entity package" /><property name="persistenceProvider"><bean class="org.hibernate.ejb.HibernatePersistence" /></property><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.MySQL5InnoDBDialect" /><!-- <property name="showSql" value="true" /> --></bean></property><property name="jpaDialect"><bean class="org.springframework.orm.jpa.vendor.HibernateJpaDialect" /></property><property name="jpaPropertyMap"><map><entry key="hibernate.query.substitutions" value="true 1, false 0" /><entry key="hibernate.default_batch_fetch_size" value="16" /><entry key="hibernate.max_fetch_depth" value="2" /><entry key="hibernate.generate_statistics" value="true" /><entry key="hibernate.bytecode.use_reflection_optimizer" value="true" /><entry key="hibernate.cache.use_second_level_cache" value="false" /><entry key="hibernate.cache.use_query_cache" value="false" /></map></property></bean><!-- 事務(wù)管理器 --><bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager"><property name="entityManagerFactory" ref="entityManagerFactory"/></bean><!-- 數(shù)據(jù)源 --><bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close"><property name="driverClassName" value="${driver}" /><property name="url" value="${url}" /><property name="username" value="${userName}" /><property name="password" value="${password}" /><property name="initialSize" value="${druid.initialSize}" /><property name="maxActive" value="${druid.maxActive}" /><property name="maxIdle" value="${druid.maxIdle}" /><property name="minIdle" value="${druid.minIdle}" /><property name="maxWait" value="${druid.maxWait}" /><property name="removeAbandoned" value="${druid.removeAbandoned}" /><property name="removeAbandonedTimeout" value="${druid.removeAbandonedTimeout}" /><property name="timeBetweenEvictionRunsMillis" value="${druid.timeBetweenEvictionRunsMillis}" /><property name="minEvictableIdleTimeMillis" value="${druid.minEvictableIdleTimeMillis}" /><property name="validationQuery" value="${druid.validationQuery}" /><property name="testWhileIdle" value="${druid.testWhileIdle}" /><property name="testOnBorrow" value="${druid.testOnBorrow}" /><property name="testOnReturn" value="${druid.testOnReturn}" /><property name="poolPreparedStatements" value="${druid.poolPreparedStatements}" /><property name="maxPoolPreparedStatementPerConnectionSize" value="${druid.maxPoolPreparedStatementPerConnectionSize}" /><property name="filters" value="${druid.filters}" /></bean><!-- 事務(wù) --><tx:advice id="txAdvice" transaction-manager="transactionManager"><tx:attributes><tx:method name="*" /><tx:method name="get*" read-only="true" /><tx:method name="find*" read-only="true" /><tx:method name="select*" read-only="true" /><tx:method name="delete*" propagation="REQUIRED" /><tx:method name="update*" propagation="REQUIRED" /><tx:method name="add*" propagation="REQUIRED" /><tx:method name="insert*" propagation="REQUIRED" /></tx:attributes></tx:advice><!-- 事務(wù)入口 --><aop:config><aop:pointcut id="allServiceMethod" expression="execution(* your service implements package.*.*(..))" /><aop:advisor pointcut-ref="allServiceMethod" advice-ref="txAdvice" /></aop:config></beans>

　　2.2對(duì)上面的配置文件進(jìn)行簡(jiǎn)單的解釋，只對(duì)“實(shí)體管理器”和“dao”進(jìn)行解釋，其他的配置在任何地方都差不太多。

　　　　1.對(duì)“實(shí)體管理器”解釋：我們知道原生的jpa的配置信息是必須放在META-INF目錄下面的，并且名字必須叫做persistence.xml，這個(gè)叫做persistence-unit，就叫做持久化單元，放在這下面我們感覺(jué)不方便，不好，于是Spring提供了

org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean

這樣一個(gè)類，可以讓你的隨心所欲的起這個(gè)配置文件的名字，也可以隨心所欲的修改這個(gè)文件的位置，只需要在這里指向這個(gè)位置就行。然而更加方便的做法是，直接把配置信息就寫在這里更好，于是就有了這實(shí)體管理器這個(gè)bean。使用

<property name="packagesToScan" value="your entity package" />

這個(gè)屬性來(lái)加載我們的entity。

　　2.3 解釋“dao”這個(gè)bean。這里衍生一下，進(jìn)行一下名詞解釋，我們知道dao這個(gè)層叫做Data Access Object，數(shù)據(jù)庫(kù)訪問(wèn)對(duì)象，這是一個(gè)廣泛的詞語(yǔ)，在jpa當(dāng)中，我們還有一個(gè)詞語(yǔ)叫做Repository，這里我們一般就用Repository結(jié)尾來(lái)表示這個(gè)dao，比如UserDao，這里我們使用UserRepository，當(dāng)然名字無(wú)所謂，隨意取，你可以意會(huì)一下我的意思，感受一下這里的含義和區(qū)別，同理，在mybatis中我們一般也不叫dao，mybatis由于使用xml映射文件（當(dāng)然也提供注解，但是官方文檔上面表示在有些地方，比如多表的復(fù)雜查詢方面，注解還是無(wú)解，只能xml），我們一般使用mapper結(jié)尾，比如我們也不叫UserDao，而叫UserMapper。

　　上面拓展了一下關(guān)于dao的解釋，那么這里的這個(gè)配置信息是什么意思呢？首先base-package屬性，代表你的Repository接口的位置，repository-impl-postfix屬性代表接口的實(shí)現(xiàn)類的后綴結(jié)尾字符，比如我們的UserRepository，那么他的實(shí)現(xiàn)類就叫做UserRepositoryImpl，和我們平時(shí)的使用習(xí)慣完全一致，于此同時(shí)，spring-data-jpa的習(xí)慣是接口和實(shí)現(xiàn)類都需要放在同一個(gè)包里面（不知道有沒(méi)有其他方式能分開放，這不是重點(diǎn)，放在一起也無(wú)所謂，影響不大），再次的，這里我們的UserRepositoryImpl這個(gè)類的定義的時(shí)候我們不需要去指定實(shí)現(xiàn)UserRepository接口，根據(jù)spring-data-jpa自動(dòng)就能判斷二者的關(guān)系。

　　比如：我們的UserRepository和UserRepositoryImpl這兩個(gè)類就像下面這樣來(lái)寫。

public interface UserRepository extends JpaRepository<User, Integer>{} public class UserRepositoryImpl {}

　　那么這里為什么要這么做呢？原因是：spring-data-jpa提供基礎(chǔ)的CRUD工作，同時(shí)也提供業(yè)務(wù)邏輯的功能（前面說(shuō)了，這是該框架的威力所在），所以我們的Repository接口要做兩項(xiàng)工作，繼承spring-data-jpa提供的基礎(chǔ)CRUD功能的接口，比如JpaRepository接口，同時(shí)自己還需要在UserRepository這個(gè)接口中定義自己的方法，那么導(dǎo)致的結(jié)局就是UserRepository這個(gè)接口中有很多的方法，那么如果我們的UserRepositoryImpl實(shí)現(xiàn)了UserRepository接口，導(dǎo)致的后果就是我們勢(shì)必需要重寫里面的所有方法，這是Java語(yǔ)法的規(guī)定，如此一來(lái)，悲劇就產(chǎn)生了，UserRepositoryImpl里面我們有很多的@Override方法，這顯然是不行的，結(jié)論就是，這里我們不用去寫implements部分。

　　spring-data-jpa實(shí)現(xiàn)了上面的能力，那他是怎么實(shí)現(xiàn)的呢？這里我們通過(guò)源代碼的方式來(lái)呈現(xiàn)他的來(lái)龍去脈，這個(gè)過(guò)程中cglib發(fā)揮了杰出的作用。

　　在spring-data-jpa內(nèi)部，有一個(gè)類，叫做

public class SimpleJpaRepository<T, ID extends Serializable> implements JpaRepository<T, ID>,JpaSpecificationExecutor<T>

我們可以看到這個(gè)類是實(shí)現(xiàn)了JpaRepository接口的，事實(shí)上如果我們按照上面的配置，在同一個(gè)包下面有UserRepository，但是沒(méi)有UserRepositoryImpl這個(gè)類的話，在運(yùn)行時(shí)期UserRepository這個(gè)接口的實(shí)現(xiàn)就是上面的SimpleJpaRepository這個(gè)接口。而如果有UserRepositoryImpl這個(gè)文件的話，那么UserRepository的實(shí)現(xiàn)類就是UserRepositoryImpl，而UserRepositoryImpl這個(gè)類又是SimpleJpaRepository的子類，如此一來(lái)就很好的解決了上面的這個(gè)不用寫implements的問(wèn)題。我們通過(guò)閱讀這個(gè)類的源代碼可以發(fā)現(xiàn)，里面包裝了entityManager，底層的調(diào)用關(guān)系還是entityManager在進(jìn)行CRUD。

　　3. 下面我們通過(guò)一個(gè)完整的項(xiàng)目來(lái)基本使用spring-data-jpa，然后我們?cè)诮榻B他的高級(jí)用法。

　　a.數(shù)據(jù)庫(kù)建表：user,主鍵自增

　　

　　b.對(duì)應(yīng)實(shí)體：User

@Entity @Table(name = "user") public class User {@Id@GeneratedValue(strategy = GenerationType.IDENTITY)private Integer id;private String name;private String password;private String birthday;// getter,setter }

　　c.簡(jiǎn)歷UserRepository接口

public interface UserRepository extends JpaRepository<User, Integer>{}

　　通過(guò)上面3步，所有的工作就做完了，User的基礎(chǔ)CRUD都能做了，簡(jiǎn)約而不簡(jiǎn)單。

　　d.我們的測(cè)試類UserRepositoryTest

public class UserRepositoryTest {@Autowiredprivate UserRepository userRepository;@Testpublic void baseTest() throws Exception {User user = new User();user.setName("Jay");user.setPassword("123456");user.setBirthday("2008-08-08");userRepository.save(user); // userRepository.delete(user); // userRepository.findOne(1); } }

　　測(cè)試通過(guò)。

　　說(shuō)到這里，和spring已經(jīng)完成。接下來(lái)第三點(diǎn)，基本使用。

4.前面把基礎(chǔ)的東西說(shuō)清楚了，接下來(lái)就是spring-data-jpa的正餐了，真正威力的地方。

　　4.1 我們的系統(tǒng)中一般都會(huì)有用戶登錄這個(gè)接口，在不使用spring-data-jpa的時(shí)候我們?cè)趺醋?#xff0c;首先在service層定義一個(gè)登錄方法。如：

User login(String name, String password);

然后在serviceImpl中寫該方法的實(shí)現(xiàn)，大致這樣：

@Overridepublic User login(String name, String password) {return userDao.login(name, password);}

接下來(lái)，UserDao大概是這么個(gè)樣子：

User getUserByNameAndPassword(String name, String password);

然后在UserDaoImpl中大概是這么個(gè)樣子：

public User getUserByNameAndPassword(String name, String password) {Query query = em.createQuery("select * from User t where t.name = ?1 and t.password = ?2");query.setParameter(1, name);query.setParameter(2, password);return (User) query.getSingleResult();}

ok，這個(gè)代碼運(yùn)行良好，那么這樣子大概有十來(lái)行代碼，我們感覺(jué)這個(gè)功能實(shí)現(xiàn)了，很不錯(cuò)。然而這樣子真正簡(jiǎn)捷么？如果這樣子就滿足了，那么spring-data-jpa就沒(méi)有必要存在了，前面提到spring-data-jpa能夠幫助你完成業(yè)務(wù)邏輯代碼的處理，那他是怎么處理的呢？這里我們根本不需要UserDaoImpl這個(gè)類，只需要在UserRepository接口中定義一個(gè)方法

User findByNameAndPassword(String name, String password);

然后在service中調(diào)用這個(gè)方法就完事了，所有的邏輯只需要這么一行代碼，一個(gè)沒(méi)有實(shí)現(xiàn)的接口方法。通過(guò)debug信息，我們看到輸出的sql語(yǔ)句是

select * from user where name = ? and password = ?

跟上面的傳統(tǒng)方式一模一樣的結(jié)果。這簡(jiǎn)單到令人發(fā)指的程度，那么這一能力是如何實(shí)現(xiàn)的呢？原理是：spring-data-jpa會(huì)根據(jù)方法的名字來(lái)自動(dòng)生成sql語(yǔ)句，我們只需要按照方法定義的規(guī)則即可，上面的方法findByNameAndPassword，spring-data-jpa規(guī)定，方法都以findBy開頭，sql的where部分就是NameAndPassword，被spring-data-jpa翻譯之后就編程了下面這種形態(tài)：

where name = ? and password = ?

在舉個(gè)例，如果是其他的操作符呢，比如like，前端模糊查詢很多都是以like的方式來(lái)查詢。比如根據(jù)名字查詢用戶，sql就是

select * from user where name like = ?

這里spring-data-jpa規(guī)定，在屬性后面接關(guān)鍵字，比如根據(jù)名字查詢用戶就成了

User findByNameLike(String name);

被翻譯之后的sql就是

select * from user where name like = ?

這也是簡(jiǎn)單到令人發(fā)指，spring-data-jpa所有的語(yǔ)法規(guī)定如下圖：

通過(guò)上面，基本CRUD和基本的業(yè)務(wù)邏輯操作都得到了解決，我們要做的工作少到僅僅需要在UserRepository接口中定義幾個(gè)方法，其他所有的工作都由spring-data-jpa來(lái)完成。

?接下來(lái)：就是比較復(fù)雜的操作了，比如動(dòng)態(tài)查詢，分頁(yè)，下面詳細(xì)介紹spring-data-jpa的第二大殺手锏，強(qiáng)大的動(dòng)態(tài)查詢能力。

在上面的介紹中，對(duì)于我們傳統(tǒng)的企業(yè)級(jí)應(yīng)用的基本操作已經(jīng)能夠基本上全部實(shí)現(xiàn)，企業(yè)級(jí)應(yīng)用一般都會(huì)有一個(gè)模糊查詢的功能，并且是多條的查詢，在有查詢條件的時(shí)候我們需要在where后面接上一個(gè) xxx = yyy 或者 xxx like '% + yyy + %'類似這樣的sql。那么我們傳統(tǒng)的JDBC的做法是使用很多的if語(yǔ)句根據(jù)傳過(guò)來(lái)的查詢條件來(lái)拼sql，mybatis的做法也類似，由于mybatis有強(qiáng)大的動(dòng)態(tài)xml文件的標(biāo)簽，在處理這種問(wèn)題的時(shí)候顯得非常的好，但是二者的原理都一致，那spring-data-jpa的原理也同樣很類似，這個(gè)道理也就說(shuō)明了解決多表關(guān)聯(lián)動(dòng)態(tài)查詢根兒上也就是這么回事。

　　那么spring-data-jpa的做法是怎么的呢？有兩種方式?？梢赃x擇其中一種，也可以結(jié)合使用，在一般的查詢中使用其中一種就夠了，就是第二種，但是有一類查詢比較棘手，比如報(bào)表相關(guān)的，報(bào)表查詢由于涉及的表很多，這些表不一定就是兩兩之間有關(guān)系，比如字典表，就很獨(dú)立，在這種情況之下，使用拼接sql的方式要容易一些。下面分別介紹這兩種方式。

　　a.使用JPQL,和Hibernate的HQL很類似。

　　　前面說(shuō)道了在UserRepository接口的同一個(gè)包下面建立一個(gè)普通類UserRepositoryImpl來(lái)表示該類的實(shí)現(xiàn)類，同時(shí)前面也介紹了完全不需要這個(gè)類的存在，但是如果使用JPQL的方式就必須要有這個(gè)類。如下：

public class StudentRepositoryImpl {@PersistenceContextprivate EntityManager em;@SuppressWarnings("unchecked")public Page<Student> search(User user) {String dataSql = "select t from User t where 1 = 1";String countSql = "select count(t) from User t where 1 = 1";if(null != user && !StringUtils.isEmpty(user.getName())) {dataSql += " and t.name = ?1";countSql += " and t.name = ?1";}Query dataQuery = em.createQuery(dataSql);Query countQuery = em.createQuery(countSql);if(null != user && !StringUtils.isEmpty(user.getName())) {dataQuery.setParameter(1, user.getName());countQuery.setParameter(1, user.getName());}long totalSize = (long) countQuery.getSingleResult();Page<User> page = new Page();page.setTotalSize(totalSize);List<User> data = dataQuery.getResultList();page.setData(data);return page;}}

通過(guò)上面的方法，我們查詢并且封裝了一個(gè)User對(duì)象的分頁(yè)信息。代碼能夠良好的運(yùn)行。這種做法也是我們傳統(tǒng)的經(jīng)典做法。那么spring-data-jpa還有另外一種更好的方式，那就是所謂的類型檢查的方式，上面我們的sql是字符串，沒(méi)有進(jìn)行類型檢查，而下面的方式就使用了類型檢查的方式。這個(gè)道理在mybatis中也有體現(xiàn)，mybatis可以使用字符串sql的方式，也可以使用接口的方式，而mybatis的官方推薦使用接口方式，因?yàn)橛蓄愋蜋z查，會(huì)更安全。

　　b.使用JPA的動(dòng)態(tài)接口，下面的接口我把注釋刪了，為了節(jié)省篇幅，注釋也沒(méi)什么用，看方法名字大概都能猜到是什么意思。

public interface JpaSpecificationExecutor<T> { T findOne(Specification<T> spec); List<T> findAll(Specification<T> spec); Page<T> findAll(Specification<T> spec, Pageable pageable); List<T> findAll(Specification<T> spec, Sort sort); long count(Specification<T> spec); }

?上面說(shuō)了，使用這種方式我們壓根兒就不需要UserRepositoryImpl這個(gè)類，說(shuō)到這里，仿佛我們就發(fā)現(xiàn)了spring-data-jpa為什么把Repository和RepositoryImpl文件放在同一個(gè)包下面，因?yàn)槲覀兊膽?yīng)用很可能根本就一個(gè)Impl文件都不存在，那么在那個(gè)包下面就只有一堆接口，即使把Repository和RepositoryImpl都放在同一個(gè)包下面，也不會(huì)造成這個(gè)包下面有正常情況下2倍那么多的文件，根本原因：只有接口而沒(méi)有實(shí)現(xiàn)類。

上面我們的UserRepository類繼承了JpaRepository和JpaSpecificationExecutor類，而我們的UserRepository這個(gè)對(duì)象都會(huì)注入到UserService里面，于是如果使用這種方式，我們的邏輯直接就寫在service里面了，下面的代碼：一個(gè)學(xué)生Student類，一個(gè)班級(jí)Clazz類，Student里面有一個(gè)對(duì)象Clazz，在數(shù)據(jù)庫(kù)中是clazz_id，這是典型的多對(duì)一的關(guān)系。我們?cè)谂渲煤胑ntity里面的關(guān)系之后。就可以在StudentServiceImpl類中做Student的模糊查詢，典型的前端grid的模糊查詢。代碼是這樣子的：

@Service public class StudentServiceImpl extends BaseServiceImpl<Student> implements StudentService {@Autowiredprivate StudentRepository studentRepository;@Overridepublic Student login(Student student) {return studentRepository.findByNameAndPassword(student.getName(), student.getPassword());}@Overridepublic Page<Student> search(final Student student, PageInfo page) {return studentRepository.findAll(new Specification<Student>() {@Overridepublic Predicate toPredicate(Root<Student> root, CriteriaQuery<?> query, CriteriaBuilder cb) {Predicate stuNameLike = null;if(null != student && !StringUtils.isEmpty(student.getName())) {
　　　　　　　　　　　// 這里也可以root.get("name").as(String.class)這種方式來(lái)強(qiáng)轉(zhuǎn)泛型類型stuNameLike = cb.like(root.<String> get("name"), "%" + student.getName() + "%");}Predicate clazzNameLike = null;if(null != student && null != student.getClazz() && !StringUtils.isEmpty(student.getClazz().getName())) {clazzNameLike = cb.like(root.<String> get("clazz").<String> get("name"), "%" + student.getClazz().getName() + "%");}if(null != stuNameLike) query.where(stuNameLike);if(null != clazzNameLike) query.where(clazzNameLike);return null;}}, new PageRequest(page.getPage() - 1, page.getLimit(), new Sort(Direction.DESC, page.getSortName())));} }

先解釋下這里的意思，然后我們?cè)诮Y(jié)合框架的源碼來(lái)深入分析。

這里我們是2個(gè)表關(guān)聯(lián)查詢，查詢條件包括Student表和Clazz表，類似的2個(gè)以上的表方式差不多，但是正如上面所說(shuō)，這種做法適合所有的表都是兩兩能夠關(guān)聯(lián)上的，涉及的表太多，或者是有一些字典表，那就使用sql拼接的方式，簡(jiǎn)單一些。

先簡(jiǎn)單解釋一下代碼的含義，然后結(jié)合框架源碼來(lái)詳細(xì)分析。兩個(gè)Predicate對(duì)象，Predicate按照中文意思是判斷，斷言的意思，那么放在我們的sql中就是where后面的東西，比如

name like '% + jay + %';

下面的PageRequest代表分頁(yè)信息，PageRequest里面的Sort對(duì)象是排序信息。上面的代碼事實(shí)上是在動(dòng)態(tài)的組合最終的sql語(yǔ)句，這里使用了一個(gè)策略模式，或者callback，就是

studentRepository.findAll(一個(gè)接口)

studentRepository接口方法調(diào)用的參數(shù)是一個(gè)接口，而接口的實(shí)現(xiàn)類調(diào)用這個(gè)方法的時(shí)候，在內(nèi)部，參數(shù)對(duì)象的實(shí)現(xiàn)類調(diào)用自己的toPredicate這個(gè)方法的實(shí)現(xiàn)內(nèi)容，可以體會(huì)一下這里的思路，就是傳一個(gè)接口，然后接口的實(shí)現(xiàn)自己來(lái)定義，這個(gè)思路在nettyJavaScript中體現(xiàn)的特別明顯，特別是JavaScript的框架中大量的這種方式，JS框架很多的做法都是上來(lái)先閉包，和瀏覽器的命名空間分開，然后入口方法就是一個(gè)回調(diào)，比如ExtJS：

Ext.onReady(function() {// xxx });

參數(shù)是一個(gè)function，其實(shí)在框架內(nèi)部就調(diào)用了這個(gè)參數(shù)，于是這個(gè)這個(gè)方法執(zhí)行了。這種模式還有一個(gè)JDK的排序集合上面也有體現(xiàn)，我們的netty框架也采用這種方式來(lái)實(shí)現(xiàn)異步IO的能力。

接下來(lái)結(jié)合框架源碼來(lái)詳細(xì)介紹這種機(jī)制，以及這種機(jī)制提供給我們的好處。

?這里首先從JPA的動(dòng)態(tài)查詢開始說(shuō)起，在JPA提供的API中，動(dòng)態(tài)查詢大概有這么一些方法，

從名字大概可以看出這些方法的意義，跟Hibernate或者一些其他的工具也都差不多，這里我們介紹參數(shù)為CriteriaQuery類型的這個(gè)方法，如果我們熟悉多種ORM框架的話，不難發(fā)現(xiàn)都有一個(gè)Criteria類似的東西，中文意思是“條件”的意思，這就是各個(gè)框架構(gòu)建動(dòng)態(tài)查詢的主體，Hibernate甚至有兩種，在線和離線兩種Criteria，mybatis也能從Example中創(chuàng)建Criteria，并且添加查詢條件。

那么第一步就需要構(gòu)建出這個(gè)參數(shù)CriteriaQuery類型的參數(shù)，這里使用建造者模式，

CriteriaBuilder builder = em.getCriteriaBuilder(); CriteriaQuery<Student> query = builder.createQuery(Student.class);

接下來(lái)：

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

在這里，我們看方法名from，意思是獲取Student的Root，其實(shí)也就是個(gè)Student的包裝對(duì)象，就代表這條sql語(yǔ)句里面的主體。接下來(lái)：

Predicate p1 = builder.like(root.<String> get("name"), "%" + student.getName() + "%");Predicate p2 = builder.equal(root.<String> get("password"), student.getPassword());

Predicate是判斷的意思，放在sql語(yǔ)句中就是where后面 xxx = yyy, xxx like yyy這種，也就是查詢條件，這里構(gòu)造了2個(gè)查詢條件，分別是根據(jù)student的name屬性進(jìn)行l(wèi)ike查詢和根據(jù)student的password進(jìn)行“=”查詢，在sql中就是

name like = ? and password = ?

這種形式，接下來(lái)

query.where(p1, p2);

這樣子一個(gè)完整的動(dòng)態(tài)查詢就構(gòu)建完成了，接下來(lái)調(diào)用getSingleResult或者getResultList返回結(jié)果，這里jpa的單個(gè)查詢?nèi)绻麨榭盏脑挄?huì)報(bào)異常，這點(diǎn)感覺(jué)框架設(shè)計(jì)的不好，如果查詢?yōu)榭罩苯臃祷匾粋€(gè)null或者一個(gè)空的List更好一點(diǎn)。

這是jpa原生的動(dòng)態(tài)查詢方式，過(guò)程大致就是，創(chuàng)建builder => 創(chuàng)建Query => 構(gòu)造條件 => 查詢。這么4個(gè)步驟，這里代碼運(yùn)行良好，如果不使用spring-data-jpa，我們就需要這么來(lái)做，但是spring-data-jpa幫我們做得更為徹底，從上面的4個(gè)步驟中，我們發(fā)現(xiàn)：所有的查詢除了第三步不一樣，其他幾步都是一模一樣的，不使用spring-data-jpa的情況下，我們要么4步驟寫完，要么自己寫個(gè)工具類，封裝一下，這里spring-data-jpa就是幫我們完成的這樣一個(gè)動(dòng)作，那就是在JpaSpecification<T>這個(gè)接口中的

Page<T> findAll(Specification<T> spec, Pageable pageable);

這個(gè)方法，前面說(shuō)了，這是個(gè)策略模式，參數(shù)spec是個(gè)接口，前面也說(shuō)了框架內(nèi)部對(duì)于這個(gè)接口有默認(rèn)的實(shí)現(xiàn)類

@Repository @Transactional(readOnly = true) public class SimpleJpaRepository<T, ID extends Serializable> implements JpaRepository<T, ID>,JpaSpecificationExecutor<T> {}

，我們的Repository接口就是繼承這個(gè)接口，而通過(guò)cglib的RepositoryImpl的代理類也是這個(gè)類的子類，默認(rèn)也就實(shí)現(xiàn)了該方法。這個(gè)方法的方法體是這樣的：

/** (non-Javadoc)* @see org.springframework.data.jpa.repository.JpaSpecificationExecutor#findOne(org.springframework.data.jpa.domain.Specification)*/public T findOne(Specification<T> spec) {try {return getQuery(spec, (Sort) null).getSingleResult();} catch (NoResultException e) {return null;}}

這里的

getQuery(spec, (Sort) null)

返回類型是

TypedQuery<T>

進(jìn)入這個(gè)getQuery方法：

/*** Creates a {@link TypedQuery} for the given {@link Specification} and {@link Sort}.* * @param spec can be {@literal null}.* @param sort can be {@literal null}.* @return*/protected TypedQuery<T> getQuery(Specification<T> spec, Sort sort) {CriteriaBuilder builder = em.getCriteriaBuilder();CriteriaQuery<T> query = builder.createQuery(getDomainClass());Root<T> root = applySpecificationToCriteria(spec, query);query.select(root);if (sort != null) {query.orderBy(toOrders(sort, root, builder));}return applyRepositoryMethodMetadata(em.createQuery(query));}

一切玄機(jī)盡收眼底，這個(gè)方法的內(nèi)容和我們前面使用原生jpa的api的過(guò)程是一樣的，而再進(jìn)入

Root<T> root = applySpecificationToCriteria(spec, query);

這個(gè)方法：

/*** Applies the given {@link Specification} to the given {@link CriteriaQuery}.* * @param spec can be {@literal null}.* @param query must not be {@literal null}.* @return*/private <S> Root<T> applySpecificationToCriteria(Specification<T> spec, CriteriaQuery<S> query) {Assert.notNull(query);Root<T> root = query.from(getDomainClass());if (spec == null) {return root;}CriteriaBuilder builder = em.getCriteriaBuilder();Predicate predicate = spec.toPredicate(root, query, builder);if (predicate != null) {query.where(predicate);}return root;}

我們可以發(fā)現(xiàn)spec參數(shù)調(diào)用了toPredicate方法，也就是我們前面service里面匿名內(nèi)部類的實(shí)現(xiàn)。

到這里spring-data-jpa的默認(rèn)實(shí)現(xiàn)已經(jīng)完全明了?？偨Y(jié)一下使用動(dòng)態(tài)查詢：前面說(shuō)的原生api需要4步，而使用spring-data-jpa只需要一步，那就是重寫匿名內(nèi)部類的toPredicate方法。在重復(fù)一下上面的Student和Clazz的查詢代碼，

1 @Override 2 public Page<Student> search(final Student student, PageInfo page) { 4 return studentRepository.findAll(new Specification<Student>() { 5 @Override 6 public Predicate toPredicate(Root<Student> root, CriteriaQuery<?> query, CriteriaBuilder cb) { 7 8 Predicate stuNameLike = null; 9 if(null != student && !StringUtils.isEmpty(student.getName())) { 10 stuNameLike = cb.like(root.<String> get("name"), "%" + student.getName() + "%"); 11 } 12 13 Predicate clazzNameLike = null; 14 if(null != student && null != student.getClazz() && !StringUtils.isEmpty(student.getClazz().getName())) { 15 clazzNameLike = cb.like(root.<String> get("clazz").<String> get("name"), "%" + student.getClazz().getName() + "%"); 16 } 17 18 if(null != stuNameLike) query.where(stuNameLike); 19 if(null != clazzNameLike) query.where(clazzNameLike); 20 return null; 21 } 22 }, new PageRequest(page.getPage() - 1, page.getLimit(), new Sort(Direction.DESC, page.getSortName()))); 23 }

到這里位置，spring-data-jpa的介紹基本上就完成了，涵蓋了該框架使用的方方面面。接下來(lái)還有一塊比較實(shí)用的東西，我們看到上面第15行位置的條件查詢，這里使用了一個(gè)多級(jí)的get，這個(gè)是spring-data-jpa支持的，就是嵌套對(duì)象的屬性，這種做法一般我們叫方法的級(jí)聯(lián)調(diào)用，就是調(diào)用的時(shí)候返回自己本身，這個(gè)在處理xml的工具中比較常見，主要是為了代碼的美觀作用，沒(méi)什么其他的用途。

最后還有一個(gè)小問(wèn)題，我們上面說(shuō)了使用動(dòng)態(tài)查詢和JPQL兩種方式都可以，在我們使用JPQL的時(shí)候，他的語(yǔ)法和常規(guī)的sql有點(diǎn)不太一樣，以Student、Clazz關(guān)系為例，比如：

select * from student t left join clazz tt on t.clazz_id = tt.id

這是一個(gè)很常規(guī)的sql，但是JPQL是這么寫：

select t from Student t left join t.clazz tt

left join右邊直接就是t的屬性，并且也沒(méi)有了on t.clazz_id == tt.id，然而并不會(huì)出現(xiàn)笛卡爾積，這里解釋一下為什么沒(méi)有這個(gè)條件，在我們的實(shí)體中配置了屬性的映射關(guān)系，并且ORM框架的最核心的目的就是要讓我們以面向?qū)ο蟮姆绞絹?lái)操作數(shù)據(jù)庫(kù)，顯然我們?cè)谑褂眠@些框架的時(shí)候就不需要關(guān)心數(shù)據(jù)庫(kù)了，只需要關(guān)系對(duì)象，而t.clazz_id = tt.id這個(gè)是數(shù)據(jù)庫(kù)的字段，由于配置了字段映射，框架內(nèi)部自己就會(huì)去處理，所以不需要on t.clazz_id = tt.id就是合理的。

　　前面介紹了spring-data-jpa的使用，還有一點(diǎn)忘了，悲觀所和樂(lè)觀鎖問(wèn)題，這里的樂(lè)觀鎖比較簡(jiǎn)單，jpa有提供注解@Version，加上該注解，自動(dòng)實(shí)現(xiàn)樂(lè)觀鎖，byId修改的時(shí)候sql自動(dòng)變成：update ... set ... where id = ? and version = ?，比較方便。

?in操作的查詢：

　　在日常手動(dòng)寫sql的時(shí)候有in這種查詢是比較多的，比如select * from user t where t.id in (1, 2, 3)；有人說(shuō)in的效率不高，要少用，但是其實(shí)只要in是主鍵，或者說(shuō)是帶有索引的，效率是很高的，mysql中如果in是子查詢貌似不會(huì)走索引，不過(guò)我個(gè)人經(jīng)驗(yàn)，在我遇到的實(shí)際應(yīng)用中，in(ids)這種是比較多的，所以一般來(lái)說(shuō)是沒(méi)有性能問(wèn)題的。

　　那么，sql里面比較好寫，但是如果使用spring-data-jpa的動(dòng)態(tài)查詢方式呢，就和前面的稍微有點(diǎn)區(qū)別。大致上是這么一個(gè)思路：

if(!CollectionUtils.isEmpty(ids)) {In<Long> in = cb.in(root.<Long> get("id"));for (Long id : parentIds) {in.value(id);}query.where(in); }

　　cb創(chuàng)建一個(gè)in的Predicate,然后給這個(gè)in賦值，最后把in加到where條件中。

手動(dòng)配置鎖：

　　spring-data-jpa支持注解方式的sql，比如：@Query(xxx)，另外，關(guān)于鎖的問(wèn)題，在實(shí)體中的某個(gè)字段配置@Version是樂(lè)觀鎖，有時(shí)候?yàn)榱耸褂靡粋€(gè)悲觀鎖，或者手動(dòng)配置一個(gè)樂(lè)觀鎖（如果實(shí)體中沒(méi)有version字段），那么可以使用@Lock這個(gè)注解，它能夠被解析成為相關(guān)的鎖。

一對(duì)多、多對(duì)多查詢（查詢條件在關(guān)聯(lián)對(duì)象中時(shí)）：

　　1、在JPA中，一個(gè)實(shí)體中如果存在多個(gè)關(guān)聯(lián)對(duì)象，那么不能同時(shí)eager獲取，只能有一個(gè)是eager獲取，其他只能lazy；在Hibernate當(dāng)中有幾種獨(dú)有的解決方法，在JPA當(dāng)中有2中方法，i.就是前面的改成延時(shí)加載；ii.把關(guān)聯(lián)對(duì)象的List改成Set（List允許重復(fù)，在多層抓去的時(shí)候無(wú)法完成映射，Hibernate默認(rèn)抓去4層，在第三層的時(shí)候如果是List就無(wú)法完成映射）。

　　2、在多對(duì)多的查詢中，我們可以使用JPQL，也可以使用原生SQL，同時(shí)還可以使用動(dòng)態(tài)查詢，這里介紹多對(duì)多的動(dòng)態(tài)查詢，這里有一個(gè)條件比較苛刻，那就是查詢參數(shù)是關(guān)聯(lián)對(duì)象的屬性，一對(duì)多類似，多對(duì)一可以利用上面介紹的級(jí)聯(lián)獲取屬性的方式。這里介紹這種方式的目的是為了更好的利用以面向?qū)ο蟮姆绞竭M(jìn)行動(dòng)態(tài)查詢。

　　舉例：2張表，分別是Employee(id, name)和Company(id, name)，二者是多對(duì)多的關(guān)系，那么當(dāng)查詢Employee的時(shí)候，條件是更具公司名稱。那么做法如下：

@Overridepublic List<Employee> findByCompanyName(final String companyName) {List<Employee> employeeList = employeeRepository.findAll(new Specification<Employee>() {public Predicate toPredicate(Root<Employee> root, CriteriaQuery<?> query, CriteriaBuilder cb) { // ListJoin<Employee, Company> companyJoin = root.join(root.getModel().getList("companyList", Company.class), JoinType.LEFT);Join<Employee, Company> companyJoin = root.join("companyList", JoinType.LEFT);return cb.equal(companyJoin.get("name"), companyName);}});return employeeList;}

　　 ? 我們可以使用上面注釋掉的方式，也可以使用下面這種比較簡(jiǎn)單的方式。因?yàn)槲覀€(gè)人的習(xí)慣是盡量不去寫DAO的實(shí)現(xiàn)類，除非查詢特別復(fù)雜，萬(wàn)不得已的情況下采用，否則我個(gè)人比較偏向于這種方式。

　　上面的情況如果更為極端的話，關(guān)聯(lián)多個(gè)對(duì)象，可以按照下面的方式：

@Overridepublic List<Employee> findByCompanyName(final String companyName, final String wage) {List<Employee> employeeList = employeeRepository.findAll(new Specification<Employee>() {public Predicate toPredicate(Root<Employee> root, CriteriaQuery<?> query, CriteriaBuilder cb) { // ListJoin<Employee, Company> companyJoin = root.join(root.getModel().getList("companyList", Company.class), JoinType.LEFT);Join<Employee, Company> companyJoin = root.join("companySet", JoinType.LEFT);Join<Employee, Wage> wageJoin = root.join("wageSet", JoinType.LEFT);Predicate p1 = cb.equal(companyJoin.get("name"), companyName);Predicate p2 = cb.equal(wageJoin.get("name"), wage); // return cb.and(p1, p2);根據(jù)spring-data-jpa的源碼，可以返回一個(gè)Predicate，框架內(nèi)部會(huì)自動(dòng)做query.where(p)的操作，也可以直接在這里處理，然后返回null，/// 也就是下面一段源碼中的實(shí)現(xiàn) query.where(p1, p2);return null;}});return employeeList;}

　　

/*** Applies the given {@link Specification} to the given {@link CriteriaQuery}.* * @param spec can be {@literal null}.* @param query must not be {@literal null}.* @return*/private <S> Root<T> applySpecificationToCriteria(Specification<T> spec, CriteriaQuery<S> query) {Assert.notNull(query);Root<T> root = query.from(getDomainClass());if (spec == null) {return root;}CriteriaBuilder builder = em.getCriteriaBuilder();Predicate predicate = spec.toPredicate(root, query, builder);// 這里如果我們重寫的toPredicate方法的返回值predicate不為空，那么調(diào)用query.where(predicate)if (predicate != null) {query.where(predicate);}return root;}

?

說(shuō)明：雖然說(shuō)JPA中這種方式查詢會(huì)存在著多次級(jí)聯(lián)查詢的問(wèn)題，對(duì)性能有所影響，但是在一般的企業(yè)級(jí)應(yīng)用當(dāng)中，為了開發(fā)的便捷，這種性能犧牲一般來(lái)說(shuō)是可以接受的。

　　特別的：在一對(duì)多中或者多對(duì)一中，即便是fetch為eager，也會(huì)先查詢主對(duì)象，再查詢關(guān)聯(lián)對(duì)象，但是在eager的情況下雖然是有多次查詢問(wèn)題，但是沒(méi)有n+1問(wèn)題，關(guān)聯(lián)對(duì)象不會(huì)像n+1那樣多查詢n次，而僅僅是把關(guān)聯(lián)對(duì)象一次性查詢出來(lái)，因此，在企業(yè)級(jí)應(yīng)用當(dāng)中，訪問(wèn)量不大的情況下一般來(lái)說(shuō)沒(méi)什么問(wèn)題。

　　補(bǔ)充一段題外話，關(guān)于Hibernate/JPA/Spring-Data-Jpa與MyBatis的區(qū)別聯(lián)系，這種話題很多討論，對(duì)于Hibernate/JPA/Spring-Data-Jpa，我個(gè)人而言基本上能夠熟練使用，談不上精通，對(duì)于mybatis，由于深入閱讀過(guò)幾次它的源碼，對(duì)mybatis的設(shè)計(jì)思想以及細(xì)化到具體的方法，屬性，參數(shù)算是比較熟悉，也開發(fā)過(guò)一些mybatis的相關(guān)插件。對(duì)于這兩個(gè)持久化框架，總體來(lái)說(shuō)的區(qū)別是，Hibernate系列的門檻相對(duì)較高，配置比較多，相對(duì)來(lái)說(shuō)難度要大一些，主要體現(xiàn)在各種關(guān)系的問(wèn)題上，據(jù)我所知，很多人的理解其實(shí)并不深刻，很多時(shí)候甚至配置得有一定的問(wèn)題，但是優(yōu)勢(shì)也很明顯，SQL自動(dòng)生成，改數(shù)據(jù)庫(kù)表結(jié)構(gòu)僅僅需要調(diào)整幾個(gè)注解就行了，在熟練使用的基礎(chǔ)上相對(duì)來(lái)說(shuō)要便捷一點(diǎn)。對(duì)于mybatis來(lái)說(shuō)，門檻很低，真的很低，低到分分鐘就能入門的程度，我個(gè)人最喜歡也是mybatis最吸引人的地方就是靈活，特別的靈活，但是修改數(shù)據(jù)庫(kù)表結(jié)構(gòu)之后需要調(diào)整的地方比較多，但是利用目前比較優(yōu)秀的插件，對(duì)于單表操作也基本上能夠達(dá)到和Hibernate差不多的境界（會(huì)稍微犧牲一點(diǎn)點(diǎn)性能），多表的情況下就要麻煩一點(diǎn)。性能方面的比較，由于我沒(méi)做過(guò)測(cè)試，不太好比較，不過(guò)應(yīng)該mybatis要稍微高一些，畢竟他的查詢SQL可控一些（當(dāng)然Hibernate也支持原生sql，但是對(duì)結(jié)果集的處理不夠友好）。

　　之后更新：Root對(duì)象還有一批fetch方法，這個(gè)目前我很少用，后面有時(shí)間再來(lái)更新。

　　補(bǔ)充：單表分頁(yè)可以傳入分頁(yè)對(duì)象，比如findByName(String name, new pageRequest(0, 10));

轉(zhuǎn)載于:https://www.cnblogs.com/sandea/p/8257828.html

總結(jié)

以上是生活随笔為你收集整理的【原创】纯干货，Spring-data-jpa详解，全方位介绍。（转）的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問(wèn)題。

如果覺(jué)得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。