Spring Data Jpa（2）：Spring Data Jpa的使用和源碼分析

一、Spring Data JPA的概述

1.1 Spring Data JPA

Spring Data JPA 是 Spring 基於 ORM思想、JPA 規範的基礎上封裝的一套，可使開發者用極簡的代碼即可實現對數據庫的訪問和操作。它提供了包括增刪改查等在內的常用功能，且易於擴展！學習並使用 Spring Data JPA 可以極大提高開發效率！

Spring Data JPA 讓我們解脫了DAO層的操作，基本上所有CRUD都可以依賴於它來實現,在實際的工作工程中，推薦使用Spring Data JPA + ORM（如：hibernate）完成操作，這樣在切換不同的ORM框架時提供了極大的方便，同時也使數據庫層操作更加簡單，方便解耦。

SpringData Jpa 極大簡化了數據庫訪問層代碼。如何簡化的呢？使用了SpringDataJpa，我們的dao層中只需要寫接口，就自動具有了增刪改查、分頁查詢等方法。

1.2 Spring Data JPA 與 JPA和hibernate之間的關係

JPA是一套規範，內部是有接口和抽象類組成的。hibernate是一套成熟的ORM框架，而且Hibernate實現了JPA規範，所以也可以稱hibernate爲JPA的一種實現方式，我們使用JPA的API編程，意味着站在更高的角度上看待問題（面向接口編程）

Spring Data JPA是Spring提供的一套對JPA操作更加高級的封裝，是在JPA規範下的專門用來進行數據持久化的解決方案。（再加了一層封裝）

二、快速入門

Spring Data JPA完成客戶的基本CRUD操作

使用Spring Data JPA，需要整合Spring與Spring Data JPA，並且需要提供JPA的服務提供者hibernate，所以需要導入spring相關座標，hibernate座標，數據庫驅動座標等

  <properties>
        <spring.version>4.2.4.RELEASE</spring.version>
        <hibernate.version>5.0.7.Final</hibernate.version>
        <slf4j.version>1.6.6</slf4j.version>
        <log4j.version>1.2.12</log4j.version>
        <c3p0.version>0.9.1.2</c3p0.version>
        <mysql.version>5.1.6</mysql.version>
    </properties>

    <dependencies>
        <!-- junit單元測試 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.9</version>
            <scope>test</scope>
        </dependency>
        
        <!-- spring beg -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.6.8</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        
        <!-- spring end -->

        <!-- hibernate beg -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>5.2.1.Final</version>
        </dependency>
        <!-- hibernate end -->

        <!-- c3p0 beg -->
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>${c3p0.version}</version>
        </dependency>
        <!-- c3p0 end -->

        <!-- log end -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>${log4j.version}</version>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4j.version}</version>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <!-- log end -->

        
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-jpa</artifactId>
            <version>1.9.0.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>4.2.4.RELEASE</version>
        </dependency>
        
        <!-- el beg 使用spring data jpa 必須引入 -->
        <dependency>  
            <groupId>javax.el</groupId>  
            <artifactId>javax.el-api</artifactId>  
            <version>2.2.4</version>  
        </dependency>  
          
        <dependency>  
            <groupId>org.glassfish.web</groupId>  
            <artifactId>javax.el</artifactId>  
            <version>2.2.4</version>  
        </dependency> 
        <!-- el end -->
    </dependencies>

2.1整合Spring Data JPA與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:aop="http://www.springframework.org/schema/aop"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:jdbc="http://www.springframework.org/schema/jdbc" xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:jpa="http://www.springframework.org/schema/data/jpa" xmlns:task="http://www.springframework.org/schema/task"
	xsi:schemaLocation="
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
		http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
		http://www.springframework.org/schema/data/jpa 
		http://www.springframework.org/schema/data/jpa/spring-jpa.xsd">
	
	<!-- 1.dataSource 配置數據庫連接池-->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="com.mysql.jdbc.Driver" />
		<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/jpa" />
		<property name="user" value="root" />
		<property name="password" value="111111" />
	</bean>
	
	<!-- 2.配置entityManagerFactory -->
	<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
		<property name="dataSource" ref="dataSource" />
		<property name="packagesToScan" value="cn.itcast.entity" />
		<property name="persistenceProvider">
			<bean class="org.hibernate.jpa.HibernatePersistenceProvider" />
		</property>
		<!--JPA的供應商適配器-->
		<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.MySQLDialect" />
				<property name="showSql" value="true" />
			</bean>
		</property>
		<property name="jpaDialect">
			<bean class="org.springframework.orm.jpa.vendor.HibernateJpaDialect" />
		</property>
	</bean>
    
	
	<!-- 3.事務管理器-->
	<!-- JPA事務管理器  -->
	<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
		<property name="entityManagerFactory" ref="entityManagerFactory" />
	</bean>
	
	<!-- 整合spring data jpa-->
	<jpa:repositories base-package="cn.itcast.dao"
		transaction-manager-ref="transactionManager"
		entity-manager-factory-ref="entityManagerFactory"></jpa:repositories>
		
	<!-- 4.txAdvice-->
	<tx:advice id="txAdvice" transaction-manager="transactionManager">
		<tx:attributes>
			<tx:method name="save*" propagation="REQUIRED"/>
			<tx:method name="insert*" propagation="REQUIRED"/>
			<tx:method name="update*" propagation="REQUIRED"/>
			<tx:method name="delete*" propagation="REQUIRED"/>
			<tx:method name="get*" read-only="true"/>
			<tx:method name="find*" read-only="true"/>
			<tx:method name="*" propagation="REQUIRED"/>
		</tx:attributes>
	</tx:advice>
	
	<!-- 5.aop聲明事務-->
	<aop:config>
		<aop:pointcut id="pointcut" expression="execution(* cn.itcast.service.*.*(..))" />
		<aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut" />
	</aop:config>
	
	<context:component-scan base-package="cn.itcast"></context:component-scan>
		
	<!--組裝其它 配置文件-->
	
