一、概述

Spring Data是Spring下的一個子專案，用於簡化資料庫訪問，並支援雲服務的開源框架。Spring Data支援NoSQL和 關係資料儲存，其主要目標是使得資料庫的訪問變得方便快捷。並支援map-reduce框架和雲端計算資料服務。對於擁有海量資料的專案，可以用Spring Data來簡化專案的開發。 然而針對不同的資料儲存訪問使用相對的類庫來操作訪問。Spring Data中已經為我們提供了很多業務中常用的一些介面和實現類來幫我們快速構建專案，比如分頁、排序、DAO一些常用的操作。 

二、環境搭建

1.1 匯入jar包

1.2 applicationContext.xml配置

<?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: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.xsd
		http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">

	<!-- 配置自動掃描的包 -->
	<context:component-scan base-package="com.test.springdata"></context:component-scan>

	<!-- 1. 配置資料來源 -->
	<context:property-placeholder location="classpath:config.properties"/>

	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="${jdbc.driver}" />
		<property name="jdbcUrl" value="${jdbc.url}" />
		<property name="user" value="${jdbc.user}" />
		<property name="password" value="${jdbc.password}" />
	</bean>

	<!-- 2. 配置 JPA 的 EntityManagerFactory -->
	<bean id="entityManagerFactory" 
		class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
		<property name="dataSource" ref="dataSource"></property>
		<property name="jpaVendorAdapter">
			<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"></bean>
		</property>
		<property name="packagesToScan" value="com.test.springdata"></property>
		<property name="jpaProperties">
			<props>
				<!-- 二級快取相關 -->
				 
				<!-- <prop key="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</prop>
				<prop key="net.sf.ehcache.configurationResourceName">ehcache-hibernate.xml</prop> -->
				
				<!-- 生成的資料表的列的對映策略 -->
				<prop key="hibernate.ejb.naming_strategy">org.hibernate.cfg.ImprovedNamingStrategy</prop>
				<!-- hibernate 基本屬性 -->
				<prop key="hibernate.dialect">org.hibernate.dialect.Oracle10gDialect</prop>
				<prop key="hibernate.show_sql">true</prop>
				<prop key="hibernate.format_sql">true</prop>
				<prop key="hibernate.hbm2ddl.auto">update</prop>
			</props>
		</property>
	</bean>

	<!-- 3. 配置事務管理器 -->
	<bean id="transactionManager"
		class="org.springframework.orm.jpa.JpaTransactionManager">
		<property name="entityManagerFactory" ref="entityManagerFactory"></property>	
	</bean>

	<!-- 4. 配置支援註解的事務 -->
	<tx:annotation-driven transaction-manager="transactionManager"/>

	<!-- 5. 配置 SpringData -->
	<!-- 加入  jpa 的名稱空間 -->
	<!-- base-package: 掃描 Repository Bean 所在的 package -->
	<jpa:repositories base-package="com.test.springdata"
		entity-manager-factory-ref="entityManagerFactory"></jpa:repositories>

</beans>
 

三、Repository介面

Repository 介面是 Spring Data 的一個核心介面，它不提供任何方法，開發者需要在自己定義的介面中宣告需要的方法。

public interface Repository<T, ID extends Serializable> {}

• Repository是一個空介面，即是一個標記介面
• 若我們定義的介面繼承了Repository，則該介面會被IOC容器識別為一個Repository Bean注入到IOC容器中，只要遵循Spring Data的方法定義規範，就無需寫實現類。
• 與繼承 Repository 等價的一種方式，就是在持久層介面上使用 @RepositoryDefinition 註解，併為其指定 domainClass
  和 idClass 屬性。如下兩種方式是完全等價的

@RepositoryDefinition(domainClass=Person.class,idClass=Integer.class)

基礎的 Repository 提供了最基本的資料訪問功能，其幾個子介面則擴充套件了一些功能。它們的繼承關係如下： 

• Repository： 僅僅是一個標識，表明任何繼承它的均為倉庫介面類
• CrudRepository： 繼承 Repository，實現了一組 CRUD 相關的方法 
• PagingAndSortingRepository： 繼承 CrudRepository，實現了一組分頁排序相關的方法 
• JpaRepository： 繼承 PagingAndSortingRepository，實現一組 JPA 規範相關的方法 

