简单的说，ORM是通过使用描述对象和数据库之间映射的元数据，将java程序中的对象自动持久化到关系数据库中。本质上就是将数据从一种形式转换到另外一种形式。将实体类与数据库表做队形，实体类中的属性与数据库中的字段做对应。这样就不用直接操作数据库，写SQL语句了，直接使用面向对象的技术，对象名.方法（）,就可以实现对数据的增删改查等。

二、JPA规范

JPA是Java Persistence API的简称，中文名Java持久层API，是JDK 5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。

JPA （Java Persistence API） Java持久化API。是一套Java官方制定的ORM 方案。

JPA是一种规范，一种标准，具体的操作交给第三方框架去实现，比如说Hibernate，OpenJPA等。

Sun引入新的JPA ORM规范出于两个原因：

其一，简化现有Java EE和Java SE应用开发工作；其二，Sun希望整合ORM技术，实现天下归一。

三、搭建JPA的基础环境

1.创建数据库表

  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;

2.创建Maven工程导入坐标

 <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <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>5.1.6</version>
        </dependency>
    </dependencies>

3.创建JPA的核心配置文件

位置：配置到类路径下的一个叫做 META-INF 的文件夹下

命名：persistence.xml

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="2.0">
    <!--需要配置persistence-unit节点
        持久化单元：
        name:持久化单元名称
        transaction-type:事务管理方式
            JTA： 分布式事务管理
            RESOURCE_LOCAL: 本地事务管理
    -->
    <persistence-unit name="myJpa" transaction-type="RESOURCE_LOCAL">
        <!--jpa的实现方式-->
        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
        <!--数据库信息-->
        <!--可选配置：配置jpa实现方的配置信息-->
        <properties>
            <!--数据库信息-->
            <property name="javax.persistence.jdbc.user" value="root"/>
            <property name="javax.persistence.jdbc.password" value="root"/>
            <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/jpa"/>

            <!--可选配置：配置jpa实现方的配置信息
                显示SQL       ：false,true

                自动创建数据库表：hibernate.hbm2ddl.auto
                        create:程序运行时创建数据库表，如果有表，先删除表再创建表
                        update:程序运行时创建数据库表，如果有表，不会创建表
                        none:不会创建表
            -->
            <property name="hibernate.show_sql" value="true"/>
            <property name="hibernate.hbm2ddl.auto" value="update"/>

        </properties>

    </persistence-unit>

</persistence>

4.编写实体类，配置映射关系

实体与表的映射和实体类属性与表字段的映射

配置映射关系 1.实体类和表的映射关系 @Entity 声明是实体类 @Table(name = "cst_customer") 实体类与表的映射关系，name配置表的名称 2.实体类中属性和表字段的映射关系 @Column(name = "cust_id") @GeneratedValue:配置主键的生成策略 strategy GenerationType.IDENTITY ：自增，mysql * 底层数据库必须支持自动增长（底层数据库支持的自动增长方式，对id自增） GenerationType.SEQUENCE : 序列，oracle * 底层数据库必须支持序列 GenerationType.TABLE : jpa提供的一种机制，通过一张数据库表的形式帮助我们完成主键自增 * GenerationType.AUTO ：由程序自动的帮助我们选择主键生成策略

