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

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

<?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-4.0.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.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">
	
	<!-- 配置自动扫描的包,扫描service层,service上面有注解就直接被spring容器实例化 -->
	<context:component-scan base-package="com.zxy.service"/>
	<!-- 1. 配置数据源 -->
	<context:property-placeholder location="classpath:db.properties"/>
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="jdbcUrl" value="${jdbcUrl}"/>
		<property name="driverClass" value="${driverClass}"/>
		<property name="user" value="${user}"/>
		<property name="password" value="${password}"/>
		<property name="initialPoolSize" value="${initialPoolSize}"/>
		<property name="maxPoolSize" value="${maxPoolSize}"/>
	</bean>
	
	<!-- 2. 配置 JPA 的 EntityManagerFactory -->
	<bean id="entityManagerFactory" 
			class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
		<property name="dataSource" ref="dataSource"/>
		<property name="jpaVendorAdapter">
			<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"></bean>
		</property>
		<!-- 配置包扫描，扫描实体 -->
		<property name="packagesToScan" value="com.zxy.entity"/>
		<property name="jpaProperties">
			<props>
				<!-- 生成的数据表的列的映射策略 -->
				<prop key="hibernate.ejb.naming_strategy">org.hibernate.cfg.ImprovedNamingStrategy</prop>
				<!-- hibernate 基本属性 -->
				<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>
	
	<!-- 3. 配置事务管理器 -->
	<bean id="transactionManager"
		class="org.springframework.orm.jpa.JpaTransactionManager">
		<property name="entityManagerFactory" ref="entityManagerFactory"/>	
	</bean>
	
	<!-- 4. 配置支持注解的事务 -->
	<tx:annotation-driven transaction-manager="transactionManager"/>
	
	<!-- 5. 配置 SpringData,需要加入  jpa 的命名空间 -->
	<!-- base-package: 扫描 Repository Bean 所在的 package -->
	<jpa:repositories base-package="com.zxy.dao" entity-manager-factory-ref="entityManagerFactory">
	</jpa:repositories>
</beans>

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

package com.zxy.entity;
import java.util.Date;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
/**
 * Person实体
 * @author   ZENG.XIAO.YAN
 * @date 	 2017年9月14日 下午2:44:23
 * @version  v1.0
 */
@Entity
@Table(name="jpa_persons")
public class Person {
	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	private Integer id;
	@Column
	private String name;
	@Column
	private String email;
	@Column
	private Date birth;
	
	/** setter and getter method */
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	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;
	}
}

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

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

/** 测试findByEmailLike方法 */
@Test
public void testFindByEmailLike() {
	PersonDao personDao = ctx.getBean(PersonDao.class);
	List<Person> list = personDao.findByEmailLike("test%");
	for (Person person : list) {
		System.out.println(person.getEmail());
	}
}
/** 测试findByIdIsLessThanOrBirthLessThan方法 */
@Test
public void testFindByIdIsLessThanOrBirthLessThan() {
	PersonDao personDao = ctx.getBean(PersonDao.class);
	List<Person> list = personDao.findByIdIsLessThanOrBirthLessThan(3, new Date());
	for (Person person : list) {
		System.out.println("查询结果： name=" + person.getName() 
			+ ",id=" + person.getId() + ",birth=" + person.getBirth());
	}
}

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

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

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

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

// 级联查询，查询address的id等于条件值
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语句，代码如下：

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

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

                  

                

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

                    

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

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

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

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

package com.zxy.service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.zxy.dao.PersonDao;
/**
 * PersonService
 * @author   ZENG.XIAO.YAN
 * @date 	 2017年9月20日 下午2:57:16
 * @version  v1.0
 */
@Service("personService")
public class PersonService {
	@Autowired
	private PersonDao personDao;
	
	@Transactional(readOnly=false)
	public int updatePersonById(Integer id, String updateName) {
		return personDao.updatePersonById(id, updateName);
	}
}

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

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