Spring Data JPA——概述、Spring Data JPA的CRUD操作

最新推荐文章于 2021-04-06 08:46:57 发布
最新推荐文章于 2021-04-06 08:46:57 发布
阅读量1k 收藏 2
点赞数 2
分类专栏： # Spring Data 文章标签： JPA String Data
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37989980/article/details/105936672
版权

目录

一、Spring Data JPA 概述

说明: 在Spring Data系列, 它们的使用都是大同小异的, 比如 SpringDataReids、SpringDataElasticsearch、SpringDataMongoDB的API都是类似的 !!!

Spring Data JPA 是 Spring 基于 ORM 框架、JPA 规范的基础上封装的一套JPA应用框架，可使开发者用极简的代码即可实现对数据库的访问和操作。它提供了包括增删改查等在内的常用功能，且易于扩展！学习并使用 Spring Data JPA 可以极大提高开发效率！

Spring Data JPA 让我们解脱了DAO层的操作，基本上所有CRUD都可以依赖于它来实现,在实际的工作工程中，推荐使用Spring Data JPA + ORM（如：hibernate）完成操作，这样在切换不同的ORM框架时提供了极大的方便，同时也使数据库层操作更加简单，方便解耦!

1、Spring Data JPA 与 JPA和hibernate之间的关系

跳转到目录

  • JPA是一套规范，内部是有接口和抽象类组成的。Hibernate是一套成熟的全自动的ORM框架，而且Hibernate实现了JPA规范，所以也可以称Hibernate为JPA的一种实现方式，我们使用JPA的API编程，意味着站在更高的角度上看待问题（面向接口编程）
  • Spring Data JPA是Spring提供的一套对JPA操作更加高级的封装，是在JPA规范下的专门用来进行数据持久化的解决方案。

在这里插入图片描述

二、Spring Data JPA入门

跳转到目录

  • Spring Data JPA完成客户的基本CRUD操作

1、环境搭建

引入Spring Data JPA的坐标

<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> 
    <!-- el end -->
</dependencies>

3、Spring整合Spring Data 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:aop="http://www.springframework.org/schema/aop"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:jdbc="http://www.springframework.org/schema/jdbc" xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:jpa="http://www.springframework.org/schema/data/jpa" xmlns:task="http://www.springframework.org/schema/task"
	xsi:schemaLocation="
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.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
		http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
		http://www.springframework.org/schema/data/jpa 
		http://www.springframework.org/schema/data/jpa/spring-jpa.xsd">
	
    <!-- Spring 和 Spring data jpa的配置 -->

    <!-- 1. 创建entityManagerFactory对象交给spring容器管理-->
    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!-- 配置要扫描的实体类包 -->
        <property name="packagesToScan" value="com.zy.domain"/>
        <!-- jpa的实现厂家 -->
        <property name="persistenceProvider">
            <bean class="org.hibernate.jpa.HibernatePersistenceProvider"/>
        </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="driverClass" value="com.mysql.jdbc.Driver" />
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/jpa?useUnicode=true&amp;characterEncoding=UTF-8" />
        <property name="user" value="root" />
        <property name="password" value="1111" />
    </bean>

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

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

    <!-- 5. 配置声明式事务(这里先不配置) -->
    <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>

    <!-- 6. 配置包扫描 -->
    <context:component-scan base-package="com.zy"/>
    
	<!-- 7.aop-->
	<aop:config>
		<aop:pointcut id="pointcut" expression="execution(* cn.itcast.service.*.*(..))" />
		<aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut" />
	</aop:config>
	
</beans>

4、使用JPA注解配置映射关系

@Entity
@Table(name = "cst_customer")
public class Customer {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name="cust_id")
    private Long custId;
    
    @Column(name="cust_address")
    private String custAddress;
    
    @Column(name="cust_industry")
    private String custIndustry;
    
    @Column(name="cust_level")
    private String custLevel;
    
    @Column(name="cust_name")
    private String custName;
    
    @Column(name="cust_phone")
    private String custPhone;
    
    @Column(name="cust_source")
    private String custSource;
    
	// 省略 getter/setter 方法
}

三、Spring Data JPA 完成CRUD

跳转到目录

