Spring Data Jpa 详解 （配置篇）

转载地址：http://doc.okbase.net/liuyitian/archive/109276.html

JPA全称Java Persistence API，即Java持久化API，它为Java开发人员提供了一种对象/关系映射工具来管理Java应用中的关系数据，结合其他ORM的使用，能达到简化开发流程的目的，使开发者能够专注于实现自己的业务逻辑上。

　　Spring Jpa 能够简化创建 JPA 数据访问层和跨存储的持久层功能，用户的持久层Dao接口只需要继承他自己定义好的（仓库）接口，无需再写实现类，就可以实现对象的CRUD操作，还有分页排序等功能。

写本章之前本来想写一个SpringMVC的，后来发现Jpa的配置可以大大简化MVC框架的配置，就先研究研究Spring Data Jpa。

准备工作：

    • 　jar包支持（不用说都知道，本章jar包待我会放在115网盘供下载）
    • web.xml配置（监听Spring容器的装载）
    • 本章采用的是阿里连接池（Druid），所以web.xml要有相关的配置
    • Spring容器的配置（主要为beans和jpa）
    • Jpa的主要配置（实体类管理、数据源、连接池、事务等）
    • 实体类、持久层接口、业务层的创建
    • 测试放在下一章节中（因为采用了SpringJunit单元测试，单独分出来讲解）

先来看一下本章节用到的包结构--如下图：

实例代码演示：

****************最后我会把本章的项目打包供下载************注释部分我尽可能详细讲解****************

jar包导入.....（略）

