Spring Data JPA
一、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); } }
本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理
【其他文章推薦】
※網頁設計公司推薦不同的風格,搶佔消費者視覺第一線
※廣告預算用在刀口上,台北網頁設計公司幫您達到更多曝光效益
※自行創業缺乏曝光? 網頁設計幫您第一時間規劃公司的形象門面
※南投搬家公司費用需注意的眉眉角角,別等搬了再說!
※教你寫出一流的銷售文案?