JPA 详解 -----Jane Eyre

最新推荐文章于 2022-06-08 13:23:33 发布

CoderLix

最新推荐文章于 2022-06-08 13:23:33 发布

阅读量490

点赞数

分类专栏：框架文章标签： JPA

本文链接：https://blog.csdn.net/zlx_508/article/details/97005499

版权

框架专栏收录该内容

5 篇文章 0 订阅

订阅专栏

1.ORM概述

在介绍JPA之前，首先对ORM（Object-Relational Mapping ）对象关系映射做一个了解。在面向对象的软件开发中，通过ORM，就可以把对象映射到关系型数据库中。只要有一套程序能够做到建立对象与数据库的关联，操作对象就可以直接操作数据库数据，就可以说这套程序实现了ORM对象关系映射

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

1.1 为什么要使用ORM？

当实现一个应用程序时（不使用O/R Mapping），我们可能会写特别多数据访问层的代码，从数据库保存数据、修改数据、删除数据，而这些代码都是重复的，造成代码冗余，不利于后期对系统的维护。而使用ORM则会大大减少重复性代码。对象关系映射（Object Relational Mapping，简称ORM），主要实现程序对象到关系数据库数据的映射。

1.2 常见的ORM框架有哪些？

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

2.hibernate与jpa的概述

2.1.hibernate

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

2.2.jpa

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

2.3.jpa优势

1. 标准化

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

2. 容器级特性的支持

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

3. 简单方便

JPA的主要目标之一就是提供更加简单的编程模型：在JPA框架下创建实体和创建Java 类一样简单，没有任何的约束和限制，只需要使用 javax.persistence.Entity进行注释，JPA的框架和接口也都非常简单，没有太多特别的规则和设计模式的要求，开发者可以很容易的掌握。JPA基于非侵入式原则设计，因此可以很容易的和其它框架或者容器集成

4. 查询能力

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

5. 高级特性

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

2.4.jpa与hibernate的关系

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

JPA和Hibernate的关系就像JDBC和JDBC驱动的关系，JPA是规范，Hibernate除了作为ORM框架之外，它也是一种JPA实现。JPA怎么取代Hibernate呢？JDBC规范可以驱动底层数据库吗？答案是否定的，也就是说，如果使用JPA规范进行数据库操作，底层需要hibernate作为其实现类完成数据持久化工作。

3.jpa常用注解

@Entity

作用：指定当前类是实体类。

@Table

作用：指定实体类和表之间的对应关系。

属性：

name：指定数据库表的名称

@Id

作用：指定当前字段是主键。

@GeneratedValue

作用：指定主键的生成方式。。

属性：

strategy ：指定主键生成策略。

IDENTITY,//主键自增长

SEQUENCE,//序列化增长

TABLE,//建表增长

AUTO;//有系统处理

@Column

作用：指定实体类属性和数据库表之间的对应关系

属性：

name：指定数据库表的列名称。

unique：是否唯一

nullable：是否可以为空

inserttable：是否可以插入

updateable：是否可以更新

columnDefinition: 定义建表时创建此列的DDL

secondaryTable: 从表名。如果此列不建在主表上（默认建在主表），该属性定义该列所在从表的名字搭建开发环境[重点]

在实体类上使用JPA注解的形式配置映射关系如下：

/**
 * 客户实体类
 *
 *      配置映射关系
 *              1.实体类和表的映射关系
 *              2.实体类属性高好数据库表字段的关系
 * @Entity:声明实体类
 * @Table:配置实体类和表的映射关系
 *          name:数据库表名
 */
@Entity
@Table(name = "cast_customer")
public class Customer {
    /**
     * @Id: 声明主键配置
     * @GenerateValue：配置主键生成个策略
     *          strategy
     *              GenerationType.IDENTITY ：自增 ，mysql
     *                      * 底层数据库必须支持自动增长（底层数据库支持的自动增长方式，对ID自增）
     *              GenerationType.SEQUENCE : 序列 ，Oracle
     *                      * 底层数据库必须支持序列
     *              GenerationType.TABLE : jpa提供的一种机制，通过一张数据库表的形式帮助我们完成主键自增
     *              GenerationType.AUTO : 由程序自动的帮助我们去选择主键的生成策略
     * @Column:配置属性和字段的映射关系
     *          name:数据库表中字段的名称
     */
    @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;