/**
* @Author: Promsing(张有博)
* @Date: 2021/10/13 - 17:29
* @Description: 客户的实体类
* @version： 1.0
*/
@Entity
@Table(name = "cst_customer")
public class Customer {
/**
* @Id：声明主键的配置
* @GeneratedValue:配置主键的生成策略
*      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 id;//主键
@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 = "cost_phone")
private String custPhone;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getCustName() {
return custName;
}
public void setCustName(String custName) {
this.custName = custName;
}
public String getCustSource() {
return custSource;
}
public void setCustSource(String custSource) {
this.custSource = custSource;
}
public String getCustIndustry() {
return custIndustry;
}
public void setCustIndustry(String custIndustry) {
this.custIndustry = custIndustry;
}
public String getCustLevel() {
return custLevel;
}
public void setCustLevel(String custLevel) {
this.custLevel = custLevel;
}
public String getCustAddress() {
return custAddress;
}
public void setCustAddress(String custAddress) {
this.custAddress = custAddress;
}
public String getCustPhone() {
return custPhone;
}
public void setCustPhone(String custPhone) {
this.custPhone = custPhone;
}
@Override
public String toString() {
return "Customer{" +
"id=" + id +
", custName='" + custName + '\'' +
", custSource='" + custSource + '\'' +
", custIndustry='" + custIndustry + '\'' +
", custLevel='" + custLevel + '\'' +
", custAddress='" + custAddress + '\'' +
", custPhone='" + custPhone + '\'' +
'}';
}
}

四、入门案例–增删改查

1.jpa的操作步骤

1.加载配置文件创建工厂（实体管理类工厂）对象 2.通过实体管理类工厂获取实体管理类 3.获取事务对象，开启事务 4.完成增删改查 5.提交事务（回滚事务） 6.释放资源

2.基本操作的详细介绍

1.加载配置文件创建实体管理器工厂

EntityManagerFactory myJpa = Persistence.createEntityManagerFactory("myJpa");

根据持久化单元名称创建实体管理器工厂，持久化单元名称就是配置文件中 persistence-unit的name属性

2.根据实体管理器工厂，创建实体管理器

//通过实体管理器工厂获取实体管理器
EntityManager em = myJpa.createEntityManager();

EntityManager内部维护的很多的内容内部维护了数据库信息，维护了缓存信息维护了所有的实体管理器对象

EntityManagerFactory是一个线程安全的对象

3.创建事务对象，开启事务

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

Transaction 对象：事务 begin：开启事务 commit：提交事务 rollback：回滚

4.增删改查操作

presist ：保存 merge ：更新 remove ：删除 find/getRefrence ：根据id查询

5.提交事务或者回滚事务

tx.commit();
tx.rollback();

6.释放资源

//先申请的后释放
//先释放实体管理器--EntityManager
//后释放实体管理器工厂--EntityManagerFactory

五、代码实战

使用JPA封装好的方法

/**
* @Author: Promsing(张有博)
* @Date: 2021/10/16 - 8:41
* @Description: jpa的测试类，完成增删改查操作
* @version： 1.0
*/
public class JpaTest {
/**
* 保存操作
*   persist(Object)
*
*/
@Test
public void testSave(){
//1.加载配置文件创建工厂对象
EntityManagerFactory myJpa = Persistence.createEntityManagerFactory("myJpa");
//2.通过实体管理器工厂获取实体管理器
EntityManager em = myJpa.createEntityManager();
//3.获取事务对象，开启事务
EntityTransaction tx = em.getTransaction();
tx.begin();
//4.完成增删改查操作
Customer customer=new Customer();
customer.setCustName("小小张自由");
customer.setCustAddress("廊坊");
customer.setCustIndustry("教育");
customer.setCustLevel("高级");
customer.setCustPhone("1502800");
customer.setCustSource("邯郸");
//5.保存，提交事务
em.persist(customer);
tx.commit();
//7.释放资源
em.close();
myJpa.close();
}
/**
* 根据id查询
*   find(需要封装实体类的字节码文件，主键值)
*     立即加载，获取实体对象，立即执行SQL语句，查询数据库
*/
@Test
public void testFind(){
//1.加载配置文件创建工厂对象
EntityManagerFactory myJpa = Persistence.createEntityManagerFactory("myJpa");
//2.通过实体管理器工厂获取实体管理器
EntityManager em = myJpa.createEntityManager();
//3.获取事务对象，开启事务
EntityTransaction tx = em.getTransaction();
tx.begin();
//4.完成增删改查操作
/**
* find(需要封装实体类的字节码文件，主键值)
* 立即加载，获取实体对象，立即执行SQL语句，查询数据库
*/
Customer customer = em.find(Customer.class, 2L);
System.out.println(customer);
//5.保存，提交事务
tx.commit();
//7.释放资源
em.close();
myJpa.close();
}
/**
* 根据id查询
*  getReference(需要封装实体类的字节码文件，主键值)
*   延迟加载（懒加载），获取动态代理对象，延迟执行SQL语句，
*   当使用到代理对象时，查询数据库
*/
@Test
public void testReference(){
//1.加载配置文件创建工厂对象
EntityManagerFactory myJpa = Persistence.createEntityManagerFactory("myJpa");
//2.通过实体管理器工厂获取实体管理器
EntityManager em = myJpa.createEntityManager();
//3.获取事务对象，开启事务
EntityTransaction tx = em.getTransaction();
tx.begin();
//4.完成增删改查操作
/**
* getReference(需要封装实体类的字节码文件，主键值)
* 延迟加载，获取动态代理对象，延迟执行SQL语句，
* 当使用到代理对象时，查询数据库
*/
Customer customer = em.getReference(Customer.class, 2L);
System.out.println(customer);
//5.保存，提交事务
tx.commit();
//7.释放资源
em.close();
myJpa.close();
}
/**
* 删除客户的案例
*  remove(Object)
*/
@Test
public void testRemove(){
//1.加载配置文件创建工厂对象
EntityManagerFactory myJpa = Persistence.createEntityManagerFactory("myJpa");
//2.通过实体管理器工厂获取实体管理器
EntityManager em = myJpa.createEntityManager();
//3.获取事务对象，开启事务
EntityTransaction tx = em.getTransaction();
tx.begin();
//4.完成增删改查操作
//根据id先查询用户
Customer customer = em.find(Customer.class, 2L);
//调用remove方法，完成删除操作
em.remove(customer);
//5.保存，提交事务
tx.commit();
//7.释放资源
em.close();
myJpa.close();
}
/**
* 更新客户的案例
*   merge(Object)
*/
@Test
public void testUpdate(){
//1.加载配置文件创建工厂对象
EntityManagerFactory myJpa = Persistence.createEntityManagerFactory("myJpa");
//2.通过实体管理器工厂获取实体管理器
EntityManager em = myJpa.createEntityManager();
//3.获取事务对象，开启事务
EntityTransaction tx = em.getTransaction();
tx.begin();
//4.完成增删改查操作
//根据id先查询用户
Customer customer = em.find(Customer.class, 1L);
//调用remove方法，完成删除操作
customer.setCustIndustry("架构师");
em.merge(customer);
//5.保存，提交事务
tx.commit();
//7.释放资源
em.close();
myJpa.close();
}
}

使用JPQL查询

JPQL(Java持久性查询语言)是一种面向对象的查询语言，用于对持久实体执行数据库操作。 JPQL不使用数据库表，而是使用实体对象模型来操作SQL查询。旨在以面向对象表达式语言的表达式，将SQL语法和简单查询语义绑定在一起·使用这种语言编写的查询是可移植的，可以被编译成所有主流数据库服务器上的SQL。

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

package com.dynamic.test;
import org.junit.Before;
import org.junit.Test;
import javax.persistence.*;
import java.util.List;
/**
* @Author: Promsing(张有博)
* @Date: 2021/10/17 - 9:48
* @Description: JPQL的测试类
* @version： 1.0
*/
public class JpqlTest {
private EntityManager em;
@Before
public void testBefore(){
//1.加载配置文件创建工厂对象
EntityManagerFactory myJpa = Persistence.createEntityManagerFactory("myJpa");
//2.通过实体管理器工厂获取实体管理器
em = myJpa.createEntityManager();
}
/**
* 查询全部
*  sql:SELECT * FROM `cst_customer`
*  jqpl:from com.dynamic.domain.Customer 或者from Customer
*/
@Test
public void testFindAll(){
//将第一第二步封装起来，
//在@test执行之前执行Before
//3.获取事务对象，开启事务
EntityTransaction tx = em.getTransaction();
tx.begin();
//4.完成增删改查操作
String jqpl="from com.dynamic.domain.Customer";
Query query = em.createQuery(jqpl);
//发送查询，并封装结果集
List resultList = query.getResultList();
for (Object o : resultList) {
System.out.println(o);
System.out.println();
}
//5.提交事务
tx.commit();
//7.释放资源
em.close();
//        myJpa.close();
}
/**
* 排序查询，根据id倒叙
*  sql:SELECT * FROM `cst_customer` ORDER BY cust_id desc ;
*  jqpl:from Customer order by custId desc
*/
@Test
public void testOrders(){
//将第一第二步封装起来，
//在@test执行之前执行Before
//3.获取事务对象，开启事务
EntityTransaction tx = em.getTransaction();
tx.begin();
//4.完成增删改查操作
String jqpl="from Customer order by id desc";
Query query = em.createQuery(jqpl);
//发送查询，并封装结果集
List resultList = query.getResultList();
for (Object o : resultList) {
System.out.println(o);
System.out.println();
}
//5.提交事务
tx.commit();
//7.释放资源
em.close();
//        myJpa.close();
}
/**
* 统计查询，使用count
*  sql:SELECT COUNT(cust_id) FROM `cst_customer`;
*  jqpl:SELECT COUNT(id) FROM Customer
*/
@Test
public void testCount(){
//将第一第二步封装起来，
//在@test执行之前执行Before
//3.获取事务对象，开启事务
EntityTransaction tx = em.getTransaction();
tx.begin();
//4.完成增删改查操作
String jqpl="SELECT COUNT(id) FROM Customer";
Query query = em.createQuery(jqpl);
//发送查询，并封装结果集
Object singleResult = query.getSingleResult();
System.out.println(singleResult);
//5.提交事务
tx.commit();
//7.释放资源
em.close();
//        myJpa.close();
}
/**
* 分页查询
*   SQL语句：SELECT * FROM `cst_customer` LIMIT 0,2
*   jpql语句：使用Query对象
*/
@Test
public void testPaged(){
//将第一第二步封装起来，
//在@test执行之前执行Before
//3.获取事务对象，开启事务
EntityTransaction tx = em.getTransaction();
tx.begin();
//4.完成增删改查操作
String jqpl="from Customer";
Query query = em.createQuery(jqpl);
//起始索引
query.setFirstResult(0);
//每次查询的长度
query.setMaxResults(2);
//发送查询，并封装结果集
List resultList = query.getResultList();
for (Object o : resultList) {
System.out.println(o);
}
//5.提交事务
tx.commit();
//7.释放资源
em.close();
//        myJpa.close();
}
/**
* 条件查询
*   SQL语句：SELECT * FROM `cst_customer` where cust_name LIKE '%自由%'
*   jpql语句：from Customer where custName like ?
*/
@Test
public void testCondition(){
//将第一第二步封装起来，
//在@test执行之前执行Before
//3.获取事务对象，开启事务
EntityTransaction tx = em.getTransaction();
tx.begin();
//4.完成增删改查操作
String jqpl="from Customer where custName like ?";
Query query = em.createQuery(jqpl);
//给占位符赋值，占位符从1开始
query.setParameter(1,"%自由%");
//发送查询，并封装结果集
List resultList = query.getResultList();
for (Object o : resultList) {
System.out.println(o);
}
//5.提交事务
tx.commit();
//7.释放资源
em.close();
//        myJpa.close();
}
}