SpringData整合JPA

红太狼 2022-03-31 13:20 443阅读 0赞

>        **如果我的博客能够帮到大家能够点个赞，关注一下，以后还会更新更过JavaWeb的高级技术，大家的支持就是我继续更新的动力。谢谢。**

**以下来演示一下，JPA的一些接口的使用。首先创建一个Java Project。在当前工程下创建一个lib 目录,导入以下Jar 包:**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x2aGFvZ3Vhbmcw_size_16_color_FFFFFF_t_70][]

*  ### **项目工程结构：** ###

**![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x2aGFvZ3Vhbmcw_size_16_color_FFFFFF_t_70 1][]**

*  ** 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.nyist.SpringData"></context:component-scan>
    	
    	<context:property-placeholder location="classpath:db.properties"/>
    	
    	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    		<property name="user" value="${jdbc.user}"></property>
    		<property name="password" value="${jdbc.password}"></property>
    		<property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
    		<property name="driverClass" value="${jdbc.driverClass}"></property>
    		
    	</bean>
    	
    	<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.nyist.SpringData"></property>
    		
    		<property name="jpaProperties">
    			<props>
    				
    				
    				
    				<prop key="hibernate.ejb.naming_strategy">org.hibernate.cfg.ImprovedNamingStrategy</prop>
    				
    				<prop key="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</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>
    	
    	<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
    		<property name="entityManagerFactory" ref="entityManagerFactory"></property>	
    	</bean>
    	
    	<tx:annotation-driven transaction-manager="transactionManager"/>
    	
    	
    	
    	<jpa:repositories base-package="com.nyist.SpringData" entity-manager-factory-ref="entityManagerFactory"></jpa:repositories>
    </beans>

*  ### db.properties ###

jdbc.user=root
    jdbc.password=root
    jdbc.driverClass=com.mysql.jdbc.Driver
    jdbc.jdbcUrl=jdbc:mysql:///jpa

*  ### 创建实体 ###
    
     *  **Person.class**

package com.nyist.SpringData.Entity;
    
    import java.util.Date;
    
    import javax.persistence.Table;
    import javax.persistence.Column;
    import javax.persistence.Entity;
    import javax.persistence.GeneratedValue;
    import javax.persistence.Id;
    import javax.persistence.JoinColumn;
    import javax.persistence.ManyToOne;
    
    @Table(name="JPA_PERSON")
    @Entity
    public class Person {
    	
    	//@GeneratedVale 自动生成主键
    	@GeneratedValue
    	@Id				//指定ID
    	private Integer id;
    	private String lastName;
    	private String email;
    	private Date birth;
    	//@ManyToOne  多对1   一个人对应多个地址
    	@JoinColumn(name="ADDRESS")
    	@ManyToOne
    	private Address address;
    	@Column(name="ADD_ID")
    	private Integer addressId;
    	
    	public Integer getAddressId() {
    		return addressId;
    	}
    	public void setAddressId(Integer addressId) {
    		this.addressId = addressId;
    	}
    	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;
    	}
    	
    	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 + ", birth=" + birth + "]";
    	}
    	
    }

*  **Address.class**

package com.nyist.SpringData.Entity;
    
    import javax.persistence.Entity;
    import javax.persistence.GeneratedValue;
    import javax.persistence.Id;
    import javax.persistence.Table;
    
    @Table(name="JPA_ADDEESS")
    @Entity
    public class Address {
    	@GeneratedValue
    	@Id
    	private Integer id;
    	private String province;
    	private String city;
    	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;
    	}
    	@Override
    	public String toString() {
    		return "Address [id=" + id + ", province=" + province + ", city=" + city + ", getId()=" + getId()
    				+ ", getProvince()=" + getProvince() + ", getCity()=" + getCity() + ", getClass()=" + getClass()
    				+ ", hashCode()=" + hashCode() + ", toString()=" + super.toString() + "]";
    	}
    	
    }

