JPA初识(ORM思想、JPA的基本操作)

最新推荐文章于 2024-08-31 19:46:21 发布
最新推荐文章于 2024-08-31 19:46:21 发布
阅读量567 收藏 1
点赞数
分类专栏： SpringDataJpa 文章标签： hibernate 数据库 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43430343/article/details/125677838
版权
本文详细介绍了ORM框架JPA和Hibernate的关系及其使用，包括JPA作为规范，Hibernate作为其实现的原理。通过实例展示了JPA的注解配置，如@Entity、@Table等，以及JPA操作数据库的步骤，如事务管理、主键生成策略。还涵盖了JPA的查询语言JPQL，以及分页、条件查询等操作。同时，提供了JPA工具类的实现，简化了数据库操作流程。
摘要由CSDN通过智能技术生成

1、ORM思想的引入

简单的说：ORM就是建立实体类和数据库表之间的关系，从而达到操作实体类就相当于操作数据库表的目的。

常见的orm框架：Mybatis（ibatis）、Hibernate、Jpa

1.1、传统的CRUD

image-20220705152936520

JPA不干活，真正干活的是依托于这个规范的实现，例如hibernate，toplink。

JPA使用规范语言提供的接口和抽象类来进行编程

image-20220705154533840

不同的表存储在不同的数据库当中就需要用到JPA的分布式事务管理。我们将所有的表存在一个数据库中称为本地事务管理。

JPA是接口，是一种规范，只有接口和规范是不能干活的。需要定义JPA的实现方式

hibernate与JPA的概述

hibernate概述

Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。

JPA概述

JPA的全称是Java Persistence API， 即Java 持久化API，是SUN公司推出的一套基于ORM的规范，内部是由一系列的接口和抽象类构成。

JPA的查询语言是面向对象而非面向数据库的，它以面向对象的自然语法构造查询语句，可以看成是Hibernate HQL的等价物。JPA定义了独特的JPQL（Java Persistence Query Language），JPQL是EJB QL的一种扩展，它是针对实体的一种查询语言，操作对象是实体，而不是关系数据库的表，而且能够支持批量更新和修改、JOIN、GROUP BY、HAVING 等通常只有 SQL 才能够提供的高级查询特性，甚至还能够支持子查询。

JPA与hibernate的关系

JPA规范本质上就是一种ORM规范，注意不是ORM框架——因为JPA并未提供ORM实现，它只是制订了一些规范，提供了一些编程的API接口，但具体实现则由服务厂商来提供实现。

img

JPA是规范，Hibernate除了作为ORM框架之外，它也是一种JPA实现. 如果使用JPA规范进行数据库操作，底层需要hibernate作为其实现类完成数据持久化工作。

入门案例

使用JPA注解的形式配置映射关系

package cn.itcast.domain;

import lombok.Data;

import javax.persistence.*;

/**
 * 客户的实体类
 * 配置映射关系：
 *  1.实体类和表的映射关系
 *      @Entity:声明实体类
 *      @Table：配置实体类和表的映射关系
 *
 *  2.实体类中属性和表中字段的映射关系
 */

@Data //提供类的get，set，equals，toString，hashCode方法
@Entity
@Table(name = "cst_customer")
public class Customer {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)//配置主键的声称策略，声明主键自增
    @Column(name = "cust_id")//数据库表中列名
    private Long custId;

    @Column(name = "cust_name")
    private String custName;

    @Column(name = "cust_source")
    private String custSource;

    @Column(name = "cust_industry")
    private String custIndustry;

    @Column(name = "cust_level")
    private String custLevel;

    @Column(name = "cust_address")
    private String custAddress;

    @Column(name = "cust_phone")
    private String custPhone;
}

常用注解的说明

@Entity
	作用：指定当前类是实体类
@Table
  作用：指定实体类和表之间的对应关系。
   属性：
       name：指定数据库表的名称
 @Id
    作用：指定当前字段是主键。
 @GeneratedValue
     作用：指定主键的生成方式。。
     属性：
         strategy ：指定主键生成策略。
 @Column
      作用：指定实体类属性和数据库表之间的对应关系
       属性：
        		name：指定数据库表的列名称。
        		unique：是否唯一  
        		nullable：是否可以为空  
        		inserttable：是否可以插入  
        		updateable：是否可以更新  
        		columnDefinition: 定义建表时创建此列的DDL  
        		secondaryTable: 从表名。如果此列不建在主表上（默认建在主表），该属性定义该列所在从表的名字搭建开发环境[重点]