3.2 Spring Data方法定義規範

查詢方法以find | read | get開頭，設計條件查詢時，條件的屬性用條件關鍵字連線，要注意的是：條件屬性以首字母大寫。 

例如：定義一個 Entity 實體類 

class User｛ 	
     private String firstName; 
     private String lastName; 
｝

使用And條件連線時，應這樣寫： 

findByLastNameAndFirstName(String lastName,String firstName); 

條件的屬性名稱與個數要與引數的位置與個數一一對應 

三、CrudRepository介面

CrudRepository 介面提供了最基本的對實體類的添刪改查操作 

• T save(T entity);//儲存單個實體 
• Iterable<T> save(Iterable<? extends T> entities);//儲存集合        
• T findOne(ID id);//根據id查詢實體         
• boolean exists(ID id);//根據id判斷實體是否存在         
• Iterable<T> findAll();//查詢所有實體,不用或慎用!         
• long count();//查詢實體數量         
• void delete(ID id);//根據Id刪除實體         
• void delete(T entity);//刪除一個實體 
• void delete(Iterable<? extends T> entities);//刪除一個實體的集合         
• void deleteAll();//刪除所有實體,不用或慎用! 

四、PagingAndSortingRepository介面

PagingAndSortingRepository介面提供了分頁與排序的功能：

• Iterable<T> findAll(Sort sort); //排序 
• Page<T> findAll(Pageable pageable); //分頁查詢（含排序功能） 

五、JpaRepository介面

JpaRepository介面提供了JPA的相關功能： 

• List<T> findAll(); //查詢所有實體 
• List<T> findAll(Sort sort); //排序、查詢所有實體 
• List<T> save(Iterable<? extends T> entities);//儲存集合 
• void flush();//執行快取與資料庫同步 
• T saveAndFlush(T entity);//強制執行持久化 
• void deleteInBatch(Iterable<T> entities);//刪除一個實體集合 

示例程式碼

Person實體類

package com.test.springdata;

import java.util.Date;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;

@Table(name="JPA_PERSONS")
@Entity
public class Person {

	private Integer id;
	private String lastName;

	private String email;
	private Date birth;
	
	private Address address;
	
	private Integer addressId;

	@GeneratedValue
	@Id
	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	public String getLastName() {
		return lastName;
	}

	public void setLastName(String lastName) {
		this.lastName = lastName;
	}

	public String getEmail() {
		return email;
	}

	public void setEmail(String email) {
		this.email = email;
	}

	public Date getBirth() {
		return birth;
	}

	public void setBirth(Date birth) {
		this.birth = birth;
	}
	
	@Column(name="ADD_ID")
	public Integer getAddressId() {
		return addressId;
	}

	public void setAddressId(Integer addressId) {
		this.addressId = addressId;
	}

	@JoinColumn(name="ADDRESS_ID")
	@ManyToOne
	public Address getAddress() {
		return address;
	}

	public void setAddress(Address address) {
		this.address = address;
	}

	@Override
	public String toString() {
		return "Person [id=" + id + ", lastName=" + lastName + ", email="
				+ email + ", brith=" + birth + "]";
	}
}

package com.test.springdata;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

@Table(name="JPA_ADDRESSES")
@Entity
public class Address {

	private Integer id;
	private String province;
	private String city;

	@GeneratedValue
	@Id
	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	public String getProvince() {
		return province;
	}

	public void setProvince(String province) {
		this.province = province;
	}

	public String getCity() {
		return city;
	}

	public void setCity(String city) {
		this.city = city;
	}

}

package com.test.springdata;

import java.util.Date;
import java.util.List;

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 org.springframework.data.repository.CrudRepository;
import org.springframework.data.repository.PagingAndSortingRepository;
import org.springframework.data.repository.Repository;
import org.springframework.data.repository.RepositoryDefinition;
import org.springframework.data.repository.query.Param;

/**
 * 1、Repository 是一個空介面，即使一個標記介面
 * 2、若我們定義的介面繼承了Repository，則該介面會被IOC容器識別為一個Repository Bean
 * 納入到IOC容器中，進而可以在該介面中定義滿足一定規範的方法
 * 3、可以通過註解的方式標記Repository介面
 */
