spring-data-jpa 使用

最近公司的一个项目需要使用spring-data-jpa框架，所以来学习下该框架。感觉spring对jpa的支持主要有下面两点：

    1.根据JPA的规范，我们需要在类路径下的META-INF文件夹中创建persistence.xml文件，spring为我们提供了org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean来进行配置，persistence.xml中的属性都可以在这个bean中进行注入。

   2.spring对EntityManagerFactoryBean的创建和销毁进行统一管理，开发者不需要关心这些。

目前暂时想到这两点。

   那么下面就通过一个例子来完成基本的CRUD操作。

   1.通过MAVEN来创建一个简单的项目，在pom里面加入对应的jar文件

   

Xml代码  

1.  <properties>  
2.     <spring.version>3.2.0.RELEASE</spring.version>  
3.     <jpa.version>2.0.0</jpa.version>  
4.     <hibernate.version>4.1.4.Final</hibernate.version>  
5.     <slf4j.version>1.6.6</slf4j.version>  
6.     <aspectj.version>1.6.12</aspectj.version>  
7.     <jodatime.version>2.1</jodatime.version>  
8.     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>  
9.     <mysql.version>5.1.24</mysql.version>  
10.     <commons-dbcp.version>1.4</commons-dbcp.version>  
11. </properties>  

    2.在类路径下创建META-INF文件夹，同时创建persistence.xml文件，内容如下：

 

   

Xml代码  

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <persistence version="2.0" xmlns="http://java.sun.com/xml/ns/persistence"   
3.             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"   
4.             xsi:schemaLocation="http://java.sun.com/xml/ns/persistence   
5.             http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">  
6.               
7.       
8.     <persistence-unit name="myJPA" >  
9.     <provider>org.hibernate.ejb.HibernatePersistence</provider>  
10.         
11.         <properties>  
12.             <property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5Dialect" />  
13.             <property name="hibernate.connection.driver_class" value="com.mysql.jdbc.Driver" />  
14.             <property name="hibernate.connection.username" value="root" />  
15.             <property name="hibernate.connection.password" value="root" />  
16.             <property name="hibernate.connection.url" value="jdbc:mysql://localhost:3306/spring_data_jpa?useUnicode=true&amp;characterEncoding=UTF-8" />  
17.             <property name="hibernate.max_fetch_depth" value="3" />  
18.             <property name="hibernate.hbm2ddl.auto" value="update" />      
19.             <property name="hibernate.show_sql" value="true" />  
20.             <property name="hibernate.format_sql" value="true" />  
21.             <property name="javax.persistence.validation.mode" value="none"/>  
22.         </properties>  
23.   
24.     </persistence-unit>  
25.             
26. </persistence>  

     我这里需要打印执行sql语句以及其他信息，如果不需要的话，可以直接写一句：

 

 

Xml代码  

1. <persistence-unit name="myJPA" >  

    也可以的。

 

    persistence-unit是定义一个单元名称，当然可以定义多个，在实际使用的时候选择其中一个就可以了。

  3.创建applicationContext.xml

     

Xml代码  

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:aop="http://www.springframework.org/schema/aop"    
6.     xmlns:tx="http://www.springframework.org/schema/tx"    
7.     xmlns:p="http://www.springframework.org/schema/p"    
8.     xmlns:cache="http://www.springframework.org/schema/cache"    
9.     xmlns:jpa="http://www.springframework.org/schema/data/jpa"  
10.       
11.     xsi:schemaLocation="http://www.springframework.org/schema/beans     
12.           http://www.springframework.org/schema/beans/spring-beans-3.1.xsd     
13.           http://www.springframework.org/schema/context     
14.           http://www.springframework.org/schema/context/spring-context-3.1.xsd     
15.           http://www.springframework.org/schema/aop     
16.           http://www.springframework.org/schema/aop/spring-aop-3.1.xsd     
17.           http://www.springframework.org/schema/tx      
18.           http://www.springframework.org/schema/tx/spring-tx-3.1.xsd  
19.           http://www.springframework.org/schema/cache   
20.           http://www.springframework.org/schema/cache/spring-cache-3.1.xsd  
21.           http://www.springframework.org/schema/data/jpa  
22.           http://www.springframework.org/schema/data/jpa/spring-jpa.xsd">    
23.           
24.         <context:annotation-config />    
25.           
26.         <context:component-scan base-package="com.jacksoft"/>  
27.   
28.     <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">  
29.         <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>  
30.         <property name="url" value="jdbc:mysql://localhost:3306/spring_data_jpa?useUnicode=true&amp;characterEncoding=UTF-8"></property>  
31.         <property name="username" value="root"></property>  
32.         <property name="password" value="root"></property>  
33.         <property name="maxActive" value="10"></property>  
34.         <property name="maxIdle" value="30"></property>  
35.         <property name="maxWait" value="10"></property>  
36.     </bean>  
37.          
38.         <bean id="entityManagerFactory"  
39.             class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">  
40.             <property name="dataSource" ref="dataSource" />  
41.             <property name="jpaVendorAdapter">  
42.                 <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">  
43.                     <property name="generateDdl" value="true" />  
44.                     <property name="database" value="MYSQL" />  
45.                 </bean>  
46.             </property>  
47.             <property name="persistenceUnitName" value="myJPA" />  
48.         </bean>  
49.            
50.          <!-- 配置事务管理器 -->    
51.            <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">    
52.             <property name="entityManagerFactory" ref="entityManagerFactory" />    
53.            </bean>   
54.          
55.           <!-- 启用 annotation事务-->   
56.            <tx:annotation-driven transaction-manager="transactionManager"/>   
57.              
58.              
59.            <!-- 配置Spring Data JPA扫描目录-->   
60.            <jpa:repositories base-package="com.jacksoft"/>  
61. </beans>  

  主要就是<jpa:repositories base-package="com.jacksoft"/>，这个可以扫描我们自己写的repository接口，当然这个也可以通过注解的形式来描述。

 

  4. 创建log4j.properties文件

     在类目录下创建log4j.properties文件

    