配置JPA的核心配置文件

在java工程的src路径下创建一个名为META-INF的文件夹，在此文件夹下创建一个名为persistence.xml的配置文件

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/persistence  
    http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd"
	version="2.0">
	<!--配置持久化单元 
		name：持久化单元名称 
		transaction-type：事务类型
		 	RESOURCE_LOCAL：本地事务管理 
		 	JTA：分布式事务管理 -->
	<persistence-unit name="myJpa" transaction-type="RESOURCE_LOCAL">
		<!--配置JPA规范的服务提供商 -->
		<provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
		<properties>
			<!-- 数据库驱动 -->
			<property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver" />
			<!-- 数据库地址 -->
			<property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/ssh" />
			<!-- 数据库用户名 -->
			<property name="javax.persistence.jdbc.user" value="root" />
			<!-- 数据库密码 -->
			<property name="javax.persistence.jdbc.password" value="111111" />

			<!--jpa提供者的可选配置：我们的JPA规范的提供者为hibernate，所以jpa的核心配置中兼容hibernate的配 -->
			<property name="hibernate.show_sql" value="true" />
			<property name="hibernate.format_sql" value="true" />
			<property name="hibernate.hbm2ddl.auto" value="create" />
		</properties>
	</persistence-unit>
</persistence>

测试

/***
   * 测试jpa的保存
   * 案例：保存一个用户到数据库
   * Jpa的操作步骤：
   *  1，加载配置文件创建工厂（实体管理器工厂）对象
   *  2，通过实体管理器工厂获取实体管理器
   *  3，获取事务对象，开启事务
   *  4，完成增删改查操作
   *  5，提交事务（回滚事务）
   *  6，释放资源
   */
  @Test
  public void testSave() {
    // 1.加载配置文件创建工厂（实体管理器工厂）对象
    EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
    // 2.通过实体管理器工厂获取实体管理器
    EntityManager em = factory.createEntityManager();
    // 3.获取事务对象，开启事务
    EntityTransaction tx = em.getTransaction(); // 获取事务对象
    tx.begin(); // 开启事务
    // 4.完成增删改查操作：保存一个客户到数据库中
    Customer customer = new Customer();
    customer.setCustName("阿斯顿");
    customer.setCustIndustry("工厂");
    // 保存，
    em.persist(customer); // 保存操作
    // 5.提交事务
    tx.commit();
    // 6.释放资源
    em.close();
    factory.close();
  }


@Test
  public void testUpdate(){
    // 1.通过工具类获取entityManager
    EntityManager entityManager = JpaUtils.getEntityManager();
    // 2，开启事务
    EntityTransaction tx = entityManager.getTransaction();
    tx.begin();
    // 3，增删改查
    Customer customer = entityManager.find(Customer.class, 1l);
    //更新客户
    customer.setCustName("黄金矿工");
    entityManager.merge(customer);
    // 4，提交事务
    tx.commit();
    // 5，释放资源
    entityManager.close();
  }

JPA主键生成策略

JPA提供的四种标准用法为TABLE,SEQUENCE,IDENTITY,AUTO。

  • IDENTITY:主键由数据库自动生成（主要是自动增长型）
  • SEQUENCE：根据底层数据库的序列来生成主键，条件是数据库支持序列。
  • AUTO：主键由程序控制
  • TABLE：使用一个特定的数据库表格来保存主键

JPA操作的步骤（API对象讲解）

Persistence对象

Persistence对象主要作用是用于获取EntityManagerFactory对象的 。通过调用该类的createEntityManagerFactory静态方法，根据配置文件中持久化单元名称创建EntityManagerFactory。

//1. 创建 EntitymanagerFactory
@Test
String unitName = "myJpa";
EntityManagerFactory factory= Persistence.createEntityManagerFactory(unitName);

EntityManagerFactory

EntityManagerFactory 接口主要用来创建 EntityManager 实例

//创建实体管理类
EntityManager em = factory.createEntityManager();

由于EntityManagerFactory 是一个线程安全的对象（即多个线程访问同一个EntityManagerFactory 对象不会有线程安全问题），并且EntityManagerFactory 的创建极其浪费资源，所以在使用JPA编程时，我们可以对EntityManagerFactory 的创建进行优化，只需要做到一个工程只存在一个EntityManagerFactory 即可