1.  **创建PersonRepository.class 接口，内容如下：**

package com.nyist.SpringData.Repostiory;
    import java.util.Date;
    import java.util.List;
    
    import org.springframework.data.jpa.repository.Modifying;
    import org.springframework.data.jpa.repository.Query;
    import org.springframework.data.repository.Repository;
    import org.springframework.data.repository.query.Param;
    
    import com.nyist.SpringData.Entity.Person;
    /*
     * 1.Repositiory 是一个空接口,即是一个标记接口。
     * 2.若我们的接口继承了Repository,则该接口会被IOC容器识别为一个Repository Bean
     * 纳入到IOC容器中,进而可以在该接口中定义满足一定的规范方法。
     * 3.实际上  也可以通过一个注解 @RepositoryDefinition 来代替继承Repository 接口
     */
    //Repostiory<Person,Integer> 需要处理的类型  主键类型
    //@RepositoryDefinition(domainClass=Person.class,idClass=Integer.class)
    /**
     * 在 Repository 子接口中声明方法
     * 1.不是随便声明的,而需要符合一定的规范
     * 2.按照 Spring Data 的规范，查询方法以 find | read | get 开头， 
     * 3.涉及条件查询时，条件的属性用条件关键字连接，
     * 4.要注意的是：条件属性以首字母大写。 
     * 5.若当前类又符合条件的属性优先使用,而不是用级联属性,若需要使用级联属性,则属性之间使用 _ 连接
     * @author LHG
     *
     */
    public interface PersonRepostory extends Repository<Person,Integer>{
    	//使用SpringData的给定的关键字  来查询
    	Person getByLastName(String lastName);
    
    	//WHERE lastName Like ?% And id < ?
    	List<Person> getByLastNameStartingWithAndIdLessThan(String lastName,Integer id);
    	
    	//WHERE lastName Like %? and id < ?
    	List<Person> getByLastNameEndingWithAndIdGreaterThan(String lastName,Integer id);
    	
    	//WHERE email IN(?,?,?) OR birth < ?
    	List<Person> getByEmailInOrBirthLessThan(String email,Date birth);
    	
    	//WHERE a.id>?
    	//级联属性  AddressId 首先在Person类中 找AddressId 如果找不到 去Address下找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();
    	
    	//为Qeury 注解传递参数的方式 ：使用占位符 
    	@Query("SELECT p FROM Person p WHERE p.lastName = ?1 AND p.email = ?2")
    	List<Person> testQueryAnnotationParms(String lastName,String email);
    	
    	//为Query 注解传递参数的方式:命名参数的方式
    	@Query("SELECT p FROM Person p WHERE p.lastName = :lastName AND p.email = :email")
    	List<Person> testQueryAnnotationParms1(@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> testQueryAnnotationLikeParm(String lastName,String email);
    	
    	//SpringData 允许在占位符上添加  命名参数的形式
    	@Query("SELECT p FROM Person p WHERE p.lastName LIKE %:lastName% OR p.email LIKE %:email%")
    	List<Person> testQueryAnnotationLikeParm2(@Param("email")String email,@Param("lastName")String lastName);
    	
    	//本地SQL查询
    	//设置 nativeQuer=true 即可以使用原生的SQL查询
    	@Query(value="SELECT count(id) FROM jpa_person",nativeQuery=true)
    	long getTotalCount();
    	
    	
    	//Modifying 标明 要做修改
    	//可以通过自定义的JPQL　完成　UPDATE　和　DELETE　操作,注意：JPQL 不支持使用INSERT 
    	//在Query注解中编写JPQL语句　但必须使用Modifying 注解,这是update 或 delete 操作
    	//在 update 或 delete 操作时候需要使用事务,次似需要定义Service 层,在Service层的方法上添加事务操作。
    	//默认情况下 SpringData 的每个方法上有事务,但都是只读事务,他们不能完成修改操作。
    	@Modifying
    	@Query("update Person p set p.email = :email where p.id = :id")
    	void updatePersonEmail(@Param("id")Integer id,@Param("email")String email);
    }

** 2.测试PersonRepository类如下：**

package com.nyist.SpringData.Test;
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.List;
    
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    import com.nyist.SpringData.Entity.Person;
    import com.nyist.SpringData.Repostiory.PersonRepostory;
    import com.nyist.SpringData.Service.PersonService;
    
    
    
    public class TestPersonRepository {
    	
    	private static ApplicationContext ctx=null;
    	private static PersonRepostory personRepostory = null;
    	private static PersonService personService = null;
    	static{
    		ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
    		personRepostory = ctx.getBean(PersonRepostory.class);
    		personService = ctx.getBean(PersonService.class);
    	}
    	@Test
    	public void testJpa(){}
    	
    	@Test
    	public void testDataSource(){
    		Object dataSource = ctx.getBean("dataSource");
    		System.out.println("DataSource:"+dataSource);
    	}
    	
    	@Test
    	public void testHelloWorldSpringData(){
    		PersonRepostory personRepostiory = ctx.getBean(PersonRepostory.class);
    		System.out.println(personRepostiory.getClass().getName());
    		Person person = personRepostiory.getByLastName("AA");
    		System.out.println(person);
    	}
    	
    	@Test
    	public void testgetByLastNameStaringWithAndIdLessThan(){
    		PersonRepostory personRepostory = ctx.getBean(PersonRepostory.class);
    		List<Person> repostory = personRepostory.getByLastNameStartingWithAndIdLessThan("h",10);
    		System.out.println(repostory);
    		
    	}
    	
    	@Test
    	public void testgetByLastNameEndingWithAndIdGreaterThan(){
    		PersonRepostory personRepostory = ctx.getBean(PersonRepostory.class);
    		List<Person> list = personRepostory.getByLastNameEndingWithAndIdGreaterThan("o", 10);
    		System.out.println(list);
    	}
    	
    	@Test
    	public void testgetByEmailInOrBirthLessThan() throws ParseException{
    		PersonRepostory personRepostory = ctx.getBean(PersonRepostory.class);
    		SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
    		String s = "2019-02-01";
    		List<Person> list = personRepostory.getByEmailInOrBirthLessThan("@qq.com",simpleDateFormat.parse(s));
    		System.out.println(list);
    	}
    	
    	@Test
    	public void testgetByAddressIdGreaterThan(){
    		PersonRepostory personRepostory = ctx.getBean(PersonRepostory.class);
    		List<Person> list = personRepostory.getByAddress_IdGreaterThan(5);
    		System.out.println(list);
    	}
    	
    	@Test
    	public void testQueryAnnotation(){
    		PersonRepostory personRepostory = ctx.getBean(PersonRepostory.class);
    		Person person = personRepostory.getMaxIdPerson();
    		System.out.println(person);
    	}
    	
    	@Test
    	public void testQueryAnnotationParms(){
    		PersonRepostory personRepostory = ctx.getBean(PersonRepostory.class);
    		List<Person> person =personRepostory.testQueryAnnotationParms("AA","qq@qq.com");
    		System.out.println(person);
    	}
    	
    	@Test
    	public void testQueryAnnotationParms1(){
    		List<Person> list = personRepostory.testQueryAnnotationParms1("qq@qq.com","AA");
    		System.out.println(list);
    	}
    	
    	
    	@Test
    	public void testQueryAnnotationListParm(){
    		List<Person> list = personRepostory.testQueryAnnotationLikeParm("AA","qq");
    		System.out.println(list);
    	}
    	
    	@Test
    	public void testQueryAnnotationLikeParm2(){
    		List<Person> list = personRepostory.testQueryAnnotationLikeParm2("AA","qq");
    		System.out.println(list);
    	}
    	
    	@Test
    	public void testgetTotalCoung(){
    		long l = personRepostory.getTotalCount();
    		System.out.println(l);
    	}
    	
    	@Test
    	public void testupdatePersonEmail(){
    		personService.updatePersonEmail("AAAAAAQ@qq.com", 1);
    	}
    	
    }

**3.CRUDRepository.java 内容如下：**

package com.nyist.SpringData.Repostiory;
    
    import org.springframework.data.repository.CrudRepository;
    
    import com.nyist.SpringData.Entity.Person;
    
    public interface CRUDRepostory extends CrudRepository<Person,Integer>{
    	/**
    	 * 所有接口:
    	 * 
    	* 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();//删除所有实体,不用或慎用! 
    
    
    	 */
    }

**4.因为做增删改需要依赖事务，事务一般时在业务逻辑上进行的，所以编写了一个CrudRepository.java，内容如下：**

package com.nyist.SpringData.Service;
    
    import java.util.List;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import org.springframework.transaction.annotation.Transactional;
    
    import com.nyist.SpringData.Entity.Person;
    import com.nyist.SpringData.Repostiory.CRUDRepostory;
    
    @Service
    public class CrudRepositoryService {
    	
    	@Autowired
    	private CRUDRepostory crudRepository;
    	
    	@Transactional
    	public void savePerson(List<Person> persons){
    		crudRepository.save(persons);
    	}
    	
    	//开启事务
    	@Transactional
    	public Person getById(Integer id){
    		return crudRepository.findOne(id);
    	}
    	
    	@Transactional
    	public boolean isExistsId(Integer id){
    		return crudRepository.exists(id);
    	}
    	
    	@Transactional
    	public List<Person> selectAll(){
    		return (List<Person>) crudRepository.findAll();
    	}
    	
    	@Transactional
    	public int deleteById(Integer id){
    		crudRepository.delete(id);
    		return 0;
    	}
    }

**5.测试TestCrudRepository类如下：**

package com.nyist.SpringData.Test;
    
    import java.util.ArrayList;
    import java.util.Date;
    import java.util.List;
    
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    import com.nyist.SpringData.Entity.Person;
    import com.nyist.SpringData.Service.CrudRepositoryService;
    
    public class TestCrudRepository {
    
    	private static ApplicationContext ctx = null;
    	private static CrudRepositoryService crudRepositoryService;
    	static{
    		ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
    		crudRepositoryService = ctx.getBean(CrudRepositoryService.class);
    	}
    	
    	
    	@Test
    	public void testCrudRepository(){
    		List<Person> list = new ArrayList<Person>();
    		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+"@nyist.com");
    			person.setLastName((char)i+""+(char)i);
    			list.add(person);
    		}
    		crudRepositoryService.savePerson(list);
    	}
    	
        @Test
        public void testgetById(){
        	Person person = crudRepositoryService.getById(1);
        	System.out.println("查询单个实体:"+person);
        }
        
        @Test
        public void testisExistsId(){
        	boolean bol = crudRepositoryService.isExistsId(5);
        	System.out.println("是否存在:"+bol);
        }
        @Test
        public void testSelectAll(){
        	List<Person> persons = crudRepositoryService.selectAll();
        	System.out.println("总实体:"+persons);
        }
        
        @Test
        public void testDeleteById(){
        	System.out.println(crudRepositoryService.deleteById(20));
        }
    }

