JPA的使用

一、maven工程搭建

基于IDEA开发工具

jpa项目结构.png

1). maven坐标 pom.xml

<packaging>jar</packaging>

<properties>
    <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>

2). resources/META-INF/persistence.xml

jpa规定的文件目录和文件名！

<?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>
            <!--
            数据库信息
            用户名，javax.persistence.jdbc.user
            密码，  javax.persistence.jdbc.password
            驱动，  javax.persistence.jdbc.driver
            数据库地址   javax.persistence.jdbc.url
            -->
            <property name="javax.persistence.jdbc.user" value="root"/>
            <property name="javax.persistence.jdbc.password" value="abc123"/>
            <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql:///jpa"/>

            <!--
            配置jpa实现方(hibernate)的配置信息
            hibernate.show_sql是否在控制台显示sql ：
              false
              true
            hibernate.hbm2ddl.auto自动创建数据库表
              create : 程序运行时创建数据库表（了解，如果有表，先删除表再创建）
              update : 程序运行时创建表（了解，如果有表，不会创建表）
              none   : 不会创建表【实际开发中使用】
            -->
            <property name="hibernate.show_sql" value="true" />
            <property name="hibernate.hbm2ddl.auto" value="none" />
        </properties>
    </persistence-unit>
</persistence>

3). 数据库准备

CREATE DATABASE IF NOT EXISTS jpa DEFAULT CHARACTER SET utf8;
USE jpa;

/*创建客户表*/
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;

二、实体类关系映射配置详解 Customer

所有的注解都是使用JPA的规范提供的注解，在导入注解包的时候，一定要导入javax.persistence下的

package com.lingting.pojo;

import javax.persistence.*;

/**
 *
 * 实体类，配置映射关系
 *   1.实体类和表的映射关系注解
 *      @Entity: 声明当前类是实体类
 *      @Table : 配置实体类和表的映射关系
 *          name : 配置数据库表的名称
 *   2.实体类中属性和表中字段的映射关系
 */
@Entity
@Table(name = "cst_customer")
public class Customer {

/** @GeneratedValue:配置主键的生成策略，strategy 值如下：
*
* GenerationType.IDENTITY ：自增，mysql
*   底层数据库必须支持自动增长（底层数据库支持的自动增长方式，对id自增）：注解用法
*      @Id
*      @GeneratedValue(strategy = GenerationType.IDENTITY)
*      @Column(name = "cust_id")
*      ...
*
* GenerationType.SEQUENCE : 序列，oracle
*   底层数据库必须支持序列：用法
*      @Id
*      @GeneratedValue(strategy = GenerationType.SEQUENCE,generator="payablemoney_seq")
*      @SequenceGenerator(name="payablemoney_seq", sequenceName="seq_payment")
*      ...
*
*      SequenceGenerator注解字段源码含义
*         String name();
*            表示该表主键生成策略的名称，它被引用在@GeneratedValue中设置的“generator”值中
*         String sequenceName() default "";
*            属性表示生成策略用到的数据库序列名称。
*         int initialValue() default 0;
*            表示主键初识值，默认为0
*         int allocationSize() default 50;
*            表示每次主键值增加的大小，例如设置1，则表示每次插入新记录后自动加1，默认为50
*
* GenerationType.AUTO ：
*   由程序自动的帮助我们选择主键生成策略: 用法
*      @Id
*      @GeneratedValue(strategy = GenerationType.AUTO)
*      ...
*
* GenerationType.TABLE :
*   jpa提供的一种机制，通过一张数据库表的形式帮助我们完成主键自增，用法
*      @Id
*      @GeneratedValue(strategy = GenerationType.TABLE, generator="pk_gen")
*      @TableGenerator(name = "pk_gen",
*          table="tb_generator",    // 表名
*          pkColumnName="gen_name", // 主键生成策略所对应键值 字段名
*          pkColumnValue="PAYABLEMOENY_PK", // 主键的值
*          valueColumnName="gen_value", // 主键生成的值，会累加
*          allocationSize=1 // 主键生成的值累加的步长
*      )
*      ...
*
*      TableGenerator注解字段源码含义
*          String name();
*             表示该表主键生成策略的名称，它被引用在@GeneratedValue中设置的“generator”值中
*          String table() default "";
*             表示表生成策略所持久化的表名，例如，这里表使用的是数据库中的“tb_generator”。
*          String catalog() default "";
*             String schema() default "";
*          catalog和schema具体指定表所在的目录名或是数据库名
*          String pkColumnName() default "";
*              属性的值表示在持久化表中，该主键生成策略所对应键值的名称。
*              例如在“tb_generator”中将“gen_name”作为主键的键值
*          String pkColumnValue() default "";
*              属性的值表示在持久化表中，该生成策略所对应的主键。
*              例如在“tb_generator”表中，将“gen_name”的值为“CUSTOMER_PK”。
*          String valueColumnName() default "";
*              属性的值表示在持久化表中，该主键当前所生成的值，它的值将会随着每次创建累加。
*              例如，在“tb_generator”中将“gen_value”作为主键的值
*          int initialValue() default 0;
*              表示主键初识值，默认为0。
*          int allocationSize() default 50;
*              表示每次主键值增加的大小，例如设置成1，则表示每次创建新记录后自动加1，默认为50。
*          UniqueConstraint[] uniqueConstraints() default {};
*/
    @Id // 声明主键的配置
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "cust_id") // 配置属性和字段的映射关系
    private Long custId; // 客户主键

    /**
     * @Column:配置属性和字段的映射关系
     *    name：数据库表中字段的名称
     *    unique：是否唯一
     *    nullable：是否可以为空
     *    inserttable：是否可以插入
     *    updateable：是否可以更新
     *    columnDefinition: 定义建表时创建此列的DDL
     *    secondaryTable: 从表名。如果此列不建在主表上（默认建在主表），
     *         该属性定义该列所在从表的名字搭建开发环境
     */
    @Column(name = "cust_name")
    private String custName;//客户名称

    @Column(name="cust_source")
    private String custSource;//客户来源

    @Column(name="cust_level")
    private String custLevel;//客户级别

    @Column(name="cust_industry")
    private String custIndustry;//客户所属行业

    @Column(name="cust_phone")
    private String custPhone;//客户的联系方式

    @Column(name="cust_address")
    private String custAddress;//客户地址

    /* get/set/toString方法请自动生成！ */
}