web.xml配置

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
 3   <display-name>springMVC</display-name>
 4
 5   <!-- 同时加载多个spring配置文件可用  -->
 6   <context-param>
 7     <param-name>contextConfigLocation</param-name>
 8     <param-value>
 9             classpath:spring-config/*.xml
10         </param-value>
11   </context-param>
12
13   <!-- spring全局监听 -->
14   <listener>
15     <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
16   </listener>
17
18   <!-- 下面为Druid默认配置，过滤掉多余的url地址 -->
19   <filter>
20     <filter-name>DruidWebStatFilter</filter-name>
21     <filter-class>com.alibaba.druid.support.http.WebStatFilter</filter-class>
22     <init-param>
23       <param-name>exclusions</param-name>
24       <param-value>*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*</param-value>
25     </init-param>
26     <init-param>
27       <param-name>principalSessionName</param-name>
28       <param-value>_dest_login_</param-value>
29     </init-param>
30   </filter>
31   <filter-mapping>
32     <filter-name>DruidWebStatFilter</filter-name>
33     <url-pattern>/*</url-pattern>
34   </filter-mapping>
35
36   <!-- StatViewServlet是一个标准的Servlet -->
37   <servlet>
38     <servlet-name>DruidStatView</servlet-name>
39     <servlet-class>com.alibaba.druid.support.http.StatViewServlet</servlet-class>
40   </servlet>
41   <servlet-mapping>
42     <servlet-name>DruidStatView</servlet-name>
43     <url-pattern>/druid/*</url-pattern>
44   </servlet-mapping>
45
46   <!-- Spring Servlet,由于把bean全部交给了SpringJap，所以Spring-mvc里面现在为空 -->
47   <servlet>
48     <servlet-name>springServlet</servlet-name>
49     <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
50     <init-param>
51       <param-name>contextConfigLocation</param-name>
52       <param-value>/WEB-INF/spring-mvc.xml</param-value>
53     </init-param>
54     <load-on-startup>1</load-on-startup>
55   </servlet>
56   <servlet-mapping>
57     <servlet-name>springServlet</servlet-name>
58     <url-pattern>/</url-pattern>
59   </servlet-mapping>
60
61   <!-- 首页 -->
62   <welcome-file-list>
63     <welcome-file>index.jsp</welcome-file>
64   </welcome-file-list>
65 </web-app>
66
67 spring-mvc.xml
68
69 <?xml version="1.0" encoding="UTF-8"?>
70 <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
71     xmlns:context="http://www.springframework.org/schema/context" xmlns:mvc="http://www.springframework.org/schema/mvc"
72     xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd
73         http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
74         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd">
75
76     <!-- bean配置在spring-jpa.xml里,所以这里暂为空，用来初始化spring容器-->
77 </beans>

spring-jpa.xml

<?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:tx="http://www.springframework.org/schema/tx"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:jpa="http://www.springframework.org/schema/data/jpa"
       xmlns:task="http://www.springframework.org/schema/task"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.1.xsd
        http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.0.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd
        http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa.xsd"
       default-lazy-init="true">

    <description>SpringJpa配置</description>

    <!-- 如果spring用了jpa，并且类型为LocalContainerEntityManagerFactoryBean，则组件注册在此配置文件出现即可，其余配置文件可忽略
           使用component来替代annotation 自动注册bean, 并保证@Required、@Autowired的属性被注入\ -->
    <context:component-scan base-package="com.spring.jpa"/>

    <!-- spring启动时扫描项目路径下的properties文件,后续用${key }方式取出对应值,这样可以代码解耦和，后续只需修改properties文件即可 -->
    <bean id="propertyPlaceholderConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="locations">
            <list>
                <!-- dataSourse连接池相关属性，代码不在此贴出，会放在打包好的项目里面 -->
                <value>classpath:db.properties</value>
            </list>
        </property>
    </bean>

    <!-- 定义实体管理器工厂
         Jpa配置   LocalContainerEntityManagerFactoryBean这个选项Spring扮演了容器的角色。完全掌管JPA -->
          点我查看 spring生成EntityManagerFactory的三种方式
    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
           <!-- 指定数据源 -->
        <property name="dataSource" ref="dataSource"/>
        <!-- 指定Jpa持久化实现厂商类,这里以Hibernate为例 -->
        <property name="jpaVendorAdapter" ref="hibernateJpaVendorAdapter"/>
        <!-- 指定Entity实体类包路径 -->
        <property name="packagesToScan" >
            <array>
                <value>com.spring.jpa</value>
            </array>
        </property>
        <!-- 指定JPA属性；如Hibernate中指定是否显示SQL的是否显示、方言等 -->
        <property name="jpaProperties">
            <props>
                <prop key="hibernate.dialect">org.hibernate.dialect.Oracle10gDialect</prop>
                <prop key="hibernate.ejb.naming_strategy">org.hibernate.cfg.ImprovedNamingStrategy</prop>
                <prop key="hibernate.cache.provider_class">org.hibernate.cache.NoCacheProvider</prop>
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hibernate.format_sql">true</prop>
                <prop key="hibernate.hbm2ddl.auto">validate</prop>
            </props>
        </property>
    </bean>

    <!-- 重要配置：启用扫描并自动创建代理的功能  -->
    <jpa:repositories base-package="com.spring.jpa"  transaction-manager-ref="transactionManager" entity-manager-factory-ref="entityManagerFactory"/>

    <!-- Hibernate对Jpa的实现 -->
    <bean id="hibernateJpaVendorAdapter" class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"/>

    <!-- Jpa 事务管理器  -->
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory"/>
    </bean>

    <!-- 开启注解事务 -->
    <tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true" />

    <!-- 数据源配置,使用应用内的DBCP数据库连接池 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
        <!--property name="driverClassName" value="${db.driverClass}"/-->
        <property name="url" value="${db.jdbcUrl}" />
        <property name="username" value="${db.user}" />
        <property name="password" value="${db.password}" />

        <!-- 配置初始化大小、最小、最大 -->
        <property name="initialSize" value="${db.initialSize}" />
        <property name="minIdle" value="${db.minIdle}" />
        <property name="maxActive" value="${db.maxActive}" />
        <!-- 配置获取连接等待超时的时间 -->
        <property name="maxWait" value="${db.maxWait}" />
        <!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 -->
        <property name="timeBetweenEvictionRunsMillis" value="${db.timeBetweenEvictionRunsMillis}" />
        <!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->
        <property name="minEvictableIdleTimeMillis" value="${db.minEvictableIdleTimeMillis}" />

        <property name="validationQuery" value="SELECT ‘x‘ from dual" />
        <property name="testWhileIdle" value="true" />
        <property name="testOnBorrow" value="false" />
        <property name="testOnReturn" value="false" />
        <!-- 打开PSCache，并且指定每个连接上PSCache的大小 -->
        <property name="poolPreparedStatements" value="${db.poolPreparedStatements}" />
        <property name="maxPoolPreparedStatementPerConnectionSize" value="${db.maxPoolPreparedStatementPerConnectionSize}" />
    </bean>

    <!-- 启动对@AspectJ（面向切面）注解的支持 -->
    <aop:aspectj-autoproxy />

</beans>


配置好了配置文件后，我们该来写对应的实体类，Dao，和service了，下面给出简单的3个类：


User 实体类


package com.spring.jpa.user;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.SequenceGenerator;
import javax.persistence.Table;

/**
 * User实体类
 * @author liuyt
 * @date  2014-10-30 下午2:27:37
 */