**6.PagingAndSortingRepository.java 内容如下：**

package com.nyist.SpringData.Repostiory;
    
    import com.nyist.SpringData.Entity.Person;
    public interface PagingAndSortingRepository extends org.springframework.data.repository.PagingAndSortingRepository<Person,Integer>{
    	/***
    	 *  Iterable<T> findAll(Sort sort); //排序 
    		Page<T> findAll(Pageable pageable); //分页查询（含排序功能） 
    	 */
    }

**7.TestPagingAndSortingRepository测试类**

package com.nyist.SpringData.Test;
    
    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.Pageable;
    import org.springframework.data.domain.Sort;
    import org.springframework.data.domain.Sort.Direction;
    import org.springframework.data.domain.Sort.Order;
    import org.springframework.data.repository.PagingAndSortingRepository;
    
    import com.nyist.SpringData.Entity.Person;
    
    
    public class TestPaginAndSortingRepository {
    	
    	private static ApplicationContext ctx = null;
    	private static PagingAndSortingRepository pagingAndSortingRepository;
    	static{
    		ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
    		pagingAndSortingRepository = ctx.getBean(PagingAndSortingRepository.class);
    	}
    	
    	@Test
    	public void testPagingAndSortingRepository(){
    		//pageNo 从 0 开始
    		int pageNo = 5 - 1;
    		int pageSize = 5;
    		//Pageable 接口通常使用的是PageRequest 实现类,其中封装了实现分页的信息
    		//排序相关
    		//Order 是具体针对某一个属性进行升序还是降序
    		Order order1 = new Order(Direction.DESC,"id");
    		Order order2 = new Order(Direction.ASC,"email");
    		Sort sort = new Sort(order1,order2);
    		PageRequest pageRequest = new PageRequest(pageNo, pageSize,sort);
    		Page<Person> page = pagingAndSortingRepository.findAll(pageRequest);
    		System.out.println("总记录数:"+page.getTotalElements());
    		System.out.println("当前第几页:"+Integer.valueOf(page.getNumber())+1);
    		System.out.println("当前页面的List:"+page.getContent());
    		System.out.println("总页数:"+page.getTotalPages());
    		System.out.println("当前页面的记录数:"+page.getNumberOfElements());
    	}
    }

