1. Spring Data JPA是什么
Spring Data JPA是Spring Data大家族中的一员，它对对持久层做了简化，用户只需要声明方法的接口，不需要实现该接口，Spring Data JPA内部会根据不同的策略、通过不同的方法创建Query操作数据库。
使用Spring Data JPA可以在几乎不用写实现的情况下实现对数据的访问和操作，除了CRUD之外还有分页、排序等常用功能。
比如，当你看到UserDao.findUserById() 这样一个方法声明，大致应该能判断出这是根据给定条件的 ID 查询出满足条件的 User 对象。Spring Data JPA 做的便是规范方法的名字，根据符合规范的名字来确定方法需要实现什么样的逻辑。
2. 如何使用
使用Spring Data JPA的套路
1. 声明持久层的接口，该接口继承Repository，Repository是一个标记型的接口，它不包含任何方法，Spring Data JPA也提供了一些Repository的一些子接口，其中定义了一些常用的增删改查，以及分页相关的方法，我们一般并不会直接继承Repository，而是继承他的一个子类叫做JpaRepository。
2. 在接口中声明需要的业务方法，Spring Data将根据特定的策略来为其生成实现代码。
3. 在 Spring 配置文件中增加一行声明，让 Spring 为声明的接口创建代理对象。配置了 <jpa:repositories> 后，Spring 初始化容器时将会扫描 base-package 指定的包目录及其子目录，为继承 Repository 或其子接口的接口创建代理对象，并将代理对象注册为Spring Bean，业务层便可以通过 Spring 自动封装的特性来直接使用该对象。
举个栗子
项目结构如下：
Spring Data JPA的配置文件叫做persistence.xml，网上说的必须放在META-INF下面，偶不信邪，只要开发者脑子没坑的话设计基本就是给一个默认的，然后提供setter来让用户定制，直接去源代码中看，有一个叫做DefaultPersistenceUnitManager的类，其中有一个叫做DEFAULT_PERSISTENCE_XML_LOCATION的成员变量提供了默认的配置文件位置，还有一个persistenceXmlLocations可以用来设置配置文件的位置：
public class DefaultPersistenceUnitManager implements PersistenceUnitManager, ResourceLoaderAware, LoadTimeWeaverAware, InitializingBean {
/** 这个保存了默认的配置文件位置 */
public static final String DEFAULT_PERSISTENCE_XML_LOCATION = "classpath*:META-INF/persistence.xml";
..........
/** 可以看到默认就已经有一个了，我们可以调用这个属性的setter来设置*/
private String[] persistenceXmlLocations = new String[]{"classpath*:META-INF/persistence.xml"};
..........
/** setter方法在这里 */
public void setPersistenceXmlLocation(String persistenceXmlLocation) {
this.persistenceXmlLocations = new String[]{persistenceXmlLocation};
}
public void setPersistenceXmlLocations(String... persistenceXmlLocations) {
this.persistenceXmlLocations = persistenceXmlLocations;
}
.........
}
在Spring的配置文件中指定配置文件的位置即可，Spring的配置文件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:jpa="http://www.springframework.org/schema/data/jpa"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/data/jpa
http://www.springframework.org/schema/data/jpa/spring-jpa.xsd">
<context:annotation-config></context:annotation-config>
<context:component-scan base-package="org.cc11001100.spring.data.jpa"></context:component-scan>
<!-- =============================== Spring Data JPA 相关配置 =============================== -->
<!-- 配置实体管理器 -->
<bean id="entityManagerFactory"
class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
<property name="jpaVendorAdapter">
<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
<property name="generateDdl" value="true" />
<property name="database" value="MYSQL" />
</bean>
</property>
<property name="persistenceUnitName" value="SimpleJPA" />
<property name="persistenceXmlLocation" value="persistence.xml" />
</bean>
<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory" ref="entityManagerFactory" />
</bean>
<!-- 配置Spring Data JPA扫描目录 -->
<jpa:repositories base-package="org.cc11001100.spring.data.jpa.dao"
entity-manager-factory-ref="entityManagerFactory"
transaction-manager-ref="transactionManager"/>
</beans>JPA的配置文件persistence.xml：
<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="2.0">
<persistence-unit name="SimpleJPA" transaction-type="RESOURCE_LOCAL">
<provider>org.hibernate.ejb.HibernatePersistence</provider>
<class>org.cc11001100.spring.data.jpa.domain.User</class>
<properties>
<property name="hibernate.connection.driver_class" value="com.mysql.jdbc.Driver"/>
<property name="hibernate.connection.url" value="jdbc:mysql:///test_jpa"/>
<property name="hibernate.connection.username" value="root"/>
<property name="hibernate.connection.password" value="toor"/>
<property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5Dialect"/>
<property name="hibernate.show_sql" value="true"/>
<property name="hibernate.format_sql" value="true"/>
<property name="hibernate.use_sql_comments" value="false"/>
<property name="hibernate.hbm2ddl.auto" value="update"/>
</properties>
</persistence-unit>
</persistence>
相关的Java文件域模型User.java：
package org.cc11001100.spring.data.jpa.domain;
import javax.persistence.*;
@Entity
@Table(name = "t_user")
public class User {
@Id
@GeneratedValue(strategy= GenerationType.AUTO)
private Long id;
private String username;
private String passwd;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPasswd() {
return passwd;
}
public void setPasswd(String passwd) {
this.passwd = passwd;
}
}
Dao层UserDao.java：
package org.cc11001100.spring.data.jpa.dao;
import org.cc11001100.spring.data.jpa.domain.User;
import org.springframework.data.jpa.repository.JpaRepository;
public interface UserDao extends JpaRepository<User, Long> {
}
Service层接口声明UserService.java：
package org.cc11001100.spring.data.jpa.service;
import org.cc11001100.spring.data.jpa.domain.User;
import org.springframework.stereotype.Service;
import java.util.List;
public interface UserService {
User findById(long id);
User save(User user);
List<User> findAll();
}
Service实现UserServiceImpl.java：
package org.cc11001100.spring.data.jpa.service;
import org.cc11001100.spring.data.jpa.dao.UserDao;
import org.cc11001100.spring.data.jpa.domain.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
@Service("userService")
public class UserServiceImpl implements UserService {
@Autowired
private UserDao userDao;
public User findById(long id) {
return userDao.findOne(id);
}
public User save(User user) {
return userDao.save(user);
}
public List<User> findAll() {
return userDao.findAll();
}
}
测试类：
package org.cc11001100.spring.data.jpa;
import org.cc11001100.spring.data.jpa.domain.User;
import org.cc11001100.spring.data.jpa.service.UserService;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Main_001 {
@Test
public void test_001(){
ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService = ctx.getBean("userService", UserService.class);
User user=new User();
user.setUsername("CC11001100");
user.setPasswd("qwerty");
userService.save(user);
}
}
MySQL表结构：
CREATE TABLE t_user( id INT PRIMARY KEY AUTO_INCREMENT , username VARCHAR(50) NOT NULL DEFAULT "二狗子" , passwd VARCHAR(100) NOT NULL ) CHARSET UTF8;
执行Test：
查询MySQL：
@Entity标识了这是一个JPA实体
如果没有使用@Table注解明确指定要持久化到哪一个表中的话，映射到的表就跟类名相同，比如上面的这个就标识这个类映射到的表是User。
@Table 明确指定这个类要映射到哪一个表。
@Id用来标识主键
Spring Data JPA中的仓库继承关系
Repository： 是一个标识接口，方便Spring扫描
CrudRepository： 继承Repository，实现了一组CRUD相关的方法
PagingAndSortingRepository: 继承CrudRepository，实现了分页、排序相关的方法
JpaRepository： 继承PagingAndSortingRepository，实现了一组JPA规范相关的方法，一般都是让Dao层接口继承这个接口。
查询规则
声明接口就直接可用是建立在接口方法命名有一定规则的基础上的，Spring Data JPA通过解析方法的名字来推测它到底想干什么从而为其自动生成代码，解析方法名的时候会首先将方法多余的前缀去掉，比如find、findBy、read、readBy、get、getBy等，然后再对剩下的部分进行解析。
如果方法的最后一个参数是Sort或者Pageable，也会做相关的排序、分页处理
方法名表达式查询关键字
And
相当于SQL中的AND关键字，比如：
User findUserByUsernameAndPasswd(String username, String passwd);
Or
相当于SQL中的OR关键字，比如：
List<User> findByUsernameOrNickname(String username, String nickname);
Not
相当于SQL中的!=，比如：
List<User> findByUsernameNot(String username);
Like
相当于SQL中的LIKE，比如：
List<User> findByUsernameLike(String usernameLike);
需要注意的是这里的?是整个传的，并不会帮我们自动添加%号，所以传入进去的参数应该自己已经拼接好%号了。
NotLike
相当于SQL中的NOT LIKE，比如：
List<User> findByUsernameNotLike(String usernameLike);
In
相当于SQL语句中的IN，比如：
List<User> findByUsernameIn(List<String> usernameList);
NotIn
相当于SQL语句中的NOT IN，比如：
List<User> findByUsernameNotIn(List<String> usernameList);
LessThan
相当于SQL中的小于号，比如：
List<User> findByAgeLessThan(int age);
GreaterThan
相当于SQL中的大于号，比如：
List<User> findByAgeGreaterThan(int age);
Between
相当于SQL中的BETWEEN关键字，比如：
List<User> findByAgeBetween(int min, int max);
IsNull
相当于SQL中的IS NULL，比如：
List<User> findByUsernameIsNull();
IsNotNull
相当于SQL中的IS NOT NULL，比如：
List<User> findByUsernameIsNotNull();
NotNull
相当于IsNotNull。
OrderBy
相当于SQL语句中的ORDER BY。
使用IDEA编辑的时候会有自动提示的，复杂的查询都是一个一个的小表达式使用AND或者OR连起来的，基本元素无非就是这些。
创建查询（Query）
上面的查询规则太复杂了，搞得人晕乎乎的，更适合阅读记忆的方式还是使用@Query注解，可以在Dao层接口方法上添加@Query注解，在其中可以书写SQL语句，调用方法的时候会执行此SQL语句。
@Query有一个参数nativeQuery为true的时候表示前面的SQL语句是原生的SQL语句。
在SQL语句中可以引用接口方法传入的参数，可以使用索引位置来引用，比如使用?1来引用接口方法第一个形参的值，使用?2来引用接口方法第二个形参的值，依次类推：
@Transactional @Modifying @Query(value="INSERT INTO t_user (username, passwd) VALUES (?1, ?2)", nativeQuery = true) int save(String username, String passwd);
还可以使用命名参数来引用，在接口方法的形参加注解@Param传入参数的命名，在SQL语句中可以使用:paramName来引用：
@Query(value = "SELECT * FROM t_user WHERE id=:id", nativeQuery = true)
User findById(@Param("id")long id);
需要注意的坑：
1. 使用@Modifying标识的方法返回值只能是void、int/Integer。
2. 进行修改操作的时候需要开启事务，在方法上使用@Transactional来开启事务。
一个使用Query查询的例子：
package org.cc11001100.spring.data.jpa.dao;
import org.cc11001100.spring.data.jpa.domain.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
public interface UserDao extends JpaRepository<User, Long> {
@Transactional
@Modifying
@Query(value="INSERT INTO t_user (username, passwd) VALUES (?1, ?2)", nativeQuery = true)
int save(String username, String passwd);
@Transactional
@Modifying
@Query(value = "DELETE FROM t_user WHERE id=?1", nativeQuery = true)
int deleteById(long id);
@Transactional
@Modifying
@Query(value = "UPDATE t_user SET passwd=:passwd WHERE id=:id", nativeQuery = true)
int updatePasswd(@Param("id") long id, @Param("passwd") String passwd);
@Query(value = "SELECT * FROM t_user WHERE id=:id", nativeQuery = true)
User findById(@Param("id")long id);
@Query(value = "SELECT * FROM t_user", nativeQuery = true)
List<User> findAll();
}
命名查询（JPA NameQuery）
使用命名查询就是事先声明好SQL语句，给它一个名字，在使用的时候可以直接用过这个名字来使用它，故称之为命名查询。
使用自定义方法
当默认提供的方法不能满足要求的时候可能就需要自定义方法了，不过一般都是用不到的，Dao只需要简单的执行数据就可以了，与业务相关的放在Service层中。
事务
Spring Data JPA规定在进行写操作的时候必须要开启事务，在方法上使用@Transactional开启事务。
参考资料：
1. Spring Data JPA官方Quick Start http://projects.spring.io/spring-data-jpa/#quick-start
2. 官方文档（英文） http://docs.spring.io/spring-data/jpa/docs/current/reference/html/
3. IBM开发者文档 使用 Spring Data JPA 简化 JPA 开发 https://www.ibm.com/developerworks/cn/opensource/os-cn-spring-jpa/index.html
.