@Entity
@Table(name="T_SPRINGJPA_USER")
public class User {
    /**
     * 主键序列：DEFAULT_SUQUENCE 是我在oracle数据库中创建的一个序列
     *           MY_SUQUENCE 是给自定义的序列创建一个引用名称
     * 指我的主键生成策略 MY_SUQUENCE 使用的是 DEFAULT_SUQUENCE 这个序列。
     */
    @SequenceGenerator(name = "MY_SUQUENCE", sequenceName = "DEFAULT_SUQUENCE")
    @Id
    @GeneratedValue(generator="MY_SUQUENCE")
    private Long id;

    @Column(name="USER_NAME")
    private String userName;

    @Column(name="USER_PASSWORD")
    private String passWord;

    /*************GET****************SET***************/
    public Long getId() {
        return id;
    }
    public void setId(Long id) {
        this.id = id;
    }
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public String getPassWord() {
        return passWord;
    }
    public void setPassWord(String passWord) {
        this.passWord = passWord;
    }
    @Override
    public String toString() {
        return "User [id=" + id + ", userName=" + userName + ", passWord="
                + passWord + "]";
    }
}


User Entity


IUserDao 持久层（jpa对持久层简化的核心基础）


 1 package com.spring.jpa.user;
 2
 3 import org.springframework.data.repository.PagingAndSortingRepository;
 4 import org.springframework.stereotype.Repository;
 5
 6 /**
 7  * 持久层接口
 8  * @author liuyt
 9  * @date  2014-10-30 下午2:09:48
10  */
11 @Repository
12 public interface IUserDao extends PagingAndSortingRepository<User, Long>{
13     /**
14      * 通过前面的配置可以看出，Spring 对 JPA 的支持已经非常强大，开发者无需过多关注 EntityManager 的创建、事务处理等 JPA 相关的处理
15      * ***********************************************************************
16      * 然而spring对Jpa的支持不止于此，它要从根本上来简化我们的业务代码                        **
17      * 在没用使用jpa支持的时候，我们的代码应该是这样的：                                    **
18      *     1、IUserDao   持久层接口                                                **
19      *     2、IUserDaoImpl   持久层实现类                                            **
20      *     3、IUserService    业务层接口.....后面不在列举                                    **
21      * 每写一个实体类，都要衍生出5、6个类来对他进行操作，即使有了注解，我们可以依赖注入方式来拿到实现类，    **
22      * 但是通用的CRUD等操作却不免在每个实现类里声明，你又说，我可以定义一个父类，利用泛型反射原理就可以了，    **
23      * 但那样你还需要为每个Dao声明自己的实现类来继承你的父类                                    **
24      * ***********************************************************************
25      * 那么问题来了...（不是挖掘机技术）对持久层的简化技术哪家强？      Spring Data Jpa            **
26      * 你唯一要做的就只是声明持久层的接口，来继承他自身已经封装好的持久层接口，正如本类IUserDao一样        **
27      * 可使用的接口有：                                                            **********
28      *　    Repository：是 Spring Data的一个核心接口，它不提供任何方法，开发者需要在自己定义的接口中声明需要的方法。**
29      *     CrudRepository：继承Repository，提供增删改查方法，可以直接调用。                            **
30      *     PagingAndSortingRepository：继承CrudRepository，具有分页查询和排序功能（本类实例）        **
31      *     JpaRepository：                         继承PagingAndSortingRepository，针对JPA技术提供的接口            **
32      *     JpaSpecificationExecutor：          可以执行原生SQL查询                                    **
33      *    继承不同的接口，有两个不同的泛型参数，他们是该持久层操作的类对象和主键类型。                            **
34      *********************************************************************************
35      */
36 }
37
38 　　这里为了方便演示，就不写业务层接口了，直接上业务层service代码
39
40 UserService 业务层
41
42 package com.spring.jpa.user;
43
44 import java.util.List;
45 import javax.annotation.Resource;
46 import org.springframework.data.domain.Page;
47 import org.springframework.data.domain.PageRequest;
48 import org.springframework.stereotype.Service;
49 /**
50  * User业务层，依赖持久层  IUserDao
51  * @author liuyt
52  * @date  2014-10-30 下午2:37:21
53  */
54 @Service
55 public class UserService {
56     // 推荐用Resource来替代AutoWrite注解
57     @Resource
58     private IUserDao userDao;
59
60     // 新增用户
61     public void saveUser(User user) {
62         userDao.save(user);
63     }
64
65     // 删除用户，参数也可以为一个含有id的User对象
66     public void deleteUser(Long id) {
67         userDao.delete(id);
68     }
69
70     // 查询所有user对象，findOne为查询单个
71     public List<User> findAllUsers() {
72         return (List<User>) userDao.findAll();
73     }
74
75     /**
76      * 根据一个分页对象查询user集合（还可以添加一个Store排序属性）
77      * PageRequest    是spring自己封装的请求分页类，实现了Pageable接口，包涵从请求中获得的分页属性（当前页和大小）和获取方法
78      * 通过调用分页方法，返回一个Page<>一个泛型集合的分页对象，里面包涵了通过查询计算出的各个属性和结果集
79      * 详细类结构和属性请参阅源码
80      * @param page
81      * @return
82      */
83     public Page<User> findAllUserByPage(PageRequest page) {
84         return (Page<User>) userDao.findAll(page);
85     }
86 }