**8.JpaRepostory.java 内容如下：**

package com.nyist.SpringData.Repostiory;
    
    import org.springframework.data.jpa.repository.JpaRepository;
    
    import com.nyist.SpringData.Entity.Person;
    
    public interface SpringDataJpaRepository extends JpaRepository<Person,Integer>{
    	
    }

**9.测试类如下：**

package com.nyist.SpringData.Test;
    
    import java.util.Date;
    
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    import com.nyist.SpringData.Entity.Person;
    import com.nyist.SpringData.Repostiory.SpringDataJpaRepository;
    
    public class TestJpaRepository {
    	
    	private static ApplicationContext ctx = null;
    	private static SpringDataJpaRepository jpaRepository = null;
    	static{
    		ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
    		jpaRepository = ctx.getBean(SpringDataJpaRepository.class);
    	}
    	
    	@Test
    	public void testJapRepository(){
    		Person person = new Person();
    		person.setBirth(new Date());
    		person.setEmail("XYZ@nyist.com");
    		person.setLastName("XY");	
    		person.setId(27);
    		Person person2 = jpaRepository.saveAndFlush(person);
    		System.out.println(person==person2);
    	}
    }

**10.SpringDataJpaSpecificationExecutor.java 内容如下：**

package com.nyist.SpringData.Repostiory;
    
    import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
    
    import com.nyist.SpringData.Entity.Person;
    
    public interface SpringDataJpaSpecificationExecutor extends PagingAndSortingRepository,JpaSpecificationExecutor<Person>{
    	
    }