EntityManager

在 JPA 规范中, EntityManager是完成持久化操作的核心对象。实体类作为普通 java对象，只有在调用 EntityManager将其持久化后才会变成持久化对象。EntityManager对象在一组实体类与底层数据源之间进行 O/R 映射的管理。它可以用来管理和更新 Entity Bean, 根椐主键查找 Entity Bean, 还可以通过JPQL语句查询实体。

我们可以通过调用EntityManager的方法完成获取事务，以及持久化数据库的操作

方法说明：

getTransaction : 获取事务对象
	persist ： 保存操作
	merge ： 更新操作
	remove ： 删除操作
	find/getReference ： 根据id查询

EntityTransaction

在 JPA 规范中, EntityTransaction是完成事务操作的核心对象，对于EntityTransaction在我们的java代码中承接的功能比较简单

  • begin：开启事务
  • commit：提交事务
  • rollback：回滚事务

抽取JPA工具类

package cn.itcast.utils;

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

public class JpaUtils {
    /**
     * 解决实体管理器工厂的浪费资源和耗时问题
     *  通过代码块的形式，当程序第一次访问此工具时，创建一个公共的实体管理器工厂对象
     *
     *  第一次访问getEntityManager方法，经过静态代码块创建一个factory对象，再调用方法创建一个EntityManager对象
     *  第二次访问getEntityManager方法，直接通过一个已经创建好的factory对象，创建一个EntityManager对象
     */
    private static EntityManagerFactory factory;

    static {
        //1.加载配置文件，创建EntityManagerFactory
         factory = Persistence.createEntityManagerFactory("myJpa");

    }

    /**
     *
     * @return 获取EntityManager对象
     */
    public static EntityManager getEntityManager(){
        return factory.createEntityManager();
    }
}

改造之前的测试代码

工厂是公共的，使用完之后不能关闭，关闭之后别人就不能使用。

@Test
  public void testFind() {
    // 1.通过工具类获取entityManager
    EntityManager entityManager = JpaUtils.getEntityManager();
    // 2，开启事务
    EntityTransaction tx = entityManager.getTransaction();
    tx.begin();
    // 3，增删改查---根据id查询客户
    Customer customer = entityManager.find(Customer.class, 1l);
    System.out.println(customer);
    // 4，提交事务
    tx.commit();
    // 5，释放资源
    entityManager.close();
  }

find方法：根据id查找客户

使用find方法查询：

​ 1、查询的对象就是当前客户对象

​ 2、在调用find方法的时候，就会发送sql语句查询数据库

立即加载

@Test
  public void testFind() {
    // 1.通过工具类获取entityManager
    EntityManager entityManager = JpaUtils.getEntityManager();
    // 2，开启事务
    EntityTransaction tx = entityManager.getTransaction();
    tx.begin();
    // 3，增删改查---根据id查询客户
    Customer customer = entityManager.find(Customer.class, 1l);
    System.out.println(customer);
    // 4，提交事务
    tx.commit();
    // 5，释放资源
    entityManager.close();
  }
image-20220706133438833

getReference方法：根据id查找客户

和上面的find方法使用和作用都一样。

1、获取的对象是一个动态代理对象

2、调用getReference方法不会立即发送sql语句查询数据库

* 当调用查询结果对象的时候，才会发送查询的sql语句，什么时候用，是什么时候发送sql语句查询数据库

延迟加载（懒加载）

  • 得到的是一个动态代理对象
  • 什么时候用，什么时候才会查询

 @Test
  public void testReference() {
    // 1.通过工具类获取entityManager
    EntityManager entityManager = JpaUtils.getEntityManager();
    // 2，开启事务
    EntityTransaction tx = entityManager.getTransaction();
    tx.begin();
    // 3，增删改查---根据id查询客户
    Customer customer = entityManager.getReference(Customer.class, 1l);
    System.out.println(customer);
    // 4，提交事务
    tx.commit();
    // 5，释放资源
    entityManager.close();
  }
image-20220706133737229

我们一般使用延迟加载的方式，因为我们可能写了一段代码加载数据库，但可能最后没有用，省得浪费资源

remove方法：删除

先查询出来客户，再进行删除

