來源:http://blog.csdn.net/victor_cindy1/article/details/52206099
先介紹一個基於註解配置簡單的demo
-
package nd.sdp.lcreporting.config;
-
-
import org.springframework.beans.factory.annotation.Value;
-
import org.springframework.context.annotation.Bean;
-
import org.springframework.context.annotation.Configuration;
-
import org.springframework.context.annotation.PropertySource;
-
import org.springframework.data.jpa.repository.config.EnableJpaAuditing;
-
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
-
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
-
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
-
import org.springframework.orm.jpa.JpaTransactionManager;
-
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
-
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
-
import org.springframework.transaction.PlatformTransactionManager;
-
import org.springframework.transaction.annotation.EnableTransactionManagement;
-
-
import javax.sql.DataSource;
-
-
@Configuration
-
@PropertySource(value = {"classpath:c3p0.properties"})
-
@EnableJpaRepositories(
-
basePackages = {
-
"com.cn.repository.dhb"
-
},
-
entityManagerFactoryRef = "espEntityManagerFactory",
-
transactionManagerRef = "espTransactionManager"
-
)
-
@EnableTransactionManagement(proxyTargetClass = true)
-
@EnableJpaAuditing
-
public class EspMySQLConfig {
-
-
@Value("${esp.c3p0.url}")
-
private String c3p0Url;
-
@Value("${esp.c3p0.user}")
-
private String c3p0User;
-
@Value("${esp.c3p0.password}")
-
private String c3p0Password;
-
-
@Bean
-
PlatformTransactionManager espTransactionManager() {
-
return new JpaTransactionManager(espEntityManagerFactory().getObject());
-
}
-
-
@Bean
-
LocalContainerEntityManagerFactoryBean espEntityManagerFactory() {
-
HibernateJpaVendorAdapter jpaVendorAdapter = new HibernateJpaVendorAdapter();
-
jpaVendorAdapter.setGenerateDdl(false);
-
jpaVendorAdapter.setShowSql(true);
-
LocalContainerEntityManagerFactoryBean factoryBean = new LocalContainerEntityManagerFactoryBean();
-
factoryBean.setDataSource(espDataSource());
-
factoryBean.setJpaVendorAdapter(jpaVendorAdapter);
-
factoryBean.setPackagesToScan("com.cn.domain");
-
return factoryBean;
-
}
-
-
@Bean
-
DataSource espDataSource() {
-
C3P0DataSourceBuilder builder = new C3P0DataSourceBuilder();
-
return builder.build(c3p0Url, c3p0User, c3p0Password);
-
}
-
-
@Bean
-
DataSourceTransactionManager dataSourceTransactionManager() {
-
return new DataSourceTransactionManager(espDataSource());
-
}
-
-
@Bean
-
NamedParameterJdbcTemplate namedParameterJdbcTemplate() {
-
return new NamedParameterJdbcTemplate(espDataSource());
-
}
-
-
@Bean(name = "lcJdbcTemplate")
-
NamedParameterJdbcTemplate lcJdbcTemplate() {
-
return new NamedParameterJdbcTemplate(espDataSource());
-
}
-
}
Entity:
-
@Entity
-
public class Customer {
-
-
@Id
-
@GeneratedValue(strategy=GenerationType.AUTO)
-
private long id;
-
private String firstName;
-
private String lastName;
-
-
private Customer() {}
-
-
public Customer(String firstName, String lastName) {
-
this.firstName = firstName;
-
this.lastName = lastName;
-
}
-
-
@Override
-
public String toString() {
-
return String.format(
-
"Customer[id=%d, firstName='%s', lastName='%s']",
-
id, firstName, lastName);
-
}
-
-
}
@Entity:說明該類是一個jpa entity,如果缺少@Table註解則默認匹配表Customer
@Id:jpa通過它定義識別對象Id,使用註解@GeneratedValue讓id自動增長
CustomerRepository.java是jpa用來存儲Customer對象的倉庫。
-
@Repository
-
public interface CustomerRepository extends JpaRepository<Customer, Long> {
-
-
List<Customer> findByLastName(String lastName);
-
-
}
@EnableJpaRepositories:告訴JPA找到繼承了repository的接口,併爲它創建相應的實現類,JpaRepository也繼承了repository。
DataSource:聲明一個存儲對象的數據庫
LocalContainerEntityManagerFactoryBean:對象的操作類,通過lef.setPackagesToScan("hello");避免了創建 persistence.xml ,它告訴JPA到hello包下面找bean類
JpaVendorAdapter:爲LocalContainerEntityManagerFactoryBean定義了基於hibernate的JPA適配器
PlatformTransactionManager:用於處理事務持久化
以下是基於xml配置:
1、Spring-data-jpa的基本介紹:JPA誕生的緣由是爲了整合第三方ORM框架,建立一種標準的方式,百度百科說是JDK爲了實現ORM的天下歸一,目前也是在按照這個方向發展,但是還沒能完全實現。在ORM框架中,Hibernate是一支很大的部隊,使用很廣泛,也很方便,能力也很強,同時Hibernate也是和JPA整合的比較良好,我們可以認爲JPA是標準,事實上也是,JPA幾乎都是接口,實現都是Hibernate在做,宏觀上面看,在JPA的統一之下Hibernate很良好的運行。
上面闡述了JPA和Hibernate的關係,那麼Spring-data-jpa又是個什麼東西呢?這地方需要稍微解釋一下,我們做Java開發的都知道Spring的強大,到目前爲止,企業級應用Spring幾乎是無所不能,無所不在,已經是事實上的標準了,企業級應用不使用Spring的幾乎沒有,這樣說沒錯吧。而Spring整合第三方框架的能力又很強,他要做的不僅僅是個最早的IOC容器這麼簡單一回事,現在Spring涉及的方面太廣,主要是體現在和第三方工具的整合上。而在與第三方整合這方面,Spring做了持久化這一塊的工作,我個人的感覺是Spring希望把持久化這塊內容也拿下。於是就有了Spring-data-**這一系列包。包括,Spring-data-jpa,Spring-data-template,Spring-data-mongodb,Spring-data-redis,還有個民間產品,mybatis-spring,和前面類似,這是和mybatis整合的第三方包,這些都是乾的持久化工具乾的事兒。
這裏介紹Spring-data-jpa,表示與jpa的整合。
2、我們都知道,在使用持久化工具的時候,一般都有一個對象來操作數據庫,在原生的Hibernate中叫做Session,在JPA中叫做EntityManager,在MyBatis中叫做SqlSession,通過這個對象來操作數據庫。我們一般按照三層結構來看的話,Service層做業務邏輯處理,Dao層和數據庫打交道,在Dao中,就存在着上面的對象。那麼ORM框架本身提供的功能有什麼呢?答案是基本的CRUD,所有的基礎CRUD框架都提供,我們使用起來感覺很方便,很給力,業務邏輯層面的處理ORM是沒有提供的,如果使用原生的框架,業務邏輯代碼我們一般會自定義,會自己去寫SQL語句,然後執行。在這個時候,Spring-data-jpa的威力就體現出來了,ORM提供的能力他都提供,ORM框架沒有提供的業務邏輯功能Spring-data-jpa也提供,全方位的解決用戶的需求。使用Spring-data-jpa進行開發的過程中,常用的功能,我們幾乎不需要寫一條sql語句,至少在我看來,企業級應用基本上可以不用寫任何一條sql,當然spring-data-jpa也提供自己寫sql的方式,這個就看個人怎麼選擇,都可以。我覺得都行。
2.1與Spring整合我們從spring配置文件開始,爲了節省篇幅,這裏我只寫出配置文件的結構。
2.2對上面的配置文件進行簡單的解釋,只對“實體管理器”和“dao”進行解釋,其他的配置在任何地方都差不太多。
1.對“實體管理器”解釋:我們知道原生的jpa的配置信息是必須放在META-INF目錄下面的,並且名字必須叫做persistence.xml,這個叫做persistence-unit,就叫做持久化單元,放在這下面我們感覺不方便,不好,於是Spring提供了
-
org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean
這樣一個類,可以讓你的隨心所欲的起這個配置文件的名字,也可以隨心所欲的修改這個文件的位置,只需要在這裏指向這個位置就行。然而更加方便的做法是,直接把配置信息就寫在這裏更好,於是就有了這實體管理器這個bean。使用
-
<property name="packagesToScan" value="your entity package" />
這個屬性來加載我們的entity。
2.3 解釋“dao”這個bean。這裏衍生一下,進行一下名詞解釋,我們知道dao這個層叫做Data Access Object,數據庫訪問對象,這是一個廣泛的詞語,在jpa當中,我們還有一個詞語叫做Repository,這裏我們一般就用Repository結尾來表示這個dao,比如UserDao,這裏我們使用UserRepository,當然名字無所謂,隨意取,你可以意會一下我的意思,感受一下這裏的含義和區別,同理,在mybatis中我們一般也不叫dao,mybatis由於使用xml映射文件(當然也提供註解,但是官方文檔上面表示在有些地方,比如多表的複雜查詢方面,註解還是無解,只能xml),我們一般使用mapper結尾,比如我們也不叫UserDao,而叫UserMapper。
上面拓展了一下關於dao的解釋,那麼這裏的這個配置信息是什麼意思呢?首先base-package屬性,代表你的Repository接口的位置,repository-impl-postfix屬性代表接口的實現類的後綴結尾字符,比如我們的UserRepository,那麼他的實現類就叫做UserRepositoryImpl,和我們平時的使用習慣完全一致,於此同時,spring-data-jpa的習慣是接口和實現類都需要放在同一個包裏面(不知道有沒有其他方式能分開放,這不是重點,放在一起也無所謂,影響不大),再次的,這裏我們的UserRepositoryImpl這個類的定義的時候我們不需要去指定實現UserRepository接口,根據spring-data-jpa自動就能判斷二者的關係。
比如:我們的UserRepository和UserRepositoryImpl這兩個類就像下面這樣來寫。
-
public interface UserRepository extends JpaRepository<User, Integer>{}
-
public class UserRepositoryImpl {}
那麼這裏爲什麼要這麼做呢?原因是:spring-data-jpa提供基礎的CRUD工作,同時也提供業務邏輯的功能(前面說了,這是該框架的威力所在),所以我們的Repository接口要做兩項工作,繼承spring-data-jpa提供的基礎CRUD功能的接口,比如JpaRepository接口,同時自己還需要在UserRepository這個接口中定義自己的方法,那麼導致的結局就是UserRepository這個接口中有很多的方法,那麼如果我們的UserRepositoryImpl實現了UserRepository接口,導致的後果就是我們勢必需要重寫裏面的所有方法,這是Java語法的規定,如此一來,悲劇就產生了,UserRepositoryImpl裏面我們有很多的@Override方法,這顯然是不行的,結論就是,這裏我們不用去寫implements部分。
spring-data-jpa實現了上面的能力,那他是怎麼實現的呢?這裏我們通過源代碼的方式來呈現他的來龍去脈,這個過程中cglib發揮了傑出的作用。
在spring-data-jpa內部,有一個類,叫做
-
public class SimpleJpaRepository<T, ID extends Serializable> implements JpaRepository<T, ID>,
-
JpaSpecificationExecutor<T>
我們可以看到這個類是實現了JpaRepository接口的,事實上如果我們按照上面的配置,在同一個包下面有UserRepository,但是沒有UserRepositoryImpl這個類的話,在運行時期UserRepository這個接口的實現就是上面的SimpleJpaRepository這個接口。而如果有UserRepositoryImpl這個文件的話,那麼UserRepository的實現類就是UserRepositoryImpl,而UserRepositoryImpl這個類又是SimpleJpaRepository的子類,如此一來就很好的解決了上面的這個不用寫implements的問題。我們通過閱讀這個類的源代碼可以發現,裏面包裝了entityManager,底層的調用關係還是entityManager在進行CRUD。
-
@Entity
-
@Table(name = "user")
-
public class User {
-
@Id
-
@GeneratedValue(strategy = GenerationType.IDENTITY)
-
private Integer id;
-
private String name;
-
private String password;
-
private String birthday;
-
-
}
UserRepository接口
-
public interface UserRepository extends JpaRepository<User, Integer>{}
通過上面3步,所有的工作就做完了,User的基礎CRUD都能做了,簡約而不簡單。
我們的測試類UserRepositoryTest
-
public class UserRepositoryTest {
-
-
@Autowired
-
private UserRepository userRepository;
-
-
@Test
-
public void baseTest() throws Exception {
-
User user = new User();
-
user.setName("Jay");
-
user.setPassword("123456");
-
user.setBirthday("2008-08-08");
-
userRepository.save(user);
-
-
-
}
-
}
測試通過。
說到這裏,和spring已經完成。接下來第三點,基本使用
4.前面把基礎的東西說清楚了,接下來就是spring-data-jpa的正餐了,真正威力的地方。
4.1 我們的系統中一般都會有用戶登錄這個接口,在不使用spring-data-jpa的時候我們怎麼做,首先在service層定義一個登錄方法。如:
-
User login(String name, String password);
然後在serviceImpl中寫該方法的實現,大致這樣:
-
@Override
-
public User login(String name, String password) {
-
return userDao.login(name, password);
-
}
接下來,UserDao大概是這麼個樣子:
-
User getUserByNameAndPassword(String name, String password);
然後在UserDaoImpl中大概是這麼個樣子:
-
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,這個代碼運行良好,那麼這樣子大概有十來行代碼,我們感覺這個功能實現了,很不錯。然而這樣子真正簡捷麼?如果這樣子就滿足了,那麼spring-data-jpa就沒有必要存在了,前面提到spring-data-jpa能夠幫助你完成業務邏輯代碼的處理,那他是怎麼處理的呢?這裏我們根本不需要UserDaoImpl這個類,只需要在UserRepository接口中定義一個方法
-
User findByNameAndPassword(String name, String password);
然後在service中調用這個方法就完事了,所有的邏輯只需要這麼一行代碼,一個沒有實現的接口方法。通過debug信息,我們看到輸出的sql語句是
-
select * from user where name = ? and password = ?
跟上面的傳統方式一模一樣的結果。這簡單到令人髮指的程度,那麼這一能力是如何實現的呢?原理是:spring-data-jpa會根據方法的名字來自動生成sql語句,我們只需要按照方法定義的規則即可,上面的方法findByNameAndPassword,spring-data-jpa規定,方法都以findBy開頭,sql的where部分就是NameAndPassword,被spring-data-jpa翻譯之後就編程了下面這種形態:
where name = ? and password = ?
接下來:就是比較複雜的操作了,比如動態查詢,分頁,下面詳細介紹spring-data-jpa的第二大殺手鐗,強大的動態查詢能力。
在上面的介紹中,對於我們傳統的企業級應用的基本操作已經能夠基本上全部實現,企業級應用一般都會有一個模糊查詢的功能,並且是多條的查詢,在有查詢條件的時候我們需要在where後面接上一個 xxx = yyy 或者 xxx like '% + yyy + %'類似這樣的sql。那麼我們傳統的JDBC的做法是使用很多的if語句根據傳過來的查詢條件來拼sql,mybatis的做法也類似,由於mybatis有強大的動態xml文件的標籤,在處理這種問題的時候顯得非常的好,但是二者的原理都一致,那spring-data-jpa的原理也同樣很類似,這個道理也就說明了解決多表關聯動態查詢根兒上也就是這麼回事。
那麼spring-data-jpa的做法是怎麼的呢?有兩種方式。可以選擇其中一種,也可以結合使用,在一般的查詢中使用其中一種就夠了,就是第二種,但是有一類查詢比較棘手,比如報表相關的,報表查詢由於涉及的表很多,這些表不一定就是兩兩之間有關係,比如字典表,就很獨立,在這種情況之下,使用拼接sql的方式要容易一些。下面分別介紹這兩種方式。
a.使用JPQL,和Hibernate的HQL很類似。
前面說道了在UserRepository接口的同一個包下面建立一個普通類UserRepositoryImpl來表示該類的實現類,同時前面也介紹了完全不需要這個類的存在,但是如果使用JPQL的方式就必須要有這個類。如下:
-
public class StudentRepositoryImpl {
-
-
@PersistenceContext
-
private 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;
-
}
-
-
}
通過上面的方法,我們查詢並且封裝了一個User對象的分頁信息。代碼能夠良好的運行。這種做法也是我們傳統的經典做法。那麼spring-data-jpa還有另外一種更好的方式,那就是所謂的類型檢查的方式,上面我們的sql是字符串,沒有進行類型檢查,而下面的方式就使用了類型檢查的方式。這個道理在mybatis中也有體現,mybatis可以使用字符串sql的方式,也可以使用接口的方式,而mybatis的官方推薦使用接口方式,因爲有類型檢查,會更安全。
b.使用JPA的動態接口
-
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);
-
}
上面說了,使用這種方式我們壓根兒就不需要UserRepositoryImpl這個類,說到這裏,彷彿我們就發現了spring-data-jpa爲什麼把Repository和RepositoryImpl文件放在同一個包下面,因爲我們的應用很可能根本就一個Impl文件都不存在,那麼在那個包下面就只有一堆接口,即使把Repository和RepositoryImpl都放在同一個包下面,也不會造成這個包下面有正常情況下2倍那麼多的文件,根本原因:只有接口而沒有實現類。
上面我們的UserRepository類繼承了JpaRepository和JpaSpecificationExecutor類,而我們的UserRepository這個對象都會注入到UserService裏面,於是如果使用這種方式,我們的邏輯直接就寫在service裏面了,下面的代碼:一個學生Student類,一個班級Clazz類,Student裏面有一個對象Clazz,在數據庫中是clazz_id,這是典型的多對一的關係。我們在配置好entity裏面的關係之後。就可以在StudentServiceImpl類中做Student的模糊查詢,典型的前端grid的模糊查詢。代碼是這樣子的:
-
@Service
-
public class StudentServiceImpl extends BaseServiceImpl<Student> implements StudentService {
-
-
@Autowired
-
private StudentRepository studentRepository;
-
-
@Override
-
public Student login(Student student) {
-
return studentRepository.findByNameAndPassword(student.getName(), student.getPassword());
-
}
-
-
@Override
-
public Page<Student> search(final Student student, PageInfo page) {
-
return studentRepository.findAll(new Specification<Student>() {
-
@Override
-
public Predicate toPredicate(Root<Student> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
-
-
Predicate stuNameLike = null;
-
if(null != student && !StringUtils.isEmpty(student.getName())) {
-
-
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())));
-
}
-
}
先解釋下這裏的意思,然後我們在結合框架的源碼來深入分析。
這裏我們是2個表關聯查詢,查詢條件包括Student表和Clazz表,類似的2個以上的表方式差不多,但是正如上面所說,這種做法適合所有的表都是兩兩能夠關聯上的,涉及的表太多,或者是有一些字典表,那就使用sql拼接的方式,簡單一些。
先簡單解釋一下代碼的含義,然後結合框架源碼來詳細分析。兩個Predicate對象,Predicate按照中文意思是判斷,斷言的意思,那麼放在我們的sql中就是where後面的東西,比如
name like '% + jay + %';
下面的PageRequest代表分頁信息,PageRequest裏面的Sort對象是排序信息。上面的代碼事實上是在動態的組合最終的sql語句,這裏使用了一個策略模式,或者callback,就是
studentRepository.findAll(一個接口)
第一步就需要構建出這個參數CriteriaQuery類型的參數,這裏使用建造者模式,
-
CriteriaBuilder builder = em.getCriteriaBuilder();
-
CriteriaQuery<Student> query = builder.createQuery(Student.class);
接下來:
-
Root<Student> root = query.from(Student.class);
在這裏,我們看方法名from,意思是獲取Student的Root,其實也就是個Student的包裝對象,就代表這條sql語句裏面的主體。接下來:
-
Predicate p1 = builder.like(root.<String> get("name"), "%" + student.getName() + "%");
-
Predicate p2 = builder.equal(root.<String> get("password"), student.getPassword());
Predicate是判斷的意思,放在sql語句中就是where後面 xxx = yyy, xxx like yyy這種,也就是查詢條件,這裏構造了2個查詢條件,分別是根據student的name屬性進行like查詢和根據student的password進行“=”查詢,在sql中就是
name like = ? and password = ?
這種形式,接下來
query.where(p1, p2);
這樣子一個完整的動態查詢就構建完成了,接下來調用getSingleResult或者getResultList返回結果,這裏jpa的單個查詢如果爲空的話會報異常,這點感覺框架設計的不好,如果查詢爲空直接返回一個null或者一個空的List更好一點。
這是jpa原生的動態查詢方式,過程大致就是,創建builder => 創建Query => 構造條件 => 查詢。這麼4個步驟,這裏代碼運行良好,如果不使用spring-data-jpa,我們就需要這麼來做,但是spring-data-jpa幫我們做得更爲徹底,從上面的4個步驟中,我們發現:所有的查詢除了第三步不一樣,其他幾步都是一模一樣的,不使用spring-data-jpa的情況下,我們要麼4步驟寫完,要麼自己寫個工具類,封裝一下,這裏spring-data-jpa就是幫我們完成的這樣一個動作,那就是在JpaSpecification<T>這個接口中的
Page<T> findAll(Specification<T> spec, Pageable pageable);
這個方法,前面說了,這是個策略模式,參數spec是個接口,前面也說了框架內部對於這個接口有默認的實現類
-
@Repository
-
@Transactional(readOnly = true)
-
public class SimpleJpaRepository<T, ID extends Serializable> implements JpaRepository<T, ID>,
-
JpaSpecificationExecutor<T> {
-
-
}
我們的Repository接口就是繼承這個接口,而通過cglib的RepositoryImpl的代理類也是這個類的子類,默認也就實現了該方法。這個方法的方法體是這樣的:
-
-
-
-
-
public T findOne(Specification<T> spec) {
-
-
try {
-
return getQuery(spec, (Sort) null).getSingleResult();
-
} catch (NoResultException e) {
-
return null;
-
}
-
}
這裏的
getQuery(spec, (Sort) null)
返回類型是
TypedQuery<T>
進入這個getQuery方法:
-
-
-
-
-
-
-
-
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));
-
}
一切玄機盡收眼底,這個方法的內容和我們前面使用原生jpa的api的過程是一樣的,而再進入
Root<T> root = applySpecificationToCriteria(spec, query);
這個方法:
-
-
-
-
-
-
-
-
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;
-
}
我們可以發現spec參數調用了toPredicate方法,也就是我們前面service裏面匿名內部類的實現。
到這裏spring-data-jpa的默認實現已經完全明瞭。總結一下使用動態查詢:前面說的原生api需要4步,而使用spring-data-jpa只需要一步,那就是重寫匿名內部類的toPredicate方法。在重複一下上面的Student和Clazz的查詢代碼,
-
@Override
-
public Page<Student> search(final Student student, PageInfo page) {
-
return studentRepository.findAll(new Specification<Student>() {
-
@Override
-
public Predicate toPredicate(Root<Student> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
-
-
Predicate stuNameLike = null;
-
if(null != student && !StringUtils.isEmpty(student.getName())) {
-
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())));
-
}
到這裏位置,spring-data-jpa的介紹基本上就完成了,涵蓋了該框架使用的方方面面。接下來還有一塊比較實用的東西,我們看到上面第15行位置的條件查詢,這裏使用了一個多級的get,這個是spring-data-jpa支持的,就是嵌套對象的屬性,這種做法一般我們叫方法的級聯調用,就是調用的時候返回自己本身,這個在處理xml的工具中比較常見,主要是爲了代碼的美觀作用,沒什麼其他的用途。