**11.测试类如下：**

package com.nyist.SpringData.Test;
    
    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 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.jpa.domain.Specification;
    
    import com.nyist.SpringData.Entity.Person;
    import com.nyist.SpringData.Repostiory.SpringDataJpaSpecificationExecutor;
    
    public class TestJpaSpecificationExecutor {
    	
    	private static ApplicationContext ctx = null;
    	private static SpringDataJpaSpecificationExecutor specificationExecutor = null;
    	static{
    		ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
    		specificationExecutor = ctx.getBean(SpringDataJpaSpecificationExecutor.class);
    	}
    	
    	//分页排序
    	@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 对象最终查询的TypeQuery 对象。
    			 * @Param *cb: CriteriaBuilder 对象。用于创建Criteria 相关对象的工厂,当然可以从中获取Predicate 对象
    			 * @return *Predicate 类型：代表一个查询条件。
    			 */ 
    			@Override
    			public Predicate toPredicate(Root<Person> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
    				//获得 实体类得 某个属性  eg:获得Id 按照Id 属性排列
    				Path path = root.get("id");
    				//cb.get()调用get方法 获得查询条件 
    				Predicate predicate = cb.gt(path,20);
    				//返回查询条件
    				return predicate;
    			}
    			
    		};
    		Page<Person> page = specificationExecutor.findAll(specification, pageable);
    		System.out.println("总记录数:"+page.getTotalElements());
    		System.out.println("当前第几页:"+(page.getNumber()+1));
    		System.out.println("当前页面的List:"+page.getContent());
    		System.out.println("总页数:"+page.getTotalPages());
    		System.out.println("当前页面的记录数:"+page.getNumberOfElements());
    	}
    }

