（转）Spring整合Jpa

Spring-data-jpa 学习笔记（一）

　　作者：zeng1994 
　　出处：http://www.cnblogs.com/zeng1994/ 

        Spring家族越来越强大，作为一名javaWeb开发人员，学习Spring家族的东西是必须的。在此记录学习Spring-data-jpa的相关知识，方便后续查阅。

一、spring-data-jpa的简单介绍

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

SpringData 项目所支持 NoSQL 存储：

•  MongoDB （文档数据库）
•  Neo4j（图形数据库）
•  Redis（键/值存储）
•  Hbase（列族数据库）

SpringData 项目所支持的关系数据存储技术：

• JDBC
• JPA

JPA Spring Data ： 致力于减少数据访问层 (DAO) 的开发量， 开发者唯一要做的就只是声明持久层的接口，其他都交给 Spring Data JPA 来帮你完成！

框架怎么可能代替开发者实现业务逻辑呢？比如：当有一个 UserDao.findUserById() 这样一个方法声明，大致应该能判断出这是根据给定条件的 ID 查询出满足条件的 User 对象。Spring Data JPA 做的便是规范方法的名字，根据符合规范的名字来确定方法需要实现什么样的逻辑。

Spring Data JPA 进行持久层(即Dao)开发一般分三个步骤：

• 声明持久层的接口，该接口继承 Repository（或Repository的子接口，其中定义了一些常用的增删改查，以及分页相关的方法）。
• 在接口中声明需要的业务方法。Spring Data 将根据给定的策略生成实现代码。
• 在 Spring 配置文件中增加一行声明，让 Spring 为声明的接口创建代理对象。配置了 <jpa:repositories> 后，Spring 初始化容器时将会扫描 base-package 指定的包目录及其子目录，为继承 Repository 或其子接口的接口创建代理对象，并将代理对象注册为 Spring Bean，业务层便可以通过 Spring 自动封装的特性来直接使用该对象。

二、QuickStart

（1）创建项目并添加Maven依赖

         首先我们在eclipse中创建一个Maven的java项目，然后添加依赖。

         项目结构见右图：        

 

         主要依赖有：

• spring-data-jpa
• Hibernate相关依赖
• c3p0依赖
• mysql驱动

         pom.xml文件的代码如下

1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
2. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
3. <modelVersion>4.0.0</modelVersion>
4. <groupId>com.zxy</groupId>
5. <artifactId>springdata-demo</artifactId>
6. <version>0.0.1-SNAPSHOT</version>
8. <!-- 全局属性配置 -->
9. <properties>
10. <project.source.encoding>utf-8</project.source.encoding>
11. <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
12. <!-- 防止控制输出台中文乱码 -->
13. <argLine>-Dfile.encoding=UTF-8</argLine>
14. </properties>
16. <dependencies>
17. <!-- junit_jar包依赖 -->
18. <dependency>
19. <groupId>junit</groupId>
20. <artifactId>junit</artifactId>
21. <version>4.11</version>
22. <!--保留到测试 -->
23. <scope>test</scope>
24. </dependency>
25. <!-- spring-data-jpa相关依赖
26. (这个依赖自动把一堆spring的东西依赖进来了，所有可以不需要再引入spring的包)-->
27. <dependency>
28. <groupId>org.springframework.data</groupId>
29. <artifactId>spring-data-jpa</artifactId>
30. <version>1.11.7.RELEASE</version>
31. </dependency>
32. <!-- Hibernate -->
33. <dependency>
34. <groupId>org.hibernate</groupId>
35. <artifactId>hibernate-core</artifactId>
36. <version>5.0.11.Final</version>
37. </dependency>
38. <dependency>
39. <groupId>org.hibernate</groupId>
40. <artifactId>hibernate-entitymanager</artifactId>
41. <version>5.0.11.Final</version>
42. </dependency>
43. <!-- https://mvnrepository.com/artifact/com.mchange/c3p0 -->
44. <dependency>
45. <groupId>com.mchange</groupId>
46. <artifactId>c3p0</artifactId>
47. <version>0.9.5.2</version>
48. </dependency>
49. <!-- mysql驱动 -->
50. <dependency>
51. <groupId>mysql</groupId>
52. <artifactId>mysql-connector-java</artifactId>
53. <version>5.1.29</version>
54. </dependency>
55. </dependencies>
57. <build>
58. <plugins>
59. <!-- 编译插件 -->
60. <plugin>
61. <groupId>org.apache.maven.plugins</groupId>
62. <artifactId>maven-compiler-plugin</artifactId>
63. <version>2.5.1</version>
64. <configuration>
65. <!-- 源码用1.8 -->
66. <source>1.8</source>
67. <!-- 打成jar用1.8 -->
68. <target>1.8</target>
69. <encoding>utf-8</encoding>
70. </configuration>
71. </plugin>
72. </plugins>
73. </build>
74. </project>

      

      这里我解释下为何不添加Spring的其他的依赖，主要是spring-data-jpa这个依赖了一堆spring相关的依赖。见下图就明白了

                

 

