JPA基本使用

最新推荐文章于 2023-12-22 13:17:39 发布
最新推荐文章于 2023-12-22 13:17:39 发布
阅读量685 收藏
点赞数 3
分类专栏： Spring Data 文章标签： java spring data
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lzy410992/article/details/110250337
版权

ORM概述

ORM（Object-Relational Mapping） 表示对象关系映射。在面向对象的软件开发中，通过ORM，可以把对象映射到关系型数据库中，从而解决程序语言域关系型数据库不匹配的问题。简单的说：ORM通过使用描述对象和数据库之间的映射的元数据将应用程序中的对象自动存储到关系数据库中，从而达到操作实体类就相当于操作数据库表的目的。
在这里插入图片描述

ORM框架的作用：
ORM框架可以帮助开发人员完成程序对象到关系数据库数据的映射，从而实现了在项目中即保持以面对对象的思想开发应用程序和持久化数据库，又能利用关系型数据的技术优势，同时使用ORM也会大大减少重复性代码，节省我们的工作时间。

在这里插入图片描述

常见ORM框架：Mybatis、Hibernate、TopLink、Ojb

JPA的概述

JPA的全称是Java Persistence API， 即Java 持久化API，是SUN公司推出的一套基于ORM的规范，内部是由一系列的接口和抽象类构成。JPA通过JDK 5.0注解描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。

在这里插入图片描述

JPA的优势：

  • 标准化： JPA 是 JCP 组织发布的 Java EE 标准之一，任何声称符合 JPA 标准的框架都遵循同样的架构，提供相同的访问API，这保证了基于JPA开发的企业应用能够经过少量的修改就能够在不同的JPA框架下运行。

  • 容器级特性的支持： JPA框架中支持大数据集、事务、并发等容器级事务，这使得 JPA 超越了简单持久化框架的局限，在企业应用发挥更大的作用。

  • 简单方便： 在JPA框架下创建实体和创建Java 类一样简单，没有任何的约束和限制，只需要使用 Entity注解进行注释即可。同时JPA基于非侵入式原则设计，可以很容易的和其它框架或者容器集成

  • 查询能力： JPA的查询语言是面向对象而非面向数据库的，它以面向对象的自然语法构造查询语句。

  • 高级特性： JPA 中能够支持面向对象的高级特性，如类之间的继承、多态和类之间的复杂关系，这样的支持能够让开发者最大限度的使用面向对象的模型设计企业应用，而不需要自行处理这些特性在关系数据库的持久化。

JPA与hibernate的关系:

JPA规范本质上就是一种ORM规范，而不是ORM框架，在其中只是提供了一些编程的API接口，而没有ORM的具体实现。JPA和Hibernate的关系就像JDBC和JDBC驱动的关系，JPA是规范，Hibernate除了作为ORM框架之外，它也是一种JPA实现。当使用JPA规范进行数据库操作，底层任需要hibernate来实现。

JPA环境搭建

项目目录：
在这里插入图片描述

1. 新建maven工程，在pom.xml中导入坐标：

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.hibernate.version>5.0.7.Final</project.hibernate.version>
</properties>
<dependencies>
    <!-- junit -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>

    <!-- hibernate对jpa的支持包 -->
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-entitymanager</artifactId>
        <version>${project.hibernate.version}</version>
    </dependency>

    <!-- c3p0 -->
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-c3p0</artifactId>
        <version>${project.hibernate.version}</version>
    </dependency>

    <!-- log日志 -->
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.17</version>
    </dependency>

    <!-- Mysql and MariaDB -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.11</version>
    </dependency>
</dependencies>

创建客户的数据库表：

 /*创建客户表*/
