JPA第一天

学于黑马和传智播客联合做的教学项目感谢

黑马官网

 传智播客官网

微信搜索"艺术行者"，关注并回复关键词"springdata"获取视频和教程资料！

b站在线视频

第一章 ORM概述(了解)

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

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

JPA类比JDBC：

1.1 为什么使用ORM

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

1.2 常见的ORM框架

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

第二章 hibernate与JPA的概述

2.1 hibernate概述

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

2.2 JPA概述

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

JPA通过JDK 5.0注解描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。

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是EJBQL的一种扩展，它是针对实体的一种查询语言，操作对象是实体，而不是关系数据库的表，而且能够支持批量更新和修改、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作为其实现类完成数据持久化工作。

第三章 JPA的入门案例

3.1 需求介绍

本章节我们是实现的功能是保存一个客户到数据库的客户表中。

3.2 开发包介绍

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

下载网址

页面显示如下图：

3.3 搭建开发环境(重点)

3.3.1 导入jar包

对于JPA操作，只需要从hibernate提供的资料中找到我们需要的jar导入到工程中即可

传统工程导入jar包

maven工程导入坐标

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

3.3.2 创建客户的数据库表和客户的实体类

package org.example.domain;

import java.io.Serializable;

/**

 * @author HackerStar

 * @create 2020-05-15 16:29

 */

public class Customer implements Serializable {

    private Long custId;//客户编号(主键)

    private String custName;//客户名称(公司名称)

    private  String custSource;//客户信息来源

    private String custIndustry;//客户所属行业

    private String custLevel;//客户级别

    private String custAddress;//客户联系地址

    private String custPhone;//客户联系电话

    @Override

    public String toString() {

        return "Customer{" +

                "custId=" + custId +

                ", custName='" + custName + '\'' +

                ", custSource='" + custSource + '\'' +

                ", custIndustry='" + custIndustry + '\'' +

                ", custLevel='" + custLevel + '\'' +

                ", custAddress='" + custAddress + '\'' +

                ", custPhone='" + custPhone + '\'' +

                '}';

    }

    public Long getCustId() {

        return custId;

    }

    public void setCustId(Long custId) {

        this.custId = custId;

    }

    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;

    }

}

3.3.3 编写实体类和数据库表的映射配置(重点)

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

package org.example.domain;

import javax.persistence.*;

import java.io.Serializable;

/**

 * 客户的实体类

 *      配置映射关系

 *    1.实体类和表的映射关系

 *       @Entity:声明实体类

 *       @Table : 配置实体类和表的映射关系

 *           name : 配置数据库表的名称

 *    2.实体类中属性和表中字段的映射关系

 */

@Entity//声明实体类

@Table(name = "cust_customer")//建立实体类和表的映射关系

public class Customer implements Serializable {

    /**

     * @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")//指定和表中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;//客户联系电话

    @Override

    public String toString() {

        return "Customer{" +

                "custId=" + custId +

                ", custName='" + custName + '\'' +

                ", custSource='" + custSource + '\'' +

                ", custIndustry='" + custIndustry + '\'' +

                ", custLevel='" + custLevel + '\'' +

                ", custAddress='" + custAddress + '\'' +

                ", custPhone='" + custPhone + '\'' +

                '}';

    }

    public Long getCustId() {

        return custId;

    }

    public void setCustId(Long custId) {

        this.custId = custId;

    }

    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;

    }

}

常用注解的说明：

@Entity

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

@Table

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

属性：

name：指定数据库表的名称

@Id

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

@GeneratedValue

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

属性：

strategy ：指定主键生成策略。

@Column

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

属性：

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

unique：是否唯一

nullable：是否可以为空

inserttable：是否可以插入

updateable：是否可以更新

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

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

3.3.4 配置JPA的核心配置文件

在java工程的src/main./resources路径下创建一个名为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>

            <!-- 数据库信息

                用户名，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="root"/>

            <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>

            <property name="javax.persistence.jdbc.url" value="jdbc:///StringDataJPA"/>

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

                显示sql           ：   false|true

                自动创建数据库表    ：  hibernate.hbm2ddl.auto

                        create      : 程序运行时创建数据库表（如果有表，先删除表再创建）

                        update      ：程序运行时创建表（如果有表，不会创建表）

                        none        ：不会创建表

            -->

            <property name="hibernate.show_sql" value="true"/>

            <property name="hibernate.hbm2ddl.auto" value="create"/>

        </properties>

    </persistence-unit>

</persistence>

3.4 实现保存操作

package org.example.test;

import org.example.domain.Customer;

import org.junit.Test;

import javax.persistence.EntityManager;

import javax.persistence.EntityManagerFactory;

import javax.persistence.EntityTransaction;

import javax.persistence.Persistence;

/**

 * @author HackerStar

 * @create 2020-05-15 16:55

 */

public class JPATest {

