JPA框架

最新推荐文章于 2024-09-02 22:18:30 发布
最新推荐文章于 2024-09-02 22:18:30 发布
阅读量3.9k 收藏 7
点赞数 15
文章标签： java spring mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_71255572/article/details/127012217
版权

一.传统SQL和JPA的区别

传统JDBC实现数据库的操作

 缺点:操作繁琐,赋值麻烦

因此,我们引入了orm思想,通过操作实体类去完成数据库操作.

orm思想:1.建立表和实体类的映射关系

                2.建立表的字段和实体类属性的关系

二.Hibernate框架

概念:一个开源的ORM映射框架,对JDBC做轻量化的封装,建立了实体类和表的映射关系

JPA规范

sun公司面对如此多的orm映射框架,制定了一套JPA映射规范,主要由接口和抽象类组成,由其他框架完成实现

JPA不干活,干活的是Hibernate这些实现框架

三.入门案例:

1.创工程,导入依赖

2.配置jpa配置文件

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="2.0">
    <!--

JPA根据下面的配置信息创建EntityManagerFactory,一个项目中可以配置多个持久单元

name:为当前持久单元命名,可以通过该名称指定加载对应的配置信息

-->
    <persistence-unit name="myPersistence" transaction-type="RESOURCE_LOCAL">
        <!--jpa的实现方式-->
        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>

        <!--指定扫描贴Entity实体类所在的jar包-->
        <properties>

            <!--数据库的方言,告诉JPA当前应用使用的数据库-->
            <property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5Dialect"/>
            <!--jpa的相关的配置信息-->
            <property name="javax.persistence.jdbc.user" value="root"/>
            <property name="javax.persistence.jdbc.password" value="123456"/>
            <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql:///jpa"/>


            <!--是否在控制台打印执行的sql语句-->
            <property name="hibernate.show_sql" value="true"/>

            <!--自动创建数据库表     create,update,non  -->
            <property name="hibernate.hbm2ddl.auto" value="update"/>

        </properties>
    </persistence-unit>
</persistence>

一个知识点:在配置数据库地址的时候  "jdbc:mysql:///jpa"三个/代表本地3306端口 

3.实体类的创建-----建立表映射关系,,建立属性和字段的映射关系

1)配置实体类和表的映射关系,需要用到@Entity  ,@Table("name=''tableName")

2)属性与字段的映射

主要分为两类:

1.主键的配置 @Id  声明主键, @GenerateValue()声明主键增长方式  @Column声明表中字段信息

2.其他属性:直接用@column即可

JPA的执行流程

 

JPA基本CRUD语句:sql执行都是通过enetiyManger实现的

package com.bozai;

import com.bozai.utils.JpaUtils;
import org.junit.Test;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;

public class Test1 {

    @Test
    public void  testJpa(){
        //1.加载配置文件,创建工厂对象
//        EntityManagerFactory factory = Persistence.createEntityManagerFactory("myPersistence");
        EntityManager entityManager = JpaUtils.getEntityManager();
        //2.通过工厂获取实体类管理器
//        EntityManager entityManager = factory.createEntityManager();
        //3.获取事务对象,开启事务
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();//开启事务
        //完成增删改查操作
        Customer customer=new Customer();
        customer.setCustAddress("利川市龙潭村");
        customer.setCustIndustry("吉利工厂");
        //保存
        entityManager.persist(customer);
        //提交事务
        transaction.commit();
        //释放资源
        entityManager.close();;
        //factory.close();

    }


    @Test
    public void  findJpa(){
        EntityManager entityManager = JpaUtils.getEntityManager();
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();
        Customer customer = entityManager.find(Customer.class, 1L);
        System.out.println(customer);
        entityManager.close();



    }

    @Test
    public void  findJpa1(){
        EntityManager entityManager = JpaUtils.getEntityManager();
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();
        Customer customer = entityManager.getReference(Customer.class, 1L);
        System.out.println(customer);
        entityManager.close();



    }

    @Test
    public void  removeJpa(){
        EntityManager entityManager = JpaUtils.getEntityManager();
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();
        Customer customer = entityManager.getReference(Customer.class, 1L);
        entityManager.remove(customer);
        System.out.println(customer);
        transaction.commit();
        entityManager.close();

    }


    @Test
    public void  updateJpa(){
        EntityManager entityManager = JpaUtils.getEntityManager();
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();
        Customer customer = entityManager.getReference(Customer.class, 2L);
        customer.setCustIndustry("法拉利工厂");
        entityManager.merge(customer);

        System.out.println(customer);
        transaction.commit();
        entityManager.close();

    }

}

