（转）Spring整合Jpa

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

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>

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. }

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. }

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. }

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

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. }

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

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

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

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

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

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

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

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

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

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

                  

                

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

                    

• 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了，测试代码如下图

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