三、抽离jpa工厂创建 JpaUtils

实体管理器工厂 是一个线程安全的类！通过静态代码块的形式，工具类在初始化时，创建一个公共的实体管理器工厂对象

package com.lingting.utils;

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


public class JpaUtils {

    private static EntityManagerFactory factory;

    static {
        // 加载配置文件, 创建工厂对象，指定【持久化单元】配置，见META-INF/persistence.xml文件
        factory = Persistence.createEntityManagerFactory("myJpa");
    }

    /**
     * 获取EntityManger对象: 完成持久化操作的核心对象
     * 让实体类与底层数据源进行O/R映射管理：方法说明
     *    getTransaction : 获取事务对象
     *    persist ： 保存操作
     *    merge ： 更新操作
     *    remove ： 删除操作
     *    find ： 根据id查询：立即查询
     *    getReference ： 根据id查询：延迟查询，
     *        返回实体类pojo的一个代理对象；
     *        没有真正查询；只是增强了各个get方法；(切面)
     *        在执行get方法之前调用【一次数】据库查询！
     *        之后的调用则不会去查询！
     *   获取事务对象EntityTransaction：
     *   EntityManger对象.getTransaction()：方法概述
     *     begin：开启事务
     *     commit：提交事务
     *     rollback：回滚事务
     */
    public static EntityManager getEntityManager() {
        return factory.createEntityManager();
    }

    /**
     * 归还资源
     */
    public static void close(EntityManager entityManager) {
        entityManager.close();
    }

    /**
     * 彻底关闭资源
     * @param entityManager
     */
    public static void closeFactory(EntityManager entityManager) {
        close(entityManager);
        factory.close();
    }
}

四、jpa基本增删改查

1. JpaTest/JpqlTest测试类模板

package com.lingting.test;

import com.lingting.pojo.Customer;
import com.lingting.utils.JpaUtils;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import javax.persistence.EntityManager;
import javax.persistence.EntityTransaction;

/**
 * 测试jpa 一般步骤
 * 1. 加载配置文件， 创建 实体管理器工厂对象(线程安全，静态)【交给工具类完成】
 * 2. 通过工厂获取实体类管理器
 * 3. 获取事务，开启事务
 * 4. 增删改查
 * 5. 提交事务/回滚事务
 * 6. 释放资源
 */
public class JpaTest { // 或者为JpqlTest类

    private EntityManager em;

    private EntityTransaction tx;

    @Before
    public void init() {
        em = JpaUtils.getEntityManager();
        tx = em.getTransaction();
    }

    /** 以下代码写在此处 */
}

2). 增

/**
 * 增
 */