/**
 * 方式一：繼承Repository<Person,Integer>介面
 * public interface PersonRepsotory extends Repository<Person,Integer>{
 * */

/**
 * 方式二：註解@RepositoryDefinition(domainClass=Person.class,idClass=Integer.class)
 * 
 */
/**
 * 在Repository子介面中宣告方法 
 * 1、不是隨便宣告的，而需要符合一定的規範 
 * 2、查詢方法以find | read | get開頭
 * 3、涉及條件查詢時，條件的屬性用條件關鍵字連線 
 * 4、要注意的是：條件屬性以首字母大寫
 * 5、支援屬性的級聯查詢，若當前類有符合條件的屬性，則優先使用，而不使用級聯屬性。若需要使用級聯屬性，則屬性之間使用_連線
 *
 */
// @RepositoryDefinition(domainClass=Person.class,idClass=Integer.class)
//public interface PersonRepsotory extends Repository<Person, Integer>{
//public interface PersonRepsotory extends CrudRepository<Person, Integer>{
//public interface PersonRepsotory extends JpaRepository<Person, Integer>,JpaSpecificationExecutor<Person>{

public interface PersonRepsotory extends Repository<Person, Integer>{
	
	// 根據lastName來獲取對應的Person
	Person getByLastName(String lastName);

	// Where lastName like ?% And id < ?
	List<Person> getByLastNameStartingWithAndIdLessThan(String lastName, Integer id);

	// Where lastName like %? And id < ?
	List<Person> getByLastNameEndingWithAndIdLessThan(String lastName, Integer id);
	
	//WHERE email IN (?, ?, ?) OR birth < ?
	List<Person> getByEmailInAndBirthLessThan(List<String> emails, Date birth);

	//WHERE a.id > ?
	List<Person> getByAddress_IdGreaterThan(Integer id);
	
	//查詢 id 值最大的那個 Person
	//使用 @Query 註解可以自定義 JPQL 語句以實現更靈活的查詢
	@Query("SELECT p FROM Person p WHERE p.id = (SELECT max(p2.id) FROM Person p2)")
	Person getMaxIdPerson();
	
	//為 @Query 註解傳遞引數的方式1: 使用佔位符. 
	@Query("SELECT p FROM Person p WHERE p.lastName = ?1 AND p.email = ?2")
	List<Person> testQueryAnnotationParams1(String lastName, String email);
	
	//為 @Query 註解傳遞引數的方式1: 命名引數的方式. 
	@Query("SELECT p FROM Person p WHERE p.lastName = :lastName AND p.email = :email")
	List<Person> testQueryAnnotationParams2(@Param("email") String email, @Param("lastName") String lastName);
	
	//SpringData 允許在佔位符上新增 %%. 
	@Query("SELECT p FROM Person p WHERE p.lastName LIKE %?1% OR p.email LIKE %?2%")
	List<Person> testQueryAnnotationLikeParam(String lastName, String email);
	
	//SpringData 允許在佔位符上新增 %%. 
	@Query("SELECT p FROM Person p WHERE p.lastName LIKE %:lastName% OR p.email LIKE %:email%")
	List<Person> testQueryAnnotationLikeParam2(@Param("email") String email, @Param("lastName") String lastName);
	
	//設定 nativeQuery=true 即可以使用原生的 SQL 查詢
	@Query(value="SELECT count(id) FROM jpa_persons", nativeQuery=true)
	long getTotalCount();
	
	//可以通過自定義的 JPQL 完成 UPDATE 和 DELETE 操作. 注意: JPQL 不支援使用 INSERT
	//在 @Query 註解中編寫 JPQL 語句, 但必須使用 @Modifying 進行修飾. 以通知 SpringData, 這是一個 UPDATE 或 DELETE 操作
	//UPDATE 或 DELETE 操作需要使用事務, 此時需要定義 Service 層. 在 Service 層的方法上新增事務操作. 
	//預設情況下, SpringData 的每個方法上有事務, 但都是一個只讀事務. 他們不能完成修改操作!
	@Modifying
	@Query("UPDATE Person p SET p.email = :email WHERE id = :id")
	void updatePersonEmail(@Param("id") Integer id, @Param("email") String email);
	
}