Java代码  

1. # Direct log messages to stdout  
2. log4j.appender.stdout=org.apache.log4j.ConsoleAppender  
3. log4j.appender.stdout.Target=System.out  
4. log4j.appender.stdout.layout=org.apache.log4j.PatternLayout  
5. log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %40.40c:%4L - %m%n  
6.   
7. # Root logger option  
8. log4j.rootLogger=error, stdout  
9.   
10. # Hibernate logging options (INFO only shows startup messages)  
11. #log4j.logger.org.springframework=INFO  
12. log4j.logger.org.springframework.data=error  

  我这里设置的都是error才会显示信息，当然可以根据实际情况进行修改

 

  5.创建Entry类

    这里我只有一个table：t_user，所以只需要创建一个User类，该类需要符合JPA规范

    

Java代码  

1. package com.jacksoft.entry;  
2.   
3.   
4. import java.io.Serializable;  
5.   
6. import javax.persistence.Column;  
7. import javax.persistence.Entity;  
8. import javax.persistence.GeneratedValue;  
9. import javax.persistence.GenerationType;  
10. import javax.persistence.Id;  
11. import javax.persistence.Table;  
12.   
13.   
14. @Entity  
15. @Table(name="t_user")  
16. public class User implements Serializable{  
17.   
18.     /** 
19.       * @Fields serialVersionUID : TODO 
20.       */  
21.       
22.     private static final long serialVersionUID = 1L;  
23.   
24.     @Id  
25.     @GeneratedValue(strategy = GenerationType.AUTO)  
26.     private Integer id;  
27.       
28.     @Column(name="username")  
29.     private String username;  
30.       
31.     @Column(name="password")  
32.     private String password;  
33.   
34.     public int getId() {  
35.         return id;  
36.     }  
37.   
38.     public void setId(Integer id) {  
39.         this.id = id;  
40.     }  
41.   
42.     public String getUsername() {  
43.         return username;  
44.     }  
45.   
46.     public void setUsername(String username) {  
47.         this.username = username;  
48.     }  
49.   
50.     public String getPassword() {  
51.         return password;  
52.     }  
53.   
54.     public void setPassword(String password) {  
55.         this.password = password;  
56.     }  
57.   
58.     @Override  
59.     public String toString() {  
60.         return "id:" + this.id + "   username:" + this.username + "  password:" + this.password;  
61.     }  
62.       
63.       
64. }  

  6.创建Repository

 

    这里只需要创建接口，而不需要对其进行实现，创建UserDao继承JpaRepository

    

Java代码  

1. package com.jacksoft.repository;  
2.   
3. import org.springframework.data.jpa.repository.JpaRepository;  
4.   
5. import com.jacksoft.entry.User;  
6.   
7. public interface UserDao extends JpaRepository<User, Integer>{  
8.   
9. }  

  注意这里的泛型，第一个是我们的Entry类，第二个是这个ID的类型,就这样就可以了，除非需要补充自己的方法，那么需要根据规范来对方法进行命名，比如 findByUsername 意思是通过username栏位进行数据查找，具体可以参照下面的表格(copy来的)：

 

  

Named Query： 针对一些复杂的SQL，支持原生SQL方式，进行查询，保证性能
Criteria Query： 支持JPA标准中的Criteria Query

  7.创建Service类

   

Java代码  