    /**

     * 测试jpa的保存

     *      案例：保存一个客户到数据库中

     *  Jpa的操作步骤

     *     1.加载配置文件创建工厂（实体管理器工厂）对象

     *     2.通过实体管理器工厂获取实体管理器

     *     3.获取事务对象，开启事务

     *     4.完成增删改查操作

     *     5.提交事务（回滚事务）

     *     6.释放资源

     */

    @Test

    public void testSave() {

         //创建实体管理类工厂，借助Persistence的静态方法获取

             //其中传递的参数为持久化单元名称，需要jpa配置文件中指定

        //1.加载配置文件从而创建实体管理器工厂对象

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

        //2.通过实体管理器工厂获取实体管理器

        EntityManager em = factory.createEntityManager();

        //3.获取事物对象，开启事物

        EntityTransaction tx = em.getTransaction();

        tx.begin();

        //4.完成增删改查操作-----保存一个客户到数据库中

        Customer customer = new Customer();

        customer.setCustName("Github");

        customer.setCustIndustry("代码管理");

        //保存

        em.persist(customer);

        //5.提交事物

        tx.commit();

        //6.释放资源

        em.close();

        factory.close();

    }

}

第四章 JPA的API介绍

4.1 Persistence对象

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

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

Persisitence：静态方法（根据持久化单元名称创建实体管理器工厂）

createEntityMnagerFactory（持久化单元名称）

作用：创建实体管理器工厂

4.2 EntityManagerFactory对象

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

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

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

EntityManagerFactory ：获取EntityManager对象

方法：createEntityManager

内部维护的很多的内容

内部维护了数据库信息，

维护了缓存信息

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

在创建EntityManagerFactory的过程中会根据配置创建数据库表

EntityManagerFactory的创建过程比较浪费资源

特点：线程安全的对象

多个线程访问同一个EntityManagerFactory不会有线程安全问题

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

思路：创建一个公共的EntityManagerFactory的对象

静态代码块的形式创建EntityManagerFactory

4.3 EntityManager对象

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

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

方法说明：

	getTransaction : 获取事务对象

	persist ： 保存操作

	merge ： 更新操作

	remove ： 删除操作

	find/getReference ： 根据id查询

创建事务对象，开启事务

EntityManager对象：实体类管理器

beginTransaction : 创建事务对象

presist ：保存

merge ：更新

remove ：删除

find/getRefrence ：根据id查询

4.4 EntityTransaction对象

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

Transaction 对象：事务对象

begin：开启事务

commit：提交事务

rollback：回滚

第五章抽取JPAUtil工具类

package org.example.utils;

import javax.persistence.EntityManager;

import javax.persistence.EntityManagerFactory;

import javax.persistence.Persistence;

/**

 * 解决实体管理器工厂的浪费资源和耗时问题

 *      通过静态代码块的形式，当程序第一次访问此工具类时，创建一个公共的实体管理器工厂对象

 *

 * 第一次访问getEntityManager方法：经过静态代码块创建一个factory对象，再调用方法创建一个EntityManager对象

 * 第二次方法getEntityManager方法：直接通过一个已经创建好的factory对象，创建EntityManager对象

 */

public class JPAUtil {

    private static EntityManagerFactory factory;

    static {

        //1.加载配置文件，创建EntityManagerFactory

        factory = Persistence.createEntityManagerFactory("myJpa");

    }

    /**

     * 获取EntityManager对象

     */