（2）整合SpringData，配置applicationContext.xml

        这个整合很重要，我在网上找了好久，没找到特别好的demo；因此特意把这一步记录下来。

       <1> 首先我们添加一个和数据库相关的properties文件；新建db.properties文件，内容如下

1. jdbcUrl=jdbc:mysql://localhost:3306/springdata?useUnicode=true&characterEncoding=utf8
2. driverClass=com.mysql.jdbc.Driver
3. user=root
4. password=root
5. initialPoolSize=10
6. maxPoolSize=30

        

        <2> 然后我们需要新建一个Spring的配置文件，因此新建一个applicationContext.xml文件。里面大致配置的东西有：

• 开启包扫描，扫描service层，让service层的对象交给Spring容器管理
• 读取properties文件
• 配置数据源dataSource
• 配置JPA的EntityManagerFactory， 这里面有个包扫描，是扫描实体类那一层的
• 配置事务管理器transactionManager
• 配置支持注解的事务
• 配置SpringData这里包扫描是扫描dao层，扫描那些定义的接口

        文件里面的具体内容如下：

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"
4. xmlns:context="http://www.springframework.org/schema/context"
5. xmlns:tx="http://www.springframework.org/schema/tx"
6. xmlns:jpa="http://www.springframework.org/schema/data/jpa"
7. xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
8. http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
9. http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
10. http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd">
12. <!-- 配置自动扫描的包,扫描service层,service上面有注解就直接被spring容器实例化 -->
13. <context:component-scan base-package="com.zxy.service"/>
14. <!-- 1. 配置数据源 -->
15. <context:property-placeholder location="classpath:db.properties"/>
16. <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
17. <property name="jdbcUrl" value="${jdbcUrl}"/>
18. <property name="driverClass" value="${driverClass}"/>
19. <property name="user" value="${user}"/>
20. <property name="password" value="${password}"/>
21. <property name="initialPoolSize" value="${initialPoolSize}"/>
22. <property name="maxPoolSize" value="${maxPoolSize}"/>
23. </bean>
25. <!-- 2. 配置 JPA 的 EntityManagerFactory -->
26. <bean id="entityManagerFactory"
27. class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
28. <property name="dataSource" ref="dataSource"/>
29. <property name="jpaVendorAdapter">
30. <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"></bean>
31. </property>
32. <!-- 配置包扫描，扫描实体 -->
33. <property name="packagesToScan" value="com.zxy.entity"/>
34. <property name="jpaProperties">
35. <props>
36. <!-- 生成的数据表的列的映射策略 -->
37. <prop key="hibernate.ejb.naming_strategy">org.hibernate.cfg.ImprovedNamingStrategy</prop>
38. <!-- hibernate 基本属性 -->
39. <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</prop>
40. <prop key="hibernate.show_sql">true</prop>
41. <prop key="hibernate.format_sql">true</prop>
42. <prop key="hibernate.hbm2ddl.auto">update</prop>
43. </props>
44. </property>
45. </bean>
47. <!-- 3. 配置事务管理器 -->
48. <bean id="transactionManager"
49. class="org.springframework.orm.jpa.JpaTransactionManager">
50. <property name="entityManagerFactory" ref="entityManagerFactory"/>
51. </bean>
53. <!-- 4. 配置支持注解的事务 -->
54. <tx:annotation-driven transaction-manager="transactionManager"/>
56. <!-- 5. 配置 SpringData,需要加入 jpa 的命名空间 -->
57. <!-- base-package: 扫描 Repository Bean 所在的 package -->
58. <jpa:repositories base-package="com.zxy.dao" entity-manager-factory-ref="entityManagerFactory">
59. </jpa:repositories>
61. </beans>

 