</beans>

2.2使用JPA註解配置映射關係

我們使用案例中的Customer實體類對象，已經配置好了映射關係

package cn.itcast.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") //建立實體類和表的映射關係
@Data
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;
    
  
}

2.3 使用Spring Data JPA完成需求

2.3.1 編寫符合Spring Data JPA規範的Dao層接口

Spring Data JPA是spring提供的一款對於數據訪問層（Dao層）的框架，不需要實現類就可以完成數據庫的增刪改查、分頁查詢等方法的定義，極大的簡化了我們的開發過程。

在Spring Data JPA中，對於定義符合規範的Dao層接口，我們只需要遵循以下幾點就可以了：

1.創建一個Dao層接口，並實現JpaRepository和JpaSpecificationExecutor
2.提供相應的泛型

package cn.itcast.dao;

import java.util.List;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;

import cn.itcast.entity.Customer;

/**
 * JpaRepository<實體類類型，主鍵類型>：用來完成基本CRUD操作
 * JpaSpecificationExecutor<實體類類型>：用於複雜查詢（分頁等查詢操作）
 */
public interface CustomerDao extends JpaRepository<Customer, Long>, JpaSpecificationExecutor<Customer> {
}

這樣我們就定義好了一個符合Spring Data JPA規範的Dao層接口

2.3.2 完成基本CRUD操作

完成了Spring Data JPA的環境搭建，並且編寫了符合Spring Data JPA 規範的Dao層接口之後，就可以使用定義好的Dao層接口進行客戶的基本CRUD操作

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations="classpath:applicationContext.xml")
public class CustomerDaoTest {

    @Autowired
    private CustomerDao customerDao;
    
    /**
     * 保存客戶：調用save(obj)方法
     */
    @Test
    public void testSave() {
        Customer c = new Customer();
        c.setCustName("xxx");
        customerDao.save(c);
    }
    
    /**
     * 修改客戶：調用save(obj)方法
     * 對於save方法的解釋：如果執行此方法是對象中存在id屬性，即爲更新操作會先根據id查詢，更新    
     * 
     * 如果執行此方法中對象中不存在id屬性，即爲保存操作
     *          
     */
    @Test
    public void testUpdate() {
        //根據id查詢id爲1的客戶
        Customer customer = customerDao.findOne(1l);
        //修改客戶名稱
        customer.setCustName("傳智播客順義校區");
        //更新
        customerDao.save(customer);
    }
    
    /**
     * 根據id刪除：調用delete(id)方法
     */
    @Test
    public void testDelete() {
        customerDao.delete(1l);
    }
    
    /**
     * 根據id查詢：調用findOne(id)方法
     */
    @Test
    public void testFindById() {
        Customer customer = customerDao.findOne(2l);
        System.out.println(customer);
    }
}

三、Spring Data JPA的源碼解析

3.1 Spring Data JPA的常用接口分析

在自定義的CustomerDao中，並沒有提供任何方法就可以使用其中的很多方法，那麼這些方法究竟是怎麼來的呢？

答案很簡單，對於我們自定義的Dao接口，由於繼承了JpaRepository和JpaSpecificationExecutor，所以我們可以使用這兩個接口的所有方法。但是這些方法都只是一些聲明，沒有具體的實現方式，那麼在 Spring Data JPA中它又是怎麼實現的呢？

3.2 Spring Data JPA的實現過程

通過分析Spring Data JPA的原來來分析程序的執行過程，我們以findOne方法爲例進行分析。

