Spring Data JPA

最新推荐文章于 2024-06-28 09:14:09 发布
最新推荐文章于 2024-06-28 09:14:09 发布
阅读量123 收藏 1
点赞数
分类专栏： spring data jpa 文章标签： jpa java 数据库 spring data jpa hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42494845/article/details/108182906
版权

概述

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

Spring Data JPA 与 JPA

Spring Data JPA是Spring提供的一套对JPA操作更加高级的封装，是在JPA规范下的专门用来进行数据持久化的解决方案。
Spring Data JPA 让我们解脱了DAO层的操作，基本上所有CRUD都可以依赖于它来实现,在实际的工作工程中，通常使用Spring Data JPA + ORM（如：hibernate）完成操作，这样在切换不同的ORM框架时提供了极大的方便，同时也使数据库层操作更加简单，方便解耦。

Spring Data JPA案例

Spring Data JPA完成学生表的基本CRUD操作

开发环境搭建

导入jar包坐标
使用Spring Data JPA，需要整合Spring与Spring Data JPA，并且需要提供JPA的服务提供者hibernate，所以需要导入spring相关坐标，hibernate坐标，数据库驱动坐标等

<properties>
        <spring.version>5.0.2.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>8.0.11</mysql.version>
    </properties>
    <dependencies>
        <!-- junit单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>javax.xml.bind</groupId>
            <artifactId>jaxb-api</artifactId>
            <version>2.3.0</version>
        </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>

        <!-- spring对orm框架的支持包-->
        <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>

        <!-- spring data jpa 的坐标-->
        <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>${spring.version}</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>

整合Spring Data JPA与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: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的配置-->

    <!-- 创建entityManagerFactory对象交给spring容器管理-->
    <bean id="entityManagerFactoty" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <!--配置的扫描的包（实体类所在的包） -->
        <property name="packagesToScan" value="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>

        <!--注入jpa的配置信息
            加载jpa的基本配置信息和jpa实现方式（hibernate）的配置信息
            hibernate.hbm2ddl.auto : 自动创建数据库表
                create ： 每次都会重新创建数据库表
                update：有表不会重新创建，没有表会重新创建表
        -->
        <property name="jpaProperties" >
            <props>
                <prop key="hibernate.hbm2ddl.auto">update</prop>
            </props>
        </property>
    </bean>

    <!--创建数据库连接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="user" value="root"></property>
        <property name="password" value="qwe123"></property>
        <property name="jdbcUrl" value="jdbc:mysql:///jpa?useSSL=false&amp;serverTimezone=UTC" ></property>
        <property name="driverClass" value="com.mysql.cj.jdbc.Driver"></property>
    </bean>

    <!--整合spring dataJpa-->
    <jpa:repositories base-package="dao" transaction-manager-ref="transactionManager"
                   entity-manager-factory-ref="entityManagerFactoty" ></jpa:repositories>

    <!--配置事务管理器 -->
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactoty"></property>
    </bean>
    <!-- txAdvice-->
    <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>

    <!-- aop-->
    <aop:config>
        <aop:pointcut id="pointcut" expression="execution(* dao.*.*(..))" />
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut" />
    </aop:config>

    <context:component-scan base-package="dao,domain" ></context:component-scan>
</beans>

使用JPA注解配置映射关系

package domain;

import javax.persistence.*;

@Entity
@Table(name = "student")
public class Student {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Long id;
    @Column(name = "name")
    private String name;
    @Column(name = "sex")
    private String sex;
    @Column(name = "age")
    private Integer age;
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", age=" + age +
                '}';
    }
}

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

Spring Data JPA是spring提供的一款对于数据访问层（Dao层）的框架，使用Spring Data JPA，只需要按照框架的规范提供dao接口，不需要实现类就可以完成数据库的增删改查、分页查询等方法的定义，极大的简化了我们的开发过程。

定义符合Spring Data JPA规范的Dao层接口

创建一个Dao层接口，并实现JpaRepository和JpaSpecificationExecutor
提供相应的泛型

package dao;

import domain.Student;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;