（3）测试整合

        <1> 先测试下Spring容器是否整合成功

        我们在com.zxy.test包中新建一个TestConfig的类，在类里面我们写单元测试的代码。主要内容有：

• 通过静态代码块创建 ClassPathXmlApplicationContext对象，让它读取applicationContext.xml，这样就启动了Spring容器
• 通过Spring容器获取dataSource对象，如果成功获取，说明整合成功了。

        代码如下：

1. package com.zxy.test;
2. import org.springframework.context.ApplicationContext;
3. import org.springframework.context.support.ClassPathXmlApplicationContext;
4. import java.sql.SQLException;
5. import javax.sql.DataSource;
6. import org.junit.Test;
8. /**
9. * 整合效果测试类
10. * @author ZENG.XIAO.YAN
11. * @date 2017年9月14日 下午11:01:20
12. * @version v1.0
13. */
14. public class TestConfig {
15. private static ApplicationContext ctx ;
16. static {
17. // 通过静态代码块的方式,让程序加载spring的配置文件
18. ctx = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
19. }
21. /** 测试spring容器是否实例化了数据源 。如果实例化了，说明Spring容器整合没问题 */
22. @Test
23. public void testDataSouce() throws SQLException {
24. DataSource dataSouce = (DataSource) ctx.getBean("dataSource");
25. System.out.println("数据源："+ dataSouce);
26. System.out.println("连接："+ dataSouce.getConnection());
27. }
29. }

        成功后控制台输出结果如下：

        

 

         <2> 测试JPA是否整合成功

        JPA是否整合成功主要是看entityManagerFactory这个对象是否起作用，这个对象起作用了就会去扫描com.zxy.eneity下面的实体类。测试方法如下：

• 有一个前提，数据库必须先创建。这里springdata这个数据库我先创建了
• 给实体类加上注解，然后开启Hibernate自动建表功能，启动Spring容器；如果数据库自动建表成功，那就整合成功

        实体类的代码如下：

1. package com.zxy.entity;
2. import java.util.Date;
3. import javax.persistence.Column;
4. import javax.persistence.Entity;
5. import javax.persistence.GeneratedValue;
6. import javax.persistence.GenerationType;
7. import javax.persistence.Id;
8. import javax.persistence.Table;
9. /**
10. * Person实体
11. * @author ZENG.XIAO.YAN
12. * @date 2017年9月14日 下午2:44:23
13. * @version v1.0
14. */
15. @Entity
16. @Table(name="jpa_persons")
17. public class Person {
18. @Id
19. @GeneratedValue(strategy=GenerationType.IDENTITY)
20. private Integer id;
21. @Column
22. private String name;
23. @Column
24. private String email;
25. @Column
26. private Date birth;
28. /** setter and getter method */
29. public Integer getId() {
30. return id;
31. }
32. public void setId(Integer id) {
33. this.id = id;
34. }
35. public String getName() {
36. return name;
37. }
38. public void setName(String name) {
39. this.name = name;
40. }
41. public String getEmail() {
42. return email;
43. }
44. public void setEmail(String email) {
45. this.email = email;
46. }
47. public Date getBirth() {
48. return birth;
49. }
50. public void setBirth(Date birth) {
51. this.birth = birth;
52. }
53. }

        添加完这个实体后，还是运行下TestConfig下的testDataSource方法，运行完后，数据库应该已经创建了一张表了。

        如果表创建成功，那就代表JPA整合成功。

 