   //省略getter&&setter方法
    .......
}

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的配 -->

                        <!--配置jpa实现方的配置信息

                                显示SQL  :  true|false
                                自动创建数据库表   ：  hibernate.hbm2ddl.auto
                                      create  : 程序运行时，创建数据库表（如果有表，先删除表在创建表）
                                      update  : 程序运行时，创建数据库表（如果有表，不回创建表）
                                      none   :  不会创建表

                        -->

			<!--显示sql语句-->
                        <property name="hibernate.show_sql" value="true" />
                        <!--格式化sql语句-->
                        <property name="hibernate.format_sql" value="true" />
                        <!--自动创建数据库表: create,update,none-->
                        <property name="hibernate.hbm2ddl.auto" value="create" />

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

4.JPA中的主键生成策略

通过annotation（注解）来映射hibernate实体的,基于annotation的hibernate主键标识为@Id, 其生成规则由@GeneratedValue设定的.这里的@id和@GeneratedValue都是JPA的标准用法。

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

1)IDENTITY:主键由数据库自动生成（主要是自动增长型）

    @Id  
    @GeneratedValue(strategy = GenerationType.IDENTITY) 
    private Long custId;

2)SEQUENCE：根据底层数据库的序列来生成主键，条件是数据库支持序列(oracle)。

(@SequenceGenerator有一个缺点，就是所有表都公用这一个sequence)

@Id  
@GeneratedValue(strategy = GenerationType.SEQUENCE,generator="payablemoney_seq")  
@SequenceGenerator(name="payablemoney_seq", sequenceName="seq_payment")  
private Long custId;


    //@SequenceGenerator源码中的定义
    @Target({TYPE, METHOD, FIELD})   
    @Retention(RUNTIME)  
    public @interface SequenceGenerator {  
       //表示该表主键生成策略的名称，它被引用在@GeneratedValue中设置的“generator”值中
       String name();  
       //属性表示生成策略用到的数据库序列名称。
       String sequenceName() default "";  
       //表示主键初识值，默认为0
       int initialValue() default 0;  
       //表示每次主键值增加的大小，例如设置1，则表示每次插入新记录后自动加1，默认为50
       int allocationSize() default 50;  
    }

3)AUTO：主键由程序控制

    @Id  
    @GeneratedValue(strategy = GenerationType.AUTO)  
    private Long custId;

4)TABLE：使用一个特定的数据库表格来保存主键

@Id  
    @GeneratedValue(strategy = GenerationType.TABLE, generator=" gen_name")  
    @TableGenerator(name = " gen_name",  
        table=" tb_biaoming",  
        pkColumnName="gen_name",  
        valueColumnName="gen_value",  
        pkColumnValue="PAYABLEMOENY_PK",  
        allocationSize=1  
    ) 
private Long custId;

 

//@TableGenerator的定义：
    @Target({TYPE, METHOD, FIELD})   
    @Retention(RUNTIME)  
    public @interface TableGenerator {  
      //表示该表主键生成策略的名称，它被引用在@GeneratedValue中设置的“generator”值中
      String name();  
      //表示表生成策略所持久化的表名，例如，这里表使用的是数据库中的“ tb_biaoming”。
      String table() default "";  
      //catalog和schema具体指定表所在的目录名或是数据库名
      String catalog() default "";  
      String schema() default "";  
      //属性的值表示在持久化表中，该主键生成策略所对应键值的名称。例如在“tb_biaoming”中将“gen_name”作为主键的键值(tb_biaoming表的主键名称)
      String pkColumnName() default "";  
      //属性的值表示在持久化表中，该主键当前所生成的值，它的值将会随着每次创建累加。例如，在“ tb_biaoming”中将“gen_value”作为主键的值(tb_biaoming表的主键名称所对应的主键值的名称)
      String valueColumnName() default "";  
      //属性的值表示在持久化表中，该生成策略所对应的主键。例如在“tb_generator”表中，将“gen_name”的值为“CUSTOMER_PK”。 ((tb_biaoming表的主键名称下的值))
      String pkColumnValue() default "";  
      //表示主键初识值，默认为0。 
      int initialValue() default 0;  
      //表示每次主键值增加的大小，例如设置成1，则表示每次创建新记录后自动加1，默认为50。
      int allocationSize() default 50;  
      UniqueConstraint[] uniqueConstraints() default {};  
    } 



 //这里应用表tb_generator，定义为 ：
    CREATE TABLE  tb_generator (  
      id NUMBER NOT NULL,  
      gen_name VARCHAR2(255) NOT NULL,  
      gen_value NUMBER NOT NULL,  
      PRIMARY KEY(id)  
    )