public interface StudentDao extends JpaRepository<Student,Long> ,JpaSpecificationExecutor<Student> {
}

基本CRUD操作

import dao.StudentDao;
import domain.Student;
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;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

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

    @Autowired
    private StudentDao studentDao;
    /**
     * 根据id查询
     */
    @Test
    public void testFindOne() {
        Student student = studentDao.findOne(2l);
        System.out.println(student);
    }

    /**
     * save : 保存或者更新
     *      根据传递的对象是否存在主键id，
     *      如果没有id主键属性：保存
     *      存在id主键属性，根据id查询数据，更新数据
     */
    @Test
    public void testSave() {
        Student student = new Student();
        student.setName("linda");
        student.setSex("female");
        student.setAge(21);
        studentDao.save(student);
    }
	//更新
    @Test
    public void testUpdate() {
        Student student = studentDao.findOne(5l);
        student.setAge(25);
        studentDao.save(student);
    }
	//删除
    @Test
    public void testDelete () {
        studentDao.delete(4l);
    }


    /**
     * 查询所有
     */
    @Test
    public void testFindAll() {
        List<Student> students = studentDao.findAll();
        for (Student student : students) {
            System.out.println(student);
        }
    }

    /**
     * 统计查询：查询学生的总数量
     *      count:统计总条数
     */
    @Test
    public void testCount() {
        long count = studentDao.count();
        System.out.println(count);
    }

    /**
     * 判断id为4的学生是否存在
     */
    @Test
    public void  testExists() {
        boolean exists = studentDao.exists(4l);
        System.out.println("id为4的学生是否存在："+exists);
    }


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

方法命名规则查询

方法命名规则查询就是根据方法的名字，就能创建查询。只需要按照Spring Data JPA提供的方法命名规则定义方法的名称，就可以完成查询工作。Spring Data JPA在程序执行的时候会根据方法名称进行解析，并自动生成查询语句进行查询

按照Spring Data JPA 定义的规则，查询方法以findBy开头，涉及条件查询时，条件的属性用条件关键字连接，要注意的是：条件属性首字母需大写。
在这里插入图片描述

例

package dao;

import domain.Student;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;

import java.util.List;

public interface StudentDao extends JpaRepository<Student,Long> ,JpaSpecificationExecutor<Student> {
	// 根据学生姓名查找
    public List<Student> findByName(String name);
	// 查询性别为参数一且年龄小于参数二的学生
    public List<Student> findBySexAndAgeLessThan(String sex,Integer age);
}

Specifications动态查询

有时我们在查询某个实体的时候，给定的条件是不固定的，这时就需要动态构建相应的查询语句，在Spring Data JPA中可以通过JpaSpecificationExecutor接口查询。相比JPQL,其优势是类型安全,更加的面向对象。

使用Specifications完成条件查询

public void testSpec() {
        /**
         * 自定义查询条件
         *      1.实现Specification接口（提供泛型：查询的对象类型）
         *      2.实现toPredicate方法（构造查询条件）
         *      3.需要借助方法参数中的两个参数（
         *          root：获取需要查询的对象属性
         *          CriteriaBuilder：构造查询条件的，内部封装了很多的查询条件（模糊匹配，精准匹配）
         *       ）
         *          查询条件
         *              1.查询方式
         *                  cb对象
         *              2.比较的属性名称
         *                  root对象
         *
         */
        Specification<Student> spec = new Specification<Student>() {
            @Override
            public Predicate toPredicate(Root<Student> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
                //获取比较的属性
                Path<Object> name = root.get("name");
                //模糊查询
                Predicate predicate = cb.like(name.as(String.class), "jack%");
                return predicate;
            }
        };
        List<Student> students = studentDao.findAll(spec);
        students.forEach(new Consumer<Student>() {
            public void accept(Student student) {
                System.out.println(student);
            }
        });
    }

基于Specifications的分页查询

