SpringData JPA入门及其案例

最新推荐文章于 2022-12-04 20:33:58 发布
最新推荐文章于 2022-12-04 20:33:58 发布
阅读量314 收藏 1
点赞数
分类专栏： mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44211388/article/details/108256430
版权

SpringData JPA

一、概述

1.springdata Jpa 简述

​ Spring Data JPA 是 Spring 基于 ORM 框架、JPA 规范的基础上封装的一套JPA应用框架，推荐使用Spring Data JPA + ORM（如：hibernate）完成操作，SpringData Jpa 极大简化了数据库访问层代码，使用了SpringDataJpa，我们的dao层中只需要写接口，就自动具有了增删改查、分页查询等方法；

2.Spring Data JPA 与 JPA和hibernate之间的关系

​ JPA是一套规范，内部是有接口和抽象类组成的。hibernate是一套成熟的ORM框架，而且Hibernate实现了JPA规范，所以也可以称hibernate为JPA的一种实现方式；

​ Spring Data JPA是Spring提供的一套对JPA操作更加高级的封装，是在JPA规范下的专门用来进行数据持久化的解决方案；

二、入门案例

1.pom文件
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.zhangzhen</groupId>
    <artifactId>Springdata_jpa</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <spring.version>4.2.4.RELEASE</spring.version>
        <hibernate.version>5.0.7.Final</hibernate.version>
        <slf4j.version>1.6.6</slf4j.version>
        <log4j.version>1.2.12</log4j.version>
        <c3p0.version>0.9.1.2</c3p0.version>
        <mysql.version>5.1.6</mysql.version>
    </properties>

    <dependencies>
    <!-- junit单元测试 -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.9</version>
        <scope>test</scope>
    </dependency>

    <!-- spring beg -->
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.6.8</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aop</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context-support</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-orm</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <!-- spring end -->

    <!-- hibernate beg -->
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-core</artifactId>
        <version>${hibernate.version}</version>
    </dependency>
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-entitymanager</artifactId>
        <version>${hibernate.version}</version>
    </dependency>
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-validator</artifactId>
        <version>5.2.1.Final</version>
    </dependency>
    <!-- hibernate end -->

    <!-- c3p0 beg -->
    <dependency>
        <groupId>c3p0</groupId>
        <artifactId>c3p0</artifactId>
        <version>${c3p0.version}</version>
    </dependency>
    <!-- c3p0 end -->

    <!-- log end -->
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>${log4j.version}</version>
    </dependency>

    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>${slf4j.version}</version>
    </dependency>

    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-log4j12</artifactId>
        <version>${slf4j.version}</version>
    </dependency>
    <!-- log end -->


    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>${mysql.version}</version>
    </dependency>

    <dependency>
        <groupId>org.springframework.data</groupId>
        <artifactId>spring-data-jpa</artifactId>
        <version>1.9.0.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>4.2.4.RELEASE</version>
    </dependency>

    <!-- el beg 使用spring data jpa 必须引入 -->
    <dependency>
    <groupId>javax.el</groupId>
    <artifactId>javax.el-api</artifactId>
        <version>2.2.4</version>
    </dependency>
        <dependency>
            <groupId>org.glassfish.web</groupId>
            <artifactId>javax.el</artifactId>
            <version>2.2.4</version>
        </dependency>
        <dependency>
            <groupId>com.zhangzhen</groupId>
            <artifactId>JPA_basic</artifactId>
            <version>1.0-SNAPSHOT</version>
            <scope>test</scope>
        </dependency>
        <!-- el end -->
    </dependencies>

