一、JPA概述：
JPA的全稱是Java Persistence API， 即Java 持久化API，是SUN公司推出的一套基於ORM的規範，內部是由一系列的接口和抽象類構成。JPA通過JDK 5.0註解描述對象－關係表的映射關係，並將運行期的實體對象持久化到數據庫中。
JPA的優勢：標準化、容器級特性的支持、簡單方便、查詢能力、高級特性
二、JPA與Hibernate的關係：
JPA規範本質上就是一種ORM規範，注意不是ORM框架——因為JPA並未提供ORM實現，它只是制訂了一些規範，提供了一些編程的API接口，但具體實現則由服務廠商來提供實現。JPA和Hibernate的關係就像JDBC和JDBC驅動的關係，JPA是規範，Hibernate除了作為ORM框架之外，它也是一種JPA實現。
三、JPA環境搭建：
1、創建一個maven工程，在pom.xml中導入對應的坐標
1 <properties>
2 <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
3 <project.hibernate.version>5.0.7.Final</project.hibernate.version>
4 </properties>
5
6 <dependencies>
7 <!-- junit -->
8 <dependency>
9 <groupId>junit</groupId>
10 <artifactId>junit</artifactId>
11 <version>4.12</version>
12 <scope>test</scope>
13 </dependency>
14
15 <!-- hibernate對jpa的支持包 -->
16 <dependency>
17 <groupId>org.hibernate</groupId>
18 <artifactId>hibernate-entitymanager</artifactId>
19 <version>${project.hibernate.version}</version>
20 </dependency>
21
22 <!-- c3p0 -->
23 <dependency>
24 <groupId>org.hibernate</groupId>
25 <artifactId>hibernate-c3p0</artifactId>
26 <version>${project.hibernate.version}</version>
27 </dependency>
28
29 <!-- log日誌 -->
30 <dependency>
31 <groupId>log4j</groupId>
32 <artifactId>log4j</artifactId>
33 <version>1.2.17</version>
34 </dependency>
35
36 <!-- Mysql and MariaDB -->
37 <dependency>
38 <groupId>mysql</groupId>
39 <artifactId>mysql-connector-java</artifactId>
40 <version>5.1.6</version>
41 </dependency>
42 </dependencies>
2、編寫實體類和數據表的映射配置，創建實體類以後，使用對應的註釋配置映射關係
@Entity
作用：指定當前類是實體類。
@Table
作用：指定實體類和表之間的對應關係。
屬性：
name：指定數據庫表的名稱
@Id
作用：指定當前字段是主鍵。
@GeneratedValue
作用：指定主鍵的生成方式。。
屬性：
strategy ：指定主鍵生成策略。
@Column
作用：指定實體類屬性和數據庫表之間的對應關係
屬性：
name：指定數據庫表的列名稱。
unique：是否唯一
nullable：是否可以為空
inserttable：是否可以插入
updateable：是否可以更新
columnDefinition: 定義建表時創建此列的DDL
secondaryTable: 從表名。如果此列不建在主表上（默認建在主表），該屬性定義該列所在從表的名字搭建開發環境[重點]
3、配置JPA的核心配置文件
在java工程的src路徑下創建一個名為META-INF的文件夾，在此文件夾下創建一個名為persistence.xml的配置文件
<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd"
version="2.0">
<!--配置持久化單元
name：持久化單元名稱
transaction-type：事務類型
RESOURCE_LOCAL：本地事務管理
JTA：分佈式事務管理 -->
<persistence-unit name="myJpa" transaction-type="RESOURCE_LOCAL">
<!--配置JPA規範的服務提供商 -->
<provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
<properties>
<!-- 數據庫驅動 -->
<property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver" />
<!-- 數據庫地址 -->
<property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/jpa" />
<!-- 數據庫用戶名 -->
<property name="javax.persistence.jdbc.user" value="root" />
<!-- 數據庫密碼 -->
<property name="javax.persistence.jdbc.password" value="111111" />
<!--jpa提供者的可選配置：我們的JPA規範的提供者為hibernate，所以jpa的核心配置中兼容hibernate的配 -->
<property name="hibernate.show_sql" value="true" />
<property name="hibernate.format_sql" value="true" />
<!--自動創建數據庫表：create（運行時創建表），update（如過有表則不創建表），none（不創建表）
<property name="hibernate.hbm2ddl.auto" value="create" />
</properties>
</persistence-unit>
</persistence>
4、測試數據庫操作
通過調用EntityManager的方法完成獲取事務，以及持久化數據庫的操作
方法說明：
getTransaction : 獲取事務對象
persist ： 保存操作
merge ： 更新操作
remove ： 刪除操作
find/getReference ： 根據id查詢
1 @Test
2 public void test() {
3 /**
4 * 創建實體管理類工廠，藉助Persistence的靜態方法獲取
5 * 其中傳遞的參數為持久化單元名稱，需要jpa配置文件中指定
6 */
7 EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
8 //創建實體管理類
9 EntityManager em = factory.createEntityManager();
10 //獲取事務對象
11 EntityTransaction tx = em.getTransaction();
12 //開啟事務
13 tx.begin();
14 Customer c = new Customer();
15 c.setCustName("天地壹號");
16 //保存操作
17 em.persist(c);
18 //提交事務
19 tx.commit();
20 //釋放資源
21 em.close();
22 factory.close();
23 }
6、抽取JPAUtil工具類，通過工具類生成實體類管理器對象
package top.biyenanhai.dao;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
public final class JPAUtil {
// JPA的實體管理器工廠：相當於Hibernate的SessionFactory
private static EntityManagerFactory em;
// 使用靜態代碼塊賦值
static {
// 注意：該方法參數必須和persistence.xml中persistence-unit標籤name屬性取值一致
em = Persistence.createEntityManagerFactory("myPersistUnit");
}
/**
* 使用管理器工廠生產一個管理器對象
*
* @return
*/
public static EntityManager getEntityManager() {
return em.createEntityManager();
}
}
三、Spring Data JPA概述：
Spring Data JPA 是 Spring 基於 ORM 框架、JPA 規範的基礎上封裝的一套JPA應用框架，可使開發者用極簡的代碼即可實現對數據庫的訪問和操作。它提供了包括增刪改查等在內的常用功能，且易於擴展！學習並使用 Spring Data JPA 可以極大提高開發效率！Spring Data JPA 讓我們解脫了DAO層的操作，基本上所有CRUD都可以依賴於它來實現,在實際的工作工程中，推薦使用Spring Data JPA + ORM（如：hibernate）完成操作，這樣在切換不同的ORM框架時提供了極大的方便，同時也使數據庫層操作更加簡單，方便解耦。
四、Spring Data JPA 與 JPA和hibernate之間的關係：
JPA是一套規範，內部是有接口和抽象類組成的。hibernate是一套成熟的ORM框架，而且Hibernate實現了JPA規範，所以也可以稱hibernate為JPA的一種實現方式，我們使用JPA的API編程，意味着站在更高的角度上看待問題（面向接口編程）。Spring Data JPA是Spring提供的一套對JPA操作更加高級的封裝，是在JPA規範下的專門用來進行數據持久化的解決方案。
五、Spring Data JPA快速搭建開發環境：
1、創建maven工程，導入Spring Data JPA的坐標
1 <properties>
2 <spring.version>4.2.4.RELEASE</spring.version>
3 <hibernate.version>5.0.7.Final</hibernate.version>
4 <slf4j.version>1.6.6</slf4j.version>
5 <log4j.version>1.2.12</log4j.version>
6 <c3p0.version>0.9.1.2</c3p0.version>
7 <mysql.version>5.1.6</mysql.version>
8 </properties>
9
10 <dependencies>
11 <!-- junit單元測試 -->
12 <dependency>
13 <groupId>junit</groupId>
14 <artifactId>junit</artifactId>
15 <version>4.12</version>
16 <scope>test</scope>
17 </dependency>
18
19 <!-- spring beg -->
20 <dependency>
21 <groupId>org.aspectj</groupId>
22 <artifactId>aspectjweaver</artifactId>
23 <version>1.6.8</version>
24 </dependency>
25
26 <dependency>
27 <groupId>org.springframework</groupId>
28 <artifactId>spring-aop</artifactId>
29 <version>${spring.version}</version>
30 </dependency>
31
32 <dependency>
33 <groupId>org.springframework</groupId>
34 <artifactId>spring-context</artifactId>
35 <version>${spring.version}</version>
36 </dependency>
37
38 <dependency>
39 <groupId>org.springframework</groupId>
40 <artifactId>spring-context-support</artifactId>
41 <version>${spring.version}</version>
42 </dependency>
43
44 <dependency>
45 <groupId>org.springframework</groupId>
46 <artifactId>spring-orm</artifactId>
47 <version>${spring.version}</version>
48 </dependency>
49
50 <dependency>
51 <groupId>org.springframework</groupId>
52 <artifactId>spring-beans</artifactId>
53 <version>${spring.version}</version>
54 </dependency>
55
56 <dependency>
57 <groupId>org.springframework</groupId>
58 <artifactId>spring-core</artifactId>
59 <version>${spring.version}</version>
60 </dependency>
61
62 <!-- spring end -->
63
64 <!-- hibernate beg -->
65 <dependency>
66 <groupId>org.hibernate</groupId>
67 <artifactId>hibernate-core</artifactId>
68 <version>${hibernate.version}</version>
69 </dependency>
70 <dependency>
71 <groupId>org.hibernate</groupId>
72 <artifactId>hibernate-entitymanager</artifactId>
73 <version>${hibernate.version}</version>
74 </dependency>
75 <dependency>
76 <groupId>org.hibernate</groupId>
77 <artifactId>hibernate-validator</artifactId>
78 <version>5.2.1.Final</version>
79 </dependency>
80 <!-- hibernate end -->
81
82 <!-- c3p0 beg -->
83 <dependency>
84 <groupId>c3p0</groupId>
85 <artifactId>c3p0</artifactId>
86 <version>${c3p0.version}</version>
87 </dependency>
88 <!-- c3p0 end -->
89
90 <!-- log end -->
91 <dependency>
92 <groupId>log4j</groupId>
93 <artifactId>log4j</artifactId>
94 <version>${log4j.version}</version>
95 </dependency>
96
97 <dependency>
98 <groupId>org.slf4j</groupId>
99 <artifactId>slf4j-api</artifactId>
100 <version>${slf4j.version}</version>
101 </dependency>
102
103 <dependency>
104 <groupId>org.slf4j</groupId>
105 <artifactId>slf4j-log4j12</artifactId>
106 <version>${slf4j.version}</version>
107 </dependency>
108 <!-- log end -->
109
110
111 <dependency>
112 <groupId>mysql</groupId>
113 <artifactId>mysql-connector-java</artifactId>
114 <version>${mysql.version}</version>
115 </dependency>
116
117 <dependency>
118 <groupId>org.springframework.data</groupId>
119 <artifactId>spring-data-jpa</artifactId>
120 <version>1.9.0.RELEASE</version>
121 </dependency>
122
123 <dependency>
124 <groupId>org.springframework</groupId>
125 <artifactId>spring-test</artifactId>
126 <version>4.2.4.RELEASE</version>
127 </dependency>
128
129 <!-- el beg 使用spring data jpa 必須引入 -->
130 <dependency>
131 <groupId>javax.el</groupId>
132 <artifactId>javax.el-api</artifactId>
133 <version>2.2.4</version>
134 </dependency>
135
136 <dependency>
137 <groupId>org.glassfish.web</groupId>
138 <artifactId>javax.el</artifactId>
139 <version>2.2.4</version>
140 </dependency>
141 <!-- el end -->
142
143 <dependency>
144 <groupId>javax.xml.bind</groupId>
145 <artifactId>jaxb-api</artifactId>
146 <version>2.3.0</version>
147 </dependency>
148 <dependency>
149 <groupId>com.sun.xml.bind</groupId>
150 <artifactId>jaxb-impl</artifactId>
151 <version>2.3.0</version>
152 </dependency>
153 <dependency>
154 <groupId>com.sun.xml.bind</groupId>
155 <artifactId>jaxb-core</artifactId>
156 <version>2.3.0</version>
157 </dependency>
158 <dependency>
159 <groupId>javax.activation</groupId>
160 <artifactId>activation</artifactId>
161 <version>1.1.1</version>
162 </dependency>
163 </dependencies>
164
2、整合Spring Data JPA與Spring
1 <?xml version="1.0" encoding="UTF-8"?>
2 <beans xmlns="http://www.springframework.org/schema/beans"
3 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
4 xmlns:context="http://www.springframework.org/schema/context"
5 xmlns:jdbc="http://www.springframework.org/schema/jdbc" xmlns:tx="http://www.springframework.org/schema/tx"
6 xmlns:jpa="http://www.springframework.org/schema/data/jpa" xmlns:task="http://www.springframework.org/schema/task"
7 xsi:schemaLocation="
8 http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
9 http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
10 http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
11 http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc.xsd
12 http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
13 http://www.springframework.org/schema/data/jpa
14 http://www.springframework.org/schema/data/jpa/spring-jpa.xsd">
15
16 <!-- 1.dataSource 配置數據庫連接池-->
17 <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
18 <property name="driverClass" value="com.mysql.jdbc.Driver" />
19 <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/jpa" />
20 <property name="user" value="root" />
21 <property name="password" value="111111" />
22 </bean>
23
24 <!-- 2.配置entityManagerFactory -->
25 <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
26 <property name="dataSource" ref="dataSource" />
27 <property name="packagesToScan" value="cn.itcast.entity" />
28 <property name="persistenceProvider">
29 <bean class="org.hibernate.jpa.HibernatePersistenceProvider" />
30 </property>
31 <!--JPA的供應商適配器-->
32 <property name="jpaVendorAdapter">
33 <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
34 <property name="generateDdl" value="false" />
35 <property name="database" value="MYSQL" />
36 <property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect" />
37 <property name="showSql" value="true" />
38 </bean>
39 </property>
40 <property name="jpaDialect">
41 <bean class="org.springframework.orm.jpa.vendor.HibernateJpaDialect" />
42 </property>
43 </bean>
44
45
46 <!-- 3.事務管理器-->
47 <!-- JPA事務管理器 -->
48 <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
49 <property name="entityManagerFactory" ref="entityManagerFactory" />
50 </bean>
51
52 <!-- 整合spring data jpa-->
53 <jpa:repositories base-package="top.biyenanhai.mapper"
54 transaction-manager-ref="transactionManager"
55 entity-manager-factory-ref="entityManagerFactory"></jpa:repositories>
56
57 <!-- 4.txAdvice-->
58 <tx:advice id="txAdvice" transaction-manager="transactionManager">
59 <tx:attributes>
60 <tx:method name="*" propagation="REQUIRED"/>
61 <tx:method name="get*" read-only="true"/>
62 <tx:method name="find*" read-only="true"/>
63 </tx:attributes>
64 </tx:advice>
65
66 <!-- 5.aop-->
67 <aop:config>
68 <aop:pointcut id="pointcut" expression="execution(* top.biyenanhai.service.*.*(..))" />
69 <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut" />
70 </aop:config>
71
72 <context:component-scan base-package="cn.itcast"></context:component-scan>
73 <!--6、配置包掃描-->
74 <context:component-scan base-package="top.biyenanhai"/>
75 <!--組裝其它 配置文件-->
76
77 </beans>
3、使用JPA註解配置映射關係
package top.biyenanhai.entity;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
/**
*
* * 所有的註解都是使用JPA的規範提供的註解，
* * 所以在導入註解包的時候，一定要導入javax.persistence下的
*/
@Entity //聲明實體類
@Table(name="cst_customer") //建立實體類和表的映射關係
public class Customer {
@Id//聲明當前私有屬性為主鍵
@GeneratedValue(strategy=GenerationType.IDENTITY) //配置主鍵的生成策略
@Column(name="cust_id") //指定和表中cust_id字段的映射關係
private Long custId;
@Column(name="cust_name") //指定和表中cust_name字段的映射關係
private String custName;
@Column(name="cust_source")//指定和表中cust_source字段的映射關係
private String custSource;
@Column(name="cust_industry")//指定和表中cust_industry字段的映射關係
private String custIndustry;
@Column(name="cust_level")//指定和表中cust_level字段的映射關係
private String custLevel;
@Column(name="cust_address")//指定和表中cust_address字段的映射關係
private String custAddress;
@Column(name="cust_phone")//指定和表中cust_phone字段的映射關係
private String custPhone;
//添加get，set方法，toString方法
}
3、編寫符合Spring Data JPA規範的Dao層接口，繼承JpaRepository<T,ID>和JpaSpecificationExecutor<T>
* JpaRepository<操作的實體類類型，實體類中主鍵屬性的類型>
* *封裝了基本CURD操作
* JpaSpecificationExecutor<操作的實體類類型>
* *封裝了複雜查詢（分頁）
package top.biyenanhai.dao;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import top.biyenanhai.domain.Customer;
import java.util.List;
/**
* Created with IntelliJ IDEA.
*
* @Auther: 畢業男孩
*
* 符合SpringDataJpa的dao接口規範
* JpaRepository<操作的實體類類型，實體類中主鍵屬性的類型>
* *封裝了基本CURD操作
* JpaSpecificationExecutor<操作的實體類類型>
* *封裝了複雜查詢（分頁）
*
*/
public interface CustomerDao extends JpaRepository<Customer, Long>, JpaSpecificationExecutor<Customer> {
/**
* 案例：根據客戶名稱查詢客戶
* 使用jpql的形式查詢
*
* jpql:from Customer where custName = ?
*
* 配置jpql語句，使用@Query註解
*/
@Query(value="from Customer where custName = ? ")
Customer findJpql(String custName);
/**
* 案例：根據客戶名稱和客戶id查詢客戶
* jqpl:from Customer where cutName = ？ and custId = ?
*
* 對於多個佔位符參數
* 賦值的時候，默認的情況下，佔位符的位置需要和方法參數中的位置保持一致
* 可以指定佔位符參數的位置
* ？索引的方式，指定此佔位的取值來源
*/
@Query(value = "from Customer where custName=?2 and custId=?1")
Customer findCustNameAndCustId(Long id,String name);
/**
* 使用jpql完成更新操作
* 案例：根據id更新，客戶的名稱
* 更新4號客戶的名稱，將名稱改為“老男孩”
*
*
* sql:update cst_customer set cust_name = ?where cust_id=?
* jpql:update Customer set custName=? where custId=?
*
* @Query:代表的是進行查詢
* 聲明此方法是用來更新操作
* @Modifying：當前執行的是一個更新操作
*/
@Query(value = "update Customer set custName=?2 where custId=?1")
@Modifying
void updateCustomer(long id, String custName);
/**
* 使用sql的形式查詢：
* 查詢全部的客戶
* sql:select * from cst_custimer;
* Query:配置sql查詢
* value: sql語句
* nativeQuery: 查詢方式
* true：sql查詢
* false：jpql查詢
*/
// @Query(value = "select * from cst_customer", nativeQuery = true) //查詢全部
@Query(value = "select * from cst_customer where cust_name like ?1",nativeQuery = true) //條件查詢
List<Object[]> findSql(String name);
/**
* 方法名的約定：
* findBy：查詢
* 對象中的屬性名（首字母大寫）：查詢的條件
* CustName
* *默認情況：使用 等於的方式查詢
* 特殊的查詢方式
* findByCustName -- 根據客戶名稱查詢
*
* 在springdataJpa的運行階段
* 會根據方法名稱進行解析 findBy from xxx(實體類)
* 屬性名稱 where custName =
*
*
* 1、findBy + 屬性名稱（根據屬性名稱進行完成匹配的查詢=）
* 2、findBy + 屬性名稱 + “查詢方式（Like|isnull）”
* 3、多條件查詢
* findBy + 屬性名 + "查詢條件" + "多條件的連接符（and|or）" + 屬性名 + “查詢方式”
*
*/
Customer findByCustName(String custName);
List<Customer> findByCustNameLike(String name);
List<Customer> findByCustNameLikeAndCustIndustry(String name, String industry);
}
4、測試基本CRUD操作
@RunWith(SpringJUnit4ClassRunner.class) //聲明spring提供的單元測試環境
@ContextConfiguration(locations = "classpath:applicationContext.xml")//指定spring容器的配置信息
public class CustomerDaoTest {
@Autowired
private CustomerDao customerDao;
/**
* 根據id查詢
*/
@Test
public void testFindOne(){
Customer customer = customerDao.findOne(1l);
System.out.println(customer);
}
......
/**
* 測試jqpl的更新操作
* 更新和刪除操作要加上事務的註解
*
* springDataJpa中使用jpql完成 更新/刪除操作
* 需要手動添加事務的支持
* 默認回執行結束之後，回滾事務
* @Rollback:設置是否自動回滾
*/
@Test
@Transactional//添加事務的支持
@Rollback(false)
public void testUpdate(){
customerDao.updateCustomer(1l, "航空航天科技有限公司");
}
......
5、具體關鍵字，使用方法和生產成SQL如下錶所示
|
Keyword
|
Sample
|
JPQL
|
|
And
|
findByLastnameAndFirstname
|
… where x.lastname = ?1 and x.firstname = ?2
|
|
Or
|
findByLastnameOrFirstname
|
… where x.lastname = ?1 or x.firstname = ?2
|
|
Is,Equals
|
findByFirstnameIs,
findByFirstnameEquals
|
… where x.firstname = ?1
|
|
Between
|
findByStartDateBetween
|
… where x.startDate between ?1 and ?2
|
|
LessThan
|
findByAgeLessThan
|
… where x.age < ?1
|
|
LessThanEqual
|
findByAgeLessThanEqual
|
… where x.age ⇐ ?1
|
|
GreaterThan
|
findByAgeGreaterThan
|
… where x.age > ?1
|
|
GreaterThanEqual
|
findByAgeGreaterThanEqual
|
… where x.age >= ?1
|
|
After
|
findByStartDateAfter
|
… where x.startDate > ?1
|
|
Before
|
findByStartDateBefore
|
… where x.startDate < ?1
|
|
IsNull
|
findByAgeIsNull
|
… where x.age is null
|
|
IsNotNull,NotNull
|
findByAge(Is)NotNull
|
… where x.age not null
|
|
Like
|
findByFirstnameLike
|
… where x.firstname like ?1
|
|
NotLike
|
findByFirstnameNotLike
|
… where x.firstname not like ?1
|
|
StartingWith
|
findByFirstnameStartingWith
|
… where x.firstname like ?1 (parameter bound with appended %)
|
|
EndingWith
|
findByFirstnameEndingWith
|
… where x.firstname like ?1 (parameter bound with prepended %)
|
|
Containing
|
findByFirstnameContaining
|
… where x.firstname like ?1 (parameter bound wrapped in %)
|
|
OrderBy
|
findByAgeOrderByLastnameDesc
|
… where x.age = ?1 order by x.lastname desc
|
|
Not
|
findByLastnameNot
|
… where x.lastname <> ?1
|
|
In
|
findByAgeIn(Collection ages)
|
… where x.age in ?1
|
|
NotIn
|
findByAgeNotIn(Collection age)
|
… where x.age not in ?1
|
|
TRUE
|
findByActiveTrue()
|
… where x.active = true
|
|
FALSE
|
findByActiveFalse()
|
… where x.active = false
|
|
IgnoreCase
|
findByFirstnameIgnoreCase
|
… where UPPER(x.firstame) = UPPER(?1)
|
六、Specifications動態查詢：
有時我們在查詢某個實體的時候，給定的條件是不固定的，這時就需要動態構建相應的查詢語句，在Spring Data JPA中可以通過JpaSpecificationExecutor接口查詢。相比JPQL,其優勢是類型安全,更加的面向對象。對於JpaSpecificationExecutor，這個接口基本是圍繞着Specification接口來定義的。我們可以簡單的理解為，Specification構造的就是查詢條件。
/**
* root ：Root接口，代表查詢的根對象，可以通過root獲取實體中的屬性
* query ：代表一個頂層查詢對象，用來自定義查詢
* cb ：用來構建查詢，此對象里有很多條件方法
**/
public Predicate toPredicate(Root<T> root, CriteriaQuery<?> query, CriteriaBuilder cb);
案例：使用Specifications完成條件查詢
//依賴注入customerDao
@Autowired
private CustomerDao customerDao;
@Test
public void testSpecifications() {
//使用匿名內部類的方式，創建一個Specification的實現類，並實現toPredicate方法
Specification <Customer> spec = new Specification<Customer>() {
public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
//cb:構建查詢，添加查詢方式 like：模糊匹配
//root：從實體Customer對象中按照custName屬性進行查詢
return cb.like(root.get("custName").as(String.class), "航天航空%");
}
};
Customer customer = customerDao.findOne(spec);
System.out.println(customer);
}
案例：基於Specifications的分頁查詢
@Test
public void testPage() {
//構造查詢條件
Specification<Customer> spec = new Specification<Customer>() {
public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
return cb.like(root.get("custName").as(String.class), "航天%");
}
};
/**
* 構造分頁參數
* Pageable : 接口
* PageRequest實現了Pageable接口，調用構造方法的形式構造
* 第一個參數：頁碼（從0開始）
* 第二個參數：每頁查詢條數
*/
Pageable pageable = new PageRequest(0, 5);
/**
* 分頁查詢，封裝為Spring Data Jpa 內部的page bean
* 此重載的findAll方法為分頁方法需要兩個參數
* 第一個參數：查詢條件Specification
* 第二個參數：分頁參數
*/
Page<Customer> page = customerDao.findAll(spec,pageable);
}
對於Spring Data JPA中的分頁查詢，是其內部自動實現的封裝過程，返回的是一個Spring Data JPA提供的pageBean對象。其中的方法說明如下：
//獲取總頁數
int getTotalPages();
//獲取總記錄數
long getTotalElements();
//獲取列表數據
List<T> getContent();
方法對應關係：
|
方法名稱
|
Sql對應關係
|
|
equal
|
filed = value
|
|
gt（greaterThan ）
|
filed > value
|
|
lt（lessThan ）
|
filed < value
|
|
ge（greaterThanOrEqualTo ）
|
filed >= value
|
|
le（ lessThanOrEqualTo）
|
filed <= value
|
|
notEqual
|
filed != value
|
|
like
|
filed like value
|
|
notLike
|
filed not like value
|
七、JPA中的一對多：
實體類（一對多，一的實體類）
/**
* 客戶的實體類
* 明確使用的註解都是JPA規範的
* 所以導包都要導入javax.persistence包下的
*/
@Entity//表示當前類是一個實體類
@Table(name="cst_customer")//建立當前實體類和表之間的對應關係
public class Customer implements Serializable {
@Id//表明當前私有屬性是主鍵
@GeneratedValue(strategy=GenerationType.IDENTITY)//指定主鍵的生成策略
@Column(name="cust_id")//指定和數據庫表中的cust_id列對應
private Long custId;
@Column(name="cust_name")//指定和數據庫表中的cust_name列對應
private String custName;
//配置客戶和聯繫人的一對多關係
@OneToMany(targetEntity=LinkMan.class)
@JoinColumn(name="lkm_cust_id",referencedColumnName="cust_id")
private Set<LinkMan> linkmans = new HashSet<LinkMan>();
...get,set方法
實體類（一對多，多的實體類）
/**
* 聯繫人的實體類（數據模型）
*/
@Entity
@Table(name="cst_linkman")
public class LinkMan implements Serializable {
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
@Column(name="lkm_id")
private Long lkmId;
@Column(name="lkm_name")
private String lkmName;
@Column(name="lkm_gender")
private String lkmGender;
@Column(name="lkm_phone")
private String lkmPhone;
//多對一關係映射：多個聯繫人對應客戶
@ManyToOne(targetEntity=Customer.class)
@JoinColumn(name="lkm_cust_id",referencedColumnName="cust_id")
private Customer customer;//用它的主鍵，對應聯繫人表中的外鍵
...get,set方法
八、JPA中的多對多：
/**
* 用戶的數據模型
*/
@Entity
@Table(name="sys_user")
public class SysUser implements Serializable {
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
@Column(name="user_id")
private Long userId;
@Column(name="user_name")
private String userName;
//多對多關係映射
@ManyToMany(mappedBy="users")
private Set<SysRole> roles = new HashSet<SysRole>();
/**
* 角色的數據模型
*/
@Entity
@Table(name="sys_role")
public class SysRole implements Serializable {
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
@Column(name="role_id")
private Long roleId;
@Column(name="role_name")
private String roleName;
//多對多關係映射
@ManyToMany
@JoinTable(name="user_role_rel",//中間表的名稱
//中間表user_role_rel字段關聯sys_role表的主鍵字段role_id
joinColumns={@JoinColumn(name="role_id",referencedColumnName="role_id")},
//中間表user_role_rel的字段關聯sys_user表的主鍵user_id
inverseJoinColumns={@JoinColumn(name="user_id",referencedColumnName="user_id")}
)
private Set<SysUser> users = new HashSet<SysUser>();
映射的註解說明
@OneToMany:
作用：建立一對多的關係映射
屬性：
targetEntityClass：指定多的多方的類的字節碼
mappedBy：指定從表實體類中引用主表對象的名稱。
cascade：指定要使用的級聯操作
fetch：指定是否採用延遲加載
@ManyToOne
作用：建立多對一的關係
屬性：
targetEntityClass：指定一的一方實體類字節碼
cascade：指定要使用的級聯操作
fetch：指定是否採用延遲加載
optional：關聯是否可選。如果設置為false，則必須始終存在非空關係。
@JoinColumn
作用：用於定義主鍵字段和外鍵字段的對應關係。
屬性：
name：指定外鍵字段的名稱
referencedColumnName：指定引用主表的主鍵字段名稱
unique：是否唯一。默認值不唯一
nullable：是否允許為空。默認值允許。
insertable：是否允許插入。默認值允許。
updatable：是否允許更新。默認值允許。
columnDefinition：列的定義信息。
九、Spring Data JPA中的多表查詢：
對象導航查詢：對象導航檢索方式是根據已經加載的對象，導航到他的關聯對象。它利用類與類之間的關係來檢索對象。例如：我們通過ID查詢方式查出一個客戶，可以調用Customer類中的getLinkMans()方法來獲取該客戶的所有聯繫人。對象導航查詢的使用要求是：兩個對象之間必須存在關聯關係。
//查詢一個客戶，獲取該客戶下的所有聯繫人
@Autowired
private CustomerDao customerDao;
@Test
//由於是在java代碼中測試，為了解決no session問題，將操作配置到同一個事務中
@Transactional
public void testFind() {
Customer customer = customerDao.findOne(5l);
Set<LinkMan> linkMans = customer.getLinkMans();//對象導航查詢
for(LinkMan linkMan : linkMans) {
System.out.println(linkMan);
}
}
//查詢一個聯繫人，獲取該聯繫人的所有客戶
@Autowired
private LinkManDao linkManDao;
@Test
public void testFind() {
LinkMan linkMan = linkManDao.findOne(4l);
Customer customer = linkMan.getCustomer(); //對象導航查詢
System.out.println(customer);
}
採用延遲加載的思想。通過配置的方式來設定當我們在需要使用時，發起真正的查詢。
配置方式：
/**
* 在客戶對象的@OneToMany註解中添加fetch屬性
* FetchType.EAGER ：立即加載
* FetchType.LAZY ：延遲加載
*/
@OneToMany(mappedBy="customer",fetch=FetchType.EAGER)
private Set<LinkMan> linkMans = new HashSet<>();
/**
* 在聯繫人對象的@ManyToOne註解中添加fetch屬性
* FetchType.EAGER ：立即加載
* FetchType.LAZY ：延遲加載
*/
@ManyToOne(targetEntity=Customer.class,fetch=FetchType.EAGER)
@JoinColumn(name="cst_lkm_id",referencedColumnName="cust_id")
private Customer customer;
使用Specification查詢
/**
* Specification的多表查詢
*/
@Test
public void testFind() {
Specification<LinkMan> spec = new Specification<LinkMan>() {
public Predicate toPredicate(Root<LinkMan> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
//Join代錶鏈接查詢，通過root對象獲取
//創建的過程中，第一個參數為關聯對象的屬性名稱，第二個參數為連接查詢的方式（left，inner，right）
//JoinType.LEFT : 左外連接,JoinType.INNER：內連接,JoinType.RIGHT：右外連接
Join<LinkMan, Customer> join = root.join("customer",JoinType.INNER);
return cb.like(join.get("custName").as(String.class),"航空航天");
}
};
List<LinkMan> list = linkManDao.findAll(spec);
for (LinkMan linkMan : list) {
System.out.println(linkMan);
}
}
本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理
【其他文章推薦】
※網頁設計公司推薦不同的風格，搶佔消費者視覺第一線
※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益
※自行創業缺乏曝光? 網頁設計幫您第一時間規劃公司的形象門面
※南投搬家公司費用需注意的眉眉角角，別等搬了再說!
※教你寫出一流的銷售文案?