**以上是JPA的几个接口的使用和测试方法。**

**================================================================================================**

**最后辐上JPAxia相关的笔记，仅供大家参考**

SpringData JPA

**一、SpringData**

1.**Spring Data**

Spring 的一个子项目。用于简化数据库访问，支持**NoSQL** 和 **关系数据存储**。其主要目标是使数据库的访问变得方便快捷。

*  SpringData 项目所支持 **NoSQL** **存储**：
    
     *  MongoDB （文档数据库）
     *  Neo4j（图形数据库）
     *  Redis（键/值存储）
     *  Hbase（列族数据库）
 *  SpringData 项目所支持的**关系数据存储技术**：
    
     *  JDBC
     *  **JPA**

**2.** **JPA Spring Data** **概述**

*  JPA Spring Data : 致力于减少数据访问层 (DAO) 的开发量. 开发者唯一要做的，就只是**声明持久层的接口**，其他都交给 Spring Data JPA 来帮你完成！
 *  框架怎么可能代替开发者实现业务逻辑呢？比如：当有一个 UserDao.findUserById()  这样一个方法声明，大致应该能判断出这是根据给定条件的 ID 查询出满足条件的 User  对象。Spring Data JPA 做的便是规范方法的名字，根据符合规范的名字来确定方法需要实现什么样的逻辑。

*  **使用 Spring Data JPA 进行持久层开发需要的四个步骤：**
    
     *  **配置** **Spring** **整合** **JPA**
     *  **在** **Spring** **配置文件中配置** **Spring Data，**让 Spring 为声明的接口创建代理对象。配置了 <jpa:repositories> 后，Spring 初始化容器时将会扫描 base-package  指定的包目录及其子目录，为继承 Repository 或其子接口的接口创建代理对象，并将代理对象注册为 Spring Bean，业务层便可以通过 Spring 自动封装的特性来直接使用该对象。
     *  **声明持久层的接口，该接口继承**  **Repository**，Repository 是一个标记型接口，它不包含任何方法，如必要，Spring Data 可实现 Repository 其他子接口，其中定义了一些常用的增删改查，以及分页相关的方法。
     *  **在接口中声明需要****的方****法**。Spring Data 将根据给定的策略（具体策略稍后讲解）来为其生成实现代码。

**3. 搭建环境**

*  同时下载 Spring Data Commons 和 Spring Data JPA 两个发布包：
    
     *  Commons 是 Spring Data 的基础包
     *  并把相关的依赖 JAR 文件加入到 CLASSPATH 中
 *  在 Spring 的配置文件中配置 Spring Data

![20190103155337445.png][]

*  示例代码:

![20190103155337518.png][]

**4. Repository 接口概述**

*  Repository 接口是 Spring Data 的一个核心接口，它不提供任何方法，开发者需要在自己定义的接口中声明需要的方法 
 *  Spring Data可以让我们只定义接口，只要遵循 **Spring Data****的规范**，就无需写实现类。 
 *  **与****继承** **Repository** **等价的一种方式，就是在持久层接口上使用** **@****RepositoryDefinition** **注解**，并为其指定 domainClass 和 idClass 属性。如下两种方式是完全等价的

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