</project>
2.整合spring 与springdata jpa
<?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:jpa="http://www.springframework.org/schema/data/jpa"
       xmlns:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">


    <!--spring 和 spring data jpa的配置-->

    <bean id="entityManager" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
        <!--配置扫描的包-->
        <property name="packagesToScan" value="com.zhangzhen.domain"></property>
        <!--jpa实现厂商-->
        <property name="persistenceProvider">
            <bean id="persistenceProvider" class="org.hibernate.jpa.HibernatePersistenceProvider"></bean>
        </property>

        <!--jpa的供应商适配器 -->
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
                <!--配置是否自动创建数据库表 -->
                <property name="generateDdl" value="false"/>
                <!--指定数据库类型 -->
                <property name="database" value="MYSQL"/>
                <!--数据库方言：支持的特有语法 -->
                <property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect"/>
                <!--是否显示sql -->
                <property name="showSql" value="true"/>
            </bean>
        </property>

        <!--jpa的方言 ：高级的特性 -->
        <property name="jpaDialect">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaDialect"/>
        </property>

    </bean>

    <!--2.创建数据库连接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="user" value="root"></property>
        <property name="password" value="****"></property>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/mysql01"></property>
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
    </bean>

    <!--3.整合spring dataJpa-->
    <jpa:repositories base-package="com.zhangzhen.*"  transaction-manager-ref="transactionManager"
                      entity-manager-factory-ref="entityManager"></jpa:repositories>


    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManager"></property>
    </bean>


    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="save*" propagation="REQUIRED"/>
            <tx:method name="insert*" propagation="REQUIRED"/>
            <tx:method name="update*" propagation="REQUIRED"/>
            <tx:method name="delete*" propagation="REQUIRED"/>
            <tx:method name="get*" read-only="true"/>
            <tx:method name="find*" read-only="true"/>
            <tx:method name="*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>

<!--
    &lt;!&ndash;aop切点&ndash;&gt;
    <aop:config >
        <aop:pointcut id="pointcut" expression="execution(*com.zhangzhen.)"
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut"></aop:advisor>
    </aop:config>
-->


    <!--5.声明式事务 -->

    <!-- 6. 配置包扫描-->
    <context:component-scan base-package="com.zhangzhen.*"></context:component-scan>

</beans>
3.实体映射关系
package com.zhangzhen.domain;

import javax.persistence.*;
import java.util.Date;

@Entity    //声明实体类
@Table(name = "user")  //建立实体类与表的映射关系
public class User {

    @Id //声明当前私有属性为主键
    @GeneratedValue(strategy = GenerationType.IDENTITY)  //配置主键的生成策略
    @Column(name = "id")        //指定和表中主键字段的映射关系

    private  Long id ;
    @Column(name = "username")
    private  String name ;
    @Column(name = "birthday")
    private Date bday;
    @Column(name = "sex")
    private  String sex;
    @Column(name = "address")
    private  String address ;
	
        /*省略get（）、set（）方法*/
}
4.编写符合Spring Data JPA规范的Dao层接口
/**
 * JpaRepository<实体类类型，主键类型>：用来完成基本CRUD操作
 * JpaSpecificationExecutor<实体类类型>：用于复杂查询（分页等查询操作）
 */
public interface UserDao extends JpaRepository<User, Long>, JpaSpecificationExecutor<User> {

}
5.完成CRUD操作
import com.zhangzhen.dao.UserDao;
import com.zhangzhen.domain.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class) //声明spring提供的单元测试环境
@ContextConfiguration(locations = "classpath:applicationContext.xml")//指定spring容器的配置信息
public class UserDaoTest {

    @Autowired
    private UserDao userDao;
    
    
   /* 对于save方法的解释：如果执行此方法是对象中存在id属性，即为更新操作会先根据id查询，再更新    
                        如果执行此方法中对象中不存在id属性，即为保存操作*/

    @Test
    public  void  testsave(){
        
        User user = new User();
        user.setName("情人节2020.08.25");
        userDao.save(user);
    }

    @Test
    public  void  Updatetest(){
        User user = userDao.findOne(61L);
        user.setName("西安大融城");
        user.setAddress("高新区");
        userDao.save(user);

    }
        
    /**
     * 根据id删除：调用delete(id)方法
     */
    @Test
    public void testDelete() {
        UserDao.delete(1l);
    }
    
    /**
     * 根据id查询：调用findOne(id)方法
     */
    @Test
    public void testFindById() {
        User user = userDao.findOne(61L);
        System.out.println(user);
    }
}

三、springsdata Jpa原理分析

1.接口分析