JPQL语句:高级语句(直接在接口上定义方法,写出一个sql的接口,然后@query()利用占位符写出查询语句)

JPQL需要先构建一个String查询语句,然后创建查询对象.通过对象去执行查询

SpringDataJPA

关系

 SpringData快速入门

1搭建环境

1)导入依赖

<?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.bozai</groupId>
    <artifactId>SpringData</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.6</version>
            <scope>runtime</scope>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-aop -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>5.2.12.RELEASE</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.18</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-context-support -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>5.3.6</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/springframework/spring-orm -->
        <dependency>
            <groupId>springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>1.1.3</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-beans -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.3.3</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-core -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.3.20</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>5.3.7.Final</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-c3p0 -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-c3p0</artifactId>
            <version>5.2.12.Final</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>5.3.7.Final</version>
        </dependency><!-- https://mvnrepository.com/artifact/org.hibernate.validator/hibernate-validator -->
        <dependency>
            <groupId>org.hibernate.validator</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>6.2.0.Final</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.16</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.36</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.6.4</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework.data/spring-data-jpa -->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-jpa</artifactId>
            <version>2.3.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.3.2</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/javax.el/javax.el-api -->
        <dependency>
            <groupId>javax.el</groupId>
            <artifactId>javax.el-api</artifactId>
            <version>2.2.4</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.glassfish/javax.el -->
        <dependency>
            <groupId>org.glassfish</groupId>
            <artifactId>javax.el</artifactId>
            <version>3.0.0</version>
        </dependency>



    </dependencies>

</project>

2)配置文件

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




    <!--需要使用 LocalContainerEntityManagerFactoryBean ，因为只有这个对象才能支持persistanceContext注解-->
    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <!--配置数据源-->
        <property name="dataSource" ref="dataSource"/>
        <!--扫描domain层包,将里面的对象纳入到entityManger的管理当中-->
        <property name="packagesToScan" value="com.bozai.domain"/>
<!--        jpa实现的厂家-->
        <property name="persistenceProvider">
            <!--找到hibernate的适配器-->
            <bean class="org.hibernate.jpa.HibernatePersistenceProvider"/>
        </property>

        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
               <!--配置数据库-->
                <property name="database" value="MYSQL"></property>
                <!--配置方言-->
                <property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect"/>
                <!--配置数据库建表策略-->
                <property name="generateDdl" value="false"/>
                <!--配置sql语句显示-->
                <property name="showSql" value="true"/>
            </bean>
        </property>
        <!--    jpa方言-->
        <property name="jpaDialect">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaDialect"></bean>
        </property>
    </bean>


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

    </bean>



    <tx:annotation-driven/>
    <!--将dao层改为repository（springdataJpa建议）-->
    <!--将repository扫描到jpa当中去，添加事务管理管理器，并且添加entityManagerFactory对象-->
    <jpa:repositories base-package="com.bozai.dao" transaction-manager-ref="transactionManager"
                      entity-manager-factory-ref="entityManagerFactory" />


    <!--开启事务管理器-->
    <!--id一定不要随意改动，因为默认回去找 id为transactionManager-->
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory"/>
    </bean>
    <!--如果一定要改,就在支持全注解的标签当中更改-->
    <!--支持全注解-->

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

    <!--扫描domain层-->
    <context:component-scan base-package="com.bozai"/>

</beans>

3)创建实体类,配置映射关系

2.写好dao层接口

package com.bozai.dao;

import com.bozai.domain.Customer;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;

//JpaRepository封装了基本crud操作
//JpaSpecificationExecutor封装了复杂查询

public interface CustomerDao extends JpaRepository<Customer,Long>, JpaSpecificationExecutor<Customer> {


}

SpringData的执行原理

springAop动态代理对象

 

SpringData只需要定义接口即可,简单的CRUD已经被封装,可以直接拿来调用,而复杂的语句需要我们在接口处直接定义,有三种定义方式:

1.SpringData通过操作实体类定义,2.通过定义Sql语句定义3.通过接口名定义

package com.bozai.dao;

import com.bozai.domain.Customer;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

//JpaRepository封装了基本crud操作
//JpaSpecificationExecutor封装了复杂查询

public interface CustomerDao extends JpaRepository<Customer,Long>, JpaSpecificationExecutor<Customer> {

    /*JPQL语句
    * */
    @Query(value = "from  Customer where  custName=?")
    public  Customer Jpql(String custName);


    @Query(value = "from  Customer  where custName=?  and custId=?")
    public Customer findByNameId(String name,Long Id);


    @Modifying
    @Query(value = "update  Customer  set  custName=?2  where custId=?1")
    @Transactional
    public void updateByIdName(Long Id,String name);