*  Repository 的子接口
    
     *  基础的 Repository 提供了最基本的数据访问功能，其几个子接口则扩展了一些功能。它们的继承关系如下： 
        
         *  **Repository**： 仅仅是一个标识，表明任何继承它的均为仓库接口类
         *  **CrudRepository**： 继承 Repository，实现了一组 CRUD 相关的方法 
         *  **PagingAndSortingRepository**： 继承 CrudRepository，实现了一组分页排序相关的方法 
         *  **JpaRepository**： 继承 PagingAndSortingRepository，实现一组 JPA 规范相关的方法 
         *  **自定义的** **XxxxRepository** 需要继承 JpaRepository，这样的 XxxxRepository 接口就具备了通用的数据访问控制层的能力。
         *  **JpaSpecificationExecutor**： 不属于Repository体系，实现一组 JPA **Criteria** 查询相关的方法

**二、SpringData 方法定义规范**

1.  **简单条件查询**
    
    1.  简单条件查询: 查询某一个实体类或者集合 
    2.  **按照** **Spring** **D****ata** **的规范**，查询方法以 **find | read | get** 开头， 
        
        **涉及条件查询时，条件的属性用条件关键字连接，要注意的是：条件属性以首字母****大写**。 
    3.  例如：定义一个 Entity 实体类 
        
        class User｛ 
        
          private String firstName; 
        
          private String lastName; 
        
        ｝ 
        
        使用And条件连接时，应这样写： 
        
        findByLastNameAndFirstName(String lastName,String firstName); 
        
        条件的属性名称与个数要与参数的位置与个数一一对应 
2.  **支持的关键字**
    
    1.  **直接在接口中定义查询方法，如果是符合规范的，可以不用写实现，目前支持的关键字写法如下：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x2aGFvZ3Vhbmcw_size_16_color_FFFFFF_t_70 2][]

**3. 查询方法解析流程**

*  假如创建如下的查询：findBy**UserDepUuid**()，框架在解析该方法时，首先剔除 findBy，然后对剩下的属性进行解析，假设查询实体为Doc
    
     *  先判断 **userDepUuid** （根据 POJO 规范，首字母变为小写）是否为查询实体的一个属性，如果是，则表示根据该属性进行查询；如果没有该属性，继续第二步；
     *  从右往左截取第一个大写字母开头的字符串(此处为**Uuid**)，然后检查剩下的字符串是否为查询实体的一个属性，如果是，则表示根据该属性进行查询；如果没有该属性，则重复第二步，继续从右往左截取；最后假设 user 为查询实体的一个属性；
     *  接着处理剩下部分（DepUuid），先判断 user 所对应的类型是否有depUuid属性，如果有，则表示该方法最终是根据 “ Doc.user.depUuid” 的取值进行查询；否则继续按照步骤 2 的规则从右往左截取，最终表示根据 “**Doc.user.dep.uuid**” 的值进行查询。
     *  可能会存在一种特殊情况，比如 Doc包含一个 user 的属性，也有一个 userDep 属性，此时会存在混淆。**可以明确在属性之间加上** **"\_"** **以显式表达意图**，比如 "findByUser\_DepUuid()" 或者 "findByUserDep\_uuid()"
 *  特殊的参数： 还可以直接在方法的参数上加入分页或排序的参数，比如：
    
     *  Page<UserModel> findByName(String name, Pageable pageable);
     *  List<UserModel> findByName(String name, Sort sort);

**4.使用@Query**

1.  **使用@Query自定义查询**

*  这种查询可以声明在 Repository 方法中，**摆脱像命名查询那样的约束，将查询直接在相应的接口方法中声明**，结构更为清晰，这是 Spring data 的特有实现。

![20190103155337641.png][]

*  **索引参数与命名参数**

*  索引参数如下所示，索引值从1开始，查询中 ”**?X**” 个数需要与方法定义的参数个数相一致，并且顺序也要一致 
 *  命名参数（推荐使用这种方式）：可以定义好参数名，赋值时采用**@****Param**("参数名")，而不用管顺序。

