2019-11-20
18:27:48
5161
springDataJPA(一)
一. ORM概述
ORM（Object-Relational Mapping） 表示对象关系映射。在面向对象的软件开发中，通过ORM，就可以把对象映射到关系型数据库中。只要有一套程序能够做到建立对象与数据库的关联，操作对象就可以直接操作数据库数据，就可以说这套程序实现了ORM对象关系映射
简单的说：ORM就是建立实体类和数据库表之间的关系，从而达到操作实体类就相当于操作数据库表的目的。
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是EJB QL的一种扩展，它是针对实体的一种查询语言，操作对象是实体，而不是关系数据库的表，而且能够支持批量更新和修改、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作为其实现类完成数据持久化工作。
三. 入门案例
3.1 案例需求
实现的功能是保存一个客户到数据库的客户表中。
3.2 开发包介绍
由于JPA是sun公司制定的API规范，所以我们不需要导入额外的JPA相关的jar包，只需要导入JPA的提供商的jar包。我们选择Hibernate作为JPA的提供商，所以需要导入Hibernate的相关jar包。
3.3 搭建开发环境
使用IDEA创建一个maven项目
3.3.1 导入jar包
<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驱动 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.6</version>
</dependency>
</dependencies>
3.3.2 创建客户的数据库表和客户的实体类
- 创建客户的数据库表
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;
- 创建客户的实体类
@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")
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;
/*此处已省略相应的getter,setter方法*/
}
-
实体类常用注解说明
@Entity 指定当前类是实体类。
@Table 指定实体类和表之间的对应关系。
属性： name：指定数据库表的名称
@Id 指定当前字段是主键。
@GeneratedValue 指定主键的生成方式。。
属性：strategy ：指定主键生成策略。
@Column 指定实体类属性和数据库表之间的对应关系
属性：
name：指定数据库表的列名称。 unique：是否唯一 nullable：是否可以为空 inserttable：是否可以插入 updateable：是否可以更新 columnDefinition: 定义建表时创建此列的DDL secondaryTable: 从表名。如果此列不建在主表上（默认建在主表），该属性定义该列所在从表的名字搭建开发环境[重点]
3.3.4 配置JPA的核心配置文件
在resources目录下创建META-INF文件夹，然后在META-INF文件夹内创建persistence.xml的配置文件
原生的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>
<!-- 数据库信息
用户名，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="123456"/>
<property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
<property name="javax.persistence.jdbc.url" value="jdbc:mysql:///jpa"/>
<!--配置jpa实现方(hibernate)的配置信息
是否显示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>
3.4 实现保存操作
public class JPATest {
@Test
public void test() {
/**
* 创建实体管理类工厂，借助Persistence的静态方法获取
* 其中传递的参数为持久化单元名称，需要jpa的配置文件中指定
*/
EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
//创建实体管理类
EntityManager em = factory.createEntityManager();
//获取事务对象
EntityTransaction tx = em.getTransaction();
//开启事务
tx.begin();
Customer c = new Customer();
c.setCustName("xsh");//操作实体类
//保存操作
em.persist(c);
//提交事务
tx.commit();
//释放资源
em.close();
factory.close();
}
}
四. JPA中的主键生成策略
通过annotation（注解）来映射hibernate实体的,基于annotation的hibernate主键标识为@Id, 其生成规则由@GeneratedValue设定的.这里的@id和@GeneratedValue都是JPA的标准用法。
JPA提供的四种标准用法为TABLE, SEQUENCE, IDENTITY, AUTO。
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long custId;
**IDENTITY: **主键由数据库自动生成（主要是自动增长型， mysql使用）
SEQUENCE：根据底层数据库的序列来生成主键，条件是数据库支持序列。(oracle不支持自增，所以只能用序列)
AUTO：主键由程序控制,自动选择主键生成策略
TABLE：使用一个特定的数据库表格来保存主键,该表中有下一次插入数据的主键
五.JPA的API介绍
5.1 Persistence对象
Persistence对象主要作用是用于获取EntityManagerFactory对象的 。通过调用该类的createEntityManagerFactory静态方法，根据配置文件中持久化单元名称创建EntityManagerFactory。
EntityManagerFactory factory= Persistence.createEntityManagerFactory("JPAName");
5.2 EntityManagerFactory
EntityManagerFactory 接口主要用来创建 EntityManager 实例
//创建实体管理类
EntityManager em = factory.createEntityManager();
由于EntityManagerFactory 是一个线程安全的对象（即多个线程访问同一个EntityManagerFactory 对象不会有线程安全问题），并且EntityManagerFactory 的创建极其浪费资源，所以在使用JPA编程时，我们可以对EntityManagerFactory 的创建进行优化，只需要做到一个工程只存在一个EntityManagerFactory 即可
5.3 EntityManager
在 JPA 规范中, EntityManager是完成持久化操作的核心对象。
我们可以通过调用EntityManager的方法完成获取事务，以及持久化数据库的操作
方法说明：
getTransaction : 获取事务对象
persist ： 保存操作
merge ： 更新操作
remove ： 删除操作
find/getReference ：根据查询
5.4 EntityTransaction
在 JPA 规范中, EntityTransaction是完成事务操作的核心对象.
执行更新，删除，插入操作时需要开启事务，执行完成后再提交事务
begin：开启事务
commit：提交事务
rollback：回滚事务
六. 使用JPA完成增删改查
import com.springdata.domain.Customer;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import javax.persistence.*;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
public class JPAtest {
//创建实体管理类工厂，借助Persistence的静态方法获取
//其中传递的参数为持久化单元名称，需要在jpa配置文件中指定
private EntityManagerFactory factory=null;//实体管理类工厂初始化
private EntityManager eManager=null;//创建实体管理类初始化
private EntityTransaction eTransaction=null;//事务对象初始化
@Before
public void init(){
//抽取初始化方法
factory= Persistence.createEntityManagerFactory("myJpa");
eManager=factory.createEntityManager();
eTransaction=eManager.getTransaction();
eTransaction.begin();
}
@After
public void destroy(){
//提交事务
eTransaction.commit();
//开始释放资源
eManager.close();
factory.close();
}
@Test
public void test1(){
//根据id查询数据
/*find立即加载,getReference延迟加载*/
Customer c1=eManager.getReference(Customer.class,2);
System.out.println(c1);
}
@Test
public void test2(){
//插入数据
Customer c=new Customer();
c.setCustName("xsh");
c.setCustAddress("上海");
c.setCustLevel("高级");
c.setCustSource("web");
eManager.persist(c); //persist方法执行插入操作
}
@Test
public void test3(){
//更新数据
Customer c=eManager.find(Customer.class,7);//指定更新的数据id
c.setCustSource("77");//需要更新的属性
//eManager.clear();//如果需要更新全部，则先把c对象从缓存中清除出去
eManager.merge(c);//merge方法执行更新操作
}
@Test
public void test4(){
//删除数据
Customer c=eManager.find(Customer.class,8);//先获取要删除的数据，8为删除的数据id
eManager.remove(c);//remove方法删除数据
}
}
七. JPQL实现复杂查询
JPQL全称 Java Persistence Query Language
其特征与原生SQL语句类似，并且完全面向对象，通过类名和属性访问，而不是表名和表的属性。
public class JPQLtest {
//创建实体管理类工厂，借助Persistence的静态方法获取
//其中传递的参数为持久化单元名称，需要在jpa配置文件中指定
private EntityManagerFactory factory=null;//实体管理类工厂初始化
private EntityManager eManager=null;//创建实体管理类初始化
private EntityTransaction eTransaction=null;//事务对象初始化
@Before
public void init(){
factory= Persistence.createEntityManagerFactory("myJpa");
eManager=factory.createEntityManager();
eTransaction=eManager.getTransaction();
eTransaction.begin();//开启事务
}
@After
public void destroy(){
//提交事务并释放资源
eTransaction.commit();
eManager.close();
factory.close();
}
@Test
public void test5(){
//查询表中全部数据
String jpql="from Customer";
Query query=eManager.createQuery(jpql);
List list=query.getResultList();
for(Object object:list){
System.out.println(object);
}
/* List<Customer> customers=query.getResultList();
for(Customer customer:customers){
System.out.println(customer);
}*/
}
@Test
public void test6(){
//分页查询表中数据
String jpql="from Customer";
Query query=eManager.createQuery(jpql);
int index=1;
int count=2;
int num=index+1;
System.out.println("开始查询：从数据库第"+num+"条数据开始查询,显示数据"+count+"条");
query.setFirstResult(index);//起始索引,从0开始
query.setMaxResults(count);//每页显示条数;
List list=query.getResultList();
for(Object object:list){
System.out.println(object);
}
}
@Test
public void test7(){
//根据条件查询表中数据
String jpql = "from Customer where custName like ? ";
Query query=eManager.createQuery(jpql);
query.setParameter(1,"%test%");//设置查询语句中的参数，从1开始
List list=query.getResultList();
for(Object object:list){
System.out.println(object);
}
}
@Test
public void test8(){
//排序查询数据，根据custId倒叙排序
String jpql = "from Customer order by custId desc";
Query query = eManager.createQuery(jpql);
List list=query.getResultList();
for(Object object:list){
System.out.println(object);
}
}
@Test
public void test9(){
//统计查询用户数量
String jpql="select count(custId) from Customer";
Query query=eManager.createQuery(jpql);
Object count=query.getResultList();
System.out.println("数据库总共有"+count+"条数据");
}
}
SpringDataJPA
评论