    public static EntityManager getEntityManager() {

        return factory.createEntityManager();

    }

}

第六章使用JPA完成增删改查

6.1 保存

		/**

     * 保存

     */

    @Test

    public void add() {

        //定义对象

        Customer customer = new Customer();

        customer.setCustName("Linux");

        customer.setCustLevel("普通用户");

        customer.setCustSource("网络");

        customer.setCustIndustry("操作系统");

        customer.setCustAddress("USA");

        customer.setCustPhone("666666");

        EntityManager em = null;

        EntityTransaction tx = null;

        try {

            //获取实体管理对象

            em = JPAUtil.getEntityManager();

            //获取事物对象

            tx = em.getTransaction();

            //开启事物

            tx.begin();

            //执行操作

            em.persist(customer);

            //提交事务

            tx.commit();

        } catch (Exception e) {

            //回滚事务

            tx.rollback();

            e.printStackTrace();

        } finally {

            //释放资源

            em.close();

        }

    }

6.2 修改

		/**

     * 更新

     *	merge(Object)

     */

    @Test

    public void update() {

        EntityManager em = null;

        EntityTransaction tx = null;

        try {

            //获取实体管理对象

            em = JPAUtil.getEntityManager();

            //获取事物对象

            tx = em.getTransaction();

            //开启事物

            tx.begin();

            //执行删除操作

            //i 根据id查询客户

            Customer customer = em.find(Customer.class, 3l);

            //ii 更新客户

            customer.setCustName("Apple");

            em.merge(customer);

            //提交事务

            tx.commit();

        } catch (Exception e) {

            //回滚事务

            tx.rollback();

            e.printStackTrace();

        } finally {

            //释放资源

            em.close();

        }

    }

6.3 根据id查询

		/**

     * 根据id查询客户

     *  使用find方法查询：

     *      1.查询的对象就是当前客户对象本身

     *      2.在调用find方法的时候，就会发送sql语句查询数据库

     *

     *  立即加载

     */

    @Test

    public void queryById() {

        EntityManager em = null;

        EntityTransaction tx = null;

        try {

            //获取实体管理对象

            em = JPAUtil.getEntityManager();

            //获取事物对象

            tx = em.getTransaction();

            //开启事务

            tx.begin();

            //执行操作

            /**

             * find : 根据id查询数据

             *      class：查询数据的结果需要包装的实体类类型的字节码

             *      id：查询的主键的取值

             */

            Customer customer = em.find(Customer.class, 4l);

            //提交事务

            tx.commit();

            System.out.println(customer);

        } catch (Exception e) {

            //回滚事务

            tx.rollback();

            e.printStackTrace();

        } finally {

            //释放资源

            em.close();

        }

    }

		/**

     * 根据id查询客户

     *      getReference方法

     *          1.获取的对象是一个动态代理对象

     *          2.调用getReference方法不会立即发送sql语句查询数据库

     *              * 当调用查询结果对象的时候，才会发送查询的sql语句：什么时候用，什么时候发送sql语句查询数据库

     *

     * 延迟加载（懒加载）

     *      * 得到的是一个动态代理对象

     *      * 什么时候用，什么使用才会查询

     */

    @Test

    public void queryById2() {

        EntityManager em = null;

        EntityTransaction tx = null;

        try {

            //获取实体管理对象

            em = JPAUtil.getEntityManager();

            //获取事物对象

            tx = em.getTransaction();

            //开启事务

            tx.begin();

            //执行操作

            /**

             * getReference : 根据id查询数据

             *      class：查询数据的结果需要包装的实体类类型的字节码

             *      id：查询的主键的取值

             */

            Customer customer = em.getReference(Customer.class, 4l);

            //提交事务

            tx.commit();

            System.out.println(customer);

        } catch (Exception e) {

            //回滚事务

            tx.rollback();

            e.printStackTrace();

        } finally {

            //释放资源

            em.close();

        }

    }

6.4 删除

		/**

     * 删除

     */

    @Test