    @Query(value = "select  * from  customer ",nativeQuery = true)
    public List<Object []> selectAll();

    @Query(value = "select  * from  customer   where cust_address like ?",nativeQuery = true)
    public List<Object []> selectMoHu(String condition);


    /*根据接口的命名方法来实现一个查询语句
    * */
    public Customer findByCustId(Long Id);

    public List<Customer>  findByCustNameLike(String name);

    public Customer findByCustNameLikeAndCustIndustry(String CustName,String CustIndustry);
}


package com.bozai;

import com.bozai.dao.CustomerDao;
import com.bozai.domain.Customer;
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.Arrays;
import java.util.List;

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

    @Autowired
    private CustomerDao customerDao;


   @Test
    public  void  testJpql(){
       Customer customer = customerDao.Jpql("abc");
       System.out.println(customer);

   }


    @Test
    public  void  testNameId(){
        Customer customer = customerDao.findByNameId("bozai",2L);
        System.out.println(customer);

    }


    @Test
    public  void  testUpdate(){
       customerDao.updateByIdName(2L,"lala");

    }

    @Test
    public  void  testSelectAll(){
        List<Object[]> objects = customerDao.selectAll();
        for (Object[] o:objects
             ) {
            System.out.println(Arrays.toString(o));

        }
    }


    @Test
    public  void  testMoHu(){
        List<Object[]> objects = customerDao.selectMoHu("利川市%");
        for (Object[] o:objects
        ) {
            System.out.println(Arrays.toString(o));

        }
    }

    @Test
    public  void  testMingming(){
        Customer byCustId = customerDao.findByCustId(1L);
        System.out.println(byCustId);
    }


    @Test
    public  void  testFindByName(){
        List<Customer> byCustNameLike = customerDao.findByCustNameLike("行%");
        for (Customer o:byCustNameLike
             ) {
            System.out.println(o);

        }
    }

    @Test
    public  void  testFindByDouble(){
        Customer customer = customerDao.findByCustNameLikeAndCustIndustry("利%", "bcd");
        System.out.println(customer);

    }
}

三.表和表的关系

首先在配置文件中加上一个部分

 

1.一对一

2.一对多

在主从两个类上都要加上@OneTomany  @manyToOne  然后cascade是级联,这样就能在删除一个主表数据的同时删除对应的从表数据

注意在一的一方需要放弃维护权,级联操作(cascade)

在多的一方需要声明维护的字段,以及对应的字段名

 

 3.多对多

在其中一方加入注解和配置信息

 

 

另外一方放弃维护权

 

 加载方式:可以设置为延迟加载,这样能提高效率.

通过一个Customer对象去找到对应的多个LinkMan对象,只要建立好一对多的映射关系即可这样查询.

 