5.jpa的API介绍

5.1 Persistence对象

1.Persistence对象主要作用是

1）用于获取EntityManagerFactory对象的。(通过调用该类的createEntityManagerFactory静态方法)

2）根据配置文件中持久化单元名称创建数据库中的表。

3）内部维护的很多的内容

* 内部维护了数据库信息，

* 维护了缓存信息

* 维护了所有的实体管理器对象

2.特点：线程安全的对象(多个线程访问同一个EntityManagerFactory不会有线程安全问题)

3.EntityManagerFactory的创建过程比较浪费资源(在使用JPA编程时，我们可以对EntityManagerFactory 的创建进行优化)

* 如何解决EntityManagerFactory的创建过程浪费资源（耗时）的问题？

思路：创建一个公共的EntityManagerFactory的对象，静态代码块的形式创建EntityManagerFactory

5.2 EntityManagerFactory

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

//创建实体管理类

EntityManager em = factory.createEntityManager();

5.3 EntityManager

在 JPA 规范中, EntityManager是完成持久化操作的核心对象。实体类作为普通 java对象，只有在调用 EntityManager将其持久化后才会变成持久化对象。

1.EntityManager对象在一组实体类与底层数据源之间进行 O/R 映射的管理。

2.它可以用来管理和更新 Entity Bean, 根椐主键查找 Entity Bean, 还可以通过JPQL语句查询实体。

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

功能方法说明：

getTransaction : 获取事务对象

persist ：保存操作

merge ：更新操作

remove ：删除操作

find/getReference ：根据id查询

5.4 EntityTransaction

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

begin：开启事务

commit：提交事务

rollback：回滚事务

6.JPA工具类的抽取

public final class JPAUtil {
	// JPA的实体管理器工厂：相当于Hibernate的SessionFactory
	private static EntityManagerFactory em;
	// 使用静态代码块赋值
	static {
		// 注意：该方法参数必须和persistence.xml中persistence-unit标签name属性取值一致
		em = Persistence.createEntityManagerFactory("myPersistUnit");
	}

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

7.JPA中的复杂查询

JPQL全称Java Persistence Query Language，Java持久化查询语言(JPQL)，它是一种可移植的查询语言，旨在以面向对象表达式语言的表达式，将SQL语法和简单查询语义绑定在一起·使用这种语言编写的查询是可移植的，可以被编译成所有主流数据库服务器上的SQL。

其特征与原生SQL语句类似，并且完全面向对象，通过类名和属性访问，而不是表名和表的属性。

7.1 查询全部

//查询所有客户
	@Test
	public void findAll() {
		EntityManager em = null;
		EntityTransaction tx = null;
		try {
			//获取实体管理对象
			em = JPAUtil.getEntityManager();
			//获取事务对象
			tx = em.getTransaction();
			tx.begin();
			// 创建query对象
			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();
		}
	}

7.2 分页查询

//分页查询客户
	@Test
	public void findPaged () {
		EntityManager em = null;
		EntityTransaction tx = null;
		try {
			//获取实体管理对象
			em = JPAUtil.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();
		}
	}

7.3 条件查询

//条件查询
	@Test
	public void findCondition () {
		EntityManager em = null;
		EntityTransaction tx = null;
		try {
			//获取实体管理对象
			em = JPAUtil.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();
		}
	}

7.4 排序查询

//根据客户id倒序查询所有客户
	//查询所有客户
	@Test
	public void testOrder() {
		EntityManager em = null;
		EntityTransaction tx = null;
		try {
			//获取实体管理对象
			em = JPAUtil.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();
		}
	}

7.5 统计查询

//统计查询
	@Test
	public void findCount() {
		EntityManager em = null;
		EntityTransaction tx = null;
		try {
			//获取实体管理对象
			em = JPAUtil.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();
		}
	}

CoderLix

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JPA 详解 -----Jane Eyre

1.ORM概述在介绍JPA之前，首先对ORM（Object-Relational Mapping ）对象关系映射做一个了解。在面向对象的软件开发中，通过ORM，就可以把对象映射到关系型数据库中。只要有一套程序能够做到建立对象与数据库的关联，操作对象就可以直接操作数据库数据，就可以说这套程序实现了ORM对象关系映射简单的说：ORM就是建立实体类和数据库表之间的关系，从而达到操作实体类就相当于...
复制链接

扫一扫