1. package com.jacksoft.entry.service;  
2.   
3. import java.util.List;  
4.   
5. import org.springframework.beans.factory.annotation.Autowired;  
6. import org.springframework.data.domain.Page;  
7. import org.springframework.data.domain.PageRequest;  
8. import org.springframework.data.domain.Pageable;  
9. import org.springframework.stereotype.Service;  
10. import org.springframework.transaction.annotation.Transactional;  
11.   
12. import com.jacksoft.entry.User;  
13. import com.jacksoft.repository.UserDao;  
14.   
15.   
16. @Service("userService")  
17. @Transactional(readOnly=true)  
18. public class UserServiceImpl {  
19.   
20.     @Autowired  
21.     private UserDao userDao;  
22.       
23.     public List<User> getAll(){  
24.         List<User> list = userDao.findAll();  
25.         return list;  
26.     }  
27.       
28.     public void deleteById(Integer id){  
29.         userDao.delete(id);  
30.     }  
31.       
32.     public Page<User> getListWithPaging(int pages,int pageSize){  
33.         Pageable pageAble = new PageRequest(pages, pageSize);  
34.         Page<User> page = userDao.findAll(pageAble);   
35.         return page;  
36.     }  
37.       
38.       
39.     public void updateById(User user){  
40.         userDao.save(user);  
41.     }  
42.       
43.     @Transactional  
44.     public void saveUser(User user) throws Exception{  
45.         try{  
46.         userDao.save(user);  
47.         int i = 0;  
48.         System.out.println(5/i);  
49.         userDao.save(user);  
50.         }catch(Exception ex){  
51.             System.out.println("执行出错哦：" + ex.getMessage());  
52.             throw ex;  
53.         }  
54.     }  
55. }  

     这里使用@Transactional(readOnly=true)来对设置只读的事务，当然在其他操作的时候，在方法上需要加上注解：@Transactional来添加事务。

   8.测试

      写一个client来进行CURD操作

     首先进行查询操作，查询所有的数据：

    

Java代码  

1. package com.jacksoft.client;  
2.   
3. import java.util.List;  
4.   
5. import org.springframework.context.ApplicationContext;  
6. import org.springframework.context.support.ClassPathXmlApplicationContext;  
7.   
8. import com.jacksoft.entry.User;  
9. import com.jacksoft.entry.service.UserServiceImpl;  
10.   
11.   
12. public class Client {  
13.   
14.     public static void main(String[] args) {  
15.         ApplicationContext context = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");  
16.         UserServiceImpl userService = context.getBean("userService",UserServiceImpl.class);  
17.           
18.         List<User> list = userService.getAll();  
19.         for(User user : list){  
20.             System.out.println(user);  
21.         }  
22.     }  
23. }  

    也就是调用UserDao的findAll方法来进行查询，运行后得到结果。

 

    接着再来分页查询数据，分页查询时需要使用一个接口来进行分页：

     org.springframework.data.domain.Pageable,

     它的一个实现类：

     org.springframework.data.domain.PageRequest

    从PageRequest来看，有这么一句话:Pages are zero indexed,所以我们在分页的时候，页码是从0开始的，这个需要进行处理下。

    

Java代码  

1. public class Client {  
2.   
3.     public static void main(String[] args) {  
4.         ApplicationContext context = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");  
5.         UserServiceImpl userService = context.getBean("userService",UserServiceImpl.class);  
6.           
7.         Pageable pageAble = new PageRequest(0, 2);  
8.         Page<User> pager = userService.getListWithPaging(pageAble);  
9.         System.out.println("总页数：" + pager.getTotalPages());  
10.         List<User> list =  pager.getContent();  
11.         for(User user : list){  
12.             System.out.println(user.toString());  
13.         }  
14.     }  
15. }  

    查询返回的结果都在Page里面，需要的信息可以从这个进行获取。

 

 

    删除修改和新增操作基本的都已经为我们提供了，只需要调用具体的方法就可以了。

   

   9.自定义查询

     当然有时候框架提供的不一定够我们使用，那么就需要我们进行自定义查询，这里我使用@Query注解的形式来完成，当然也可以通过在Entry上面用@NamedQuery注解具体的sql和对应的方法。

    在UserDao中添加两个方法，如下：

    

Java代码  

1. @Query(value="select * from t_user u where u.username=?1",nativeQuery=true)  
2. public User findByusername(String username);  
3.   
4. @Query("select u from User u where u.password=:password")  
5. public User findByPassword(@Param("password") String password);  

    第一个方法通过注解值nativeQuery=true说明这个是一个原生的sql语句查询，当然结果会自动帮我们进行转换，是不是很方便？对于参数赋值，可以通过?占位符，这个的话，就需要注意参数的位置，也可以通过:的形式，这个就需要@Param注解来定义。

    分别执行这两个方法，我们查看log信息：

   

Java代码  

1. Hibernate:   
2.     select  
3.         *   
4.     from  
5.         t_user u   
6.     where  
7.         u.username=?  
8. id:2   username:Jack  password:5555  
9. Hibernate:   
10.     select  
11.         user0_.id as id0_,  
12.         user0_.password as password0_,  
13.         user0_.username as username0_   
14.     from  
15.         t_user user0_   
16.     where  
17.         user0_.password=? limit ?  
18. id:2   username:Jack  password:5555  

    可以看到原生sql和生成的语句区别。

 

 

   到这里基本的操作就告一段，当然也可以参考spring-data-jpa的文档，直接下载附件即可

   官网： http://www.springsource.org/spring-data/jpa