public void testSpecPages() {
        Specification<Student> spec = new Specification<Student>() {
            @Override
            public Predicate toPredicate(Root<Student> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
                Path<Object> name = root.get("name");
                Predicate predicate = cb.like(name.as(String.class), "jack%");
                return predicate;
            }
        };
        // 4条记录一页，查询第2页数据（从第0页开始算）
        Pageable pageable = new PageRequest(2,4);
        Page<Student> studentPage = studentDao.findAll(spec, pageable);
        long count = studentPage.getTotalElements();
        int pages = studentPage.getTotalPages();
        List<Student> students = studentPage.getContent();
        System.out.println("查询到符合条件的总记录数为："+count);
        System.out.println("总页数为："+pages);
        System.out.println("当前页的记录如下：");
        for (Student student : students) {
            System.out.println(student);
        }
    }

排序查询

public void testSpecSort() {
		//根据ID从大到小排序
        Sort sort = new Sort(Sort.Direction.DESC,"id");
        List<Student> students = studentDao.findAll(sort);
        for (Student student : students) {
            System.out.println(student);
        }
    }

今天的分享就到这里了，欢迎关注。

红丶
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JPA框架jar包
12-10
JPA框架所需的jar包，本jar包适用于ORM框架。
Spring Data JPA的优点和难点.pdf
12-05
Spring Data JPA是Spring生态中的一个强大ORM框架，它极大地提高了Java开发者在处理数据库操作时的效率。Spring Data JPA的主要优点在于其高度的开发效率、成熟的语法结构以及与Spring框架的紧密集成。 1. **开发...
JPA架构
流年、你奈我何
04-20 3487
JPA(Java持久性API)是存储业务实体关联的实体的来源。它显示了如何定义一个面向普通Java对象(POJO)作为一个实体，以及如何与管理关系实体。 类级别架构 下图显示了JPA的类的层次结构。它显示核心类和JPA接口。 下表描述了每个在上述架构的显示单元。 单元 描述 EntityManagerFactory 这是一个EntityMana
Spring Data JPA：全面指南
最新发布
FireFox1997
06-28 395
JPA（Java Persistence API）是一个 Java EE 标准，用于管理关系数据的持久化。它定义了一组接口，允许开发者以面向对象的方式操作数据库，而无需编写大量的 SQL 语句。JPA 的核心概念包括实体（Entity）、实体管理器（EntityManager）和持久化单元（Persistence Unit）。实体是一个轻量级的持久化领域对象，通常映射到数据库表。实体管理器是用于管理实体的接口，提供了CRUD（创建、读取、更新、删除）操作的方法。
Spring Data JPA框架
niceyoo的博客
12-01 128
1、前言 扔一个 spring data jpa 的代码，可运行，后续补充博客内容。 环境：eclipse + tomcat8 2、部分截图 3、源码 https://gitee.com/niceyoo/jpa-demo 4、sql 既然都是 spring data jpa ，还要啥数据库呀，自己创建一个数据库，更改 jeenotes.properti...
jpa框架的搭建
gaoge19861207的专栏
09-27 1119
1：导入jpa的jar包不同jpa实现导入的jar包是不同的，如果是用hibernate来实现的，那么就要导入hibernate实现的jia包。这里因为是用Hibernate来实现的，所以就需要两个，一个是Hibernate的核心包(hibernate-3.2文件里相应的jar包，就是hibernate的核心包hibernate3.jar和lib文件夹下所有的第三方实现.jar文件）；还有
jpa框架
西瓜
03-30 5250
https://www.jianshu.com/p/2b68af9aa0f5/
Spring Data JPA中文文档[1.4.3]_springdatajpa_erlang_waitxpf_
10-02
**Spring Data JPA** 是一个基于 **Java** 的开源框架，它是 **Spring Framework** 的一个模块，主要用于简化 **Java Persistence API (JPA)** 的使用。JPA 是 Java 平台上的一个标准，用于管理和持久化应用程序的...
Spring Data JPA API（Spring Data JPA 开发文档）.CHM
08-31
Spring Data JPA API。 Spring Data JPA 开发文档。 官网 Spring Data JPA API。
spring注解+spring data jpa文档+JPA文档.rar
04-05
Spring框架的核心特性包括依赖注入（DI）和面向切面编程（AOP），并且它还提供了对数据库操作的支持，这主要通过Spring Data JPA和Java Persistence API（JPA）实现。 Spring注解是Spring框架中的一大特色，它极大...
Spring Data Jpa实现自定义repository转DTO
08-18
Spring Data Jpa 实现自定义 Repository 转 DTO Spring Data Jpa 是 Java 持久层框架，提供了基于 Java 持久性 API（JPA）的实现。它提供了许多有用的功能，例如自动生成数据库表、自动处理关系数据库、支持 JPQL ...
JPA框架
CZW2181119177的博客
08-05 9993
一、JPA 介绍 1、JDBC 2、JPA是什么 二、搭建 JPA 环境 三、JPA 注解 四、JPA API 1、缓存 2、EntityManager 3、API 五、关联关系映射 1、一对一映射 2、单向一对多 3、单向多对一 4、双向一对多及多对一 5、双向多对多 六、JPQL 1、createQuery 2、createNativeQuery......
Spring Data JPA 框架
xhuiting的博客
09-29 2111
前言 Spring Data Jpa 是应⽤于Dao层的⼀个框架，简化数据库开发的，作⽤和Mybatis框架⼀样，但是在使⽤⽅式和底层机制是有所不同的。最明显的⼀个特点， Spring Data Jpa 开发Dao的时候，很多场景我们连sql语句都不需要开发。由Spring出品。第⼀部分 Spring Data JPA 概述 什么是 Spring Data JPA Spring Data JPA 是 Spring 基于JPA 规范的基础上封装的⼀套 JPA 应⽤框架，可使开发者⽤极简的代码即可实现对数据库
java jpa框架,Spring Data JPA 框架
weixin_36064575的博客
03-19 518
Spring Data JPA 框架简介Spring Data Jpa 是应⽤于Dao层的⼀个框架，简化数据库开发的，作⽤和Mybatis框架⼀样，但是在使⽤⽅式和底层机制是有所不同的。最明显的⼀个特点，Spring Data Jpa 开发Dao的时候，很多场景我们连sql语句都不需要开发。由Spring出品。Spring Data JPA 是 Spring 基于JPA 规范的基础上封装的⼀套 J...
JPA框架：快速入门
大连赵哥的博客
01-05 524
JPA框架：快速入门
JPA框架的学习：
LOVE_Me__的博客
07-21 420
Repository接口讲解： Repository接口是Spring Data的核心接口，不提供任何方法 public interface Repository<T,ID extends Serializable> { } @RepositoryDefinition的使用 Repository类的定义： public interface Repository<T,ID extends Serializable> { } Repository是一个空接口，标记接.
Hibernate级联那些事儿（JPA框架）
haha_mingg的专栏
04-18 1161
在开发后台JAVA代码的时候（基于ECAFE_APPLCATION 2.2），联级关联如果用到@ManyToOne(cascade = CascadeType.ALL)的时候，会在控制台出现异常错误。而我用@ManyToOne(cascade = CascadeType.REFRESH)的时候，则不报错正常。出现这一情况，我也不知道怎么回事儿，不过使用我们有必要去了解联级操作。 1.对Hiber
JPA
abcdefgh666的博客
08-27 97
JPA的由来 ORM框架能够将Java对象映射到关系型数据库中，能够直接持久化复杂的Java对象。ORM框架的出现，可以让开发者从数据库编程中解脱出来，把更更多的精力放在业务模型与业务逻辑上。目前比较流行的ORM框架有MyBatis、Hibernate、TopLink、JDO等。 在JPA规范之前，由于没有官方的标准，使得各ORM框架之间的JPI差别很大，使用了某种ORM框架的系统会严重受制于该ORM的标准。基于此，Sun引入新的JPA ORM，主要的原因有：其一，简化现有的Java EE和Java SE应
Spring Data JPA新增特性详解
"新增及注意点-rsoft教程学习-Spring Data JPA PDF" Spring Data JPA 是一个流行的数据访问框架，它简化了与Java Persistence API (JPA) 的交互，尤其是与关系数据库的交互。本教程主要关注Spring Data JPA 的新增...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值