@Test
public void persist() {
    // 开启事务
    tx.begin();

    // 创建实体类，进行保存
    Customer customer = new Customer();
    customer.setCustName("星环城");
    customer.setCustIndustry("太空能源开发");

    // 保存
    em.persist(customer);

    // 提交事务
    tx.commit();

    // 释放资源
    em.close();
}

3). 改

/**
 * 改: 根据id修改,null值会覆盖原有值
 */
@Test
public void merge() {
    tx.begin();
    Customer customer = em.find(Customer.class, 1L);
    customer.setCustName("新星环城");
    customer.setCustIndustry("太空能源开发");
    // 清空缓存，把customer对象从缓存中清除
    em.clear();
    em.merge(customer);
    tx.commit();
    em.close();
}

4). 删

/**
 * 删除：根据id进行删除
 */
@Test
public void remove() {
    tx.begin();
    try {
        Customer customer = em.find(Customer.class, 1L);

        /* ~~~~ 清空id，清空缓存，再删除会失败 ~~~~
        customer.setCustId(null);
        em.clear();
        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */

        em.remove(customer);
        tx.commit();
    } catch (Exception e) {
        tx.rollback();
    } finally {
        em.close();
    }
}

5). 查

/**
 * 立即查询：根据id查询客户
 * 查询不需要事务吧！
 */
@Test
public void find() {
    // 第一个参数为pojo字节码对象，第二个为id
    Customer customer = em.find(Customer.class, 1L);
    System.out.println(customer);
    em.close();
}

/**
 * 懒加载（延迟加载）：动态代理
 * 返回pojo的动态代理类，在get等方法中配置查询数据库的切面，
 * 只有第一次调用时回去查询！
 */
@Test
public void getReference() {
    Customer reference = em.getReference(Customer.class, 2L);
    System.out.println(reference);
    em.close();
}

/**
 * EntityManager 的实体缓存现象！
 */
@Test
public void cache() {
    Customer c1 = em.find(Customer.class, 2L);
    Customer c2 = em.find(Customer.class, 2L);
    System.out.println(c1 == c2);
    // 清空缓存，对象就不一样了！
    em.clear();
    Customer c3 = em.find(Customer.class, 3L);
    System.out.println(c2 == c3);
}

五、jpql复杂查询 JpqlTest

test模板如上 四、...

1). 查询全部

/**
 * 查询全部: jpql 不支持 `select *`
 * sql：SELECT * FROM cst_customer
 * jqpl：from cn.itcast.domain.Customer
 * 或者简写包名
 */
@Test
public void findAll() {
    String jpql = "from Customer";

    // 创建Query查询对象，query对象才是指定jpql的对象
    Query query = em.createQuery(jpql);

    // 发送查询，并封装结果集
    List list = query.getResultList();
    list.forEach(System.out::println);

    em.close();
}

2). 分页 + 倒叙

/**
 * 分页查询 + 倒叙查询【先倒叙，后分页；如果要反过来，需要进行复杂查询，jpa的方式很麻烦】
 * sql：select * from cst_customer ORDER BY cust_id DESC limit ?,?
 * jqpl : from Customer order by custId desc
 */
@Test
public void pageQuery() {

    String jpql = "from Customer order by custId desc";
    Query query = em.createQuery(jpql);

    // 偏移量 = (查询页码 - 1) * 每页条数
    query.setFirstResult((2 - 1) * 2);

    // 每页查询的条数
    query.setMaxResults(2);

    /**
     * getResultList ： 直接将查询结果封装为list集合
     * getSingleResult : 得到唯一的结果集
     */
    List list = query.getResultList();
    list.forEach(System.out::println);
    em.close();
}

3). 条件查询

/**
 * 条件查询：以 “新” 开头的客户
 * sql：SELECT * FROM cst_customer WHERE cust_name LIKE  ?
 * jpql : from Customer where custName like ?
 */
@Test
public void conditionQuery() {
    String jpql = "from Customer where custName like ?";
    Query query = em.createQuery(jpql);

    // 设置参数
    query.setParameter(1, "新%");
    List list = query.getResultList();
    list.forEach(System.out::println);
    em.close();
}

3). 聚合查询

/**
 * 聚合查询，统计总数
 * sql：SELECT COUNT(cust_id) FROM cst_customer
 * jpql：select count(custId) from Customer
 */
@Test
public void aggregationQuery() {
    String jpql = "select count(custId) from Customer";
    Query query = em.createQuery(jpql);
    Object singleResult = query.getSingleResult();
    System.out.println(singleResult);
    em.close();
}