@Test
  public void testRemove(){
    // 1.通过工具类获取entityManager
    EntityManager entityManager = JpaUtils.getEntityManager();
    // 2，开启事务
    EntityTransaction tx = entityManager.getTransaction();
    tx.begin();
    // 3，增删改查
    Customer customer = entityManager.find(Customer.class, 2l);
    entityManager.remove(customer);
    // 4，提交事务
    tx.commit();
    // 5，释放资源
    entityManager.close();
  }

merge方法：更新

先查出来客户，再将其作为形参传入merge方法中

@Test
  public void testUpdate(){
    // 1.通过工具类获取entityManager
    EntityManager entityManager = JpaUtils.getEntityManager();
    // 2，开启事务
    EntityTransaction tx = entityManager.getTransaction();
    tx.begin();
    // 3，增删改查
    Customer customer = entityManager.find(Customer.class, 1l);
    //更新客户
    customer.setCustName("黄金矿工");
    entityManager.merge(customer);
    // 4，提交事务
    tx.commit();
    // 5，释放资源
    entityManager.close();
  }

总结

persist ： 保存
merge ： 更新
remove ： 删除
find/getRefrence ： 根据id查询

jpql介绍

JPQL全称Java Persistence Query Language

==sql：查询的是表和表中的字段
jpql：查询的是实体类和类中的属性

  • jpql和sql语句的语法相似

    1.查询全部
2.分页查询
3.统计查询
4.条件查询
5.排序

查询所有

/**
 * 查询全部
 * jpql：from Customer
 * sql:select * from cst_customer
 */

@Test
  public void testFindAll(){
    //1.获取entityManager对象
    EntityManager entityManager = JpaUtils.getEntityManager();
    //2，开启事务
    EntityTransaction tx = entityManager.getTransaction();
    tx.begin();
    //3，查询全部
    String jpql="from Customer";
    Query query = entityManager.createQuery(jpql);//创建Query查询对象，query对象才是执行jpql的对象

    List list = query.getResultList();
    for (Object o : list) {
      System.out.println(o);
    }

    //4，提交事务
    tx.commit();
    //5，释放资源
    entityManager.close();
  }

倒序

/**
 * 倒序查询
 * jpql：from Customer order by custId desc
 * sql:select * from cst_customer order by cust_id desc
 */

@Test
  public void testOrders(){
    //1.获取entityManager对象
    EntityManager entityManager = JpaUtils.getEntityManager();
    //2，开启事务
    EntityTransaction tx = entityManager.getTransaction();
    tx.begin();
    //3，查询全部
    String jpql="from Customer order by custId desc";
    Query query = entityManager.createQuery(jpql);//创建Query查询对象，query对象才是执行jpql的对象

    List list = query.getResultList();
    for (Object o : list) {
      System.out.println(o);
    }

    //4，提交事务
    tx.commit();
    //5，释放资源
    entityManager.close();
  }

总结：进行jpql查询

1、创建query查询对象

2、对参数进行赋值

3、查询，并得到返回结果

jpql不可以写select * ，但是可以写select count(id)，字段名称要写对象的属性值

/**
 * sql:select count(id) from cst_customer
 * jpql:select count(id) from Customer
 */


@Test
  public void testCount(){
    //1.获取entityManager对象
    EntityManager entityManager = JpaUtils.getEntityManager();
    //2，开启事务
    EntityTransaction tx = entityManager.getTransaction();
    tx.begin();
    //3，查询全部
    String jpql="select count(custId) from Customer";
    Query query = entityManager.createQuery(jpql);//创建Query查询对象，query对象才是执行jpql的对象

    Object result = query.getSingleResult();
    System.out.println(result);

    //4，提交事务
    tx.commit();
    //5，释放资源
    entityManager.close();
  }

getResultList:直接将查询结果封装为list集合
  
getSingleResult:得到唯一的结果集

分页查询

/**
* sql:select * from cst_customer limit 0,2
* jpql:from Customer
*/

@Test
  public void testPage(){
    //1.获取entityManager对象
    EntityManager entityManager = JpaUtils.getEntityManager();
    //2，开启事务
    EntityTransaction tx = entityManager.getTransaction();
    tx.begin();
    //3，查询全部
    String jpql="from Customer";
    Query query = entityManager.createQuery(jpql);//创建Query查询对象，query对象才是执行jpql的对象
    //对参数赋值--分页参数
    //起始索引
    query.setFirstResult(0);
    //每页查询的条数
    query.setMaxResults(2);

    //发送查询，并封装结果
    List list = query.getResultList();
    for (Object o : list) {
      System.out.println(o);
    }

    //4，提交事务
    tx.commit();
    //5，释放资源
    entityManager.close();
  }

