1.JPA概述

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

1.2JPA优势

1.标准化

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

2.容器级特性的支持

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

3.简单方便

JPA 的主要目标之一就是提供更加简单的编程模型：在 JPA 框架下创建实体和创建 Java 类一样简单，没有任何的约束和限制，只需要使用 javax.persistence.Entity 进行注释

4.查询能力

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

5.高级特性

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

1.3JPA与hibernate关系

jpa层次.JPG
image.png

1.4JPA入门

JPA 是 sun 公司制定的 API 规范，所以我们不需要导入额外的 JPA 相关的 jar 包，只需要导入 JPA 的提供商的 jar 包。我们选择 Hibernate 作为 JPA 的提供商，所以需要导入 Hibernate的相关 jar 包。

1.4.1搭建环境

1.4.1.1引入依赖

  1. <properties>
  2.     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  3.     <project.hibernate.version>5.0.7.Final</project.hibernate.version>
  4. </properties>
  5. <dependencies>
  7.     <!-- hibernate对jpa的支持包 -->
  8.     <dependency>
  9.         <groupId>org.hibernate</groupId>
  10.         <artifactId>hibernate-entitymanager</artifactId>
  11.         <version>${project.hibernate.version}</version>
  12.     </dependency>
  13.     <!-- c3p0 -->
  14.     <dependency>
  15.         <groupId>org.hibernate</groupId>
  16.         <artifactId>hibernate-c3p0</artifactId>
  17.         <version>${project.hibernate.version}</version>
  18.     </dependency>
  20.     <!-- Mysql and MariaDB -->
  21.     <dependency>
  22.         <groupId>mysql</groupId>
  23.         <artifactId>mysql-connector-java</artifactId>
  24.         <version>5.1.6</version>
  25.     </dependency>
  26. </dependencies>

1.4.2创建实体类

  1. public class Customer implements Serializable {
  2. private Long custId;
  3. private String custName;
  4. private String custSource;
  5. private String custIndustry;
  6. private String custLevel;
  7. private String custAddress;
  8. private String custPhone;
  9. //getter/setter/toString/构造方法省略
  10. }