CREATE TABLE cst_customer (
      cust_id bigint(32) NOT NULL AUTO_INCREMENT COMMENT '客户编号(主键)',
      cust_name varchar(32) NOT NULL COMMENT '客户名称(公司名称)',
      cust_source varchar(32) DEFAULT NULL COMMENT '客户信息来源',
      cust_industry varchar(32) DEFAULT NULL COMMENT '客户所属行业',
      cust_level varchar(32) DEFAULT NULL COMMENT '客户级别',
      cust_address varchar(128) DEFAULT NULL COMMENT '客户联系地址',
      cust_phone varchar(64) DEFAULT NULL COMMENT '客户联系电话',
      PRIMARY KEY (`cust_id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

创建客户的实体类，编写映射配置：

在实体类上使用JPA注解的形式配置映射关系，所有的注解都是使用JPA的规范提供的注解，在导入注解包的时候，一定要导入javax.persistence下的包。常用注解的说明：

  • @Entity 作用： 指定当前类是实体类。
  • @Table 作用： 指定实体类和表之间的对应关系。属性：name：指定数据库表的名称
  • @Id 作用： 指定当前字段是主键。
  • @GeneratedValue 作用： 指定主键的生成方式。 属性：strategy ：指定主键生成策略。
    GenerationType.IDENTITY：主键由数据库自动生成，需要数据库支持自增长，适用于mysql数据库
    GenerationType.SEQUENCE：根据底层数据库的序列来生成主键，需要数据库支持序列，适用于Oracle
    GenerationType.AUTO：主键由程序控制，会在数据库中生成数据库表格保存主键
    GenerationType.TABLE：使用一个特定的数据库表格来保存主键，可以自动生成
  • @Column 作用： 指定实体类属性和数据库表之间的对应关系
    name：指定数据库表的列名称。
    unique：是否唯一
    nullable：是否可以为空
    inserttable：是否可以插入
    updateable：是否可以更新
    columnDefinition: 定义建表时创建此列的DDL
    secondaryTable: 从表名，如果此列不建在主表上（默认建在主表），该属性定义该列所在从表的名字搭建开发环境
@Entity //声明实体类
@Table(name="cst_customer") //建立实体类和表的映射关系
public class Customer implements Serializable {

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

    @Column(name="cust_name") //指定和表中cust_name字段的映射关系
    private String custName;

    @Column(name="cust_source")//指定和表中cust_source字段的映射关系
    private String custSource;

    @Column(name="cust_industry")//指定和表中cust_industry字段的映射关系
    private String custIndustry;

    @Column(name="cust_level")//指定和表中cust_level字段的映射关系
    private String custLevel;

    @Column(name="cust_address")//指定和表中cust_address字段的映射关系
    private String custAddress;

    @Column(name="cust_phone")//指定和表中cust_phone字段的映射关系
    private String custPhone;

    /**
     * Get、Set、toString
     */
}

配置JPA的核心配置文件:

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

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence" 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.cj.jdbc.Driver" />
            <!-- 数据库地址 -->
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/jpa?serverTimezone=GMT%2B8&amp;useUnicode=true&amp;characterEncoding=utf-8" />
            <!-- 数据库用户名 -->
            <property name="javax.persistence.jdbc.user" value="root" />
            <!-- 数据库密码 -->
            <property name="javax.persistence.jdbc.password" value="520992" />

            <!--jpa提供者的可选配置：我们的JPA规范的提供者为hibernate，所以jpa的核心配置中兼容hibernate的配置 -->
            <!--配置jap实现（hibernate）的配置信息
                显示sql    :false|true
                自动创建数据库表：hibernate.hbm2dd1.auto
                   create :程序运行时创建数据库表（如果表存在，先删除表再创建表）
                   update :程序运行时创建表（如果表存在，不创建）
                   none   :不会创建表
            -->
            <property name="hibernate.show_sql" value="true" />
            <property name="hibernate.format_sql" value="true" />
            <property name="hibernate.hbm2ddl.auto" value="update" />
        </properties>
    </persistence-unit>
</persistence>

JPA的API介绍

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

String unitName = "myJpa";
EntityManagerFactory factory= Persistence.createEntityManagerFactory(unitName);

EntityManagerFactory：主要用来创建 EntityManager 实例，由于EntityManagerFactory 是一个线程安全的对象（即多个线程访问同一个EntityManagerFactory 对象不会有线程安全问题），并且EntityManagerFactory 的创建极其浪费资源，所以在使用JPA编程时，我们可以对其进行优化，满足一个项目中只有一个EntityManagerFactory。

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

EntityManager： 是完成持久化操作的核心对象，通过调用 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：回滚事务

测试代码：

@Test
public void test() {
    /**
     * 创建实体管理类工厂，借助Persistence的静态方法获取
     * 		其中传递的参数为持久化单元名称，需要jpa配置文件中指定
     */
    EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
    //创建实体管理类,工厂对象
    EntityManager em = factory.createEntityManager();

    //获取事务对象,通过实体管理类工厂获取实体管理器
    EntityTransaction tx = em.getTransaction();
    //开启事务,获取事务对象
    tx.begin();

    //完成增删改查操作
    Customer c = new Customer();
    c.setCustName("客户1");
    c.setCustIndustry("程序员");
    //保存操作
    em.persist(c);

    //提交事务（回滚事务）
    tx.commit();
    //释放资源
    em.close();
    factory.close();
}

JPA中的主键生成策略:

  • IDENTITY： 主键由数据库自动生成（主要是自动增长型）
@Id  
@GeneratedValue(strategy = GenerationType.IDENTITY) 
private Long custId;
  • SEQUENCE： 根据底层数据库的序列来生成主键，条件是数据库支持序列。
@Id  
@GeneratedValue(strategy = GenerationType.SEQUENCE,generator="payablemoney_seq")  
@SequenceGenerator(name="payablemoney_seq", sequenceName="seq_payment")  
private Long custId;
  • AUTO： 主键由程序控制
@Id  
@GeneratedValue(strategy = GenerationType.AUTO)  
private Long custId;
  • TABLE： 使用一个特定的数据库表格来保存主键
@Id  
@GeneratedValue(strategy = GenerationType.TABLE, generator="payablemoney_gen")  
@TableGenerator(name = "pk_gen",  
    table="tb_generator",  
    pkColumnName="gen_name",  
    valueColumnName="gen_value",  
    pkColumnValue="PAYABLEMOENY_PK",  
    allocationSize=1  
) private Long custId;

使用JPA完成增删改查操作

1. 抽取JPAUtil工具类:

通过静态代码块的形式， 解决实体管理类(EntityManagerFactory)工厂资源浪费和耗时问题。 使用静态代码块，当程序第一次访问此工具类的getEntityManager方法，经过静态代码块创建一个factory对象，再次调用方法创建一个EntityManager对象，当程序第二次访问getEntityManager方法时，直接通过一个已经创建好的factory对象，创建EntityManager对象。

/**
 * @Author: Ly
 * @Date: 2020-11-27 21:09
 */
public class JpaUtils {
    // JPA的实体管理器工厂：相当于Hibernate的SessionFactory
    private static EntityManagerFactory factory;
    // 使用静态代码块赋值
    static {
        // 注意：该方法参数必须和persistence.xml中persistence-unit标签name属性取值一致
        factory = Persistence.createEntityManagerFactory("myJpa");
    }

    /**
     * 使用管理器工厂生产一个管理器对象
     * @return
     */
    public static EntityManager getEntityManager() {
        return factory.createEntityManager();
    }
}

2. 测试增删改查：

  • persist ：保存

  • merge ： 更新

  • remove ： 删除

  • find/getRefrence：根据id查询
    class:：查询数据的结果需要包装的实体类类型的字节码
    id： 查询主键的取值

2.1 保存

@Test
public void testSave() {

    EntityManager em = JpaUtils.getEntityManager();
    //获取事务对象,通过实体管理类工厂获取实体管理器
    EntityTransaction tx = em.getTransaction();
    //开启事务,获取事务对象
    tx.begin();

    //完成保存操作
    Customer customer = new Customer();
    customer.setCustName("客户2");
    customer.setCustIndustry("教育");
    //保存操作
    em.persist(customer);

    //提交事务（回滚事务）
    tx.commit();
    //释放资源
    em.close();
}

2.2 修改

@Test
public void testUpdate() {

    EntityManager em = JpaUtils.getEntityManager();
    //获取事务对象,通过实体管理类工厂获取实体管理器
    EntityTransaction tx = em.getTransaction();
    //开启事务,获取事务对象
    tx.begin();

    //更新客户
    Customer customer=em.find(Customer.class,1l);
    customer.setCustIndustry("IT教育");
    em.merge(customer);

    //提交事务（回滚事务）
    tx.commit();
    //释放资源
    em.close();
}

2.3 删除

@Test
public void testRemove() {

    EntityManager em = JpaUtils.getEntityManager();
    //获取事务对象,通过实体管理类工厂获取实体管理器
    EntityTransaction tx = em.getTransaction();
    //开启事务,获取事务对象
    tx.begin();

    //删除客户
    //根据id查询
    Customer customer = em.find(Customer.class, 1l);
    //删除用户
    em.remove(customer);
    
    //提交事务（回滚事务）
    tx.commit();
    //释放资源
    em.close();
}

2.4 根据id查询
find与getReference：

  • find： 查询的对象是当前客户对象本身，在调用find方法的时候，就会发送sql语句数据库 （立即加载）
  • getReference： 查询对象是一个动态代理对象，调用getReference方法立即发送sql语句查询数据，当调用查询结果对象的时候，才会发送查询的sql语句，即什么时候用，什么时候发送sql语句查询数据库 （延迟加载）
@Test
public void testFind() {

    //通过工具类获取 entityManager
    EntityManager em = JpaUtils.getEntityManager();
    //获取事务对象,通过实体管理类工厂获取实体管理器
    EntityTransaction tx = em.getTransaction();
    //开启事务,获取事务对象
    tx.begin();

    //完成查询操作
    //Customer customer = em.find(Customer.class,1l);
    Customer customer = em.getReference(Customer.class,1l);
    System.out.println(customer);

    //提交事务（回滚事务）
    tx.commit();
    //释放资源
    em.close();
}

JPA中的复杂查询

JPA定义了独特的JPQL（Java Persistence Query Language），JPQL是EJB查询语言的一种扩展，以面向对象表达式语言的表达式，将SQL语法和简单查询语义绑定在一起。它是针对实体的一种查询语言，操作对象是实体，而不是关系数据库的表，因此其具有可移植性，可以被编译成所有主流数据库服务器上的SQL。其特征与原生SQL语句类似，并且完全面向对象，通过类名和属性访问，而不是表名和表的属性。

JPQL支持批量更新和修改、JOIN、GROUP BY、HAVING 等高级查询特性，同时还能够支持子查询

1. 查询全部

//查询所有客户
@Test
public void findAll() {
    EntityManager em = null;
    EntityTransaction tx = null;
    try {
        //获取实体管理对象
        em = JpaUtils.getEntityManager();

        //获取事务对象
        tx = em.getTransaction();
        tx.begin();

        // 创建query对象
        //jqpl: from com.ly.domain.Customer
        //sql: select * from cst_cus_customer
        String jpql = "from Customer";
        Query query = em.createQuery(jpql);

        // 查询并得到返回结果
        List list = query.getResultList(); // 得到集合返回类型
        for (Object object : list) {
            System.out.println(object);
        }
        tx.commit();
    } catch (Exception e) {
        // 回滚事务
        tx.rollback();
        e.printStackTrace();
    } finally {
        // 释放资源
        em.close();
    }
}

2. 分页查询

//分页查询客户
@Test
public void findPaged () {
   EntityManager em = null;
   EntityTransaction tx = null;
   try {
       //获取实体管理对象
       em = JpaUtils.getEntityManager();
       //获取事务对象
       tx = em.getTransaction();
       tx.begin();

       //创建query对象
       String jpql = "from Customer";
       Query query = em.createQuery(jpql);
       //起始索引
       query.setFirstResult(0);
       //每页显示条数
       query.setMaxResults(2);
       //查询并得到返回结果
       List list = query.getResultList(); //得到集合返回类型
       for (Object object : list) {
           System.out.println(object);
       }
       tx.commit();
   } catch (Exception e) {
       // 回滚事务
       tx.rollback();
       e.printStackTrace();
   } finally {
       // 释放资源
       em.close();
   }
}

3. 条件查询

//条件查询
@Test
public void findCondition () {
    EntityManager em = null;
    EntityTransaction tx = null;
    try {
        //获取实体管理对象
        em = JpaUtils.getEntityManager();
        //获取事务对象
        tx = em.getTransaction();
        tx.begin();
        //创建query对象
        String jpql = "from Customer where custName like ? ";
        Query query = em.createQuery(jpql);
        //对占位符赋值，从1开始
        query.setParameter(1, "传智播客%");
        //查询并得到返回结果
        Object object = query.getSingleResult(); //得到唯一的结果集对象
        System.out.println(object);
        tx.commit();
    } catch (Exception e) {
        // 回滚事务
        tx.rollback();
        e.printStackTrace();
    } finally {
        // 释放资源
        em.close();
    }
}

4. 排序查询

//根据客户id倒序查询所有客户
//查询所有客户
@Test
public void testOrder() {
    EntityManager em = null;
    EntityTransaction tx = null;
    try {
        //获取实体管理对象
        em = JpaUtils.getEntityManager();
        //获取事务对象
        tx = em.getTransaction();
        tx.begin();
        // 创建query对象
        String jpql = "from Customer order by custId desc";
        Query query = em.createQuery(jpql);
        // 查询并得到返回结果
        List list = query.getResultList(); // 得到集合返回类型
        for (Object object : list) {
            System.out.println(object);
        }
        tx.commit();
    } catch (Exception e) {
        // 回滚事务
        tx.rollback();
        e.printStackTrace();
    } finally {
        // 释放资源
        em.close();
    }
}

5. 统计查询

//统计查询
@Test
public void findCount() {
    EntityManager em = null;
    EntityTransaction tx = null;
    try {
        //获取实体管理对象
        em = JpaUtils.getEntityManager();
        //获取事务对象
        tx = em.getTransaction();
        tx.begin();
        // 查询全部客户
        // 1.创建query对象
        String jpql = "select count(custId) from Customer";
        Query query = em.createQuery(jpql);
        // 2.查询并得到返回结果
        Object count = query.getSingleResult(); // 得到集合返回类型
        System.out.println(count);
        tx.commit();
    } catch (Exception e) {
        // 回滚事务
        tx.rollback();
        e.printStackTrace();
    } finally {
        // 释放资源
        em.close();
    }
}
龙源lll
关注
专栏目录
Spring Data JPA的简单使用
IT小小鸟
09-08 221
前言 什么是Spring Data Spring Data的特点 2. 什么是JPA 3. Spring Data 与JPA的关系 4. Spring Data JPA工作原理 Spring Data JPA的简单使用 Spring项目的基本配置如下： # 数据库配置 spring.datasource.url=jdbc:mysql://localhost:3306/vip_test?serverTimezone=UTC&characterEncoding=utf-8 spring
JPA基本使用，java面试流程图
m0_60707660的博客
03-14 887
/在java工程的src路径下创建一个名为META-INF的文件夹，在此文件夹下创建一个名为persistence.xml的配置文件配置持久化单元name：持久化单元名称transaction-type：事务类型RESOURCE_LOCAL：本地事务管理JTA：分布式事务管理**需要zi料+ 绿色徽【vip1024b】**配置JPA规范的服务提供商数据库驱动数据库地址数据库用户名数据库密码。
SpringDataJpa--jpa基础
T_Ghost的博客
08-27 201
1、ORM概述 2、Hibernate概述 3、JPA概述—面向对象操作数据 4、具体实现
JPA基本介绍以及使用
weixin_30295091的博客
12-27 133
JPA即Java Persistence Architecture，Java持久化规范，从EJB2.x版本中原来的实体Bean分离出来的，EJB3.x中不再有实体Bean，而是将实体Bean放到JPA中来实现。可以说，JPA借鉴了Hibernate的设计，JPA的设计者就是Hibernate框架的作者。 JPA的底层实现是一些流行的ORM框架，比如Hibernate，Ecl...
jpa的使用
weixin_46102505的博客
04-13 6609
目录 什么是jpa？ spring data jpa springboot演示jpa 1.pom依赖 2.application.properties 配置 3.建立用户实体类 4. 声明UserRepository接口，继承JpaRepository 5.定义测试类，演示添加操作 6.查询 什么是jpa？ JPA是Java Persistence API的简称，中文名Java持久层API， 是 Sun 官方提出的 Java 持久化规范。它为 Java...
Spring Data JPA基本使用及部分原理(核心概念)
01-20
**Spring Data JPA基本使用及部分原理** Spring Data JPA是Spring框架的一部分，它为Java开发者提供了方便的数据访问层抽象，使得与各种持久化技术（如JPA、Hibernate）的交互变得简单。本文将深入探讨Spring Data ...
JPA基本使用，java工作三年面试题
m0_64384350的博客
12-05 844
JPA的API介绍 Persistence对象： 主要作用是用于获取EntityManagerFactory对象的，通过调用该类的createEntityManagerFactory静态方法，根据配置文件中持久化单元名称创建EntityManagerFactory。 String unitName = “myJpa”; EntityManagerFactory factory= Persistence.createEntityManagerFactory(unitNam...
basic-jpa-example-javase:在 JavaSE 上使用 Java JPA 的基本示例
07-18
在"basic-jpa-example-javase"项目中，我们可以看到如何在JavaSE环境下利用JPA进行数据库操作的基本步骤。首先，我们需要引入JPA的依赖库，通常包括Hibernate或EclipseLink等实现，这些实现提供了JPA规范的具体功能...
springboot基本使用十（搭建jpa）
最新发布
05-14
以上就是使用SpringBoot搭建JPA的基本流程。在实际项目中，可能还需要配置更多JPA属性，例如连接池、事务管理、查询语言(HQL)等。通过JPA，我们可以方便地处理复杂的关联关系，执行自定义SQL，甚至进行分页和排序等...
JPA使用教程
08-25
spring-data-jpa psf文档，全面的jpa使用教程，提供全面api操作说明
SpringBoot JPA 使用教程
showadwalker的博客
05-02 4103
文章目录1. 简介2. 常用注解2.1 @Entity2.2 @Table2.3 @Id 、@GeneratedValue、@SequenceGenerator、@Column2.3.1 @Id2.3.2 @GeneratedValue2.3.3 @SequenceGenerator2.3.4 @Column2.4 @Transient2.5 @Temproal3. EntityManagerFactory 1. 简介 Jpa 是一套ORM 的规范 hibernate 不就是一个 ORM 框架也提供了对于
一篇文章带你搞定 JPA 的基本使用
南淮北安的博客
07-10 1752
本文通过保存客户信息到数据库表中的操作，来讲述 JPA 的基本操作 文章目录一、环境搭建二、创建 persistence.xml三、编写实体类和数据库表的映射配置四、映射配置常用注解的归纳五、测试保存操作的执行六、注意事项 一、环境搭建 （1）创建 maven 工程 （2）导入pom坐标 <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <proje
JPA的简单使用
q756665001的博客
09-15 1741
JPA增删改查的简单使用导入maven依赖application配置实体类创建Repository创建分别创建Service接口和实现类Controller创建 作为一个java小白(*__*) 嘻嘻，发现公司在用JPA操作数据库 ，简单的自己实现了一个Demo，不是很标准，只记录一下学习过程，毕竟第一次嘛，后面会深入的 ^_^ 导入maven依赖 <dependencies> <!-- https://mvnrepository.com/artifact/com.
JPA 常见用法
Dily_Su的博客
12-22 1492
JPA 使用中的常见用法
JPA基础介绍与使用
myllxy
11-27 307
JPA简介 什么是JPA JPA是Java Persistence API的简称 Java EE 5.0 平台标准的 对象关系映射(ORM) 规范 ORM 就是通过将Java对象映射到数据库表，通过操作Java对象，就可以完成对数据表的操作 Hibernate和JPA的关系 Hibernate： 一个开放源代码的对象关系映射(ORM)框架 对JDBC进行了非常轻量级(相对于EJB这一套)的对...
jpa如何使用
06-02
JPA（Java Persistence API）是 Java EE 5 规范中的持久化框架，它提供了一种面向对象的方式来管理数据库的持久化操作，使得开发者可以更加方便...以上是 JPA 的基本使用步骤，具体的实现细节可以查看 JPA 的官方文档。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

龙源lll

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值