代理子類的實現過程

斷點執行到方法上時，我們可以發現注入的customerDao對象，本質上是通過JdkDynamicAopProxy生成的一個代理對象。
代理對象中方法調用的分析

當程序執行的時候，會通過JdkDynamicAopProxy的invoke方法，對customerDao對象生成動態代理對象。要想進行findOne查詢方法，最終還是會出現JPA規範的API完成操作，那麼這些底層代碼存在於何處呢？答案很簡單，都隱藏在通過JdkDynamicAopProxy生成的動態代理對象當中，而這個動態代理對象就是SimpleJpaRepository。

通過SimpleJpaRepository的源碼分析，定位到了findOne方法，在此方法中，返回em.find()的返回結果，我們發現em就是EntityManager對象，而他是JPA原生的實現方式。

結論：Spring Data JPA只是對標準JPA操作進行了進一步封裝，簡化了Dao層代碼的開發

3.3 Spring Data JPA完整的調用過程分析

四、Spring Data JPA的查詢方式

4.1 使用Spring Data JPA中接口定義的方法進行查詢

在繼承JpaRepository，和JpaRepository接口後,我們就可以使用接口中定義的方法進行查詢

繼承JpaRepository後的方法列表
繼承JpaSpecificationExecutor的方法列表（複雜查詢）

4.2 @Query註解JPQL的方式查詢

使用Spring Data JPA提供的查詢方法已經可以解決大部分的應用場景，但是對於某些業務來說，我們還需要靈活的構造查詢條件，這時就可以使用@Query註解，結合JPQL的語句方式完成查詢。

只需在方法上面標註@Query註解，同時提供一個JPQL查詢語句即可。

public interface CustomerDao extends JpaRepository<Customer, Long>,JpaSpecificationExecutor<Customer> {    
    //@Query 使用jpql的方式查詢。
    @Query(value="from Customer")
    public List<Customer> findAllCustomer();
    
    //@Query 使用jpql的方式查詢。?1代表參數的佔位符，其中1對應方法中的參數索引
    @Query(value="from Customer where custName = ?1")
    public Customer findCustomer(String custName);
}

此外，也可以通過使用 @Query 來執行一個更新操作，爲此，我們需要在使用 @Query 的同時，用 @Modifying 來將該操作標識爲修改查詢，這樣框架最終會生成一個更新的操作，而非查詢

@Query(value="update Customer set custName = ?1 where custId = ?2")
@Modifying//表明該方法爲修改
public void updateCustomer(String custName,Long custId);

4.3 使用SQL語句查詢

@Query同樣也支持sql語句的查詢，如下：

/**
 * nativeQuery : 使用本地sql的方式查詢
 */
@Query(value="select * from cst_customer",nativeQuery=true)
public void findSql();

4.4 方法命名規則查詢

顧名思義，方法命名規則查詢就是根據方法的名字，就能創建查詢。按照Spring Data JPA提供的方法命名規則定義方法的名稱，就可以完成查詢工作。

查詢方法以findBy開頭，涉及條件查詢時，條件的屬性用條件關鍵字連接，要注意的是：條件屬性首字母需大寫。框架在進行方法名解析時，會先把方法名多餘的前綴截取掉，然後對剩下部分進行解析。

//方法命名方式查詢（根據客戶名稱查詢客戶）
public Customer findByCustName(String custName);

具體的關鍵字，使用方法和生產成SQL如下表所示

Spring Data Jpa（2）：Spring Data Jpa的使用和源碼分析

Spring Data Jpa（2）：Spring Data Jpa的使用和源碼分析

一、Spring Data JPA的概述

1.1 Spring Data JPA

1.2 Spring Data JPA 與 JPA和hibernate之間的關係

二、快速入門

2.1整合Spring Data JPA與Spring

2.2使用JPA註解配置映射關係

2.3 使用Spring Data JPA完成需求

2.3.1 編寫符合Spring Data JPA規範的Dao層接口

2.3.2 完成基本CRUD操作

三、Spring Data JPA的源碼解析

3.1 Spring Data JPA的常用接口分析

3.2 Spring Data JPA的實現過程

3.3 Spring Data JPA完整的調用過程分析

四、Spring Data JPA的查詢方式

4.1 使用Spring Data JPA中接口定義的方法進行查詢

4.2 @Query註解JPQL的方式查詢

4.3 使用SQL語句查詢

4.4 方法命名規則查詢

Python 潮流週刊#52：Python 處理 Excel 的資源

微服務架構（14）：SpringCloud微服務項目技術總結

微服務架構（9）：Thymeleaf頁面靜態化

微服務架構（1）：SpringBoot

嵌入式團隊培訓_線性結構

快慢指針在騰訊面試題的應用

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結