** SpringData Jpa_篇1 [Jpa共3天_day01] *
Spring Data jpa 三天课程安排：
day1：
* orm思想和hibernate以及jpa的概述和jpd的基本操作
day2：
* springdatajps的运行原理和基本操作
day3：
* 多表操作，复杂查询
今日内容：
- orm思想
- hibeinate框架介绍
- JPA规范
- jpa的基本操作
- 搭建环境的过程
- 完成基本CRUD案列
回顾传统JDBC完成用户保存操作和ORM思想的引入
orm思想概述
1. 主要目的：
* 操作实体类就相当于操作数据表
2. 需要做什么？
* 建立两个映射关系
1. 实体类和表的映射关系
2. 实体类中属性和表中字段的映射关系
* 不再重点关注：
- sql语句
3. 实现了orm思想的框架：
* mybaits
* hibernate
Hibernate框架介绍
- 概述：
1. Hibernate是一个开放源代码的对象关系映射框架
2. 它对JDBC进行了非常轻量级的对象封装
3. 它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，是一个全自动的orm框架； 【工作中已经基本不使用了】
JPA
1. 介绍：
* JPA的全称是Java Persistence API ， 即Java持久化API，是SUN公司推出的一套基于ORM的规范，内部是由一系列的接口和抽象类构成；
* JPA通过JDK5.0注解描述对象-关系表的映射关系，将运行期的实体对象持久化到数据库中。
2. 图解：
3. 分析：
* 它是一套规范，类似于JDBC规范，它规定了语法格式的接口，而实现类为各生产厂家，掌握了这一套规范就掌握了下面所有实现了它规范的实现产品；如果要更换产品，修改的只是配置文件，其他地方基本上不用改；
4. JPA与hibernate的关系图
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是EJB QL的一种扩展，它是针对实体的一种查询语言，操作对象是实体，而不是关系数据库的表，而且能够支持批量更新和修改、JOIN、GROUP BY、HAVING等通常只有SQL才能够提供的高级查询特性，甚至还能够支持子查询；
5. 高级特性
* JPA中能够支持面向对象的高级特性，如类之间的继承。多态和类之间的复杂关系，这样的支持能够让开发者最大限度的使用面向对象的模型设计企业应用，而不需要自行处理这些特性在关系数据库的持久化；
JPA中的主键生成策略【需要记住IDENTITY和SEQUENCE】
1. 通过 annotation（注解）来映射 hibernate 实体的,基于 annotation 的 hibernate 主键标识为@Id, 其生成规则的@GeneratedValue 设定的.这里的@id 和@GeneratedValue 都是 JPA的标准用法。
2. JPA 提供的四种标准用法为 TABLE,SEQUENCE,IDENTITY,AUTO
1. IDENTITY:
1. 主键由数据库自动生成（主要是自动增长型）
2. 代码：
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long custId;
2. SEQUENCE ：
1. 根据底层数据库的序列来生成主键，条件是数据库支持序列。
2. 代码：
@Id
@GeneratedValue(strategy = GenerationType.SEQUENCE,generator="payablemoney_seq")
@SequenceGenerator(name="payablemoney_seq", sequenceName="seq_payment")
private Long custId;
3. 注释：
//@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;
}
3. AUTO ：
1. 主键由程序控制
2. 代码：
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long custId;
4. TABLE：
1. 使用一个特定的数据库表格来保存主键
2. 代码：
@Id
@GeneratedValue(strategy = GenerationType.TABLE, generator="payablemoney_gen")
@TableGenerator(name = "pk_gen",
table="tb_generator",
pkColumnName="gen_name",
valueColumnName="gen_value",
pkColumnValue="PAYABLEMOENY_PK",
allocationSize=1
)
4. 注释：
//@TableGenerator 的定义：
@Target({TYPE, METHOD, FIELD})
@Retention(RUNTIME)
public @interface TableGenerator {
//表示该表主键生成策略的名称，它被引用在@GeneratedValue 中设置的“generator”值中
String name();
//表示表生成策略所持久化的表名，例如，这里表使用的是数据库中的“tb_generator”。
String table() default "";
//catalog 和 schema 具体指定表所在的目录名或是数据库名
String catalog() default "";
String schema() default "";
//属性的值表示在持久化表中，该主键生成策略所对应键值的名称。例如在“tb_generator”中将
“gen_name”作为主键的键值
String pkColumnName() default "";
//属性的值表示在持久化表中，该主键当前所生成的值，它的值将会随着每次创建累加。例如，在
“tb_generator”中将“gen_value”作为主键的值
String valueColumnName() default "";
//属性的值表示在持久化表中，该生成策略所对应的主键。例如在“tb_generator”表中，将“gen_name”
的值为“CUSTOMER_PK”。
String pkColumnValue() default "";
//表示主键初识值，默认为 0。
int initialValue() default 0;
//表示每次主键值增加的大小，例如设置成 1，则表示每次创建新记录后自动加 1，默认为 50。
int allocationSize() default 50;
UniqueConstraint[] uniqueConstraints() default {};
}
//这里应用表 tb_generator，定义为 ：
CREATE TABLE tb_generator (
id NUMBER NOT NULL,
gen_name VARCHAR2(255) NOT NULL,
gen_value NUMBER NOT NULL,
PRIMARY KEY(id)
)
JPA的api介绍：
1. Persistence对象
1. Persistence 对象主要作用是用于获取 EntityManagerFactory 对象的 。通过调用该类的createEntityManagerFactory 静 态 方 法 ， 根 据 配 置 文 件 中 持 久 化 单 元 名 称 创 建EntityManagerFactory。
2. 代码：
//1. 创建 EntitymanagerFactory
@Test
String unitName = "myJpa";
EntityManagerFactory factory= Persistence.createEntityManagerFactory(unitName);
2. EntityManagerFactory
1. EntityManagerFactory 接口主要用来创建 EntityManager 实例
2. 代码：
//创建实体管理类
EntityManager em = factory.createEntityManager();
4. 注意：
* 由 于 EntityManagerFactory 是 一 个 线 程 安 全 的 对 象 （ 即 多 个 线 程 访 问 同 一 个EntityManagerFactory 对象不会有线程安全问题），并且 EntityManagerFactory 的创建极其浪费资源，所以在使用 JPA 编程时，我们可以对 EntityManagerFactory 的创建进行优化，只需要做到一个工程只存在一个 EntityManagerFactory 即可
3. EntityManager
1. 在 JPA 规范中, EntityManager 是完成持久化操作的核心对象。实体类作为普通 java 对象，只有在调用 EntityManager 将其持久化后才会变成持久化对象。EntityManager 对象在一组实体类与底层数据源之间进行 O/R 映射的管理。它可以用来管理和更新 Entity Bean, 根椐主键查找 Entity Bean, 还可以通过 JPQL 语句查询实体。
2. 我们可以通过调用 EntityManager 的方法完成获取事务，以及持久化数据库的操作
3. 方法说明：
getTransaction : 获取事务对象
persist ： 保存操作
merge ： 更新操作
remove ： 删除操作
find/getReference ： 根据 id 查询
4. EntityTransaction
1. 在 JPA 规范中, EntityTransaction 是完成事务操作的核心对象，对于 EntityTransaction在我们的 java 代码中承接的功能比较简单
2. 用法：
begin：开启事务
commit：提交事务
rollback：回滚事务
jpa的基本操作
- 案例： 对"客户表"的相关操作（增删改查）
-
操作步骤：
-
加载配置文件创建实体管理器工厂
- persisitence:静态方法（根据持久化单元名称创建实体管理器工厂）
- createEntityManagerFactory(持久化单元名称)
- 作用：创建实体管理器工厂
- persisitence:静态方法（根据持久化单元名称创建实体管理器工厂）
-
根据实体管理器工厂，创建实体管理器
- EntityManagerFactory:获取EntityManager对象
- 方法：createEntityManager
-
内部维护了很多内容：
- 内部维护了数据库信息
- 维护了缓存信息
- 维护了所有的实体管理器对象
- 再创建EntityManagerFactory的过程中会根据配置创建数据库表
-
EntityManagerFactory的创建过程比较浪费资源
-
- 特点：线程安全的对象
- 多个线程访问同一个EntityManagerFactory不会有线程安全问题
- 问题： 如何解决EntityManagerFactory的创建过程浪费资源（耗时）的问题？
- 思路： 创建一个公共的EntityManagerFactory的对象
- 静态代码块的形式创建EntityManagerFactory，这样在程序加载的时候就创建了，不会影响性能
- 思路： 创建一个公共的EntityManagerFactory的对象
-
创建事务对象，开启事务
-
EntityManager对象：实体类管理器
- beginTransaction: 创建事务对象
- presist: 保存
- merge: 更新
- remove: 删除
- find/getRefrence: 根据id查询
-
Transaction： 对象： 事务
- begin: 开启事务
- commit: 提交事务
- rollback: 回滚
-
-
增删改查操作
-
提交事务
-
释放资源
-
-
搭建环境的过程：
-
创建maven工程导入坐标
-
需要配置jpa的核心配置文件
- 位置： 配置到类路径下的一个叫做META-INF的文件夹下
- 命名： persistence.xml
-
编写客户的实体类
-
配置实体类和表，类中属性和表中字段的映射关系
-
保存客户到数据库中
-
-
完成基本CRUD案例
- persist: 保存
- merge： 更新
- remove: 删除
- find/getReference: 根据id查询
jpql查询
-
概念：
- JPQL 全称 Java Persistence Query Language
- 基于首次在 EJB2.0 中引入的 EJB 查询语言(EJB QL),Java 持久化查询语言(JPQL)是一种可移植的查询语言，旨在以面向对象表达式语言的表达式，将 SQL 语法和简单查询语义绑定在一起·使用这种语言编写的查询是可移植的，可以被编译成所有主流数据库服务器上的 SQL。
- 其特征与原生 SQL 语句类似，并且完全面向对象，通过类名和属性访问，而不是表名和表的属性。
-
查询内容：
-
查询全部
-
分页查询
-
统计查询
-
条件查询
-
排序
-
JPA的入门案例：
1. 需求：
* 我们是实现的功能是保存一个客户到数据库的客户表中。
2. 开发包介绍：
* 由于 JPA 是 sun 公司制定的 API 规范，所以我们不需要导入额外的 JPA 相关的 jar 包，只需要导入 JPA 的提供商的 jar 包。我们选择 Hibernate 作为 JPA 的提供商，所以需要导入 Hibernate的相关 jar 包
* 下载网址：
http://sourceforge.net/projects/hibernate/files/hibernate-orm/5.0.7.Final/
* 页面显示如下图：
3. 导入jar 包：
1. 传统工程如图：
2. 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>
4. 数据库表：
/*创建客户表*/
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;
5. 创建客户实体类：
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;
get方法和set方法...
toString方法...
}
7. 编写映射关系：
/**
* * 所有的注解都是使用 JPA 的规范提供的注解，
* * 所以在导入注解包的时候，一定要导入 javax.persistence 下的
*/
@Entity //声明实体类
@Table(name="cst_customer") //建立实体类和表的映射关系
public class Customer {
@Id//声明当前私有属性为主键
@GeneratedValue(strategy=GenerationType.IDENTITY) //配置主键的生成策略
@Column(name="cust_id") //指定和表中 cust_id 字段的映射关系
private Long custId;
@Column(name="cust_name") //指定和表中 cust_name 字段的映射关系
private String custName;
@Column(name="cust_source")//指定和表中 cust_source 字段的映射关系
private String custSource;
@Column(name="cust_industry")//指定和表中 cust_industry 字段的映射关系
private String custIndustry;
@Column(name="cust_level")//指定和表中 cust_level 字段的映射关系
private String custLevel;
@Column(name="cust_address")//指定和表中 cust_address 字段的映射关系
private String custAddress;
@Column(name="cust_phone")//指定和表中 cust_phone 字段的映射关系
private String custPhone;
getset和toString方法省略...
}
- 常用注解说明：
@Entity
作用：指定当前类是实体类。
@Table
作用：指定实体类和表之间的对应关系。
属性：
name：指定数据库表的名称
@Id
作用：指定当前字段是主键。
@GeneratedValue
作用：指定主键的生成方式。。
属性：
strategy ：指定主键生成策略。
@Column
作用：指定实体类属性和数据库表之间的对应关系
属性：
name：指定数据库表的列名称。
unique：是否唯一
nullable：是否可以为空
inserttable：是否可以插入
updateable：是否可以更新
columnDefinition: 定义建表时创建此列的 DDL
secondaryTable: 从表名。如果此列不建在主表上（默认建在主表），该属性
定义该列所在从表的名字搭建开发环境[重点]
9. 配置JPA的核心配置文件：
1. 在 java 工程的 src 路径下创建一个名为 META-INF 的文件夹，在此文件夹下创建一个名为persistence.xml 的配置文件
<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd"
version="2.0">
<!--配置持久化单元
name：持久化单元名称
transaction-type：事务类型
RESOURCE_LOCAL：本地事务管理
JTA：分布式事务管理 -->
<persistence-unit name="myJpa" transaction-type="RESOURCE_LOCAL">
<!--配置 JPA 规范的服务提供商 -->
<provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
<properties>
<!-- 数据库驱动 -->
<property name="javax.persistence.jdbc.driver"
value="com.mysql.jdbc.Driver" />
<!-- 数据库地址 -->
<property name="javax.persistence.jdbc.url"
value="jdbc:mysql://localhost:3306/ssh" />
<!-- 数据库用户名 -->
<property name="javax.persistence.jdbc.user" value="root" />
<!-- 数据库密码 -->
<property name="javax.persistence.jdbc.password" value="111111" />
<!--jpa 提供者的可选配置：我们的 JPA 规范的提供者为 hibernate，所以 jpa 的核心配置中兼
容 hibernate 的配 -->
<property name="hibernate.show_sql" value="true" />
<property name="hibernate.format_sql" value="true" />
<property name="hibernate.hbm2ddl.auto" value="create" />
</properties>
</persistence-unit>
</persistence>
提升效率，JpaUtils
1. 问题：
1. 解决实体管理器工厂的浪费资源和耗时问题
2. 通过静态代码块的形式，当程序第一次访问此工具类时，创建一个公共的实体管理器工厂对象
* 第一次访问getEntityManager方法：经过静态代码块创建一个factory对象，再调用方法创建一个EntityManager对象
* 第二次方法getEntityManager方法：直接通过一个已经创建好的factory对象，创建EntityManager对象
2. 代码：
package cn.itcast.util;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
/**
* JpaUtils
* hasee
* 2018/12/16
* 16:02
*
* @Version 1.0
**/
/*
* jpa工具类
*
* 解决实体管理器工厂的浪费资源和耗时问题
* 通过静态代码块的形式，当程序第一次访问此工具类时，创建一个公共的实体管理器工厂对象
* 1. 第一次访问getEntityManager方法：经过静态代码块创建一个factory对象，再调用方法创建一个EntityManager对象
* 2. 第二次方法getEntityManager方法：直接通过一个已经创建好的factory对象，创建EntityManager对象
*
*
* */
public class JpaUtils {
private static EntityManagerFactory factory=null;
//1. 加载配置文件，创建entityManagerFactory
static {
factory=Persistence.createEntityManagerFactory("myJpa");
}
/*
* 获取EntityManager对象
* */
public static EntityManager getEntityManager(){
return factory.createEntityManager();
}
}
测试-- 增删查改：【简单查询】
package cn.itcast.test;
import cn.itcast.domin.Customer;
import cn.itcast.util.JpaUtils;
import org.junit.Test;
import javax.persistence.*;
/**
* JpaTest
* hasee
* 2018/12/16
* 15:01
*
* @Version 1.0
**/
public class JpaTest {
/*
*
* 测试jpa的保存
* 案例：保存一个客户到数据库中；
* Jpa的操作步骤
* 1. 加载配置文件创建工厂（实体管理类工厂）对象
* 2. 通过实体管理类工厂获取实体管理器
* 3. 获取事务对象，开启事务
* 4. 完成增删改查操作
* 5. 提交事务（回滚事务）
* 6. 释放资源
* */
@Test
public void testSave(){
//1. 加载配置文件创建工厂（实体管理器工厂）对象
// EntityManagerFactory factory=Persistence.createEntityManagerFactory("myJpa");
// //2. 通过实体管理器工厂获取实体管理器
EntityManager em=JpaUtils.getEntityManager(); //通过工具类创建实体管理器
//3. 获取事务对象，开启事务；
EntityTransaction tx=em.getTransaction(); //获取事务对象
tx.begin(); //开启事务
//4. 完成增删改查操作：保存一个数据到数据库中
//4.1 创建一个实体类
Customer customer=new Customer();
customer.setCustName("暗余");
customer.setAddress("成都");
customer.setCustPhone("15982131554");
customer.setCustLevel("5");
// 4.2 保存操作
em.persist(customer);
//5.提交事务
tx.commit();
//6. 释放资源
em.clear();
//通过工具类创建实体类管理器后，factory不必关闭资源，因为它是一个公共的factory,后面其他线程如果需要使用此factory就可以直接使用了；
// factory.close();
}
//根据id查询客户
/*
* 使用id查询客户
* 使用find方法查询：
* 1. 查询的对象就是当前客户对象本身
* 2. 在调用find方法的时候，就会发送sql语句查询数据库
* 特点：
* 立即加载
* 1. 它是在调用find方法本身，而且是在调用find方法的时候就已经完成查询
* 2. 使用它会浪费内存效率，所以我们一般使用getReference方法进行查询；
* */
@Test
public void testFind(){
//1.通过工具类获取EntityManager
EntityManager entityManager=JpaUtils.getEntityManager();
//2. 开启事务
EntityTransaction transaction=entityManager.getTransaction();
transaction.begin();
//3. 增删改查
/*
* find: 根据id查询数据
* class:查询数据的结果需要包装的实体类类型的字节码
* id:查询的主键的取值 (l是必须要带上的，否则会报错)
*
* */
Customer customer=entityManager.find(Customer.class,1l);
System.out.println(customer);
//4. 提交事务
transaction.commit();
//5. 释放资源
entityManager.close();
}
/*
* 根据id查询用户
* getReference方法
* 1. 获取的对象是一个动态代理对象
* 2. 调用getReference方法不会立即发送sql语句查询数据库
* * 当调用查询结果对象的时候，不会发送查询的sql语句，什么时候用，什么时候发送sql语句查询数据库
* 查询的特点：
* 延迟加载（懒加载）
* 1. 什么时候用，什么时候才会加载
* 2. 得到的是一个动态代理对象
* */
@Test
public void testReference(){
//1.通过工具类获取EntityManager
EntityManager entityManager=JpaUtils.getEntityManager();
//2. 开启事务
EntityTransaction transaction=entityManager.getTransaction();
transaction.begin();
//3. 增删改查
/*
* find: 根据id查询数据
* class:查询数据的结果需要包装的实体类类型的字节码
* id:查询的主键的取值 (l是必须要带上的，否则会报错)
*
* */
Customer customer=entityManager.getReference(Customer.class,1l);
System.out.println(customer);
//4. 提交事务
transaction.commit();
//5. 释放资源
entityManager.close();
}
/*
* 删除
* */
@Test
public void testRemove(){
//1.通过工具类获取EntityManager
EntityManager entityManager=JpaUtils.getEntityManager();
//2. 开启事务
EntityTransaction transaction=entityManager.getTransaction();
transaction.begin();
//3. 增删改查-- 删除客户
//3.1 根据客户id查询用户
Customer customer=entityManager.find(Customer.class, 1l);
//3.2 根据客户查询得到的对象删除用户
entityManager.remove(customer);
//4. 提交事务
transaction.commit();
//5. 释放资源
entityManager.close();
}
/*
*
* 更新
* merge(Object)
* */
@Test
public void testUpdate(){
//1.通过工具类获取EntityManager
EntityManager entityManager=JpaUtils.getEntityManager();
//2. 开启事务
EntityTransaction transaction=entityManager.getTransaction();
transaction.begin();
//3. 增删改查-- 更新操作
//i 查询客户
Customer customer=entityManager.getReference(Customer.class, 2l);
customer.setCustName("暗余大神");
//ii 更新客户
entityManager.merge(customer);
//4. 提交事务
transaction.commit();
//5. 释放资源
entityManager.close();
}
}
测试- JPQL表达式： 查询全部，倒序查询desc，count，limit，条件like 【复杂查询】
package cn.itcast.test;
import cn.itcast.util.JpaUtils;
import org.junit.Test;
import org.omg.IOP.ENCODING_CDR_ENCAPS;
import javax.persistence.Entity;
import javax.persistence.EntityManager;
import javax.persistence.EntityTransaction;
import javax.persistence.Query;
import java.util.List;
/**
* JpqlTest
* hasee
* 2018/12/16
* 20:05
*
* @Version 1.0
**/
/*
* 测试jpql查询
* 1. 创建query查询对象
* 2. 对参数进行赋值
* 3. 查询，并得到返回结果
*
* */
public class JpqlTest {
/*
*
* 查询全部：
* jpql:from cn.itcast.domain.Customer
* sql: SELECT * FROM cst_customer
* */
@Test
public void testFindAll(){
//1. 获取entityManager对象
EntityManager em=JpaUtils.getEntityManager();
//2.1获取事务
EntityTransaction tx=em.getTransaction();
//2.2开启事务
tx.begin();
//3. 查询全部
// 全限定名方式：String jpq1="from cn.itcast.domin.Customer";
//支持简写
String jpq1="from Customer";
//4. 创建Query查询对象，query对象才是执行jpql的对象；
Query query=em.createQuery(jpq1);
//5. 发送查询并封装结果集
List list=query.getResultList();
for (Object obj : list) {
System.out.println(obj);
}
//6. 提交事务
tx.commit();
//7.释放资源
em.close();
}
/*
* 倒序DESC
*
* 倒序查询
* sql：SELECT * FROM cst_customer ORDER BY cust_id DESC
* jpql: from Customer order by custId
*
* */
@Test
public void testOrders(){
//1. 获取entityManager对象
EntityManager em=JpaUtils.getEntityManager();
//2. 开启事务
EntityTransaction transaction=em.getTransaction();
transaction.begin();
//3. 查询事务
String jpq1="from Customer order by custId";
Query query=em.createQuery(jpq1); //创建Query查询对象，query对象才是执行jpq1的对象
// 发送查询，并封装结果集
List list=query.getResultList();
for (Object obj : list) {
System.out.println(obj);
}
//4. 提交事务
transaction.commit();
//5. 释放资源
em.close();
}
/*
* 统计Count
*
* 使用jpql查询，统计客户的总数
* sql: SELECT COUNT(cust_id) FROM cst_customer
* jpql: select count(sustId) from Customer
*
* */
@Test
public void testCount(){
//1. 获取entityManager对象
EntityManager em=JpaUtils.getEntityManager();
//2. 开启事务
EntityTransaction transaction=em.getTransaction();
transaction.begin();
//3. 查询
//3.1 根据jpql语句创建Query查询对象
String jpql="select count(custId) from Customer";
Query query=em.createQuery(jpql);
//3.2对参数赋值
//3.3 发送查询并封装结果
/*
* getResultList:直接将查询结果封装为list集合
* getSingleResult: 得到唯一的结果集
*
* */
Object result=query.getSingleResult();
System.out.println(result);
//4. 提交事务
transaction.commit();
//5. 释放资源
em.close();
}
/*
* 分页查询Limit
*
* sql: select * from cst_customer limit 0,2
* jqpl: from Customer
*
*
*
* */
@Test
public void testPaged(){
//1. 获取entityManager 对象
EntityManager em=JpaUtils.getEntityManager();
//2. 开启事务
EntityTransaction transaction=em.getTransaction();
transaction.begin();
//3. 查询
//3.1 根据jpql语句查询创建Query查询对象
String jpql="from Customer";
Query query=em.createQuery(jpql);
//3.2 对参数赋值 -- 分页参数
//起始索引
query.setFirstResult(0);
//每页查询的条数
query.setMaxResults(2);
//3.3 发送查询，获取结果
List list=query.getResultList();
for (Object obj : list) {
System.out.println(obj);
}
//4. 提交事务
transaction.commit();
//5. 关闭资源
em.close();
}
/*
*
* 条件查询
* 案例：查询客户名称以：“暗”开头的用户
* sql:select * from cst_customer where cust_name LIKE ?
* jpql: form Customer where custName like ?
*
* */
@Test
public void testCondition(){
//1. 获取entityManager 对象
EntityManager entityManager=JpaUtils.getEntityManager();
//2. 开启事务
EntityTransaction transaction=entityManager.getTransaction();
transaction.begin();
//3. 查询
//3.1 根据jpql语句创建Query查询对象
String jpql="from Customer where custName like ? ";
Query query=entityManager.createQuery(jpql);
//3.2 对参数赋值
query.setParameter(1,"%暗%");
/*
* getResultList: 直接将查询结果封装为list集合
* getSingleResult: 得到唯一的结果集
*
* */
List list=query.getResultList();
for (Object obj : list) {
System.out.println(obj);
}
// 4. 提交事务
transaction.commit();
//5. 关闭资源
entityManager.close();
}
}