（4）在dao层声明接口

        在框架整合完成后，我们就可以开始使用SpringData了，在（3）中我们新建了一个Person实体类，我们就利用这个Person类来展开讲解。

        使用SpringData后，我们只需要在com.zxy.dao层声明接口，接口中定义我们要的方法，且接口继承Repository接口或者是Repository的子接口，这样就可以操作数据库了。但是在接口中定义的方法是要符合一定的规则的，这个规则在后面会讲到。其实我们也可以写接口的实现类，这个在后续也会讲解。

        先新建一个名为PersonDao的接口，它继承Repository接口；继承Repository接口的时候那两个泛型需要指定具体的java类型。第一个泛型是写实体类的类型，这里是Person；第二个泛型是主键的类型，这里是Integer。 在这个接口中定义一个叫做getById(Integer id)的方法，然后我们后面在调用这个方法测试下。

        PersonDao的代码如下：

1. package com.zxy.dao;
2. import org.springframework.data.repository.Repository;
3. import org.springframework.data.repository.RepositoryDefinition;
4. import com.zxy.entity.Person;
6. /**
7. * PersonDao
8. * @author ZENG.XIAO.YAN
9. * @date 2017年9月18日 下午4:25:39
10. * @version v1.0
11. */
13. /*
14. * 1.Repository是一个空接口，即是一个标记接口
15. * 2.若我们定义的接口继承了Repository，则该接口会被IOC容器识别为一个Repository Bean
16. * 注入到IOC容器中，进而可以在该接口中定义满足一定规则的接口
17. * 3.实际上也可以通过一个注解@RepositoryDefination 注解来替代Repository接口
18. */
19. //@RepositoryDefinition(domainClass=Person.class,idClass=Integer.class)
20. public interface PersonDao extends Repository<Person, Integer> {
21. // 通过id查找实体
22. Person getById(Integer id);
23. }

        其实也可以用注解@RepositoryDefination来代替继承接口Repository接口，这里不做过多介绍这个注解，更多和该注解的相关知识请查阅相关资料。

 

（5）测试dao层接口

        由于我们数据库中jpa_persons这个表还没数据，先在这表中手动插入几条测试数据。

        

        有了数据后，我们在com.zxy.test层新建一个名为TestQucikStart的测试类。还是采用静态代码快的方式来加载Spring配置文件的方式来使用Spring容器，在后续贴的代码中，这部分代码可能会不贴出来。这里先声明一下，后续在代码中看到的ctx是其实就是Spring容器的意思，它都是这样获取的。

        

        测试类代码如下：

1. package com.zxy.test;
2. import org.junit.Test;
3. import org.springframework.context.ApplicationContext;
4. import org.springframework.context.support.ClassPathXmlApplicationContext;
5. import com.zxy.dao.PersonDao;
6. import com.zxy.entity.Person;
8. /**
9. * SpringData快速入门测试类
10. * @author ZENG.XIAO.YAN
11. * @date 2017年9月18日 下午5:33:42
12. * @version v1.0
13. */
14. public class TestQuickStart {
15. private static ApplicationContext ctx ;
16. static {
17. // 通过静态代码块的方式,让程序加载spring的配置文件
18. ctx = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
19. }
21. /** 测试PersonDao中定义的getById的方法能否查询出结果 */
22. @Test
23. public void testGetById() {
24. PersonDao personDao = ctx.getBean(PersonDao.class);
25. Person person = personDao.getById(1);
26. System.out.println("查询结果： name=" + person.getName() + ",id=" + person.getId());
27. }
29. }

            测试的结果如下图所示，我们只声明了接口和定义了方法就从数据库查到了数据，这就是SpringData的强大之处。

            

 

三、SpringData方法定义规范

        通过上面的QucikStart的案例，我们了解到在使用SpringData时只需要定义Dao层接口及定义方法就可以操作数据库。但是，这个Dao层接口中的方法也是有定义规范的，只有按这个规范来，SpringData才能识别并实现该方法。下面来说说方法定义的规范。

（1）简单的条件查询的方法定义规范

        方法定义规范如下：