1.4.3编写实体类和数据库表的映射配置

  1. /**
  2. *  * 所有的注解都是使用 JPA 的规范提供的注解，
  3. * * 所以在导入注解包的时候，一定要导入 javax.persistence 下的
  4. */
  5. @Entity //声明实体类
  6. @Table(name="cst_customer") //建立实体类和表的映射关系
  7. public class Customer {
  8. @Id//声明当前私有属性为主键
  9. @GeneratedValue(strategy=GenerationType.IDENTITY) //配置主键的生成策略
  10. @Column(name="cust_id") //指定和表中 cust_id 字段的映射关系
  11. private Long custId;
  12. @Column(name="cust_name") //指定和表中 cust_name 字段的映射关系
  13. private String custName;
  14. @Column(name="cust_source")//指定和表中 cust_source 字段的映射关系
  15. private String custSource;
  16. @Column(name="cust_industry")//指定和表中 cust_industry 字段的映射关系
  17. private String custIndustry;
  18. @Column(name="cust_level")//指定和表中 cust_level 字段的映射关系
  19. private String custLevel;
  20. @Column(name="cust_address")//指定和表中 cust_address 字段的映射关系
  21. private String custAddress;
  22. @Column(name="cust_phone")//指定和表中 cust_phone 字段的映射关系
  23. private String custPhone;

常用注解说明

  1. 常用注解的说明
  2. @Entity
  3. 作用：指定当前类是实体类。
  4. @Table
  5. 作用：指定实体类和表之间的对应关系。
  6. 属性：
  7. name：指定数据库表的名称
  8. @Id
  9. 作用：指定当前字段是主键。
  10. @GeneratedValue
  11. 作用：指定主键的生成方式。。
  12. 属性：
  13. strategy ：指定主键生成策略。
  14. @Column
  15. 作用：指定实体类属性和数据库表之间的对应关系
  16. 属性：
  17. name：指定数据库表的列名称。
  18. unique：是否唯一
  19. nullable：是否可以为空
  20. inserttable：是否可以插入
  21. updateable：是否可以更新
  22. columnDefinition: 定义建表时创建此列的 DDL
  23. secondaryTable: 从表名。如果此列不建在主表上（默认建在主表），该属性定义该列所在从表的名字搭建开发环境[重点]

JPA主键生成策略

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

JPA 提供的四种标准用法为 TABLE,SEQUENCE,IDENTITY,AUTO。
具体说明如下：
IDENTITY: 主键由数据库自动生成（主要是自动增长型）
用法：

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

SEQUENCE ：根据底层数据库的序列来生成主键，条件是数据库支持序列。
用法：

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

AUTO ：主键由程序控制
用法：

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

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

  1. @Id
  2. @GeneratedValue(strategy = GenerationType.TABLE, generator="payablemoney_gen")
  3. @TableGenerator(name = "pk_gen",
  4. table="tb_generator",
  5. pkColumnName="gen_name",
  6. valueColumnName="gen_value",
  7. pkColumnValue="PAYABLEMOENY_PK",
  8. allocationSize=1
  9. )
  10. private Long custId;

1.4.4配置 JPA 的核心配置文件

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

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <persistence xmlns="http://java.sun.com/xml/ns/persistence"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
  5. http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd"
  6. version="2.0">
  8.     <!--配置持久化单元
  9.     name：持久化单元名称
  10.     transaction-type：事务类型
  11.     RESOURCE_LOCAL：本地事务管理
  12.     JTA：分布式事务管理 -->
  13.     <persistence-unit name="myJpa" transaction-type="RESOURCE_LOCAL">
  15.     <!--配置 JPA 规范的服务提供商 -->
  16.     <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
  17.         <properties>
  18.             <!-- 数据库驱动 -->
  19.             <property  name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver" />
  20.             <!-- 数据库地址 -->
  21.             <property  name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/ssh" />
  22.             <!-- 数据库用户名 -->
  23.             <property name="javax.persistence.jdbc.user" value="root" />
  24.             <!-- 数据库密码 -->
  25.             <property name="javax.persistence.jdbc.password" value="root" />
  26.         <!--jpa提供者的可选配置：我们的 JPA规范的提供者为 hibernate，所以 jpa的核心配置中兼容 hibernate 的配置
  27.                 显示sql           ：   false|true
  28.                 自动创建数据库表    ：  hibernate.hbm2ddl.auto
  29.                         create      : 程序运行时创建数据库表（如果有表，先删除表再创建）
  30.                         update      ：程序运行时创建表（如果有表，不会创建表）
  31.                         none        ：不会创建表
  32.         -->
  33.         <property name="hibernate.show_sql" value="true" />
  34.         <property name="hibernate.format_sql" value="true" />
  35.         <property name="hibernate.hbm2ddl.auto" value="create" />
  36.         </properties>
  37.     </persistence-unit>
  38. </persistence>

1.4.5实现保存方法

  1. public class Demo01Test {
  2.     /**
  3.      * 创建实体管理类工厂，借助 Persistence 的静态方法获取
  4.      * 其中传递的参数为持久化单元名称，需要 jpa 配置文件中指定
  5.      */
  6.     @Test
  7.     public void tset() {
  8.         //1.加载配置文件创建工厂（实体管理器工厂）对象
  9.         EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
  10.         //2.通过实体管理器工厂获取实体管理器
  11.         EntityManager em = factory.createEntityManager();
  12.         //3.获取事务对象，开启事务
  13.         EntityTransaction tx = em.getTransaction(); //获取事务对象
  14.         tx.begin();//开启事务
  15.         //4.完成增删改查操作：保存一个客户到数据库中
  16.         Customer customer = new Customer();
  17.         customer.setCustName("传智播客2");
  18.         customer.setCustIndustry("教育2");
  19.         //保存，
  20.         em.persist(customer); //保存操作
  21.         //5.提交事务
  22.         tx.commit();
  23.         //6.释放资源
  24.         em.close();
  25.         factory.close();
  26.     }
  27. }

1.5JPA中API介绍

1.5.1Persistence对象

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

1.5.2EntityManagerFactory

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

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

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

1..5.3EntityManager

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

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

1.5.4EntityTransaction

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

  1. begin：开启事务
  2. commit：提交事务
  3. rollback：回滚事务

1.6抽取JPA工具类

  1. public final class JPAUtil {
  2.     // JPA的实体管理器工厂：相当于Hibernate的SessionFactory
  3.     private static EntityManagerFactory em;
  4.     // 使用静态代码块赋值
  5.     static {
  6.         // 注意：该方法参数必须和persistence.xml中persistence-unit标签name属性取值一致
  7.         em = Persistence.createEntityManagerFactory("myPersistUnit");
  8.     }
  9.     /**
  10. * 使用管理器工厂生产一个管理器对象
  11. *
  12. * @return
  13. */
  14.     public static EntityManager getEntityManager() {
  15.         return em.createEntityManager();
  16.     }
  17. }

1.7对数据库的CRUD

1.7.1保存

  1. /**
  2. * 保存一个实体
  3. */
  4. @Test
  5. public void testAdd() {
  6. // 定义对象
  7. Customer c = new Customer();
  8. c.setCustName("传智学院");
  9. c.setCustLevel("VIP客户");
  10. c.setCustSource("网络");
  11. c.setCustIndustry("IT教育");
  12. c.setCustAddress("昌平区北七家镇");
  13. c.setCustPhone("010-84389340");
  14. EntityManager em = null;
  15. EntityTransaction tx = null;
  16. try {
  17. // 获取实体管理对象
  18. em = JPAUtil.getEntityManager();
  19. // 获取事务对象
  20. tx = em.getTransaction();
  21. // 开启事务
  22. tx.begin();
  23. // 执行操作
  24. em.persist(c);
  25. // 提交事务
  26. tx.commit();
  27. } catch (Exception e) {
  28. // 回滚事务
  29. tx.rollback();
  30. e.printStackTrace();
  31. } finally {
  32. // 释放资源
  33. em.close();
  34. }
  35. }

1.7.2修改

  1. @Test
  2. public void testMerge(){
  3. //定义对象
  4. EntityManager em=null;
  5. EntityTransaction tx=null;
  6. try{
  7. //获取实体管理对象
  8. em=JPAUtil.getEntityManager();
  9. //获取事务对象
  10. tx=em.getTransaction();
  11. //开启事务
  12. tx.begin();
  13. //执行操作
  14. Customer c1 = em.find(Customer.class, 6L);
  15. c1.setCustName("江苏传智学院");
  16. em.clear();//把c1对象从缓存中清除出去
  17. em.merge(c1);
  18. //提交事务
  19. tx.commit();
  20. }catch(Exception e){
  21. //回滚事务
  22. tx.rollback();
  23. e.printStackTrace();
  24. }finally{
  25. //释放资源
  26. em.close();
  27. }
  28. }

1.7.3删除

  1. /**
  2. * 删除
  3. */
  4. @Test
  5. public void testRemove() {
  6. // 定义对象
  7. EntityManager em = null;
  8. EntityTransaction tx = null;
  9. try {
  10. // 获取实体管理对象
  11. em = JPAUtil.getEntityManager();
  12. // 获取事务对象
  13. tx = em.getTransaction();
  14. // 开启事务
  15. tx.begin();
  16. // 执行操作
  17. Customer c1 = em.find(Customer.class, 6L);
  18. em.remove(c1);
  19. // 提交事务
  20. tx.commit();
  21. } catch (Exception e) {
  22. // 回滚事务
  23. tx.rollback();
  24. e.printStackTrace();
  25. } finally {
  26. // 释放资源
  27. em.close();
  28. }
  29. }

1.7.4根据ID查询

  1. /**
  2. * 查询一个： 使用立即加载的策略
  3. */
  4. @Test
  5. public void testGetOne() {
  6. // 定义对象
  7. EntityManager em = null;
  8. EntityTransaction tx = null;
  9. try {
  10. // 获取实体管理对象
  11. em = JPAUtil.getEntityManager();
  12. // 获取事务对象
  13. tx = em.getTransaction();
  14. // 开启事务
  15. tx.begin();
  16. // 执行操作
  17. Customer c1 = em.find(Customer.class, 1L);//立即加载
  19.  // 执行操作
  20. //Customer c1 = em.getReference(Customer.class, 1L);//懒加载
  21. // 提交事务
  22. tx.commit();
  23. System.out.println(c1); // 输出查询对象
  24. } catch (Exception e) {
  25. // 回滚事务
  26. tx.rollback();
  27. e.printStackTrace();
  28. } finally {
  29. // 释放资源
  30. em.close();
  31. }
  32. }

1.8JPQL语句

查询全部

image.png

分页查询

image.png

条件查询

image.png

排序查询

image.png

统计查询

image.png