![20190103155337630.png][]

*  **如果****是** **@Query** **中有** **LIKE** **关键字**，后面的参数需要前面或者后面加 %，这样在传递参数值的时候就可以不加 %：
    
     *  **@Query("select o from UserModel o where o.name like ?1%")**
     *  **@Query("select o from UserModel o where o.name like %?1")**
     *  **@Query("select o from UserModel o where o.name like %?1%")**
     *  **public List<UserModel> findByUuidOrAge(String name);**
     *  **public List<UserModel> findByUuidOrAge(String name);**
     *  **public List<UserModel> findByUuidOrAge(String name);**
 *  **用@Query来指定本地查询**
    
     *  还可以使用@Query来指定本地查询，只要设置**nativeQuery****为****true**，比如：
     *  **@Query(value="select \* from tbl\_user where name like %?1" ,nativeQuery=true)**
     *  **public List<UserModel> findByUuidOrAge(String name);**

**5. @Modifying 注解和事务**

*  **@Query 与 @Modifying 执行更新操作**
    
     *  **@Query 与 @Modifying 这两个 annotation一起声明，可定义个性化更新操作，例如只涉及某些字段更新时最为常用，示例如下：**

![20190103155337606.png][]

*  **注意：**
    
     *  **方法的返回值应该是 int，表示更新语句所影响的行数**
     *  **在调用的地方必须加事务，没有事务不能正常执行**

**6.事务**

*  **Spring Data 提供了默认的事务处理方式，即所有的查询均声明为只读事务。**
 *  **对于自定义的方法，如需改变 Spring Data 提供的事务默认方式，可以在方法上注解 @Transactional 声明**
 *  **进行多个 Repository 操作时，也应该使它们在同一个事务中处理，按照分层架构的思想，这部分属于业务逻辑层，因此，需要在 Service 层实现对多个 Repository 的调用，并在相应的方法上声明事务。**

**7. 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();//删除所有实体,不用或慎用! **

**8. PagingAndSortingRepository接口**

--------------------

*  **该接口提供了分页与排序功能**
    
     *  **Iterable<T> findAll(Sort sort); //排序**
     *  **Page<T> findAll(Pageable pageable); //分页查询（含排序功能）**

**9.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);//删除一个实体集合**

**10. JpaSpecificationExecutor接口**

--------------------

*  **不属于Repository体系，实现一组 JPA Criteria 查询相关的方法 **

![20190103155337614.png][]

*  **Specification：封装  JPA Criteria 查询条件。通常使用匿名内部类的方式来创建该接口的对象**
 *  **下载源码：[下载][Link 1]**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x2aGFvZ3Vhbmcw_size_16_color_FFFFFF_t_70]: /images/20220331/80dccdabe6df4decb5e4168aff92d832.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x2aGFvZ3Vhbmcw_size_16_color_FFFFFF_t_70 1]: /images/20220331/38f52a94eb864721a3c40e800b0ce98d.png
[20190103155337445.png]: /images/20220331/f3124cb34a2340f7b8fab36e4397e8cf.png
[20190103155337518.png]: /images/20220331/33951d74653445bfa80a811171744fbb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x2aGFvZ3Vhbmcw_size_16_color_FFFFFF_t_70 2]: /images/20220331/56e187ed98cc496183e0bb924ffd106e.png
[20190103155337641.png]: /images/20220331/39851193bfb54284a1769d9eeacf3661.png
[20190103155337630.png]: /images/20220331/432fb6b9c6064994b3a7d5223cbdf0b1.png
[20190103155337606.png]: /images/20220331/87ee282d563748a5bd6100a6c10f8d9d.png
[20190103155337614.png]: /images/20220331/c008baa11ac2424cb0b0be2904dd8696.png
[Link 1]: https://download.csdn.net/download/lvhaoguang0/10897495