• 简单条件查询：查询某一个实体或者集合
• 按照SpringData规范，查询方法于find|read|get开头，涉及条件查询时，条件的属性用条件关键字连接，要注意的是：属性首字母需要大写。
• 支持属性的级联查询；若当前类有符合条件的属性， 则优先使用， 而不使用级联属性。 若需要使用级联属性， 则属性之间使用 _ 进行连接。

        

    下面来看个案例吧，操作的实体依旧上面的Person，下面写个通过id和name查询出Person对象的案例。

        在PersonDao这个接口中，定义一个通过id和name查询的方法

1. // 通过id和name查询实体,sql: select * from jpa_persons where id = ? and name = ?
2. Person findByIdAndName(Integer id, String name);

        在TestQucikStart这个测试类中，写个单元测试方法testFindByIdAndName来测试这个dao层的方法是否可用

1. /** 测试getByIdAndName方法 */
2. @Test
3. public void testGetByIdAndName() {
4. PersonDao personDao = ctx.getBean(PersonDao.class);
5. Person person = personDao.findByIdAndName(1, "test0");
6. System.out.println(person);
7. }

        运行的结果如下，成功的查询到了数据

        

 

（2）支持的关键字

        直接在接口中定义方法，如果符合规范，则不用写实现。目前支持的关键字写法如下：

        

        

        

        下面直接展示个案例来介绍下这些方法吧，

         PersonDao接口新增代码如下：

1. // where id < ? or birth < ?
2. List<Person> findByIdIsLessThanOrBirthLessThan(Integer id, Date birth);
4. // where email like ?
5. List<Person> findByEmailLike(String email);
6.  
7. // 也支持count查询
8. long countByEmailLike(String email);

        在TestQucikStart中添加以下2个单元测试方法，测试dao层接口中的方法是否可用

1. /** 测试findByEmailLike方法 */
2. @Test
3. public void testFindByEmailLike() {
4. PersonDao personDao = ctx.getBean(PersonDao.class);
5. List<Person> list = personDao.findByEmailLike("test%");
6. for (Person person : list) {
7. System.out.println(person.getEmail());
8. }
9. }
11. /** 测试findByIdIsLessThanOrBirthLessThan方法 */
12. @Test
13. public void testFindByIdIsLessThanOrBirthLessThan() {
14. PersonDao personDao = ctx.getBean(PersonDao.class);
15. List<Person> list = personDao.findByIdIsLessThanOrBirthLessThan(3, new Date());
16. for (Person person : list) {
17. System.out.println("查询结果： name=" + person.getName()
18. + ",id=" + person.getId() + ",birth=" + person.getBirth());
19. }
20. }

        运行结果如下：

              

 

（3）一个属性级联查询的案例

        Dao层接口中定义的方法支持级联查询，下面通过一个案例来介绍这个级联查询：

• 在com.zxy.entity包下新建一个Address的实体，代码如下图，setter和getter方法我省略了

                    

 

• 修改Person类，添加address属性，使Person和Address成多对一的关系，设置外键列名为address_id ，添加的代码如下图：

                    

 

• 运行我们上面的任意一个测试方法，只要启动了项目，数据库的表都会更新。在表更新后我们需要手动插入一些数据，我插入的数据如下：

                    

• 修改jpa_persons表，使address_id这个外键列有值，修改后的效果如下图：

                    

 

• 在PersonDao接口中定义一个方法，代码如下：

1. // 级联查询，查询address的id等于条件值
2. List<Person> findByAddressId(Integer addressId);

• 在TestQucik这个测试类中定义一个单元测试方法，测试这个dao的方法是否可用。代码如下：

1. /** 测试findByAddressId方法 */
2. @Test
3. public void testFindByAddressId() {
4. PersonDao personDao = ctx.getBean(PersonDao.class);
5. // 查出地址id为1的person集合
6. List<Person> list = personDao.findByAddressId(1);
7. for (Person person : list) {
8. System.out.println(person.getName()
9. + "---addressId="
10. + person.getAddress().getId());
11. }
12. }

 

