JPA相关接口/类
1.Persistence
.Persistence类是用于获取EntityManagerFactory实例.
该类包含一个名为createEntityManagerFactory的静态方法
.createEntityManagerFactory方法有如下两个重载形式:
-带有一个参数的方法以JPA配置文件persistence.xml中的持久化单元名为参数
-带有两个参数的方法:前一个参数含义相同,后一个参数Map类型,
用于设置JPA的相关属性,这时将忽略其他地方设置的属性.Map对象的属性名必须是
JPA实现库提供商的名字空间约定的属性名
2.EntityManagerFactory
.EntityManagerFactory接口主要用来创建EntityManager实例.该接口约定了如下4个方法:
-createEntityManager():用于创建实体管理器对象实例
-createEntityManager(Map map):用于创建实体管理器对象实例的重载方法,
Map参数用于提供EntityManager的属性
-isOpen():检查EntityManagerFactory是否处于打开状态.
EntityManagerFactory创建后一直处于打开状态,除非调用close()将其关闭.
-close():关闭EntityManagerFactory,EntityManagerFactory关闭后将释放所有资源,
isOpen()方法测试将返回false,其他方法将不能调用,
否则将导致IllegalStateException异常.
3.EntityManager
.在JPA规范中,EntityManager是完成持久化操作的核心对象,实体作为普通Java对象,
只有在调用EntityManager将其持久化后才会变成持久化对象.EntityManager对象在
一组实体类与底层数据源之间进行O/R映射的管理,它可以用来管理和更新Entity Bean,
根据主键查找Entity Bean,还可以通过JPQL语句来查询实体.
.实体的状态:
-新建状态:新创建的对象,尚未拥有持久性主键
-持久化状态:已经拥有持久性主键和持久化建立了上下文环境
-游离状态:拥有持久化主键,但是没有与持久化建立上下文环境
-删除状态:拥有持久化主键,已经和持久化建立上下文环境,但是从数据库删除
.find(Class<T> entityClass,Object primaryKey):返回指定的OID对应的实体类对象,
如果这个实体存在于当前持久化环境,则返回一个被缓存的对象,否则会创建一个新的
Entity,并加载数据库中相关信息,若OID不存在于数据库中,则返回一个null,第一个参数
为被查询的实体类类型,第二个参数为待查找实体的主键值.
.getReference(Class<T> entityClass,Object primaryKey):与find()类似,不同的是:
如果缓存中不存在指定的Entity.EntityManager会创建一个Entity类的代理,但是不会
立即加载数据库中的信息,只有第一次真正使用此Entity的属性才加载,所以如果此OID
在数据库不存在,getReference()不会返回null值,而是抛出EntityNotFoundException
.persist(Object entity):用于将新创建的Entity纳入到EntityManager的管理,该方法执行后,
传入persist()方法的Entity对象转换成持久化状态
-如果传入persist()方法的Entity对象已经处于持久化状态,则persist()方法什么都不做
-如果对删除状态的Entity进行persist()操作,会转换为持久化状态.
-如果对游离状态的实体执行persist()操作,可能会在persist()方法抛出EntityExistException,
也有可能是在flush或事务提交后抛出
-remove(Object entity):如果实例是被管理的,则与数据库实体记录关联,同时会删除关联的数据库记录.
4.merge(T entity):merge()用于处理Entity的同步.即数据库的插入和更新操作,代码如下:
package com.wayne.test;
import static org.junit.Assert.*;
import java.util.Date;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import com.wayne.helloworld.Customer;
public class JPATest {
private EntityManagerFactory entityManagerFactory;
private EntityManager entityManager;
private EntityTransaction transaction;
//每条测试之前的执行操作
@Before
public void init() {
entityManagerFactory = Persistence.createEntityManagerFactory("jpa_1_helloworld");
entityManager = entityManagerFactory.createEntityManager();
transaction = entityManager.getTransaction();
transaction.begin();
}
//每条测试之后的执行操作
@After
public void destroy() {
transaction.commit();
entityManager.close();
entityManagerFactory.close();
}
// 类似于hibernate中的Session的get()
@Test
public void testFind() {
Customer customer = entityManager.find(Customer.class, 1);
System.out.println("-------------");
System.out.println(customer.toString());
}
// 类似于hibernate中Session的load方法
@Test
public void testGetReference() {
Customer customer = entityManager.getReference(Customer.class, 1);
/*
* 生成代理对象
*/
System.out.println(customer.getClass().getName());
System.out.println("-------------");
/*
* transaction.commit(); entityManager.close();
*/
System.out.println(customer.toString());
}
// 类似于hibernate的save方法,使对象由临时状态变为持久化状态
// 与save()的不同:若对象有id,则不能执行insert操作,而是抛出异常
@Test
public void testPersistence() {
Customer customer = new Customer();
customer.setAge(22);
customer.setEmail("www.wayne.com");
customer.setLastName("wayne");
customer.setCreatedDate(new Date());
customer.setBirthDay(new Date());
entityManager.persist(customer);
System.out.println(customer.getId());
}
// 类似于hibernate的delete(),把对象对应的记录从数据库中移除
// 该方法只能移除持久化对象,而hibernate的delete方法实际上还可以移除游离对象
@Test
public void testRemove() {
/*
* 不能删除游离对象 Customer customer=new Customer(); customer.setId(2);
*/
Customer customer = entityManager.find(Customer.class, 2);
entityManager.remove(customer);
}
//类似于hibernate Session的saveOrUpdate方法
//1.若传入的是一个临时对象
@Test
public void testMerge1(){
Customer customer=new Customer();
customer.setAge(22);
customer.setEmail("www.wayne.com");
customer.setLastName("wayne");
customer.setCreatedDate(new Date());
customer.setBirthDay(new Date());
/*
* merge临时状态的对象会新建一个相同类型的对象
* 对新对象进行insert操作
* 所以新对象会有id,而临时状态的对象没有
*/
Customer customer2 = entityManager.merge(customer);
//null
System.out.println(customer.getId());
//新的主键
System.out.println(customer2.getId());
}
/*若传入的是一个游离对象,即传入的对象有OID
1.若在EntityManager缓存中没有该对象
2.若在数据库中也没有对应的记录
3.JPA会创建一个新的对象,然后把当前游离对象的属性复制到新创建的对象中
4.对对象进行insert操作*/
@Test
public void testMerge2(){
Customer customer=new Customer();
customer.setId(4);
customer.setAge(500);
customer.setEmail("www.wayne.com");
customer.setLastName("wayne");
customer.setCreatedDate(new Date());
customer.setBirthDay(new Date());
Customer customer2 = entityManager.merge(customer);
System.out.println(customer.getId());
System.out.println(customer2.getId());
}
/*若传入的是一个游离对象,即传入的对象有OID
1.若在EntityManager缓存中没有该对象
2.若在数据库中有对应的记录
3.JPA会查询对应的记录,然后返回该记录对应一个的对象,再然后会把游离对象的属性复制到查询到的对象中
4.对对象进行update操作*/
@Test
public void testMerge3(){
Customer customer=new Customer();
customer.setId(4);
customer.setAge(500);
customer.setEmail("www.wayne.com");
customer.setLastName("wayne");
customer.setCreatedDate(new Date());
customer.setBirthDay(new Date());
Customer customer2 = entityManager.merge(customer);
System.out.println(customer.getId());
System.out.println(customer2.getId());
System.err.println(customer==customer2);
}
/*若传入的是一个游离对象,即传入的对象有OID
1.若在EntityManager缓存中有该对象
2.JPA会把游离对象的属性复制到查询到EntityManager缓存中的对象中
(hibernate不会关联两个具有相同OID的对象,jpa可以)
3.EntityManager缓存中的对象执行update*/
@Test
public void testMerge4(){
Customer customer=new Customer();
customer.setId(4);
customer.setAge(500);
customer.setEmail("www.wayne.com");
customer.setLastName("wayne");
customer.setCreatedDate(new Date());
customer.setBirthDay(new Date());
Customer customer2 = entityManager.find(Customer.class,customer.getId());
entityManager.merge(customer);
System.out.println(customer.getId());
System.out.println(customer2.getId());
System.err.println(customer==customer2);
}
}
5..flush():同步持久上下文环境,即将持久上下文环境的所有为保存实体的状态信息保存
到数据库中
.setFlushMode(FlushModeType flushMode):设置持久上下文环境的Flush模式.
参数可以取2个枚举:
-FlushModeType.AUTO为自动更新数据库实体
-FlushModeType.COMMIT为直到提交事务时才更新数据库记录
.getFlushMode():获取持久上下文环境的Flush模式,返回FlushModeType类的枚举值
.refresh(Object entity):用数据库实体记录的值更新实体对象的状态,即更新实例的属性值
.clear():清除持久上下文环境,断开所有关联的实体,如果这时还有未提交的更新则会被撤销
.contains:判断一个实例是否属于当前持久上下文环境管理的实体
.isOpen():判断当前的实体管理器是否为打开状态
.getTransaction():返回资源层的事务对象,EntityTransaction实例可以用于开始和提交多个事务
.close():关闭实体管理器.之后若调用实体管理器实例的方法或其派生的查询对象的方法都将抛出
IllegalstateException异常,除了getTransaction和isOpen方法(返回false).不过,当与实体管理器
关联的事务处于活动状态时,调用close方法后持久上下文将仍处于管理状态,直到事务完成
.createQuery(String qlString):创建一个查询对象
.createNameQuery(String name):根据命名的查询语句块创建查询对象.参数为命名的查询语句
.createNativeQuery(String sqlString):使用标准SQL语句创建查询对象,参数为标准SQL语句字符串
.createNativeQuery(String sqls,String resultSetMapping):使用标准SQL语句创建查询对象,并指定返回结果集Map的名称
6.EntityTransaction
.EntityTransaction接口用来管理资源层实体管理器的事务操作.通过调用实体管理器的getTransaction方法获得其实例.
.begin():用于启动一个事务,此后的多个数据库操作将作为整体被提交或撤销.
若这时事务已启动则会抛出IllegalStateException异常
.commit():用于提交当前事务,即将事务启动以后的所有数据库更新操作持久化至数据库中
.rollback:回滚(撤销)当前事务,即回滚事务启动后的所有数据库更新操作,从而不对数据库产生影响
.setRollbackOnly:使当前事务只能被撤销
.getRollbackOnly:查看当前事务是否设置了只能撤销标志
.isActive():查看当前事务是否是活动的,如果返回true则不能调用begin(),否则将抛出
IllegalStateException异常,如果返回false则不能调用commit,rollback,setRollbackOnly
及getRollbackOnly方法,否则将抛出IllegalStateException异常.