    public void remove() {

        EntityManager em = null;

        EntityTransaction tx = null;

        try {

            //获取实体管理对象

            em = JPAUtil.getEntityManager();

            //获取事物对象

            tx = em.getTransaction();

            //开启事物

            tx.begin();

            //执行删除操作

            //i 根据id查询客户

            Customer customer = em.find(Customer.class, 2l);

            //ii 调用remove方法完成删除操作

            em.remove(customer);

            //提交事务

            tx.commit();

        } catch (Exception e) {

            //回滚事务

            tx.rollback();

            e.printStackTrace();

        } finally {

            //释放资源

            em.close();

        }

    }

6.5 JPA中的复杂查询

JPQl全称Java Persistence Query Language

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

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

6.5.1 查询全部

package org.example.test;

import org.example.utils.JPAUtil;

import org.junit.Test;

import javax.persistence.EntityManager;

import javax.persistence.EntityTransaction;

import javax.persistence.Query;

import java.util.List;

/**

 * 测试jpql查询

 * @author HackerStar

 * @create 2020-05-15 19:46

 */

public class JPATest2 {

    /**

     * 查询全部

     *      jqpl：from org.example.domain.Customer （包名可以省略）

     *      sql：SELECT * FROM cst_customer

     */

    @Test

    public void findAll() {

        //1.获取EntityManager对象

        EntityManager entityManager = JPAUtil.getEntityManager();

        //2. 开启事务

        EntityTransaction transaction = entityManager.getTransaction();

        transaction.begin();

        //3. 查询全部

        String jpql = "from Customer";

        Query query = entityManager.createQuery(jpql);//创建Query查询对象，query对象才是执行jqpl的对象

        //发送查询，并封装结果集

        List resultList = query.getResultList();

        resultList.forEach(customer -> System.out.println(customer));

        //4. 提交事务

        transaction.commit();

        //5. 释放资源

        entityManager.close();

    }

}

6.5.2 分页查询

/**

     * 分页查询

     *      sql：select * from cst_customer limit 0,2

     *      jqpl : from Customer

     */

    @Test

    public void page() {

        //1.获取EntityManager对象

        EntityManager entityManager = JPAUtil.getEntityManager();

        //2. 开启事务

        EntityTransaction transaction = entityManager.getTransaction();

        transaction.begin();

        //3. 查询全部

        //i.根据jpql语句创建Query查询对象

        String jpql = "from Customer ";

        Query query = entityManager.createQuery(jpql);//创建Query查询对象，query对象才是执行jqpl的对象

        //ii.对参数赋值

        //起始索引

        query.setFirstResult(0);

        //每页查询的条数

        query.setMaxResults(2);

        //iii.发送查询，并封装结果

        /**

         * getResultList ： 直接将查询结果封装为list集合

         * getSingleResult : 得到唯一的结果集

         */

        query.getResultList().forEach(customer -> System.out.println(customer));

        //4. 提交事务

        transaction.commit();

        //5. 释放资源

        entityManager.close();

    }

6.5.3 统计查询

		/**

     * 使用jpql查询，统计客户的总数

     *      sql：SELECT COUNT(cust_id) FROM cst_customer

     *      jpql：select count(custId) from Customer

     */

    @Test

    public void count() {

        //1.获取EntityManager对象

        EntityManager entityManager = JPAUtil.getEntityManager();

        //2. 开启事务

        EntityTransaction transaction = entityManager.getTransaction();

        transaction.begin();

        //3. 查询全部

        //i.根据jpql语句创建Query查询对象

        String jpql = "select count(custId) from Customer ";

        Query query = entityManager.createQuery(jpql);//创建Query查询对象，query对象才是执行jqpl的对象

        //ii.对参数赋值

        //iii.发送查询，并封装结果

        //发送查询，并封装结果集

        Object result = query.getSingleResult();

        System.out.println(result);

        //4. 提交事务

        transaction.commit();

        //5. 释放资源

        entityManager.close();

    }

6.5.4 排序查询

		/**

     * 排序查询： 倒序查询全部客户（根据id倒序）

     *      sql：SELECT * FROM cst_customer ORDER BY cust_id DESC

     *      jpql：from Customer order by custId desc

     *

     * 进行jpql查询

     *      1.创建query查询对象

     *      2.对参数进行赋值

     *      3.查询，并得到返回结果

     */