• 运行测试方法，通过控制台可观察生成的sql语句和查询的结果。结果如下图所示：

                

                

     这里我解释下这个生成的sql吧，首先是一个左外连接查询出结果，由于Person中有个Address的实体，所以就又发送了一次查询address的sql。产生这个的原因是@ManyToOne这个注解默认是禁用延迟加载的，所以会把关联属性的值也会查询出来。

 

（4）查询方法解析流程

        通过以上的学习，掌握了在接口中定义方法的规则，我们就可以定义出很多不用写实现的方法了。这里再介绍下查询方法的解析的流程吧，掌握了这个流程，对于定义方法有更深的理解。

        <1> 方法参数不带特殊参数的查询

        假如创建如下的查询：findByUserDepUuid()，框架在解析该方法时，流程如下：

• 首先剔除 findBy，然后对剩下的属性进行解析，假设查询实体为Doc
• 先判断 userDepUuid（根据 POJO 规范，首字母变为小写）是否为查询实体的一个属性，如果是，则表示根据该属性进行查询；如果没有该属性，继续往下走
• 从右往左截取第一个大写字母开头的字符串(此处为Uuid)，然后检查剩下的字符串是否为查询实体的一个属性，如果是，则表示根据该属性进行查询；如果没有该属性，则重复这一步，继续从右往左截取；最后假设 user 为查询实体的一个属性
• 接着处理剩下部分（DepUuid），先判断 user 所对应的类型是否有depUuid属性，如果有，则表示该方法最终是根据 "Doc.user.depUuid" 的取值进行查询；否则继续按照步骤3的规则从右往左截取，最终表示根据 "Doc.user.dep.uuid" 的值进行查询。

        可能会存在一种特殊情况，比如 Doc包含一个 user 的属性，也有一个 userDep 属性，此时会存在混淆。可以明确在级联的属性之间加上 "_" 以显式表达意图，比如 "findByUser_DepUuid()" 或者 "findByUserDep_uuid()"。

 

        <2> 方法参数带特殊参数的查询

         特殊的参数： 还可以直接在方法的参数上加入分页或排序的参数，比如：

         Page<UserModel> findByName(String name, Pageable pageable)

         List<UserModel> findByName(String name, Sort sort);

 

四、@Query注解

        通过上面的学习，我们在dao层接口按照规则来定义方法就可以不用写方法的实现也能操作数据库。但是如果一个条件查询有多个条件时，写出来的方法名字就太长了，所以我们就想着不按规则来定义方法名。我们可以使用@Query这个注解来实现这个功能，在定义的方法上加上@Query这个注解，将查询语句声明在注解中，也可以查询到数据库的数据。

（1）使用Query结合jpql语句实现自定义查询

• 在PersonDao接口中声明方法，放上面加上Query注解，注解里面写jpql语句，代码如下：

1. // 自定义的查询,直接写jpql语句; 查询id<? 或者 名字 like?的person集合
2. @Query("from Person where id < ?1 or name like ?2")
3. List<Person> testPerson(Integer id, String name);
5. // 自定义查询之子查询,直接写jpql语句; 查询出id最大的person
6. @Query("from Person where id = (select max(p.id) from Person as p)")
7. Person testSubquery();

• 在TestQuickStart中添加以下代码，测试dao层中使用Query注解的方法是否可用

1. /** 测试用Query注解自定义的方法 */
2. @Test
3. public void testCustomMethod() {
4. PersonDao personDao = ctx.getBean(PersonDao.class);
5. List<Person> list = personDao.testPerson(2, "%admin%");
6. for (Person person : list) {
7. System.out.println("查询结果： name=" + person.getName() + ",id=" + person.getId());
8. }
9. System.out.println("===============分割线===============");
10. Person person = personDao.testSubquery();
11. System.out.println("查询结果： name=" + person.getName() + ",id=" + person.getId());
12. }

• 查询结果及生成的sql语句如下所示

                  

                

 

（2）索引参数和命名参数

        在写jpql语句时，查询条件的参数的表示有以下2种方式：

• 索引参数方式如下图所示，索引值从1开始，查询中'?x'的个数要和方法的参数个数一致，且顺序也要一致

                    

