javascript
Spring Data JPA入门
見：http://sishuok.com/forum/blogPost/list/7000.html
Spring Data是什么
Spring Data是一個用于簡化數據庫訪問，并支持云服務的開源框架。其主要目標是使得對數據的訪問變得方便快捷，并支持map-reduce框架和云計算數據服務。 Spring Data 包含多個子項目：
Commons - 提供共享的基礎框架，適合各個子項目使用，支持跨數據庫持久化
JPA - 簡化創建 JPA 數據訪問層和跨存儲的持久層功能
Hadoop - 基于 Spring 的 Hadoop 作業配置和一個 POJO 編程模型的 MapReduce 作業
Key-Value? - 集成了 Redis 和 Riak ，提供多個常用場景下的簡單封裝
Document - 集成文檔數據庫：CouchDB 和 MongoDB 并提供基本的配置映射和資料庫支持
Graph - 集成 Neo4j 提供強大的基于 POJO 的編程模型
Graph Roo AddOn - Roo support for Neo4j
JDBC Extensions - 支持 Oracle RAD、高級隊列和高級數據類型
Mapping - 基于 Grails 的提供對象映射框架，支持不同的數據庫
Examples - 示例程序、文檔和圖數據庫
Guidance - 高級文檔
Spring Data JPA是什么
由Spring提供的一個用于簡化JPA開發的框架
nSpring Data JPA能干什么
可以極大的簡化JPA的寫法，可以在幾乎不用寫實現的情況下，實現對數據的訪問和操作。除了CRUD外，還包括如分頁、排序等一些常用的功能。
Spring Data JPA有什么
主要來看看Spring Data JPA提供的接口，也是Spring Data JPA的核心概念：
1：Repository：最頂層的接口，是一個空的接口，目的是為了統一所有Repository的類型，且能讓組件掃描的時候自動識別。
2：CrudRepository ：是Repository的子接口，提供CRUD的功能
3：PagingAndSortingRepository：是CrudRepository的子接口，添加分頁和排序的功能
4：JpaRepository：是PagingAndSortingRepository的子接口，增加了一些實用的功能，比如：批量操作等。
5：JpaSpecificationExecutor：用來做負責查詢的接口
6：Specification：是Spring Data JPA提供的一個查詢規范，要做復雜的查詢，只需圍繞這個規范來設置查詢條件即可
?
HelloWorld
n環境構建
在Eclipse里面構建一個普通的Java工程，主要就是要加入一堆的jar包。
1：首先去官網下載Spring Data Common 和 Spring Data JPA的包，把里面dist的jar包加入到工程中，這里是spring-data-commons-1.5.0.RELEASE.jar和spring-data-jpa-1.3.2.RELEASE.jar
2：把Spring3.2.3的jar包添加到工程中
3：JPA的實現選用的是Hibernate4.2.0，總共還需要額外加入如下的jar：
antlr-2.7.7.jar、aopalliance-1.0.jar、asm-3.2.jar、aspectjrt-1.7.1.jar、aspectjweaver-1.7.1.jar、commons-beanutils-1.8.3.jar、commons-codec-1.7.jar、commons-collections-3.2.1.jar、commons-dbcp-1.4.jar、commons-fileupload-1.2.2.jar、commons-io-2.4.jar、commons-lang3-3.1.jar、commons-logging-1.1.1.jar、commons-pool-1.6.jar、dom4j-1.6.1.jar、hibernate-commons-annotations-4.0.1.Final.jar、hibernate-core-4.2.0.Final.jar、hibernate-entitymanager-4.2.0.Final.jar、hibernate-jpa-2.0-api-1.0.1.Final.jar、javassist-3.15.0-GA.jar、jboss-logging-3.1.0.GA.jar、jboss-transaction-api_1.1_spec-1.0.0.Final.jar、mysql-connector-java-5.1.9.jar、slf4j-api-1.7.3.jar
n實體對象，就是以前的實現方式
@Entity
@Table(name="tbl_user")
public class UserModel {
@Id
private Integer uuid;
private String name;
private Integer age;
//省略getter/setter
}
nDAO的接口
public interface UserRepository extends JpaRepository<UserModel, Integer>{
//空的，可以什么都不用寫
}
無需提供實現，Spring Data JPA會為我們搞定一切
n寫個邏輯層的Service，其實就相當于DAO的客戶端，用來測試
@Service
@Transactional
public class Client {
@Autowired
private UserRepository ur;
?
public void testAdd(UserModel um){ ur.save(um); }
?
public static void main(String[] args) {
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
?
Client c = (Client)ctx.getBean("client");
UserModel um = new UserModel();
um.setAge(1);
um.setName("張三");
um.setUuid(1);
?
c.testAdd(um);
} }
n同樣需要在Spring的配置文件中配置，基本跟使用注解的配置類似：
<?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:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
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.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa.xsd
">
<context:component-scan base-package="cn.javass">
<context:exclude-filter type="annotation“ expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
<aop:aspectj-autoproxy proxy-target-class="true"/>
<!-- 開啟注解事務 只對當前配置文件有效 -->
<tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true"/>
? ??<jpa:repositories
??????????? base-package="cn.javass"
??????????? repository-impl-postfix="Impl"
??????????? entity-manager-factory-ref="entityManagerFactory"
??????????? transaction-manager-ref="transactionManager">
??? </jpa:repositories>???
?????<bean id="entityManagerFactory"
????????? class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
??????? <property name="dataSource" ref="dataSource"/>
??????? <property name="packagesToScan" value="cn.javass"/>
??????? <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>
<!--事務管理器配置-->
??? <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
??????? <property name="entityManagerFactory" ref="entityManagerFactory"/>
??? </bean>
?
<bean name="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName"><value>org.gjt.mm.mysql.Driver</value></property>
<property name="url"><value>jdbc:mysql://localhost:3306/cc?useUnicode=true&characterEncoding=UTF-8</value></property>
<property name="username"> <value>root</value> </property>
<property name="password" value="cc"/>
</bean>
</beans>
?
配置完成后，可以去運行Client測試一下了，當然數據庫和表需要先準備好
也可以在<jpa:repositories>下面添加filter，形如：
<repositories base-package="com.acme.repositories">
<context:exclude-filter type="regex" expression=".*SomeRepository" />
</repositories>
?
?
第二章：JpaRepository基本功能
JpaRepository的基本功能示范
具體的看代碼演示
其中：Pageable接口的實現類是PageRequest，Page接口的實現類是PageImpl。
示例如下：
Page<UserModel> p =? ur.findAll(new PageRequest(0,2,new Sort(new Order(Direction.?DESC,"uuid"))));
System.?out.println("list="+p.getContent());
?
?
第三章：JpaRepository的查詢
直接在接口中定義查詢方法，如果是符合規范的，可以不用寫實現，目前支持的關鍵字寫法如下：
?
?
??
Spring Data JPA框架在進行方法名解析時，會先把方法名多余的前綴截取掉，比如 find、findBy、read、readBy、get、getBy，然后對剩下部分進行解析。
假如創建如下的查詢：findByUserDepUuid()，框架在解析該方法時，首先剔除 findBy，然后對剩下的屬性進行解析，假設查詢實體為Doc
1：先判斷 userDepUuid （根據 POJO 規范，首字母變為小寫）是否為查詢實體的一個屬性，如果是，則表示根據該屬性進行查詢；如果沒有該屬性，繼續第二步；
2：從右往左截取第一個大寫字母開頭的字符串此處為Uuid），然后檢查剩下的字符串是否為查詢實體的一個屬性，如果是，則表示根據該屬性進行查詢；如果沒有該屬性，則重復第二步，繼續從右往左截取；最后假設user為查詢實體的一個屬性；
3：接著處理剩下部分（DepUuid），先判斷 user 所對應的類型是否有depUuid屬性，如果有，則表示該方法最終是根據 “ Doc.user.depUuid” 的取值進行查詢；否則繼續按照步驟 2 的規則從右往左截取，最終表示根據 “Doc.user.dep.uuid” 的值進行查詢。
4:可能會存在一種特殊情況，比如 Doc包含一個 user 的屬性，也有一個 userDep 屬性，此時會存在混淆。可以明確在屬性之間加上 "_" 以顯式表達意圖，比如 "findByUser_DepUuid()" 或者 "findByUserDep_uuid()"
特殊的參數： 還可以直接在方法的參數上加入分頁或排序的參數，比如：
Page<UserModel> findByName(String name, Pageable pageable);
List<UserModel> findByName(String name, Sort sort);
?
也可以使用JPA的NamedQueries，方法如下：
1：在實體類上使用@NamedQuery，示例如下：
@NamedQuery(name = "UserModel.findByAge",query = "select o from UserModel o where o.age >= ?1")
2：在自己實現的DAO的Repository接口里面定義一個同名的方法，示例如下：
public List<UserModel> findByAge(int age);
3：然后就可以使用了，Spring會先找是否有同名的NamedQuery，如果有，那么就不會按照接口定義的方法來解析。
?
使用@Query
可以在自定義的查詢方法上使用@Query來指定該方法要執行的查詢語句，比如：
@Query("select o from UserModel o where o.uuid=?1")
public List<UserModel> findByUuidOrAge(int uuid);
注意：
1：方法的參數個數必須和@Query里面需要的參數個數一致
2：如果是like，后面的參數需要前面或者后面加“%”，比如下面都對：
@Query("select o from UserModel o where o.name like ?1%")
public List<UserModel> findByUuidOrAge(String name);
?
@Query("select o from UserModel o where o.name like %?1")
public List<UserModel> findByUuidOrAge(String name);
?
@Query("select o from UserModel o where o.name like %?1%")
public List<UserModel> findByUuidOrAge(String name);
?
當然，這樣在傳遞參數值的時候就可以不加‘%’了，當然加了也不會錯
?
n還可以使用@Query來指定本地查詢，只要設置nativeQuery為true，比如：
@Query(value="select * from tbl_user where name like %?1" ,nativeQuery=true)
public List<UserModel> findByUuidOrAge(String name);
注意：當前版本的本地查詢不支持翻頁和動態的排序
?
使用命名化參數，使用@Param即可，比如：
@Query(value="select o from UserModel o where o.name like %:nn")
public List<UserModel> findByUuidOrAge(@Param("nn") String name);
同樣支持更新類的Query語句，添加@Modifying即可，比如：
@Modifying
@Query(value="update UserModel o set o.name=:newName where o.name like %:nn")
public int findByUuidOrAge(@Param("nn") String name,@Param("newName") String newName);
注意：
1：方法的返回值應該是int，表示更新語句所影響的行數
2：在調用的地方必須加事務，沒有事務不能正常執行
?
JpaRepository的查詢功能
創建查詢的順序
Spring Data JPA 在為接口創建代理對象時，如果發現同時存在多種上述情況可用，它該優先采用哪種策略呢？
<jpa:repositories> 提供了 query-lookup-strategy 屬性，用以指定查找的順序。它有如下三個取值：
1：create-if-not-found：如果方法通過@Query指定了查詢語句，則使用該語句實現查詢；如果沒有，則查找是否定義了符合條件的命名查詢，如果找到，則使用該命名查詢；如果兩者都沒有找到，則通過解析方法名字來創建查詢。這是 query-lookup-strategy 屬性的默認值
2：create：通過解析方法名字來創建查詢。即使有符合的命名查詢，或者方法通過 @Query指定的查詢語句，都將會被忽略
3：use-declared-query：如果方法通過@Query指定了查詢語句，則使用該語句實現查詢；如果沒有，則查找是否定義了符合條件的命名查詢，如果找到，則使用該命名查詢；如果兩者都沒有找到，則拋出異常
?
第四章：客戶化擴展JpaRepository
如果你不想暴露那么多的方法，可以自己訂制自己的Repository，還可以在自己的Repository里面添加自己使用的公共方法
當然更靈活的是自己寫一個實現類，來實現自己需要的方法
1：寫一個與接口同名的類，加上后綴為Impl，這個在前面xml里面配置過，可以自動被掃描到。這個類不需要實現任何接口。
2：在接口中加入自己需要的方法，比如：
public Page<Object[]> getByCondition(UserQueryModel u);
3：在實現類中，去實現這個方法就好了，會被自動找到
java代碼：
查看復制到剪貼板打印
?
第五章：Specifications查詢
Spring Data JPA支持JPA2.0的Criteria查詢，相應的接口是JpaSpecificationExecutor。
Criteria 查詢：是一種類型安全和更面向對象的查詢
?
這個接口基本是圍繞著Specification接口來定義的， Specification接口中只定義了如下一個方法：
Predicate toPredicate(Root<T> root, CriteriaQuery<?> query, CriteriaBuilder cb);
?
要理解這個方法，以及正確的使用它，就需要對JPA2.0的Criteria查詢有一個足夠的熟悉和理解，因為這個方法的參數和返回值都是JPA標準里面定義的對象。
?
Criteria查詢基本概念
Criteria 查詢是以元模型的概念為基礎的，元模型是為具體持久化單元的受管實體定義的，這些實體可以是實體類，嵌入類或者映射的父類。
CriteriaQuery接口：代表一個specific的頂層查詢對象，它包含著查詢的各個部分，比如：select 、from、where、group by、order by等
注意：CriteriaQuery對象只對實體類型或嵌入式類型的Criteria查詢起作用
Root接口：代表Criteria查詢的根對象，Criteria查詢的查詢根定義了實體類型，能為將來導航獲得想要的結果，它與SQL查詢中的FROM子句類似
1：Root實例是類型化的，且定義了查詢的FROM子句中能夠出現的類型。
2：查詢根實例能通過傳入一個實體類型給?AbstractQuery.from方法獲得。
3：Criteria查詢，可以有多個查詢根。?
4：AbstractQuery是CriteriaQuery?接口的父類，它提供得到查詢根的方法。
CriteriaBuilder接口：用來構建CritiaQuery的構建器對象
Predicate：一個簡單或復雜的謂詞類型，其實就相當于條件或者是條件組合。
?
Criteria查詢
基本對象的構建
1：通過EntityManager的getCriteriaBuilder或EntityManagerFactory的getCriteriaBuilder方法可以得到CriteriaBuilder對象
2：通過調用CriteriaBuilder的createQuery或createTupleQuery方法可以獲得CriteriaQuery的實例
3：通過調用CriteriaQuery的from方法可以獲得Root實例
過濾條件
1：過濾條件會被應用到SQL語句的FROM子句中。在criteria?查詢中，查詢條件通過Predicate或Expression實例應用到CriteriaQuery對象上。
2：這些條件使用?CriteriaQuery .where?方法應用到CriteriaQuery?對象上
3：CriteriaBuilder也作為Predicate實例的工廠，通過調用CriteriaBuilder?的條件方法（?equal，notEqual，?gt，?ge，lt，?le，between，like等）創建Predicate對象。
4：復合的Predicate?語句可以使用CriteriaBuilder的and,?or?andnot?方法構建。
?
構建簡單的Predicate示例：
Predicate p1=cb.like(root.get(“name”).as(String.class), “%”+uqm.getName()+“%”);
Predicate p2=cb.equal(root.get("uuid").as(Integer.class), uqm.getUuid());
Predicate p3=cb.gt(root.get("age").as(Integer.class), uqm.getAge());
構建組合的Predicate示例：
Predicate p = cb.and(p3,cb.or(p1,p2));
?
當然也可以形如前面動態拼接查詢語句的方式，比如：
java代碼：
查看復制到剪貼板打印
?
也可以使用CriteriaQuery來得到最后的Predicate，示例如下：
??
java代碼：
查看復制到剪貼板打印
多表聯接
n多表連接查詢稍微麻煩一些，下面演示一下常見的1:M，順帶演示一下1:1
n使用Criteria查詢實現1對多的查詢
1：首先要添加一個實體對象DepModel，并設置好UserModel和它的1對多關系，如下：
@Entity
@Table(name="tbl_user")
public class UserModel {
@Id
private Integer uuid;
private String name;
private Integer age;
@OneToMany(mappedBy = "um", fetch = FetchType.?LAZY, cascade = {CascadeType.?ALL})
private Set<DepModel> setDep;
//省略getter/setter
}
?
@Entity
@Table(name="tbl_dep")
public class DepModel {
@Id
private Integer uuid;
private String name;
@ManyToOne()
? @JoinColumn(name = "user_id", nullable = false)
//表示在tbl_dep里面有user_id的字段
private UserModel um = new UserModel();
//省略getter/setter
}
?
2：配置好Model及其關系后，就可以在構建Specification的時候使用了，示例如下：
Specification<UserModel> spec = new Specification<UserModel>() {
public Predicate toPredicate(Root<UserModel> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
Predicate p1 = cb.like(root.get("name").as(String.class), "%"+um.getName()+"%");
Predicate p2 = cb.equal(root.get("uuid").as(Integer.class), um.getUuid());
Predicate p3 = cb.gt(root.get("age").as(Integer.class), um.getAge());
SetJoin<UserModel,DepModel> depJoin =?root.join(root.getModel().getSet("setDep",DepModel.class) , JoinType.LEFT);
?
Predicate p4 = cb.equal(depJoin.get("name").as(String.class), "ddd");
//把Predicate應用到CriteriaQuery去,因為還可以給CriteriaQuery添加其他的功能，比如排序、分組啥?的
query.where(cb.and(cb.and(p3,cb.or(p1,p2)),p4));
//添加分組的功能
query.orderBy(cb.desc(root.get("uuid").as(Integer.class)));
return query.getRestriction();
}};
n接下來看看使用Criteria查詢實現1:1的查詢
1：在UserModel中去掉setDep的屬性及其配置，然后添加如下的屬性和配置：
@OneToOne()
@JoinColumn(name = "depUuid")
private DepModel dep;
public DepModel getDep() { return dep;}
public void setDep(DepModel dep) {this.dep = dep;? }
2：在DepModel中um屬性上的注解配置去掉，換成如下的配置：
@OneToOne(mappedBy = "dep", fetch = FetchType.?EAGER, cascade = {CascadeType.?ALL})
3：在Specification實現中，把SetJoin的那句換成如下的語句：
Join<UserModel,DepModel> depJoin =
root.join(root.getModel().getSingularAttribute("dep",DepModel.class),JoinType.LEFT);
//root.join(“dep”,JoinType.LEFT); //這句話和上面一句的功能一樣，更簡單
?
?
?
總結
以上是生活随笔為你收集整理的Spring Data JPA入门的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： Sybase资料下载（参考手册，功能讲解
- 下一篇： 到亿位的金额小写转大写JS代码