条件查询

案例：查询客户名称以黄开头的

/** 条件查询
 * sql:select * from cst_customer where cust_name LIKE ?
 * jpql:from Customer where custName like ?
 */

@Test
  public void testCondition(){
    //1.获取entityManager对象
    EntityManager entityManager = JpaUtils.getEntityManager();
    //2，开启事务
    EntityTransaction tx = entityManager.getTransaction();
    tx.begin();
    //3，查询全部
    String jpql="from Customer where custName like ?";
    Query query = entityManager.createQuery(jpql);//创建Query查询对象，query对象才是执行jpql的对象
    //对参数进行赋值--占位符参数
    //第一个参数，占位符的索引位置（从1开始），第二个参数，取值
    query.setParameter(1,"黄%");


    //发送查询，并封装结果
    List list = query.getResultList();
    for (Object o : list) {
      System.out.println(o);
    }

    //4，提交事务
    tx.commit();
    //5，释放资源
    entityManager.close();
  }
JPA ORM组件
流年、你奈我何
04-20 831
最现代的应用程序使用关系型数据库来存储数据。最近，许多厂商改用对象数据库，以减少其对数据的维护负担。这意味着对象数据库或对象关系技术正在存储，检索，更新和维护数据的照顾。这个对象关系型技术的核心部分是映射orm.xml中的文件。随着XML不需要编译，可以很容易地进行修改多个数据源较少的管理。 对象关系映射 对象关系映射(ORM)简要地告诉什么是ORM以及它是如何工作。 ORM是从对象类型的数据
【SpringBoot学习笔记】初识SpringBootJPA
AC_sunK的博客
09-19 495
初次见面SpringBootJPA 文章目录初次见面SpringBootJPA一、关于SpringBootJPA二、SpringBootDataJPA的使用 一、关于SpringBootJPA ​ JPA是Java Persistence API的简称，中文名Java持久层API，是JDK 5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。 ​ Sun引入新的JPA ORM规范出于两个原因：其一，简化现有Java EE和Java SE应用开发工作；其二，Sun希望整合ORM
ORM框架之JPA
zhaojunwei666的博客
07-25 514
1 JPA常用注解： @Entity:修饰实体类，指明该类映射到指定的数据表 @Table:实体类与映射表不同名时指定数据库的表名 @Id:该属性标识主键，一般标注在getter()方法是 @GeneratedValue:标注主键的生成策略，通过strategy策略，mysql默认是auto; 一般有： Identity: id自增长策略，oracle不支持 auto:JPA自动选择合适策略 SE...
手把手教会你 SpringBoot 怎么通过JPA进行数据访问
最新发布
whs_8792的博客
08-31 1748
手把手教会你 SpringBoot 怎么通过JPA进行数据访问 ,通过JPA 基本可以解决80%的sql 可以不用手动编写SQL通过 Hibernate 他会自动生成SQL ！！！可以直接调用方法！
JPA的基本操作
Student111w的博客
02-21 282
增删改查操作
JPA基本操作(一)
码无止境的博客
10-11 492
一、JPA简介： JPA是Java Persistence API的简称，中文名Java持久层API，是JDK 5.0注解或 XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。 Sun引入新的JPA ORM规范出于两个原因：其一，简化现有Java EE和Java SE应用开发工作；其二，Sun希望整合ORM技术，实现天下归一。 作用：使得应用程序以统一的方式访问持久层 ...
ORM框架之Spring Data JPA（一）Hibernate实现JPA规范
小蜜蜂1010的博客
10-05 1713
一、ORM简述 ORM（Object-Relational Mapping） 表示对象关系映射。在面向对象的软件开发中，通过ORM，就可以把对象映射到关系型数据库中。只要有一套程序能够做到建立对象与数据库的关联，操作对象就可以直接操作数据库数据，就可以说这套程序实现了ORM对象关系映射。简单的说：ORM就是建立实体类和数据库表之间的关系，从而达到操作实体类就相当于操作数据库表的目的...
初识ORM框架：基本概念与实现原理
在软件开发中，ORM（Object-Relational Mapping）框架是一种程序库，它的作用是在关系型数据库和面向对象的应用程序之间做一个映射，这样，我们就可以通过操作对象的方式来操作数据库，而不需要直接编写SQL语句。...
CH01-初识JPA、注解、API.pptx
12-28
JPA（Java Persistence API，Java持久化API），定义了对象-关系映射（ORM）以及实体对象持久化的标准接口 JPA概述： Java EE 5.0 平台标准的 ORM 规范，使得应用程序以统一的方式访问持久层
一.初识JPA2.0
03-23
初识JPA 2.0** Java Persistence API (JPA) 是Java平台上的一个标准，用于处理对象关系映射（ORM），它允许Java开发者将对象模型与关系数据库进行交互。JPA 2.0是这个标准的一个重要版本，引入了许多新特性和改进...
第1章 初识Spring的基本应用.ppt
11-11
ORM模块支持对象/关系映射，与JPA、JDO、Hibernate等集成；事务管理模块提供了编程和声明式事务管理的支持；Web模块则包含WebSocket、Servlet、Web MVC等，支持Web应用的开发。 **Spring的优点**在于其非侵入式设计...
02、JPA开发环境和思想介绍
03-19
NULL 博文链接：https://mzhj.iteye.com/blog/708879
JPA和ORM介绍
fightingXia的博客
06-18 4859
##ORM介绍ORM的全称是：Object Relation Mapping，意思是：对象关系映射，用于在关系型数据库和业务实体对象之间作一个映射。从效果上说，它其实是创建了一个可在编程语言里使用的“虚拟对象数据库”。说白了就是把关系型数据库封装成业务实体对象，这样，我们在具体的操作业务对象的时候，就不需要再去和复杂的SQL语句打交道，只需简单的操作对象的属性和方法。ORM的出现是由于面向对象的大...
JPA与ORM以及Hibernate
dianqueshi9054的博客
03-10 299
有没有办法让程序员彻底抛弃书写SQL思想，完全的使用面向对象思想开发软件呢？ 需要一种可行的ORM框架。 什么是ORM？ 不同的数据库使用的SQL语法不同，比如PL/SQL(Oracle)和T/SQL(SQL SERVER)； 同样的功能不同的数据库有不同的实现方式； 程序过分依赖SQL对程序的移植性及扩展维护等带来很大的麻烦。 ORM框架包括Entity EJB、Hi...
SpringData JPA - ORM 框架下，打造高效数据访问层
CYK_byte的博客
05-03 1424
全英文名叫 Java Persistence API，就是 java 持久化 api ，是SUN公司推出的一套基于 ORM 的规范。ORM（Object Relational Mapping）表示对象关系映射. 简单来讲，通过 ORM，就可以把对象映射到关系型数据库中（为了不用 JDBC 那套方法来操作数据库）.
JPA的基本使用
qq_42058998的博客
05-29 3549
JPA使用教程
ORM框架与JPA规范
weixin_45853783的博客
02-18 346
一、ORM框架 1.ORM简单介绍 对象关系映射，（Object Relational Mapping，简称ORM）,是通过使用描述对象和数据库之间的映射的元数据，将面向对象语言程序中的对象自动持久化到关系数据库中，本质上讲就是将数据从一种形式转换为另一种形式，也就是在开发当中操作实体类对象就是操作数据库表。实际应用中即在关系型数据库和业务对象之间做一个映射，就不需要和SQL语句打交道，只要像平时操作对象一样就可以了，常见的ORM框架有Hibernate、TopLink、Castor JDO、Apache
JPA 和 ORM 概念
gcf_oo的专栏
01-04 7493
ORM规范: JPA
长不大的大灰狼
02-10 1252
ORM规范: JPA一、基本使用1、创建数据表2、编写实体类3、主键生成策略二、Spring Data JPA1.创建一个Dao层接口，并实现JpaRepository和JpaSpecificationExecutor2、完成基本CRUD操作3、使用JPQL的方式查询4、使用SQL语句查询5、方法命名规则查询三、Specifications动态查询1、使用Specifications完成条件查询2、基于Specifications完成分页查询四、多表设计1、一对多2、多对多 JPA(Java Persist
SpringDataJPA入门：ORM实践与基本操作指南
4. JPA基本操作 - **配置与初始化**：首先，通过读取配置文件（如persistence.xml）创建实体管理器工厂（EntityManagerFactory），这是连接数据库的关键组件。 - **获取实体管理器**：使用工厂创建实体管理器...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值