PersonService類

package com.test.springdata;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class PersonService {

	@Autowired
	private PersonRepsotory personRepsotory;
	
	@Transactional
	public void savePersons(List<Person> persons){
		personRepsotory.save(persons);
	}
	
	@Transactional
	public void updatePersonEmail(String email, Integer id){
		personRepsotory.updatePersonEmail(id, email);
	}
}

package com.test.springdata.test;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;

import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Path;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import javax.sql.DataSource;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.data.domain.Sort.Direction;
import org.springframework.data.domain.Sort.Order;
import org.springframework.data.jpa.domain.Specification;

import com.test.springdata.Person;
import com.test.springdata.PersonRepsotory;
import com.test.springdata.PersonService;


public class SpringDataTest {

	private ApplicationContext ctx = null;
	private PersonRepsotory personRepsotory = null;
	private PersonService personService;
	
	{
		ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
		personRepsotory = ctx.getBean(PersonRepsotory.class);
		personService = ctx.getBean(PersonService.class);
	}
	
	/*@Test
	public void testCommonCustomRepositoryMethod(){
		ApplicationContext ctx2 = new ClassPathXmlApplicationContext("classpath:com/atguigu/springdata/commonrepositorymethod/applicationContext2.xml");
		AddressRepository addressRepository = ctx2.getBean(AddressRepository.class);
		addressRepository.method();
	}
	
	@Test
	public void testCustomRepositoryMethod(){
		personRepsotory.test();
	}*/
		
	/**
	 * 目標: 實現帶查詢條件的分頁. id > 5 的條件
	 * 
	 * 呼叫 JpaSpecificationExecutor 的 Page<T> findAll(Specification<T> spec, Pageable pageable);
	 * Specification: 封裝了 JPA Criteria 查詢的查詢條件
	 * Pageable: 封裝了請求分頁的資訊: 例如 pageNo, pageSize, Sort
	 */
	/*@Test
	public void testJpaSpecificationExecutor(){
		int pageNo = 3 - 1;
		int pageSize = 5;
		PageRequest pageable = new PageRequest(pageNo, pageSize);
		
		//通常使用 Specification 的匿名內部類
		Specification<Person> specification = new Specification<Person>() {
			*//**
			 * @param *root: 代表查詢的實體類. 
			 * @param query: 可以從中可到 Root 物件, 即告知 JPA Criteria 查詢要查詢哪一個實體類. 還可以
			 * 來新增查詢條件, 還可以結合 EntityManager 物件得到最終查詢的 TypedQuery 物件. 
			 * @param *cb: CriteriaBuilder 物件. 用於建立 Criteria 相關物件的工廠. 當然可以從中獲取到 Predicate 物件
			 * @return: *Predicate 型別, 代表一個查詢條件. 
			 *//*
			@Override
			public Predicate toPredicate(Root<Person> root,
					CriteriaQuery<?> query, CriteriaBuilder cb) {
				Path path = root.get("id");
				Predicate predicate = cb.gt(path, 5);
				return predicate;
			}
		};
		
		Page<Person> page = personRepsotory.findAll(specification, pageable);
		
		System.out.println("總記錄數: " + page.getTotalElements());
		System.out.println("當前第幾頁: " + (page.getNumber() + 1));
		System.out.println("總頁數: " + page.getTotalPages());
		System.out.println("當前頁面的 List: " + page.getContent());
		System.out.println("當前頁面的記錄數: " + page.getNumberOfElements());
	}*/
	
	/*@Test
	public void testJpaRepository(){
		Person person = new Person();
		person.setBirth(new Date());
		person.setEmail("[email protected]");
		person.setLastName("xyz");
		
		Person person2 = personRepsotory.saveAndFlush(person);
		
		System.out.println(person == person2);
	}*/
	