至此，整体SpringJpa框架就搭建好了，剩下的就是写页面和控制器进行测试了，这里不做演示，因为会在下一章节利用SpringUnit单元测试，通过注解的方式进行方法测试，详情请移步：待更新...




总结：


    

  • 　在学习期间可能jar包的导入会很头疼，因为各类框架的jar有时候会出现不兼容的情况（点击下载本章节jar包）到期请提醒
    • 

  • 本章节用到的Druid连接池配置，详细配置请异步度娘
    • 

  • spring-jpa.xml里面可以针对不同需求，可以选择不同的EntityManagerFactory实体类管理
    • 

  • 别忘记<jpa:repositories />标签的配置，他用来声明Jpa涉及到的包路径
    • 

  • SpringJpa集成了声明式事务，记得开启注解事务即可
    • 

  • 持久层的实现接口有很多，根据需求灵活选择（本章演示有关分页的接口，因为网上对该接口的介绍都比较粗略）
    • 

  • 未涉及：其他功能：如Query查询，Dao接口方法的新增　　　　　　　　　　　　　　　　　　　　
    • 



 
				


				
时间： 2024-10-08 08:50:55 

		


		


	

	
	

		


		
Spring Data Jpa 详解 （配置篇）的相关文章


								

		

			

                spring data jpa 详解
			

		

		

									

				https://www.cnblogs.com/cmfwm/p/8109433.html posted @ 2017-12-25 14:57 start枫 阅读(22613) 评论(3) 编辑 收藏 本篇进行Spring-data-jpa的介绍,几乎涵盖该框架的所有方面,在日常的开发当中,基本上能满足所有需求.这里不讲解JPA和Spring-data-jpa单独使用,所有的内容都是在和Spring整合的环境中实现.如果需要了解该框架的入门,百度一下,很多入门的介绍.在这篇文章的接下来一篇,会有一			

		

	

				

		

			

                Spring Boot教程35——Spring Data JPA
			

		

		

									

				Hibernate是数据访问解决技术的绝对霸主.JPA是由Hibernate主导的一个基于O/R映射的标准规范.O/R映射即将领域模型类和数据库的表进行映射,通过程序操作对象而实现表数据操作的能力,让数据访问操作无须关注数据库相关的技术. Spring Data JPA介绍 1.定义数据访问层 使用Spring Data JPA建立数据访问层十分简单,只需定义一个继承JpaRepository的接口即可: public interface PersonRepository extends Jpa			

		

	

				

		

			

                Spring Boot2 系列教程(二十三)理解 Spring Data Jpa
			

		

		

									

				有很多读者留言希望松哥能好好聊聊 Spring Data Jpa! 其实这个话题松哥以前零零散散的介绍过,在我的书里也有介绍过,但是在公众号中还没和大伙聊过,因此本文就和大家来仔细聊聊 Spring Data 和 Jpa! 本文大纲: 1. 故事的主角 1.1 Jpa 1.1.1 JPA 是什么 Java Persistence API:用于对象持久化的 API Java EE 5.0 平台标准的 ORM 规范,使得应用程序以统一的方式访问持久层 1.1.2 JPA 和 Hibernate 的关			

		

	

				

		

			

                Spring Data JPA 1.10.1 详解二之快速Demo
			

		

		

									

				一.maven配置文件加入依赖 Spring Data JPA 依赖,最新稳定的版本为1.10.1.RELEASE,这里需要说明下的是,其依然依赖hibernate JPA相关JAR,hibernate-core之类的是不需要的.hibernate是JPA规范的一种实现,所以需要加入其依赖.ehcache是hibernate二级缓存的配置,不是必须的. <dependency>         <groupId>org.springframework.data</groupI			

		

	

				

		

			

                Spring Data Jpa配置
			

		

		

									

				Spring Data JPA提供的接口,也是Spring Data JPA的核心概念: 1:Repository:最顶层的接口,是一个空的接口,目的是为了统一所有Repository的类型,且能让组件扫描的时候自动识别. 2:CrudRepository :是Repository的子接口,提供CRUD的功能 3:PagingAndSortingRepository:是CrudRepository的子接口,添加分页和排序的功能 4:JpaRepository:是PagingAndSortingR			

		

	

				

		

			

                spring boot系列（五）spring boot 配置spring data jpa (查询方法)
			

		

		

									

				接着上面spring boot系列(四)spring boot 配置spring data jpa 保存修改方法继续做查询的测试: 1 创建UserInfo实体类,代码和https://www.cnblogs.com/kxm87/p/9273555.html中的一样. 2 创建数据库操作类相当于dao层,主要创建一个接口UserRepository,继承JpaRepository接口即可.本代码中主要都是自定义方法. 使用findXX 或者countXX(这两个不用编写sql,jpa会自动生成)			

		

	

				

		

			

                spring data jpa的使用
			

		

		

									

				在上篇文章springboot(二):web综合开发中简单介绍了一下spring data jpa的基础性使用,这篇文章将更加全面的介绍spring data jpa 常见用法以及注意事项 使用spring data jpa 开发时,发现国内对spring boot jpa全面介绍的文章比较少案例也比较零碎,因此写文章总结一下.本人也正在翻译Spring Data JPA 参考指南,有兴趣的同学欢迎联系我,一起加入翻译中! spring data jpa介绍 首先了解JPA是什么? JPA(Ja			

		

	

				

		

			

                《Spring Data JPA从入门到精通》内容简介、前言
			

		

		

									

				内容简介 本书以Spring Boot为技术基础,从入门到精通,由浅入深地介绍Spring Data JPA的使用.有语法,有实践,有原理剖析. 本书分为12章,内容包括整体认识JPA.JPA基础查询方法.定义查询方法.注解式查询方法.@Entity实例里面常用注解详解.JpaRepository扩展详解.JPA的MVC扩展REST支持.DataSource的配置.乐观锁.SpEL表达式在Spring Data里面的应用.Spring Data Redis实现cacheable的实践.Intel			

		

	

				

		

			

                Spring Data JPA进阶——Specifications和Querydsl
			

		

		

									

				Spring Data JPA进阶--Specifications和Querydsl 本篇介绍一下Spring Data JPA中能为数据访问程序的开发带来更多便利的特性,我们知道,Spring Data repository的配置很简单,一个典型的repository像下面这样: public interface CustomerRepository extends JpaRepository<Customer, Long> { Customer findByEmailAddress(Str