    @Test

    public void orderQuery() {

        //1.获取EntityManager对象

        EntityManager entityManager = JPAUtil.getEntityManager();

        //2. 开启事务

        EntityTransaction transaction = entityManager.getTransaction();

        transaction.begin();

        //3. 查询全部

        String jpql = "from Customer order by custId desc ";

        Query query = entityManager.createQuery(jpql);//创建Query查询对象，query对象才是执行jqpl的对象

        //发送查询，并封装结果集

        List resultList = query.getResultList();

        resultList.forEach(customer -> System.out.println(customer));

        //4. 提交事务

        transaction.commit();

        //5. 释放资源

        entityManager.close();

    }

6.5.5 条件查询

		@Test

    public void queryByCondition() {

        //1.获取EntityManager对象

        EntityManager entityManager = JPAUtil.getEntityManager();

        //2. 开启事务

        EntityTransaction transaction = entityManager.getTransaction();

        transaction.begin();

        //3. 查询全部

        //i.根据jpql语句创建Query查询对象

        String jpql = "from Customer where custName like ? ";

        Query query = entityManager.createQuery(jpql);//创建Query查询对象，query对象才是执行jqpl的对象

        //ii.对参数赋值

        //第一个参数：占位符的索引位置（从1开始），第二个参数：取值

        query.setParameter(1, "Apple%");

        //iii.发送查询，并封装结果

        /**

         * getResultList ： 直接将查询结果封装为list集合

         * getSingleResult : 得到唯一的结果集

         */

        query.getResultList().forEach(customer -> System.out.println(customer));

        //4. 提交事务

        transaction.commit();

        //5. 释放资源

        entityManager.close();

    }

巴特西

JPA第一天

第一章 ORM概述(了解)

1.1 为什么使用ORM

1.2 常见的ORM框架

第二章 hibernate与JPA的概述

2.1 hibernate概述

2.2 JPA概述

2.3 JPA的优势

2.4 JPA与hibernate的关系

第三章 JPA的入门案例

3.1 需求介绍

3.2 开发包介绍

3.3 搭建开发环境(重点)

3.3.1 导入jar包

3.3.2 创建客户的数据库表和客户的实体类

3.3.3 编写实体类和数据库表的映射配置(重点)

3.3.4 配置JPA的核心配置文件

3.4 实现保存操作

第四章 JPA的API介绍

4.1 Persistence对象

4.2 EntityManagerFactory对象

4.3 EntityManager对象

4.4 EntityTransaction对象

第五章抽取JPAUtil工具类

第六章使用JPA完成增删改查

6.1 保存

6.2 修改

6.3 根据id查询

6.4 删除

6.5 JPA中的复杂查询

6.5.1 查询全部

6.5.2 分页查询

6.5.3 统计查询

6.5.4 排序查询

6.5.5 条件查询

最新文章

热门文章

巴特西

JPA第一天

第一章 ORM概述(了解)

1.1 为什么使用ORM

1.2 常见的ORM框架

第二章 hibernate与JPA的概述

2.1 hibernate概述

2.2 JPA概述

2.3 JPA的优势

2.4 JPA与hibernate的关系

第三章 JPA的入门案例

3.1 需求介绍

3.2 开发包介绍

3.3 搭建开发环境(重点)

3.3.1 导入jar包

3.3.2 创建客户的数据库表和客户的实体类

3.3.3 编写实体类和数据库表的映射配置(重点)

3.3.4 配置JPA的核心配置文件

3.4 实现保存操作

第四章 JPA的API介绍

4.1 Persistence对象

4.2 EntityManagerFactory对象

4.3 EntityManager对象

4.4 EntityTransaction对象

第五章 抽取JPAUtil工具类

第六章 使用JPA完成增删改查

6.1 保存

6.2 修改

6.3 根据id查询

6.4 删除

6.5 JPA中的复杂查询

6.5.1 查询全部

6.5.2 分页查询

6.5.3 统计查询

6.5.4 排序查询

6.5.5 条件查询

最新文章

热门文章

第五章抽取JPAUtil工具类

第六章使用JPA完成增删改查