spring之spring data jpa(入门一)

spring data 是一个用于建行数据库访问,并支持云服务的开源框架,其主要目标是使得对数据库的访问变得更方便快捷,并支持map-reduce框架和云计算数据服务.spring data包含多个字项目:

• Commons - 提供共享的基础框架，适合各个子项目使用，支持跨数据库持久化
• JPA - 简化创建 JPA 数据访问层和跨存储的持久层功能
• Hadoop - 基于 Spring 的 Hadoop 作业配置和一个 POJO 编程模型的 MapReduce 作业.
• Key-Value  - 集成了 Redis 和 Riak ，提供多个常用场景下的简单封装
• Document - 集成文档数据库：CouchDB 和 MongoDB 并提供基本的配置映射和资料库支持
• Graph - 集成 Neo4j 提供强大的基于 POJO 的编程模型
• Graph Roo AddOn - Roo support for Neo4j
• JDBC Extensions - 支持 Oracle RAD、高级队列和高级数据类型
• Mapping - 基于 Grails 的提供对象映射框架，支持不同的数据库
• Examples - 示例程序、文档和图数据库
• Guidance - 高级文档

spring data jpa

是由spring提供的一个用于简化JPA开发的框架.它,可以极大的简化JPA的写法,可以再几乎不用写实现的情况下,实现对数据库的访问和操作,除了CRUD外,还包括如分页,排序等一些常用的功能.

spring data jpa提供的接口,也是spring data jpa的核心概念:

1. Repository：最顶层的接口，是一个空的接口，目的是为了统一所有Repository的类型，且能让组件扫描的时候自动识别。
2. CrudRepository ：是Repository的子接口，提供CRUD的功能
3. PagingAndSortingRepository：是CrudRepository的子接口，添加分页和排序的功能.
4. JpaRepository：是PagingAndSortingRepository的子接口，增加了一些实用的功能，比如：批量操作等。
5. JpaSpecificationExecutor：用来做负责查询的接口
6. Specification：是Spring Data JPA提供的一个查询规范，要做复杂的查询，只需围绕这个规范来设置查询条件即可

参考:http://www.ibm.com/developerworks/cn/opensource/os-cn-spring-jpa/

http://my.oschina.net/ztlyde/blog/68513

示例

引入依赖:

<dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.9</version>
      <scope>test</scope>
    </dependency>

    <dependency>
    	<groupId>org.hibernate</groupId>
    	<artifactId>hibernate-entitymanager</artifactId>
    	<version>4.3.7.Final</version>
    </dependency>
    
    <dependency>
    	<groupId>mysql</groupId>
    	<artifactId>mysql-connector-java</artifactId>
    	<version>5.1.33</version>
    </dependency>

    <dependency>
    	<groupId>org.springframework</groupId>
    	<artifactId>spring-context</artifactId>
    	<version>4.1.1.RELEASE</version>
    </dependency>
    <dependency>
    	<groupId>org.springframework</groupId>
    	<artifactId>spring-orm</artifactId>
    	<version>4.1.1.RELEASE</version>
    </dependency>
    <dependency>
    	<groupId>org.springframework</groupId>
    	<artifactId>spring-test</artifactId>
    	<version>4.1.1.RELEASE</version>
    </dependency>
    <dependency>
    	<groupId>org.springframework.data</groupId>
    	<artifactId>spring-data-jpa</artifactId>
    	<version>1.7.1.RELEASE</version>
    </dependency>

 

spring的配置文件:

<?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:p="http://www.springframework.org/schema/p"
	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-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/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
	http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa.xsd">

	<!-- 开启注解扫描 -->
	<context:component-scan base-package="com.zt.*"/>
	<!-- 开启注解事务支持 -->
	<tx:annotation-driven transaction-manager="transactionManager"/>
	
	<!-- 实体管理器工厂 
		LocalEntityManagerFactoryBean：适用于那些仅使用JPA进行数据访问的项目，
		该FactoryBean将根据JPA PersistenceProvider自动检测配置文件进行工作，
		一般从“META-INF/persistence.xml”读取配置信息，这种方式最简单，
		但不能设置Spring中定义的DataSource，且不支持Spring管理的全局事务，
		而且JPA 实现商可能在JVM启动时依赖于VM agent从而允许它们进行持久化类字节码转换（不同的实现厂商要求不同，需要时阅读其文档），不建议使用这种方式；
	-->
	<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalEntityManagerFactoryBean">
			<!-- 持久化单元的名称,此处为myJPA -->
		<property name="persistenceUnitName" value="myJPA"></property>
	</bean>
	
	<!-- Jpa 事务管理器  -->
	<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
		<property name="entityManagerFactory" ref="entityManagerFactory"/>
	</bean>
	
	<!-- 启用扫描并自动创建代理的功能 ,Spring 初始化容器时将会扫描 base-package 指定的包目录及其子目录，
	为继承 Repository 或其子接口的接口创建代理对象，并将代理对象注册为 Spring Bean，
	业务层便可以通过 Spring 自动封装的特性来直接使用该对象-->
	<jpa:repositories base-package="com.zt.dao" entity-manager-factory-ref="entityManagerFactory" transaction-manager-ref="transactionManager">
		
	</jpa:repositories>

</beans>

 <jpa:repository> 还提供了一些属性和子标签，便于做更细粒度的控制。可以在 <jpa:repository> 内部使用 <context:include-filter>、<context:exclude-filter> 来过滤掉一些不希望被扫描到的接口

 

 persistence.xml:

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence"
	version="2.0">
	<!-- 持久化单元.一个持久化单元可以创建一个EntityManagerFactory -->
	<persistence-unit name="myJPA" transaction-type="RESOURCE_LOCAL">
		<properties>
			<property name="hibernate.connection.driver_class" value="com.mysql.jdbc.Driver" />
			<property name="hibernate.connection.url" value="jdbc:mysql://127.0.0.1:3306/tests" />
			<property name="hibernate.connection.username" value="root" />
			<property name="hibernate.connection.password" value="root" />
			<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" />
			<!-- 设置外连接抓取树的最大深度 -->
			<property name="hibernate.max_fetch_depth" value="3"/>
		</properties>
	</persistence-unit>
</persistence>

 实体对象:

@Entity
@Table(name="t_accountinfo")
public class User implements Serializable {

	@Id
	@GeneratedValue
	private Long accountId;
	
	@Column(length=20)
	private String balance;
//....

}

UserDao:

让持久层接口 UserDao 继承 Repository 接口。该接口使用了泛型，需要为其提供两个类型：第一个为该接口处理的域对象类型，第二个为该域对象的主键类型.

public interface UserDao  extends Repository<User, Long>{
	
	public void save(User accountInfo);
	
	public User findByAccountId(Long accountId);
}

userService:

public interface UserService {
	
	public void save(String name);
	
	public User findByAccountId(Long accountId); 
}

 UserServiceImpl:

 

@Service
public class UserServiceImpl implements UserService {

	@Autowired
	private UserDao userDao;

	public void save(String name) {
		User accountInfo = new User(name);
		userDao.save(accountInfo);
	}

	public User findByAccountId(Long accountId) {
		
		return userDao.findByAccountId(accountId);
	}
}

测试:

@ContextConfiguration("classpath:applicationContext.xml")
@RunWith(SpringJUnit4ClassRunner.class)
public class AppTest {
	@Autowired
	private UserService userService;
	
	@Test
	public void test() {
		userService.save("嘿嘿");
	}
	
	@Test
	public void test01(){
		User a = userService.findByAccountId(1L);
		System.out.println(a.getBalance());
	}
}

 此时,完全没有写UserDaoImpl,甚至都没有这个类.框架已经为我们完成了业务逻辑.查看源码，可以找到针对JpaRepository和JpaSpecificationExecutor有一个实现类，SimpleJpaRepository.class，这个类实现了刚才所提的两个接口。而Spring在给我们注入实现类的时候，就正是这个SimpleJpaRepository.class.

 

对UserDao接口还有一种写法,通过注解.

与继承 Repository 等价的一种方式，就是在持久层接口上使用 @RepositoryDefinition 注解，并为其指定 domainClass 和 idClass 属性。.

@RepositoryDefinition(domainClass = AccountInfo.class, idClass = Long.class) 
 public interface UserDao { 
  …… 
}