​ 我们发现在自定义的CustomerDao中，并没有提供任何方法就可以使用其中的很多方法，那么这些方法究竟是怎么来的呢？答案很简单，对于我们自定义的Dao接口，由于继承了JpaRepository和JpaSpecificationExecutor，所以我们可以使用这两个接口的所有方法；
在这里插入图片描述

2.Spring Data JPA的实现过程
*** 代理子类的实现过程**

在这里插入图片描述

代理对象中方法调用的分析

​ 当程序执行的时候，会通过JdkDynamicAopProxy的invoke方法，对customerDao对象生成动态代理对象。根据对Spring Data JPA介绍而知，要想进行findOne查询方法，最终还是会出现JPA规范的API完成操作，那么这些底层代码存在于何处呢？答案很简单，都隐藏在通过JdkDynamicAopProxy生成的动态代理对象当中，而这个动态代理对象就是SimpleJpaRepository；

四、查询方式

1.JPQL
public interface CustomerDao extends JpaRepository<Customer,Long>,JpaSpecificationExecutor<Customer> {    
    //@Query 使用jpql的方式查询。
    @Query(value="from Customer")    //Customer为实体类名，非数据库表名
    public List<Customer> findAllCustomer();
    
    //@Query 使用jpql的方式查询。?1代表参数的占位符，其中1对应方法中的参数索引
    @Query(value="from Customer where custName = ?1")
    public Customer findCustomer(String custName);
}

    @Query(value="update Customer set custName = ?1 where custId = ?2")
    @Modifying  //更新操作注解，标识未修改查询
    public void updateCustomer(String custName,Long custId);

，非数据库表名
public List findAllCustomer();

//@Query 使用jpql的方式查询。?1代表参数的占位符，其中1对应方法中的参数索引
@Query(value="from Customer where custName = ?1")
public Customer findCustomer(String custName);

}