bozai603
关注
JPA框架深入了解
snailisBigbull的博客
07-25 2870
1.JPA主键生成策略(掌握) 主键：唯一地标识表中的某一条记录 主键特点：非空且唯一 主键分类： 自然主键 ：具有实际意义的列来作为主键 ​ 代理主键 ：没有实际意义的列来作为主键 --单体项目 什么主键的生成策略： ​ jpa采取的方案方式去生成主键 jpa： （1）auto策略 – 默认使用这种：根据数据库方言来选择的到底使用哪种策略 ​ 比如 配置mysql的方言...
【原创】纯干货，Spring-data-jpa详解，全方位介绍。
weixin_33955681的博客
02-01 7964
本篇进行Spring-data-jpa的介绍，几乎涵盖该框架的所有方面，在日常的开发当中，基本上能满足所有需求。这里不讲解JPA和Spring-data-jpa单独使用，所有的内容都是在和Spring整合的环境中实现。如果需要了解该框架的入门，百度一下，很多入门的介绍。在这篇文章的接下来一篇，会有一个系列来讲解mybatis，这个系列从mybatis的入门开始，到基本使用，和spring整合，和第...
SpringBoot（JPA）
cuishujian_2003的博客
09-02 359
JPA是Sun官方提出的Java持久化规范。它在为Java开发人员提供了一种对象/关系映射工具来管理Java应用中的关系数据。
JPA架构
流年、你奈我何
04-20 3508
JPA(Java持久性API)是存储业务实体关联的实体的来源。它显示了如何定义一个面向普通Java对象(POJO)作为一个实体，以及如何与管理关系实体。 类级别架构 下图显示了JPA的类的层次结构。它显示核心类和JPA接口。 下表描述了每个在上述架构的显示单元。 单元 描述 EntityManagerFactory 这是一个EntityMana
jpa框架的搭建
gaoge19861207的专栏
09-27 1134
1：导入jpa的jar包不同jpa实现导入的jar包是不同的，如果是用hibernate来实现的，那么就要导入hibernate实现的jia包。这里因为是用Hibernate来实现的，所以就需要两个，一个是Hibernate的核心包(hibernate-3.2文件里相应的jar包，就是hibernate的核心包hibernate3.jar和lib文件夹下所有的第三方实现.jar文件）；还有
最基础的spring-boot-jpa框架
03-23
在"最基础的spring-boot-jpa框架"中，我们可以深入探讨以下几个关键知识点： 1. **Spring Boot 简介**：Spring Boot 通过“约定优于配置”的原则，简化了Spring应用的配置。它默认配置了很多常见的应用设置，比如...
spring Data JPA框架实例
07-20
总结来说，这个"spring Data JPA框架实例"涵盖了Spring Data JPA的基本用法，包括数据库操作、登录验证和分页查询。通过学习和实践这个实例，开发者能够快速理解和掌握Spring Data JPA的精髓，从而在实际项目中高效...
基于Java的velox-jpa轻量级JPA框架设计源码
05-22
velox-jpa轻量级JPA框架设计源码：该项目基于Java开发，包含151个文件，主要使用Java语言。velox-jpa是一个轻量级的JPA框架，具有强大的扩展性和灵活性，支持对象关系映射（ORM），适用于Java应用的数据库操作和数据...
基于Java的JPA框架设计与实践教程源码
最新发布
09-29
该项目是针对Java语言的JPA框架设计与实践教程源码，总计包含225个文件，其中167个为XML配置文件，35个为Java源文件，还包括9个xlsx文件、5个iml文件、2个md文件、2个xls文件、2个class文件、1个idea工作空间文件、1...
java中JPA框架的集成
04-07
JPA框架的集成使用 package com.itcast.bean.product; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id; @...
jpa框架
西瓜
03-30 5276
https://www.jianshu.com/p/2b68af9aa0f5/
Spring Data JPA框架
niceyoo的博客
12-01 133
1、前言 扔一个 spring data jpa 的代码，可运行，后续补充博客内容。 环境：eclipse + tomcat8 2、部分截图 3、源码 https://gitee.com/niceyoo/jpa-demo 4、sql 既然都是 spring data jpa ，还要啥数据库呀，自己创建一个数据库，更改 jeenotes.properti...
JPA框架比较
Android-Java
01-21 185
作者 James Kao译者 宋玮 发布于 2008年1月16日 上午1时39分 社区 Java 主题 数据访问 java.net刊登了一篇由Sharad Acharya所写的名为Java Persistence Framework: Which, When, and What?的文章，文中比较了四种流行的持久化框架：CMP Entity EJBs、JPA、Hibernate和T...
java jpa框架,Spring Data JPA 框架
weixin_36064575的博客
03-19 533
Spring Data JPA 框架简介Spring Data Jpa 是应⽤于Dao层的⼀个框架，简化数据库开发的，作⽤和Mybatis框架⼀样，但是在使⽤⽅式和底层机制是有所不同的。最明显的⼀个特点，Spring Data Jpa 开发Dao的时候，很多场景我们连sql语句都不需要开发。由Spring出品。Spring Data JPA 是 Spring 基于JPA 规范的基础上封装的⼀套 J...
JPA框架的学习：
LOVE_Me__的博客
07-21 439
Repository接口讲解： Repository接口是Spring Data的核心接口，不提供任何方法 public interface Repository<T,ID extends Serializable> { } @RepositoryDefinition的使用 Repository类的定义： public interface Repository<T,ID extends Serializable> { } Repository是一个空接口，标记接.
1.3.4 常见的实现JPA的框架
05-09 885
目前已经有多个ORM开源框架支持JPA，如Hibernate，TopLink，OpenJPA等等。有关这些框架的内容，读者请参阅本书的第14章。 
JPA框架：快速入门
大连赵哥的博客
01-05 536
JPA框架：快速入门
java JPA框架
09-19
JPA 是 Java 持久层 API，旨在规范和简化 Java 对象的持久化工作，并整合了 ORM 技术。JPA 的实现包括 Hibernate 框架，Spring Data JPA 是在 JPA 规范基础上封装的一套 JPA 应用框架，它能够方便地在不同的 ORM 框架之间进行切换而不需要更改代码。Spring Data JPA 的目标是通过统一 ORM 框架的访问持久层的操作，提高开发人员的效率。JPA 框架的集成使用可以通过使用 @Entity、@GeneratedValue、@Id 等注解来实现。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值