• 命名参数方式（推荐使用这种方式）如下图所示，可以用':参数名'的形式，在方法参数中使用@Param（"参数名"）注解，这样就可以不用按顺序来定义形参

                    

        说一个特殊情况，那就是自定义的Query查询中jpql语句有like查询时，可以直接把%号写在参数的前后，这样传参数就不用把%号拼接进去了。使用案例如下，调用该方法时传递的参数直接传就ok。

               

 

（3）使用@Query来指定使用本地SQL查询

        如果你不熟悉jpql语句，你也可以写sql语句查询，只需要在@Query注解中设置nativeQuery=true。直接来看案例吧

• dao层接口写法如下图所示

                    

• 测试代码这里直接不贴了，下面是控制台中打印的语句和结果

                    

 

五、@Modifying注解和事务

（1）@Modifying注解的使用

        @Query与@Modifying这两个注解一起使用时，可实现个性化更新操作及删除操作；例如只涉及某些字段更新时最为常见。

下面演示一个案例，把id小于3的person的name都改为'admin'

• dao层代码如下所示

1. //可以通过自定义的 JPQL 完成 UPDATE 和 DELETE 操作. 注意: JPQL 不支持使用 INSERT
2. //在 @Query 注解中编写 JPQL 语句, 但必须使用 @Modifying 进行修饰. 以通知 SpringData, 这是一个 UPDATE 或 DELETE 操作
3. //UPDATE 或 DELETE 操作需要使用事务, 此时需要定义 Service 层. 在 Service 层的方法上添加事务操作.
4. //默认情况下, SpringData 的每个方法上有事务, 但都是一个只读事务. 他们不能完成修改操作!
5. @Modifying
6. @Query("UPDATE Person p SET p.name = :name WHERE p.id < :id")
7. int updatePersonById(@Param("id")Integer id, @Param("name")String updateName);

• 由于这个更新操作，只读事务是不能实现的，因此新建PersonService类，在Service方法中添加事务注解。PersonService的代码如下图所示

1. package com.zxy.service;
2. import org.springframework.beans.factory.annotation.Autowired;
3. import org.springframework.stereotype.Service;
4. import org.springframework.transaction.annotation.Transactional;
5. import com.zxy.dao.PersonDao;
6. /**
7. * PersonService
8. * @author ZENG.XIAO.YAN
9. * @date 2017年9月20日 下午2:57:16
10. * @version v1.0
11. */
12. @Service("personService")
13. public class PersonService {
14. @Autowired
15. private PersonDao personDao;
17. @Transactional(readOnly=false)
18. public int updatePersonById(Integer id, String updateName) {
19. return personDao.updatePersonById(id, updateName);
20. }
21. }

• 测试类中直接调用service的方法就ok了，测试代码如下图

                

 

        使用@Modifying+@Query时的注意事项：

• 方法返回值是int，表示影响的行数
• 在调用的地方必须加事务，没事务不执行

（2）事务

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

六、本文小结

        （1）本文只简单介绍了下SpringData，知道了SpringData简化了dao层的代码，我们可以只声明接口就可以完成对数据库的操作。

        （2）介绍了一个SpringData的入门案例，其中包含了需要哪些依赖的jar包，如何整合Spring-data-jpa以及怎么测试是否整合成功等。

        （3）介绍了Dao层接口继承了Repository接口后，该按照什么规则去定义方法就可以被SpringData解析；且展示了SpringData对级联查询的案例。同时也讲解了SpringData解析方法的整个流程。

        （4）介绍了@Query注解的使用，有了这个注解，我们就可以随便定义方法的名字，方法的功能由我们自己写jqpl语句或者是sql语句来实现。在介绍这个注解的时候，也讲解了jpql或者sql中参数可以用索引参数和命名参数的两种方式来表示。

        （5）介绍了@Modifying注解结合@Query注解，实现更新和删除。同时也介绍了SpringData的事务。

         

作者：zeng1994 
出处：http://www.cnblogs.com/zeng1994/ 
本文版权归作者和博客园共有，欢迎转载！但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文链接！