```java
    @Query(value="update Customer set custName = ?1 where custId = ?2")
    @Modifying  //更新操作注解，标识未修改查询
    public void updateCustomer(String custName,Long custId);
别为泼翻的牛奶哭泣
关注
专栏目录
Spring Boot入门(11)：轻松上手！Spring Boot与Spring Data JPA的完美结合
**My Coding Family**
04-17 1万+
轻松上手！Spring Boot与Spring Data JPA的完美结合。
SpringMVC以及SpringBoot整合SpringDataJPA简单入门
mashizhong521的博客
08-15 782
1.Spring Data JPA的概述 Spring Data JPA 是 Spring 基于 ORM 框架、JPA 规范的基础上封装的一套JPA应用框架，可使开发者用极简的代码即可实现对数据库的访问和操作。它提供了包括增删改查等在内的常用功能，且易于扩展！学习并使用 Spring Data JPA 可以极大提高开发效率！ Spring Data JPA 让我们解脱了DAO层的操作...
spring Data JPA框架实例
07-20
用了spring data Jpa做的增删改查登录分页查询的简单实例
SpringData JPA示例
xiang__liu的博客
07-02 848
1. SpringData JPA只是SpringData中的一个子模块 JPA是一套标准接口，而Hibernate是JPA的实现 SpringData JPA 底层默认实现是使用Hibernate2. spring.jpa.properties.hibernate.hbm2ddl.auto是hibernate的配置属性，其主要作用是：自动创建、更新、验证数据库表结构。该参数的...
Spring Boot 系列 - 数据层 集成Spring-data-jpa
chiyan5284的博客
07-19 149
实际开发中，不可避免地会对数据进行反复的增删改查操作，然而这部分工作是十分繁琐枯燥的。那么，随即而生的ORM框架就能很好的解决这个问题。 我们常用的ORM框架有：Hibernate、Mybatis、Jpa 等。本文介绍SpringBoot 中集成 Jpa 框架。 集成 JPA (Java Pe...
Spring Data JPA简单实例
MyArrow的专栏
03-03 4794
转自：http://itindex.net/detail/47162-spring-data-jpa 我们都知道Spring是一个非常优秀的JavaEE整合框架，它尽可能的减少我们开发的工作量和难度。  　　在持久层的业务逻辑方面，Spring开源组织又给我们带来了同样优秀的Spring Data JPA。  　　通常我们写持久层，都是先写一个接口，再写接口对应的实现类，在实现类中进
Spring Data JPA 应用案例实现
丿涛哥哥的博客
07-15 262
Spring Data JPA 应用案例实现 需求：使用 Spring Data JPA 完成对 tb_resume 表（简历表）的Dao 层操作（增删改查，排序，分页等） 数据表设计 初始化Sql语句 SET NAMES utf8mb4; SET FOREIGN_KEY_CHECKS = 0; -- ---------------------------- -- Table structure for tb_resume -- ---------------------------- DROP TAB
Spring Data JPA
12-22
这个入门项目实例旨在帮助开发者快速掌握Spring Data JPA的基本用法和核心概念，通过实际案例进行学习和交流。 在Spring Data JPA中，你可以避免大量编写SQL语句和手动管理实体对象的状态，因为Spring Data JPA为你...
springboot中使用Spring Data Jpa
最新发布
daimenglaoshi的博客
12-04 863
ORM即Object-Relationl Mapping，它的作用是在关系型数据库和对象之间作一个映射，这样，我们在具体的操作数据库的时候，就不需要再去和复杂的SQL语句打交道，只要像平时操作对象一样操作它就可以了 。在ORM出现之前，我们是用jdbc来操作数据库，但jdbc没有封装，对于大项目来说，使用复杂，也难以实现MVC的概念，所以人们就开发了ORM框架来解决这些问题。比如Hibernate，Mybatis，不过Hibernate是完全的ORM框架，mybatis是半ORM框架，因为它需要手动建表和自
一个完整的spring data jpa 的实例
金戈铁马
05-17 3482
创建项目 用 spring tool suite 创建一个 spring starter project ： (笔者使用的 STS 版本为 4-4.0.1.RELEASE) 依赖包中选择 web 及JPA pom.xml 额外增加 mysql 相关依赖，最终的 pom.xml 依赖： <dependencies> <dependency> ...
spring data jpa 实例源码
06-02
spring data jpa 实例源码 spring data jpa 实例源码 spring data jpa 实例源码
spring data jpa 案例
03-06
spring data jpa 案例，用于学习springdata jpa一些常用api
spring data jpa简单案例
08-12
NULL 博文链接：https://chentian114.iteye.com/blog/2287028
SpringData案例
12-26
springData 增删查 一对一 一对多 多对多关联 详细解析基于springboot+maven项目管理
Spring Data JPA 入门例子极简代码
09-23
Spring Data JPA 入门例子，博文地址http://blog.csdn.net/wu_boy/article/details/45172625
Spring Data JPA 入门案例
weixin_40055163的博客
10-21 286
Spring Data JPA 入门案例 1.打开IDEA工具的界面如图所示，点击Create New Project。 2.选择Maven工程和JDK的版本，并点击Next。如图所示： 3.填写项目名称和保存的地址，点击Finish。如图所示： 4.导入相应的依赖jar包的代码如下： <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmln
spring data jpa入门示例
lucasma的博客
06-29 1234
文章目录什么是JPAjava数据库编程的进化史spring data jpa的功能介绍使用示例测试 什么是JPA JPA的全称是Java Persistence API，提供了一个规范，用于将数据通过Java对象持久化、读取和管理数据库中的关系表。所以JPA本质上就是一种ORM规范，它的目标是实现ORM的天下归一。 java数据库编程的进化史 这里我以自己的经历来简单说说。 我刚接触java的时候...
SpringDataJpa系列一之初识及入门案例搭建
程序员大航子
12-06 2757
本文章参考文档为《SpringDataJpa从入门到精通》 首先， 我觉得入门SpringDataJpa的话， 我们首先要理清楚。 JPA、Hibernate和SpringDataJpa的关系。 什么是JPA？ 全称Java Persistence API，可以通过注解或者XML描述【对象-关系表】之间的映射关系，并将实体对象持久化到数据库中。 但是它只是提供了一种规范， 而Hibernate...
spring-data JPA demo例子。jpa超简易例子。
SacredOath的博客
06-02 230
jpa比mybatis简单太多了。加之spring-data，可以实现全自动的数据访问功能，几乎不用写代码。 1. maven依赖 <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>4.2.9.RELEASE</version> </depen
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值