	/*@Test
	public void testPagingAndSortingRespository(){
		//pageNo 從 0 開始. 
		int pageNo = 0;
		int pageSize = 5;
		//Pageable 介面通常使用的其 PageRequest 實現類. 其中封裝了需要分頁的資訊
		//排序相關的. Sort 封裝了排序的資訊
		//Order 是具體針對於某一個屬性進行升序還是降序. 
		Order order1 = new Order(Direction.DESC, "id");
		Order order2 = new Order(Direction.ASC, "email");
		Sort sort = new Sort(order1, order2);
		
		PageRequest pageable = new PageRequest(pageNo, pageSize, sort);
		Page<Person> page = personRepsotory.findAll(pageable);
		
		System.out.println("總記錄數: " + page.getTotalElements());
		System.out.println("當前第幾頁: " + (page.getNumber() + 1));
		System.out.println("總頁數: " + page.getTotalPages());
		System.out.println("當前頁面的 List: " + page.getContent());
		System.out.println("當前頁面的記錄數: " + page.getNumberOfElements());
	}*/
	
	@Test
	public void testCrudReposiory(){
		List<Person> persons = new ArrayList<>();
		
		for(int i = 'a'; i <= 'z'; i++){
			Person person = new Person();
			person.setAddressId(i + 1);
			person.setBirth(new Date());
			person.setEmail((char)i + "" + (char)i + "@atguigu.com");
			person.setLastName((char)i + "" + (char)i);
			
			persons.add(person);
		}
		
		personService.savePersons(persons);
	}
	
	@Test
	public void testModifying(){
//		personRepsotory.updatePersonEmail(1, "[email protected]");
		personService.updatePersonEmail("[email protected]", 1);
	}
	
	@Test
	public void testNativeQuery(){
		long count = personRepsotory.getTotalCount();
		System.out.println(count);
	}
	
	@Test
	public void testQueryAnnotationLikeParam(){
//		List<Person> persons = personRepsotory.testQueryAnnotationLikeParam("%A%", "%bb%");
//		System.out.println(persons.size());
		
//		List<Person> persons = personRepsotory.testQueryAnnotationLikeParam("A", "bb");
//		System.out.println(persons.size());
		
		List<Person> persons = personRepsotory.testQueryAnnotationLikeParam2("bb", "A");
		System.out.println(persons.size());
	}
	
	@Test
	public void testQueryAnnotationParams2(){
		List<Person> persons = personRepsotory.testQueryAnnotationParams2("[email protected]", "AA");
		System.out.println(persons);
	}
	
	@Test
	public void testQueryAnnotationParams1(){
		List<Person> persons = personRepsotory.testQueryAnnotationParams1("AA", "[email protected]");
		System.out.println(persons);
	}
	
	@Test
	public void testQueryAnnotation(){
		Person person = personRepsotory.getMaxIdPerson();
		System.out.println(person);
	}
	
	@Test
	public void testKeyWords2(){
		List<Person> persons = personRepsotory.getByAddress_IdGreaterThan(1);
		System.out.println(persons);
	}
	
	@Test
	public void testKeyWords(){
		List<Person> persons = personRepsotory.getByLastNameStartingWithAndIdLessThan("X", 10);
		System.out.println(persons);
		
		persons = personRepsotory.getByLastNameEndingWithAndIdLessThan("X", 10);
		System.out.println(persons);
		
		persons = personRepsotory.getByEmailInAndBirthLessThan(Arrays.asList("[email protected]", "[email protected]", 
				"[email protected]"), new Date());
		System.out.println(persons.size());
	}
	
	@Test
	public void testHelloWorldSpringData() throws FileNotFoundException, IOException, InstantiationException, IllegalAccessException{
		System.out.println(personRepsotory.getClass().getName());
		
		Person person = personRepsotory.getByLastName("AA");
		System.out.println(person);
	}
	
	@Test
	public void testJpa(){
		
	}
	
	@Test
	public void testDataSource() throws SQLException {
		DataSource dataSource = ctx.getBean(DataSource.class);
		System.out.println(dataSource.getConnection());
	}

}

不屬於Repository體系，實現一組 JPA Criteria 查詢相關的方法 


Specification：封裝  JPA Criteria 查詢條件。

通常使用匿名內部類的方式來建立該介面的物件

示例程式碼：

Test程式碼，其他程式碼參考JpaRepository

