关于JPA总共写了三篇内容，下面附上链接：
JPA01：https://www.cnblogs.com/buwei/p/9979794.html
JPA02：https://www.cnblogs.com/buwei/p/9985287.html
JPA03：https://www.cnblogs.com/buwei/p/9985941.html
一、Spring Data JPA的概述
1.1 Spring Data JPA概述
Spring Data JPA是Spring基于ORM框架、JPA规范的基础上封装的一套JPA应用框架。他提供了包括增删改查在内的常用功能，且易于扩展。
Spring Data JPA让我们解脱了DAO的操作，基本上所有的CRUD都可以依赖于它来实现，在试驾的工程中，推荐使用Spring Data JPA+ORM（如：Hibernate）完成操作，这样在切换不同的ORM框架时提供了极大的方便，同时也使数据库层操作更加简单，方便解耦。
1.2 Spring Data JPA的特性
使用Spring Data JPA，我们的DAO层只需要写接口，就自动具有了增删改查、分页查询等方法。
1.3 Spring Data JPA与JPA和Hibernate之间的关系
JPA是一套规范，内部是由接口和抽象内组成，Hibernate是一套乘数的ORM框架，而且Hibernate实现了JPA规范，所以也可以称Hibernate是JPA的一种实现方式，我们使用JPA的API编程，是一种面向接口编程的思想。
二、Spring Data JPA的快速入门
2.1 需求说明
Spring Data JPA完成客户的基本CRUD操作
2.2 搭建Spring Data JPA的开发环境
1. 引入Spring Data JPA的坐标
使用Spring Data JPA，需要整合Spring与Spring Data JPA，并且需要提供JPA的服务提供者Hibernate，所以需要导入Spring相关坐标，Hibernate坐标，数据库驱动坐标等。
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 <dependencies> 10 <!-- junit单元测试 --> 11 <dependency> 12 <groupId>junit</groupId> 13 <artifactId>junit</artifactId> 14 <version>4.9</version> 15 <scope>test</scope> 16 </dependency> 17 18 <!-- spring beg --> 19 <dependency> 20 <groupId>org.aspectj</groupId> 21 <artifactId>aspectjweaver</artifactId> 22 <version>1.6.8</version> 23 </dependency> 24 25 <dependency> 26 <groupId>org.springframework</groupId> 27 <artifactId>spring-aop</artifactId> 28 <version>${spring.version}</version> 29 </dependency> 30 31 <dependency> 32 <groupId>org.springframework</groupId> 33 <artifactId>spring-context</artifactId> 34 <version>${spring.version}</version> 35 </dependency> 36 37 <dependency> 38 <groupId>org.springframework</groupId> 39 <artifactId>spring-context-support</artifactId> 40 <version>${spring.version}</version> 41 </dependency> 42 43 <dependency> 44 <groupId>org.springframework</groupId> 45 <artifactId>spring-orm</artifactId> 46 <version>${spring.version}</version> 47 </dependency> 48 49 <dependency> 50 <groupId>org.springframework</groupId> 51 <artifactId>spring-beans</artifactId> 52 <version>${spring.version}</version> 53 </dependency> 54 55 <dependency> 56 <groupId>org.springframework</groupId> 57 <artifactId>spring-core</artifactId> 58 <version>${spring.version}</version> 59 </dependency> 60 <!-- spring end --> 61 62 <!-- hibernate beg --> 63 <dependency> 64 <groupId>org.hibernate</groupId> 65 <artifactId>hibernate-core</artifactId> 66 <version>${hibernate.version}</version> 67 </dependency> 68 <dependency> 69 <groupId>org.hibernate</groupId> 70 <artifactId>hibernate-entitymanager</artifactId> 71 <version>${hibernate.version}</version> 72 </dependency> 73 <dependency> 74 <groupId>org.hibernate</groupId> 75 <artifactId>hibernate-validator</artifactId> 76 <version>5.2.1.Final</version> 77 </dependency> 78 <!-- hibernate end --> 79 80 <!-- c3p0 beg --> 81 <dependency> 82 <groupId>c3p0</groupId> 83 <artifactId>c3p0</artifactId> 84 <version>${c3p0.version}</version> 85 </dependency> 86 <!-- c3p0 end --> 87 88 <!-- log end --> 89 <dependency> 90 <groupId>log4j</groupId> 91 <artifactId>log4j</artifactId> 92 <version>${log4j.version}</version> 93 </dependency> 94 95 <dependency> 96 <groupId>org.slf4j</groupId> 97 <artifactId>slf4j-api</artifactId> 98 <version>${slf4j.version}</version> 99 </dependency> 100 101 <dependency> 102 <groupId>org.slf4j</groupId> 103 <artifactId>slf4j-log4j12</artifactId> 104 <version>${slf4j.version}</version> 105 </dependency> 106 <!-- log end --> 107 108 109 <dependency> 110 <groupId>mysql</groupId> 111 <artifactId>mysql-connector-java</artifactId> 112 <version>${mysql.version}</version> 113 </dependency> 114 115 <dependency> 116 <groupId>org.springframework.data</groupId> 117 <artifactId>spring-data-jpa</artifactId> 118 <version>1.9.0.RELEASE</version> 119 </dependency> 120 121 <dependency> 122 <groupId>org.springframework</groupId> 123 <artifactId>spring-test</artifactId> 124 <version>4.2.4.RELEASE</version> 125 </dependency> 126 127 <!-- el beg 使用spring data jpa 必须引入 --> 128 <dependency> 129 <groupId>javax.el</groupId> 130 <artifactId>javax.el-api</artifactId> 131 <version>2.2.4</version> 132 </dependency> 133 134 <dependency> 135 <groupId>org.glassfish.web</groupId> 136 <artifactId>javax.el</artifactId> 137 <version>2.2.4</version> 138 </dependency> 139 <!-- el end --> 140 </dependencies>
2. 整合Spring Data JPA与JPA
创建applicationContext.xml配置文件
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/spring_jpa" /> 20 <property name="user" value="root" /> 21 <property name="password" value="root" /> 22 </bean> 23 24 <!-- spring和spring data jpa的配置 --> 25 <!-- 2.配置entityManagerFactory对象交个spring容器管理 --> 26 <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean"> 27 <property name="dataSource" ref="dataSource" /> 28 <!-- 配置要扫描的包（实体类所在的包）--> 29 <property name="packagesToScan" value="com.buwei.domain" /> 30 <!-- jpa的实现厂商 --> 31 <property name="persistenceProvider"> 32 <bean class="org.hibernate.jpa.HibernatePersistenceProvider" /> 33 </property> 34 <!--JPA的供应商适配器--> 35 <property name="jpaVendorAdapter"> 36 <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"> 37 <!-- 配置是否自动创建数据库表 --> 38 <property name="generateDdl" value="false" /> 39 <!-- 指定数据库类型 --> 40 <property name="database" value="MYSQL" /> 41 <!-- 数据库方言，支持的特有语法 --> 42 <property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect" /> 43 <!-- 是否显示sql--> 44 <property name="showSql" value="true" /> 45 </bean> 46 </property> 47 48 <!-- jpa的方言：高级特性 --> 49 <property name="jpaDialect"> 50 <bean class="org.springframework.orm.jpa.vendor.HibernateJpaDialect" /> 51 </property> 52 53 <!--注入jpa的配置信息 54 加载jpa的基本配置信息和jpa实现方式（hibernate）的配置信息 55 hibernate.hbm2ddl.auto : 自动创建数据库表 56 create ： 每次都会重新创建数据库表 57 update：有表不会重新创建，没有表会重新创建表 58 none：不创建表 59 --> 60 <property name="jpaProperties" > 61 <props> 62 <prop key="hibernate.hbm2ddl.auto">update</prop> 63 </props> 64 </property> 65 66 </bean> 67 <!-- 3.事务管理器--> 68 <!-- JPA事务管理器 --> 69 <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager"> 70 <property name="entityManagerFactory" ref="entityManagerFactory" /> 71 </bean> 72 73 <!-- 整合spring data jpa--> 74 <jpa:repositories base-package="com.buwei.mapper" transaction-manager-ref="transactionManager" 75 entity-manager-factory-ref="entityManagerFactory"></jpa:repositories> 76 77 <!-- 4.txAdvice--> 78 <tx:advice id="txAdvice" transaction-manager="transactionManager"> 79 <tx:attributes> 80 <tx:method name="save*" propagation="REQUIRED"/> 81 <tx:method name="insert*" propagation="REQUIRED"/> 82 <tx:method name="update*" propagation="REQUIRED"/> 83 <tx:method name="delete*" propagation="REQUIRED"/> 84 <tx:method name="get*" read-only="true"/> 85 <tx:method name="find*" read-only="true"/> 86 <tx:method name="*" propagation="REQUIRED"/> 87 </tx:attributes> 88 </tx:advice> 89 90 <!-- 5.aop--> 91 <aop:config> 92 <aop:pointcut id="pointcut" expression="execution(* com.buwei.service.*.*(..))" /> 93 <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut" /> 94 </aop:config> 95 96 <!-- 6.配置包扫描 --> 97 <context:component-scan base-package="com.buwei"></context:component-scan> 98 99 <!--组装其它 配置文件--> 100 101 </beans>
3. 使用JPA注解配置映射关系
1 /** 2 * 所有的注解都是使用JPA的规范提供的注解， 3 * 所以在导入注解包的时候，一定要导入javax.persistence下的 4 */ 5 @Entity //声明实体类 6 @Table(name="cst_customer") //建立实体类和表的映射关系 7 public class Customer implements Serializable { 8 @Id//声明当前私有属性为主键 9 @GeneratedValue(strategy= GenerationType.IDENTITY) //配置主键的生成策略 10 @Column(name="cust_id") //指定和表中cust_id字段的映射关系 11 private Long custId; 12 13 @Column(name="cust_name") //指定和表中cust_name字段的映射关系 14 private String custName; 15 16 @Column(name="cust_source")//指定和表中cust_source字段的映射关系 17 private String custSource; 18 19 @Column(name="cust_industry")//指定和表中cust_industry字段的映射关系 20 private String custIndustry; 21 22 @Column(name="cust_level")//指定和表中cust_level字段的映射关系 23 private String custLevel; 24 25 @Column(name="cust_address")//指定和表中cust_address字段的映射关系 26 private String custAddress; 27 28 @Column(name="cust_phone")//指定和表中cust_phone字段的映射关系 29 private String custPhone; 30 31 //省略getter和setter方法 32 }
2.3 使用Spring Data JPA完成需求
1. 编写符合Spring Data JPA规范的Dao层接口
Spring Data JPA是spring提供的一款对于数据访问层（DAO）的框架，使用Spring Data JPA，只需要按照框架的规范提供DAO接口，不需要实现类就可以完成数据库的增删改查、分页查询等方法的定义。
在Spring Data JPA中，对于定义符合规范的DAO接口，我们只需要遵循以下几点就可以了：
1.创建一个DAO层接口，并实现JapReponsitory和JpaSpecificationExecutor
2.提供相应的泛型
1 /** 2 * JpaRepository<实体类类型，主键类型>：用来完成基本CRUD操作 3 * JpaSpecificationExecutor<实体类类型>：用于复杂查询（分页等查询操作） 4 */ 5 public interface CustomerDAO extends 6 JpaRepository<Customer, Long>,JpaSpecificationExecutor<Customer> { 7 8 }
2.编写测试类完成基本CRUD操作
1 @RunWith(SpringJUnit4ClassRunner.class) 2 @ContextConfiguration(locations = "classpath:applicationContext.xml") 3 public class CustomerDaoTest { 4 @Autowired 5 private CustomerDAO customerDao; 6 7 /** 8 * 保存：调用save（obj）方法 9 * 对于save方法，当执行此方法的对象中id无值，及为新增操作 10 */ 11 @Test 12 public void testInsert(){ 13 // 创建一个新的用户 14 Customer customer = new Customer(); 15 customer.setCustName("不为"); 16 // 新增 17 customerDao.save(customer); 18 } 19 20 /** 21 * 根据ID查询：调用findOne方法 22 */ 23 @Test 24 public void testFindById(){ 25 Customer customer = customerDao.findOne(1L); 26 System.out.println(customer); 27 } 28 29 /** 30 * 修改:调用save（obj）方法 31 * 对于save方法，当执行此方法的对象中id有值，及为更新操作 32 */ 33 @Test 34 public void testUpdate(){ 35 // 查询id为1的用户 36 Customer customer = customerDao.findOne(1L); 37 // 修改客户名称 38 customer.setCustName("不为——为"); 39 // 更新 40 customerDao.save(customer); 41 } 42 43 /** 44 * 根据id删除：调用delete（id）方法 45 */ 46 @Test 47 public void testDelete(){ 48 customerDao.delete(1L); 49 } 50 }
三、Spring Data JPA的内部原理剖析
3.1 Spring Data JPA的常用接口分析
在上面的案例中，我们发现对于customerDao，我们并没有提供任何方法就可以调用增删改查方法，是因为接口继承了JpaReponsitory和JpaSpecificationExecutor，我们使用的方法就是上面两个接口中的方法。
3.2 Spring Data JPA的实现过程
等理解清楚了再来作补充。。。。也欢迎大家留言。。。。
四、Spring Data JPA的查询方式
4.1 使用Spring DataJPA中接口定义的方法进行查询
上面用到的方法直接使用了JpaReponsitory与JpaSpecificationExecutor接口中的方法，源码如下：
1 @NoRepositoryBean 2 public interface JpaRepository<T, ID extends Serializable> extends PagingAndSortingRepository<T, ID> { 3 List<T> findAll(); 4 5 List<T> findAll(Sort var1); 6 7 List<T> findAll(Iterable<ID> var1); 8 9 <S extends T> List<S> save(Iterable<S> var1); 10 11 void flush(); 12 13 <S extends T> S saveAndFlush(S var1); 14 15 void deleteInBatch(Iterable<T> var1); 16 17 void deleteAllInBatch(); 18 19 T getOne(ID var1); 20 }
1 public interface JpaSpecificationExecutor<T> { 2 T findOne(Specification<T> var1); 3 4 List<T> findAll(Specification<T> var1); 5 6 Page<T> findAll(Specification<T> var1, Pageable var2); 7 8 List<T> findAll(Specification<T> var1, Sort var2); 9 10 long count(Specification<T> var1); 11 }
4.2 使用JPQL的方式查询
使用Spring Data JPA提供的查询方法已经可以解决大部分的应用场景，但是对于有些业务，我们还需要灵活的构造查询条件，这时就可以使用@Query注解，结合JPQL语句完成查询。
@Query注解的使用非常简单，只需要在方法上面标注该注解，同时童工一个JPQL查询语句即可。
1 public interface CustomerDAO extends 2 JpaRepository<Customer, Long>,JpaSpecificationExecutor<Customer> { 3 4 /** 5 * @Query 使用jpql的方式查询。 6 */ 7 @Query(value="from Customer") 8 public List<Customer> findAllCustomer(); 9 10 /** 11 * @Query 使用jpql的方式查询。?1代表参数的占位符，其中1对应方法中的参数索引 12 * @param custName 13 * @return 14 */ 15 @Query(value="from Customer where custName = ?1") 16 public Customer findCustomer(String custName); 17 18 /** 19 * @Modifying是标识该操作为修改查询操作 20 * @param custName 21 * @param custId 22 */ 23 @Query(value="update Customer set custName = ?1 where custId = ?2") 24 @Modifying 25 public void updateCustomer(String custName,Long custId); 26 }
4.3 使用SQL语句查询
使用SQL语句查询如下：
1 /** 2 * nativeQuery : 标识使用本地sql的方式查询 3 */ 4 @Query(value="select * from cst_customer",nativeQuery=true) 5 public void findBySql();
4.4 方法命名规则查询
按照Spring Data JPA定义的规则，查询方法一FindBy开头，设计条件查询时，条件的属性用条件关键词连接，方法名命名需符合小驼峰规则，框架会自动对方法名进行解析。
1 /** 2 * 方法命名方式查询（根据客户名称查询客户） 3 * @param custName 4 * @return 5 */ 6 public Customer findByCustName(String custName);
对应的具体的关键字适用方法和对应的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) |