ORM概述

对象关系映射（Object Relational Mapping，简称ORM），主要实现程序对象到关系数据库数据的映射。 常见的orm框架：Mybatis（ibatis）、Hibernate、Jpa

hibernate 与 JPA 的概述

hibernate概述

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

JPA 概述

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

JPA与hibernate的关系

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

JPA的入门案例

maven 工程导入坐标

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

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

  1. /**
  2. *        * 所有的注解都是使用JPA的规范提供的注解，
  3.  *        * 所以在导入注解包的时候，一定要导入javax.persistence下的
  4.  */
  5. @Entity //声明实体类
  6. @Table(name="cst_customer") //建立实体类和表的映射关系
  7. public class Customer {
  9.     @Id//声明当前私有属性为主键
  10.     @GeneratedValue(strategy=GenerationType.IDENTITY) //配置主键的生成策略
  11.     @Column(name="cust_id") //指定和表中cust_id字段的映射关系
  12.     private Long custId;
  14.     @Column(name="cust_name") //指定和表中cust_name字段的映射关系
  15.     private String custName;
  17.     @Column(name="cust_source")//指定和表中cust_source字段的映射关系
  18.     private String custSource;
  20.     @Column(name="cust_industry")//指定和表中cust_industry字段的映射关系
  21.     private String custIndustry;
  23.     @Column(name="cust_level")//指定和表中cust_level字段的映射关系
  24.     private String custLevel;
  26.     @Column(name="cust_address")//指定和表中cust_address字段的映射关系
  27.     private String custAddress;
  29.     @Column(name="cust_phone")//指定和表中cust_phone字段的映射关系
  30.     private String custPhone;
  31.     ...
  32. }
  • @Entity
    • 作用：指定当前类是实体类。
  • @Table
    • 作用：指定实体类和表之间的对应关系。
    • 属性：
      • name：指定数据库表的名称
  • @Id
    • 作用：指定当前字段是主键。
  • @GeneratedValue
    • 作用：指定主键的生成方式。。
    • 属性：
      • strategy ：指定主键生成策略。
  • @Column
    • 作用：指定实体类属性和数据库表之间的对应关系
    • 属性：
      • name：指定数据库表的列名称。
      • unique：是否唯一
      • nullable：是否可以为空
      • inserttable：是否可以插入
      • updateable：是否可以更新
      • columnDefinition: 定义建表时创建此列的DDL
      • secondaryTable: 从表名。如果此列不建在主表上（默认建在主表），该属性定义该列所在从表的名字搭建开发环境[重点

JPA核心配置文件

  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">
  7.     <!--配置持久化单元 
  8.         name：持久化单元名称 
  9.         transaction-type：事务类型
  10.              RESOURCE_LOCAL：本地事务管理 
  11.              JTA：分布式事务管理 -->
  12.     <persistence-unit name="myJpa" transaction-type="RESOURCE_LOCAL">
  13.         <!--配置JPA规范的服务提供商 -->
  14.         <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
  15.         <properties>
  16.             <!-- 数据库驱动 -->
  17.             <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver" />
  18.             <!-- 数据库地址 -->
  19.             <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/ssh" />
  20.             <!-- 数据库用户名 -->
  21.             <property name="javax.persistence.jdbc.user" value="root" />
  22.             <!-- 数据库密码 -->
  23.             <property name="javax.persistence.jdbc.password" value="111111" />
  25.             <!--jpa提供者的可选配置：我们的JPA规范的提供者为hibernate，所以jpa的核心配置中兼容hibernate的配 -->
  26.             <property name="hibernate.show_sql" value="true" />
  27.             <property name="hibernate.format_sql" value="true" />
  28.             <property name="hibernate.hbm2ddl.auto" value="create" />
  29.         </properties>
  30.     </persistence-unit>
  31. </persistence>

实现保存操作

  1. @Test
  2. public void test() {
  5.      // 1.创建实体管理类工厂，借助Persistence的静态方法获取，
  6.     //   其中传递的参数为持久化单元名称，需要jpa配置文件中指定
  7.     EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
  8.     // 2. 创建实体管理类
  9.     EntityManager em = factory.createEntityManager();
  10.     // 3. 获取事务对象
  11.     EntityTransaction tx = em.getTransaction();
  12.     // 4. 开启事务
  13.     tx.begin();
  14.     Customer c = new Customer();
  15.     c.setCustName("传智播客");
  16.     // 5. 保存操作
  17.     em.persist(c);
  18.     // 6. 提交事务
  19.     tx.commit();
  20.     // 7. 释放资源
  21.     em.close();
  22.     // 如果没有使用公共的实体管理工厂，则关闭
  23.     factory.close();
  24. }

JPA 中主键生成策略

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

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

**

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

    1. // 底层数据库必须支持自动增长
    2. @Id  
    3. @GeneratedValue(strategy = GenerationType.IDENTITY) 
    4. private Long custId;

  • SEQUENCE：根据底层数据库的序列来生成主键，条件是数据库支持序列。
     ```java // 适合Oracle @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;
}

  2. - **TABLE：使用一个特定的数据库表格来保存主键**
  3. ```java
  4. @Id  
  5. @GeneratedValue(strategy = GenerationType.TABLE, generator="payablemoney_gen")  
  6. @TableGenerator(name = "pk_gen",  
  7.     table="tb_generator",  
  8.     pkColumnName="gen_name",  
  9.     valueColumnName="gen_value",  
  10.     pkColumnValue="PAYABLEMOENY_PK",  
  11.     allocationSize=1  
  12. ) 
  13. private Long custId;
  16. //@TableGenerator的定义：
  17. @Target({TYPE, METHOD, FIELD})   
  18. @Retention(RUNTIME)  
  19. public @interface TableGenerator {  
  20.   //表示该表主键生成策略的名称，它被引用在@GeneratedValue中设置的“generator”值中
  21.   String name();  
  22.   //表示表生成策略所持久化的表名，例如，这里表使用的是数据库中的“tb_generator”。
  23.   String table() default "";  
  24.   //catalog和schema具体指定表所在的目录名或是数据库名
  25.   String catalog() default "";  
  26.   String schema() default "";  
  27.   //属性的值表示在持久化表中，该主键生成策略所对应键值的名称。例如在“tb_generator”中将“gen_name”作为主键的键值
  28.   String pkColumnName() default "";  
  29.   //属性的值表示在持久化表中，该主键当前所生成的值，它的值将会随着每次创建累加。例如，在“tb_generator”中将“gen_value”作为主键的值 
  30.   String valueColumnName() default "";  
  31.   //属性的值表示在持久化表中，该生成策略所对应的主键。例如在“tb_generator”表中，将“gen_name”的值为“CUSTOMER_PK”。 
  32.   String pkColumnValue() default "";  
  33.   //表示主键初识值，默认为0。 
  34.   int initialValue() default 0;  
  35.   //表示每次主键值增加的大小，例如设置成1，则表示每次创建新记录后自动加1，默认为50。
  36.   int allocationSize() default 50;  
  37.   UniqueConstraint[] uniqueConstraints() default {};  
  38. } 
  40. //这里应用表tb_generator，定义为 ：
  41. CREATE TABLE  tb_generator (  
  42.   id NUMBER NOT NULL,  
  43.   gen_name VARCHAR2(255) NOT NULL,  
  44.   gen_value NUMBER NOT NULL,  
  45.   PRIMARY KEY(id)  
  46. )

AUTO：主键由程序控制

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

JPA的API介绍

Persistence对象

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

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

EntityManagerFactory

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

  1. //创建实体管理类
  2. 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：回滚事务

    抽取JPAUtil工具类

    ```java package cn.itcast.dao;

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

  • 解决实体管理器工厂浪费资源和耗时问题
  • 通过静态代码块的形式，当程序第一次访问此工具类时，创建公共的实体管理工厂对象
  • 第一次访问getEntityManager方法；经过静态代码块创建一个factory对象，再调用方法创建一个EntityManger对象

  • 第二次访问getEntityManager方法；直接通过一个已经创建好的factory对象，创建EntityManager对象 */ public final class JPAUtil { // JPA的实体管理器工厂：相当于Hibernate的SessionFactory private static EntityManagerFactory em; // 使用静态代码块赋值 static {

    1.  // 注意：该方法参数必须和persistence.xml中persistence-unit标签name属性取值一致
    2.  em = Persistence.createEntityManagerFactory("myPersistUnit");

    }

    /**

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

      使用JPA完成增删改查操作

      保存

      ```java /**
    • 保存一个实体 */ @Test public void testAdd() { // 定义对象 Customer c = new Customer(); c.setCustName(“传智学院”); c.setCustLevel(“VIP客户”); c.setCustSource(“网络”); c.setCustIndustry(“IT教育”); c.setCustAddress(“昌平区北七家镇”); c.setCustPhone(“010-84389340”); EntityManager em = null; EntityTransaction tx = null; try {
      1.  // 获取实体管理对象
      2.  em = JPAUtil.getEntityManager();
      3.  // 获取事务对象
      4.  tx = em.getTransaction();
      5.  // 开启事务
      6.  tx.begin();
      7.  // 执行操作
      8.  em.persist(c);
      9.  // 提交事务
      10.  tx.commit();
      } catch (Exception e) {
      1.  // 回滚事务
      2.  tx.rollback();
      3.  e.printStackTrace();
      } finally {
      1.  // 释放资源
      2.  em.close();
      } }
  1. <a name="snMkx"></a>
  2. #### 修改
  3. ```java
  4. @Test
  5. public void testMerge(){  
  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.         c1.setCustName("江苏传智学院");
  19.         em.clear();//把c1对象从缓存中清除出去
  20.         em.merge(c1);
  21.         //提交事务
  22.         tx.commit(); 
  23.     }catch(Exception e){
  24.         //回滚事务
  25.         tx.rollback();
  26.         e.printStackTrace();  
  27.     }finally{  
  28.         //释放资源
  29.         em.close();  
  30.     }    
  31. }

删除

  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. }

根据id查询

  1. /**
  2.  * 查询一个： 使用立即加载的策略
  3.  * find 方法查询：
  4.  * 1. 调用find方法，就会发送sql语句  立即加载
  5.  * 2. 查询对象就是当前对象本身
  6.  */
  7. @Test
  8. public void testGetOne() {
  9.     // 定义对象
  10.     EntityManager em = null;
  11.     EntityTransaction tx = null;
  12.     try {
  13.         // 获取实体管理对象
  14.         em = JPAUtil.getEntityManager();
  15.         // 获取事务对象
  16.         tx = em.getTransaction();
  17.         // 开启事务
  18.         tx.begin();
  19.         // 执行操作
  20.         Customer c1 = em.find(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. }
  34. // 查询实体的缓存问题
  35. /**
  36.  * getReference方法
  37.  * 1. 获取对象是一个动态代理对象
  38.  * 2. 调用getReference 方法不会立即发送sql语句
  39.         当调用查询结果对象的时候，才会发送查询的sql语句，  懒加载
  40.  */
  41. @Test
  42. public void testGetOne() {
  43.     // 定义对象
  44.     EntityManager em = null;
  45.     EntityTransaction tx = null;
  46.     try {
  47.         // 获取实体管理对象
  48.         em = JPAUtil.getEntityManager();
  49.         // 获取事务对象
  50.         tx = em.getTransaction();
  51.         // 开启事务
  52.         tx.begin();
  53.         // 执行操作
  54.         Customer c1 = em.find(Customer.class, 1L);
  55.         Customer c2 = em.find(Customer.class, 1L);
  56.         System.out.println(c1 == c2);// 输出结果是true，EntityManager也有缓存
  57.         // 提交事务
  58.         tx.commit();
  59.         System.out.println(c1);
  60.     } catch (Exception e) {
  61.         // 回滚事务
  62.         tx.rollback();
  63.         e.printStackTrace();
  64.     } finally {
  65.         // 释放资源
  66.         em.close();
  67.     }
  68. }

JPA中的复杂查询

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

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

查询全部

  1.     //查询所有客户
  2.     @Test
  3.     public void findAll() {
  4.         EntityManager em = null;
  5.         EntityTransaction tx = null;
  6.         try {
  7.             //获取实体管理对象
  8.             em = JPAUtil.getEntityManager();
  9.             //获取事务对象
  10.             tx = em.getTransaction();
  11.             tx.begin();
  12.             // 创建query对象
  13.             String jpql = "from Customer";
  14.             Query query = em.createQuery(jpql);
  15.             // 查询并得到返回结果
  16.             List list = query.getResultList(); // 得到集合返回类型
  17.             for (Object object : list) {
  18.                 System.out.println(object);
  19.             }
  20.             tx.commit();
  21.         } catch (Exception e) {
  22.             // 回滚事务
  23.             tx.rollback();
  24.             e.printStackTrace();
  25.         } finally {
  26.             // 释放资源
  27.             em.close();
  28.         }
  29.     }

分页查询

  1. //分页查询客户
  2. @Test
  3. public void findPaged () {
  4.     EntityManager em = null;
  5.     EntityTransaction tx = null;
  6.     try {
  7.         //获取实体管理对象
  8.         em = JPAUtil.getEntityManager();
  9.         //获取事务对象
  10.         tx = em.getTransaction();
  11.         tx.begin();
  13.         //创建query对象
  14.         String jpql = "from Customer";
  15.         Query query = em.createQuery(jpql);
  16.         //起始索引
  17.         query.setFirstResult(0);
  18.         //每页显示条数
  19.         query.setMaxResults(2);
  20.         //查询并得到返回结果
  21.         List list = query.getResultList(); //得到集合返回类型
  22.         for (Object object : list) {
  23.             System.out.println(object);
  24.         }
  25.         tx.commit();
  26.     } catch (Exception e) {
  27.         // 回滚事务
  28.         tx.rollback();
  29.         e.printStackTrace();
  30.     } finally {
  31.         // 释放资源
  32.         em.close();
  33.     }
  34. }

条件查询

  1. //条件查询
  2. @Test
  3. public void findCondition () {
  4.     EntityManager em = null;
  5.     EntityTransaction tx = null;
  6.     try {
  7.         //获取实体管理对象
  8.         em = JPAUtil.getEntityManager();
  9.         //获取事务对象
  10.         tx = em.getTransaction();
  11.         tx.begin();
  12.         //创建query对象
  13.         String jpql = "from Customer where custName like ? ";
  14.         Query query = em.createQuery(jpql);
  15.         //对占位符赋值，从1开始
  16.         query.setParameter(1, "传智播客%");
  17.         //查询并得到返回结果
  18.         Object object = query.getSingleResult(); //得到唯一的结果集对象
  19.         System.out.println(object);
  20.         tx.commit();
  21.     } catch (Exception e) {
  22.         // 回滚事务
  23.         tx.rollback();
  24.         e.printStackTrace();
  25.     } finally {
  26.         // 释放资源
  27.         em.close();
  28.     }
  29. }

排序查询

  1. //根据客户id倒序查询所有客户
  2. //查询所有客户
  3. @Test
  4. public void testOrder() {
  5.     EntityManager em = null;
  6.     EntityTransaction tx = null;
  7.     try {
  8.         //获取实体管理对象
  9.         em = JPAUtil.getEntityManager();
  10.         //获取事务对象
  11.         tx = em.getTransaction();
  12.         tx.begin();
  13.         // 创建query对象
  14.         String jpql = "from Customer order by custId desc";
  15.         Query query = em.createQuery(jpql);
  16.         // 查询并得到返回结果
  17.         List list = query.getResultList(); // 得到集合返回类型
  18.         for (Object object : list) {
  19.             System.out.println(object);
  20.         }
  21.         tx.commit();
  22.     } catch (Exception e) {
  23.         // 回滚事务
  24.         tx.rollback();
  25.         e.printStackTrace();
  26.     } finally {
  27.         // 释放资源
  28.         em.close();
  29.     }
  30. }

统计查询

  1. //统计查询
  2. @Test
  3. public void findCount() {
  4.     EntityManager em = null;
  5.     EntityTransaction tx = null;
  6.     try {
  7.         //获取实体管理对象
  8.         em = JPAUtil.getEntityManager();
  9.         //获取事务对象
  10.         tx = em.getTransaction();
  11.         tx.begin();
  12.         // 查询全部客户
  13.         // 1.创建query对象
  14.         String jpql = "select count(custId) from Customer";
  15.         Query query = em.createQuery(jpql);
  16.         // 2.查询并得到返回结果
  17.         Object count = query.getSingleResult(); // 得到集合返回类型
  18.         System.out.println(count);
  19.         tx.commit();
  20.     } catch (Exception e) {
  21.         // 回滚事务
  22.         tx.rollback();
  23.         e.printStackTrace();
  24.     } finally {
  25.         // 释放资源
  26.         em.close();
  27.     }
  28. }