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

最新推荐文章于 2022-09-07 10:51:25 发布

你好y

最新推荐文章于 2022-09-07 10:51:25 发布

阅读量463

点赞数

分类专栏： SpringDataJpa 文章标签： hibernate 数据库 java

本文链接：https://blog.csdn.net/qq_43430343/article/details/125677838

版权

SpringDataJpa 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

1、ORM思想的引入

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

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

1.1、传统的CRUD

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

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

不同的表存储在不同的数据库当中就需要用到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接口，但具体实现则由服务厂商来提供实现。

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();
  }

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();
  }

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

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();
  }

你好y

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
JPA初识(ORM思想、JPA的基本操作)

简单的说：ORM就是建立实体类和数据库表之间的关系，从而达到操作实体类就相当于操作数据库表的目的。常见的orm框架：Mybatis（ibatis）、Hibernate、JpaJPA不干活，真正干活的是依托于这个规范的实现，例如hibernate，toplink。JPA使用规范语言提供的接口和抽象类来进行编程不同的表存储在不同的数据库当中就需要用到JPA的分布式事务管理。我们将所有的表存在一个数据库中称为本地事务管理。JPA是接口，是一种规范，只有接口和规范是不能干活的。需要定义JPA的实现方式Hiberna
复制链接

扫一扫