1、编写符合Spring Data JPA规范的Dao层接口

  • Spring Data JPA是spring提供的一款对于数据访问层（Dao层）的框架，使用Spring Data JPA，只需要按照框架的规范提供dao接口，不需要实现类就可以完成数据库的增删改查、分页查询等方法的定义，极大的简化了我们的开发过程。
  • 在Spring Data JPA中，对于定义符合规范的Dao层接口，我们只需要遵循以下几点就可以了：
    1.创建一个Dao层接口，并实现JpaRepository和JpaSpecificationExecutor
    2.提供相应的泛型
/**
 * Description: 客户dao
 *
 * @author zygui
 * @date 2020/5/5 13:45
 */

/**
 * 符合SpringDataJpa的dao层接口规范
 *      JpaRepository<操作的实体类类型，实体类中主键属性的类型>
 *          * 封装了基本CRUD操作
 *      JpaSpecificationExecutor<操作的实体类类型>
 *          * 封装了复杂查询（分页）
 */
public interface CustomerDao extends JpaRepository<Customer, Long>, JpaSpecificationExecutor<Customer> 
{
}

这样我们就定义好了一个符合Spring Data JPA规范的Dao层接口

2、完成CRUD操作

/**
 * Description:
 *
 * @author zygui
 * @date 2020/5/5 13:50
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class CustomerDaoTest {

    @Autowired
    private CustomerDao customerDao;

    /**
     * 根据id来查询
     */
    @Test
    public void testFindOne() {
        Customer customer = customerDao.findOne(1L);
        System.out.println(customer);
    }

    /**
     * save : 保存或者更新
     *      根据传递的对象是否存在主键id，
     *      如果没有id主键属性：保存
     *      存在id主键属性，根据id查询数据，更新数据
     */
    @Test
    public void testSave() {
        Customer customer = new Customer();
        customer.setCustName("栗子");
        customer.setCustLevel("vip");
        customer.setCustIndustry("foot");
        customerDao.save(customer);
    }

    @Test
    public void testUpdate() {
        Customer customer = new Customer();
        customer.setCustId(4L);
        customer.setCustName("鸽子1");
        customer.setCustLevel("svip");
        customerDao.save(customer);
    }

    @Test
    public void testDelete() {
        customerDao.delete(3L);
    }

    @Test
    public void testFindAll() {
        List<Customer> list = customerDao.findAll();
        for (Customer customer : list) {
            System.out.println(customer);
        }
    }

    // 查询客户数量
    @Test
    public void testCount() {
        long count = customerDao.count();
        System.out.println(count);
    }

    /**
     * 测试：判断id为4的客户是否存在
     *      1. 可以查询以下id为4的客户
     *          如果值为空，代表不存在，如果不为空，代表存在
     *      2. 判断数据库中id为4的客户的数量
     *          如果数量为0，代表不存在，如果大于0，代表存在
     */
    @Test
    public void testExists() {
        boolean exists = customerDao.exists(4L);
        System.out.println("id为4的客户 是否存在："+exists);
    }

    /**
     * 根据id从数据库查询
     *      @Transactional : 保证getOne正常运行
     *
     *  findOne：
     *      em.find()           :立即加载
     *  getOne：
     *      em.getReference     :延迟加载
     *      * 返回的是一个客户的动态代理对象
     *      * 什么时候用，什么时候查询
     */
    @Test
    @Transactional
    public void testGetOne() {
        Customer customer = customerDao.getOne(4L);
        System.out.println(customer);
    }

}
white camel
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
spring Data JPA框架实例
07-20
用了spring data Jpa做的增删改查登录分页查询的简单实例
spring整合jpa简单实例
12-11
spring整合jpa简单实例，本人亲测正式有效，导入成功即可运行。
SpringDataJpa系列一之初识及入门案例搭建
程序员大航子
12-06 2721
本文章参考文档为《SpringDataJpa从入门到精通》 首先， 我觉得入门SpringDataJpa的话， 我们首先要理清楚。 JPA、Hibernate和SpringDataJpa的关系。 什么是JPA？ 全称Java Persistence API，可以通过注解或者XML描述【对象-关系表】之间的映射关系，并将实体对象持久化到数据库中。 但是它只是提供了一种规范， 而Hibernate...
JPA搭建及简单实例
Charge8的博客
10-17 1813
JPA 搭建以及简单实例 eclipse    mysql     Hibernate5.2.17      JPA2.1 一、JPA 概述 1、JPA是 Java Persistence API（Java 持久层 API）的简称，是JDK 5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体类对象持久化到数据库中。作用：使得应用程序以统一的方式访问持久层 2、JPA 与 Hib...
JPA的入门案例
heijunwei的博客
01-28 201
一、需求介绍 本章节我们是实现的功能是保存一个参会人员到数据库的参会表中。 二、开发包介绍 由于JPA是sun公司制定的API规范，所以我们不需要导入额外的JPA相关的jar包，只需要导入JPA的提供商的jar包。我们选择Hibernate作为JPA的提供商，所以需要导入Hibernate的相关jar包。 下载网址： http://sourceforge.net/projects/hibernate/files/hibernate-orm/5.0.7.Final/ ​​​​​​​三、..
SpringBoot使用Spring-Data-Jpa实现CRUD操作
08-27
主要为大家详细介绍了SpringBoot使用Spring-Data-Jpa实现CRUD操作，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
SpringBoot集成Spring Data JPA及读写分离
08-30
最后，通过Spring Data JPA提供的Repository接口，可以便捷地实现数据的CRUD操作。例如，定义一个用户Repository： ```java public interface UserRepository extends JpaRepository, Long> { } ``` 只需继承`Jpa...
整合Spring Data JPA1
最新发布
08-03
【Spring Data JPA 知识点详解】 Spring Data JPA 是 Spring Data 框架的一个重要组成部分，它为 Java 持久层提供了一种基于 JPA（Java Persistence API）的简单、高效的解决方案。JPA 是 Java 标准，用于管理关系...
spring data jpa使用详解(推荐)
08-27
Spring Data JPA 使用详解 Spring Data JPA 是基于 Spring 的一个开源框架，用于简化数据库访问，并支持云服务。其主要目标是使得对数据的访问变得方便快捷，并支持 Map-Reduce 框架和云计算数据服务。 Spring ...
idea下整合springboot+spring data jpa
02-02
Spring Boot提供了快速启动和配置的机制，而Spring Data JPA则是Spring框架的一部分，专注于数据库交互，使得开发者可以使用更加高级、抽象的方式来操作数据库，无需编写大量的JDBC代码。本文将详细介绍如何在...
SpringData案例
12-26
springData 增删查 一对一 一对多 多对多关联 详细解析基于springboot+maven项目管理
JPA例子(里面有一对一，一对多的例子)
08-06
JPA的几个例子，一对一，一对多。 @ManyToOne(cascade = {CascadeType.ALL}, fetch = FetchType.LAZY) @JoinColumn(name = "personid", unique = false, nullable = true, insertable = true, updatable = true) public Person getPerson() { return this.person; } public void setPerson(Person person) { this.person = person; }
springboot jpa的使用案例_02.zip
11-19
springboot jpa的使用案例- mysql、redis、resteful. jpa提供了统一接口，让访问飞一般的感觉。
Spring Data JPA 常用 CRUD 操作汇总 及 关联关系（ 操作 h2 内存数据）
蚩尤后裔-汪茂雄
04-27 3496
目录 JpaRepository 接口常用 API 环境准备 实体 Entity 持久化层 Service 层 控制器层 Controller JpaRepository 接口常用 API org.springframework.data.jpa.repository.JpaRepository 接口常用 API List<T> findAll() 查询...
Spring Data Jpa实践案例
一蓑烟雨任平生
04-06 142
https://www.cnblogs.com/chenglc/p/11226693.html
springboot+jpa 简单实例创建
liyang_nash的专栏
06-14 6314
参考:https://blog.csdn.net/wazz753/article/details/72472411#commentsedit1.展示效果2.开始2.1创建maven工程2.2修改pom文件&lt;project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-...
JPA介绍与实例
oscar999的专栏
09-19 2252
JPA的起源对象关系映射ORM（Object-Relation Mapping）是用来将对象和对象之间的关系对应到数据库中表与表之间的关系的一种模式。ORM框架能够将Java对象映射到关系数据库，能够直接持久化复杂的Java对象。ORM框架的出现，使开发者从数据库编程中解脱出来，把更多的精力放在了业务模型与业务逻辑上。目前比较流行的ORM框架有Hibernate、iBatis、TopLink等。在
SpringDataJpa入门案例：分析 的
qq_41934719的博客
02-13 273
SpringData Jpa原理 剖析 动态代理 的 实现 测试、--------------- 使用debug 来进行 代理实现的验证 效果如下图----------- 下图就是 动态代理 的 源码的分析 SpringAOP 的 实现的就是---- 1：JDKDynamicAopProxy======== 进行动态代理 2：SimpaleJpaReposistory======...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

white camel

感谢支持~

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值