/**
	 * 目標: 實現帶查詢條件的分頁. id > 5 的條件
	 * 
	 * 呼叫 JpaSpecificationExecutor 的 Page<T> findAll(Specification<T> spec, Pageable pageable);
	 * Specification: 封裝了 JPA Criteria 查詢的查詢條件
	 * Pageable: 封裝了請求分頁的資訊: 例如 pageNo, pageSize, Sort
	 */
	@Test
	public void testJpaSpecificationExecutor(){
		int pageNo = 3 - 1;
		int pageSize = 5;
		PageRequest pageable = new PageRequest(pageNo, pageSize);
		
		//通常使用 Specification 的匿名內部類
		Specification<Person> specification = new Specification<Person>() {
			/**
			 * @param *root: 代表查詢的實體類. 
			 * @param query: 可以從中可到 Root 物件, 即告知 JPA Criteria 查詢要查詢哪一個實體類. 還可以
			 * 來新增查詢條件, 還可以結合 EntityManager 物件得到最終查詢的 TypedQuery 物件. 
			 * @param *cb: CriteriaBuilder 物件. 用於建立 Criteria 相關物件的工廠. 當然可以從中獲取到 Predicate 物件
			 * @return: *Predicate 型別, 代表一個查詢條件. 
			 */
			@Override
			public Predicate toPredicate(Root<Person> root,
					CriteriaQuery<?> query, CriteriaBuilder cb) {
				Path path = root.get("id");
				Predicate predicate = cb.gt(path, 5);
				return predicate;
			}
		};
		
		Page<Person> page = personRepsotory.findAll(specification, pageable);
		
		System.out.println("總記錄數: " + page.getTotalElements());
		System.out.println("當前第幾頁: " + (page.getNumber() + 1));
		System.out.println("總頁數: " + page.getTotalPages());
		System.out.println("當前頁面的 List: " + page.getContent());
		System.out.println("當前頁面的記錄數: " + page.getNumberOfElements());
	}

七、自定義Repository介面

步驟：

• 定義一個介面: 宣告要新增的, 並自實現的方法
• 提供該介面的實現類: 類名需在要宣告的 Repository 後新增 Impl, 並實現方法
• 宣告 Repository 介面, 並繼承 1) 宣告的介面使用。

示例程式碼：

PersonDao介面

package com.test.springdata;

public interface PersonDao {
	
	void test();
	
}

package com.test.springdata;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

public class PersonRepsotoryImpl implements PersonDao {
	
	@PersistenceContext
	private EntityManager entityManager;
	
	@Override
	public void test() {
		Person person = entityManager.find(Person.class, 11);
		System.out.println("-->" + person);
	}

}

Test方法

@Test
	public void testCustomRepositoryMethod(){
		personRepsotory.test();
	}

八、@Query註解

8.1 使用@Query自定義查詢，這種查詢可以宣告在Repository方法中，擺脫像命名查詢那樣的約束，將查詢直接在響應的介面方法中宣告，結構更為清晰，這是Spring data的特有實現。

//為 @Query 註解傳遞引數的方式1: 命名引數的方式. 
	@Query("SELECT p FROM Person p WHERE p.lastName = :lastName AND p.email = :email")
	List<Person> testQueryAnnotationParams2(@Param("email") String email, @Param("lastName") String lastName);

//設定 nativeQuery=true 即可以使用原生的 SQL 查詢
	@Query(value="SELECT count(id) FROM jpa_persons", nativeQuery=true)
	long getTotalCount();

九、@Modifying註解

在 @Query 註解中編寫 JPQL 語句, 但必須使用 @Modifying 進行修飾. 以通知 SpringData, 這是一個 UPDATE 或 DELETE 操作

//可以通過自定義的 JPQL 完成 UPDATE 和 DELETE 操作. 注意: JPQL 不支援使用 INSERT
	//在 @Query 註解中編寫 JPQL 語句, 但必須使用 @Modifying 進行修飾. 以通知 SpringData, 這是一個 UPDATE 或 DELETE 操作
	//UPDATE 或 DELETE 操作需要使用事務, 此時需要定義 Service 層. 在 Service 層的方法上新增事務操作. 
	//預設情況下, SpringData 的每個方法上有事務, 但都是一個只讀事務. 他們不能完成修改操作!
	@Modifying
	@Query("UPDATE Person p SET p.email = :email WHERE id = :id")
	void updatePersonEmail(@Param("id") Integer id, @Param("email") String email);