JPA

概述

JPA:Java Persistence API，用于对象持久化的API
Java EE 5.0平台标准的ORM规范，使得应用程序以统一的方式访问持久层

JPA和Hibernate的关系

JPA是规范，JPA实质上就是一种ORM规范，不是ORM框架——因为JPA并未提供ORM实现，它只是制定了一些规范，提供了一些编程的API接口，但具体实现则由ORM厂商提供实现

JDBC规范

JPA规范

JPA的供应商

JPA的目标之一是制定一个可以由很多供应商实现的API，目前Hibernate 3.2+、TopLink 10.1+以及OpenJPA都提供了JPA的实现

JPA包括3方面的技术

1. ORM映射元数据：JPA支持XML和JDK 5.0注解两种元数据的形式，元数据描述对象和表之间的映射关系，框架据此将实体对象
2. 持久化到数据库表中。
3. JPA的API：用来操作实体对象，执行CRUD操作，框架在后台完成所有事情，开发者从频繁的JDBC和SQL代码中解脱出来。
4. 查询语言（JPQL）：这是持久化操作中很重要的一个方面，通过面向对象而非面向数据库的查询语言查询数据，避免程序和具体的SQL紧密耦合。

基础配置

步骤

1. 配置persistence.xml，persistence.xml位于META-INF目录下
2. 创建实体类，使用annotation来描述实体类跟数据库表之间的映射关系
3. 使用JPA API完成数据增删改查操作（EntityManager）

需要用到的jar包

• antlr-2.7.7.jar
• dom4j-1.6.1.jar
• hibernate-commons-annotations.jar
• hibernate-core-4.2.4.Final.jar
• hibernate-entitymanager-4.2.3.Final.jar
• hibernate-jpa-2.0-api-1.0.1.Final.jar
• javassist-3.15.0-GA.jar
• jboss-logging-3.1.0.GA.jar
• jboss-transaction-api_1.1_spec-1.0.jar
• mysql-connector-java-5.1.7.bin.jar

配置persistence.xml

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0"
	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">
	<persistence-unit name="jpa-01">
		<!-- 配置是用什么ORM产品作为JPA的实现 1. 实际上配置的是javax.persistence.spi.PersistenceProvider接口的实现类 
			2. 若JPA项目中只有一个JPA的实现产品，则也可以不配置该节点 -->
		<provider>org.hibernate.ejb.HibernatePersistence</provider>
		<class>com.iuie.jpa.entity.Customer</class>

		<properties>
			<!-- 连接数据库的基本信息 -->
			<property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver" />
			<property name="javax.persistence.jdbc.url" value="jdbc:mysql:///ns" />
			<property name="javax.persistence.jdbc.user" value="root" />
			<property name="javax.persistence.jdbc.password" value="123456" />

			<!-- 配置JPA实现产品的基本属性，配置hibernate的基本属性 -->
			<property name="hibernate.format_sql" value="true" />
			<property name="hibernate.show_sql" value="true" />
			<property name="hibernate.hbm2ddl.auto" value="update" />
		</properties>

	</persistence-unit>
</persistence>

常用注解

@GeneratedValue注解

作用

用于标注主键的生成策略，通过strategy属性指定。默认情况下，JPA自动选择一个最适合底层数据库的主键生成策略：

• SQL Server：identity
• MySQL：auto increment

在javax.persistence.GenerationType中定义了以下几种可供选择的策略：

• IDENTITY:采用数据库ID自增长的方式来自增主键字段，Oracle不支持这种方式
• AUTO：JPA自动选择合适的策略，是默认选项
• SEQUENCE:通过序列产生主键，通过@SequenceGenerator注解指定程序名，MySQL不支持这种方式
• TABLE:通过表产生主键，框架借由表模拟序列产生主键，使用该策略可以使应用更易于数据库移植

@Column注解

作用

设置每一列的属性

属性

• name属性：用于设置映射数据库表的列名
• unique属性：指定是否允许重复值
• length属性：指定字段的长度
• nullable属性：指定是否非空

@Transient注解

作用

表示该属性并非一个到数据库表的字段的映射，ORM框架将忽略该属性如果一个属性并非数据库表的字段映射，就务必将其标示为@Transient，否则，ORM框架默认将其注解为@Basic

@Temporal注解

作用

指明日期的表达形式，value属性需要指定TemporalType的枚举值,
TemporalType 的枚举值包括：

• TemporalType.TIMESTAMP // yyyy-MM-dd HH:mm:ss形式
• TemporalType.DATE // yyyy-MM-dd形式

示例

private Date loginTime;

private Date birthday;
// yyyy-MM-dd HH:mm:ss
@Temporal(TemporalType.TIMESTAMP)
public Date getLoginTime(){
	return this.loginTime;
}
public void setLoginTime(Date loginTime){
	this.loginTime=loginTime;
}
// yyyy-MM-dd
@Temporal(TemporalType.DATE)
public Date getBirthday(){
	return this.birthday;
}
public void setBirthday(Date birthday){
	this.birthday=birthday;
}

用table来生成主键策略

（使用的情景相对较少）

步骤

·1. 创建一个生成主键的表：

表名：JPA_ID_GENERATOR(数据表ID生成策略表)

columnName	dataType	length	是否主键	是否不为空	描述
ID	int	10	y	y	生成表的ID
PK_NAME	varchar	50	n	y	需要使用此策略的表名称
PK_VALUE	int	10	n	y	起始值，种子

·2. 插入几个值

ID	PK_NAME	PK_VALUE
1	CUSTOMER_ID	1
2	STUDENT_ID	10
3	ORDER_ID	100

·3. 编写Customer.java

private Integer id;

@TableGenerator(name="ID_GENERATOR",table="JPA_ID_GENERATOR",pkColumnName="PK_NAME",
	pkColumnValue="CUSTOMER_ID",valueColumnName="PK_VALUE",allocationSize=100)
@GeneratedValue(strategy=GenerationType.TABLE,generator="ID_GENERATOR")
@Id
public Integer getId(){
	return id;
}

·4. 执行向Customer表中插入2条数据（因为ID采用table生成策略，所以插入数据时，不需要指定ID）

插入后，结果显示Customer表的ID分别为
100
200

JPA API

Persistencce类

作用：获取EntityManagerFactory的实例
·1. 仅传unitName的参数获取EntityManagerFactory

EntityManagerFactory Persistence.createEntityManagerFactory(String persistenceUnitName);

·2. 传入Map<String,Object> properties 设置参数的方法

Map<String,Object> properties = new HashMap<String,Object>();
properties.put("hibernate.show_sql",false); // 设置上去之后，将不会打印SQL，不常用
// properties：设置实例参数，此处的实例为hibernate，故设置的是
EntityManagerFactory Persistence.createEntityManagerFactory(Map<String,Object> properties,String persistenceUnitName); hibernate的参数

EntityManagerFactory类

作用：创建EntityManager实例

• createEntityManager(); // 创建EntityManager的实例，类似于Hibernate的sessionFactory
• createEntityManager(Map map); // 用于创建实体管理器对象实例的重载方法，Map参数用于提供EntityManager的属性，不常用
• isOpen(); // 检查EntityManagerFactory是否处于打开状态。实体管理器工厂创建后一直处于打开状态，除非调用close方法将其关闭。
• close(); // 关闭EntityManagerFactory，关闭后将释放所有资源，isOpen方法测试将返回false，其它方法将不能调用，否则将导致IllegalStateException

EntityManager类

具体实例中讲解

public class Customer {
	private Integer id;
	createTime,birthday,age,lastName,email
	...
	@GeneratedValue(strategy=GenerationType.AUTO)
	@Id
	public Integer getId(){
		return this.id;
	}
	...
	toString()...
}

public class JPATest {
	private EntityManager entitymanager;
	
	private EneityMangerFactory entitymanagerFactory;
	
	private EntityTransaction transaction;
	
	@Before
	public void init(){
		entitymanagerFactory = Persistencce.createEntityManagerFactory("jpa-1");
		entitymanager = entitymanagerFactory.createEntityManager();
		transaction = entitymanager.getTransaction();
		transaction.begin();
	}
	
	// 类似于Hibernate的sessionFactory.get 方法
	// 执行结果特点：1. 打印查询SQL 2. 打印横线 3. 打印查询结果 （未使用懒加载）
	@Test
	public void testFind(){
		Customer customer = entitymanager.find(Customer.class,1); // 数据库中请确保有一条记录
		sysout("-----------------");
		sysout(customer);
	}
	
	// 类似于Hibernate的sessionFactory.load方法
	// 执行结果特点：1. 打印横线 2. 打印查询SQL 3. 打印查询结果 （使用了懒加载，在查询结果被真正使用时才做查询）
	// 如果在查询结果被真正使用前，关闭了session，调用查询结果时会报session关闭的异常，即：
	// 		org.hibernate.LazyInitializationException:could not initialize proxy - no Session
	@Test
	public void testGetReference(){
		Customer customer = entitymanager.getReference(Customer.class,1); // 数据库中请确保有一条记录
		sysout("-----------------");
		sysout(customer);
	}
	
	// 类似于 hibernate的save方法，使对象由临时状态变为持久化状态。
	// 和hibernate的save方法的不同之处：若对象有id，则不能执行insert操作，而会抛出异常
	@Test
	public void testPersistence(){
		Customer customer = new Customer();
		customer.setAge...;
		customer.setBirthday...
		customer.setCreateTime...
		customer.setEmail...
		customer.setLastName...
		
		entitymanager.persist(customer);
		
		sysout(customer.getId());// 能看到id被打印
	}
	// 类似于hibernate的delete方法，把对象对应的记录从数据库中移除
	// 但注意：该方法只能移除持久化对象，但hibernate的delte方法实际上还可以移除游离对象
	@Test
	public void testRemove(){
		// Customer customer = new...;
		// customer.setId(2) ;// 请确保表中有这条数据
		// entitymanager.remove(customer);// 这样做会报错,hibernate.delete可以这样做
		
		Customer customer2 = entitymanager.find(Customer.class,2);
		entitymanager.remove(customer2);// 这样做就不会报错
	}
	@After
	public void destroy(){
		transaction.commit();
		entitymanager.close();
		entitymanagerFactory.close();
	}
	// 总的来说，类似于hibernate的session的saveOrUpdate方法
	// 会创建一个新的对象，把临时对象的属性复制到新的对象中，然后对新的对象执行持久化操作，
	// 所以新的对象有id，但以前的临时对象中没有id。
	@Test
	public void testMerge1(){
		Customer   c = new Customer()..
		c.setAge...
		c.setBirthday...
		c.setCreateTime new Date....
		c.setEmail...
		c.setLastName...
		
		Customer c2= entitymanager.merge(c);
		
		sysout(c.id); // c 不会有id
		sysout(c2.id); // c2 有id，持久化的是c2
		
	}
	// 若传入的是一个游离对象，即传入的对象有ID。
	// 1. 若在EntityManger 缓存中没有该对象
	// 2. 若在数据库中也没有对应的记 录
	// 3. JPA会创建一个新的对象，然后把当前游离的对象的属性复制到新创建的对象中
	// 4. 对新创建的对象执行insert操作。
	@Test 
	public void testMerge2(){
		Customer   c = new Customer()..
		c.setAge...
		c.setBirthday...
		c.setCreateTime new Date....
		c.setEmail...
		c.setLastName...
		
		c.setId(100); // 使c变成游离对象
		
		Customer c2= entitymanager.merge(c);
		
		sysout(c.id); // 打印100
		sysout(c2.id); // 打印持久化后的值，不一定就是100
	}
	// 若传入的是一个游离对象，即传入的对象有ID。
	// 1. 若在EntityManger 缓存中没有该对象
	// 2. 若在数据库中有对应的记录
	// 3. JPA会查询对应的记录，然后返回该记录对应的对象，再然后会把游离对象的属性复制到查询到的对象中
	// 4. 对查询到的对象执行update操作。
	@Test
	public void testMerge3(){
		Customer   c = new Customer()..
		c.setAge...
		c.setBirthday...
		c.setCreateTime new Date....
		c.setEmail...
		c.setLastName...
		
		c.setId(4); // 使c变成游离对象 , 确保数据库中存在id=4的对象
		
		Customer c2= entitymanager.merge(c);
		
		sysout(c== c2); // false
	}
	// 若传入的是一个游离对象，即传入的对象有ID。
	// 1. 若在EntityManger 缓存中有该对象
	// 2. JPA会把游离对象的属性复制到查询到EntityManager缓存中的对象中
	// 3. EntityManager 缓存中的对象执行UPDATE
	// hibernate中，在缓存中不能存在两个id相同的对象，在hibernate中、
	// Customer c1=....实例化...，确保c1的id=4
	// Customer c2 = entityManager.find(Customer.class,4) ;
	// session.saveOrUpdate(c1); // 这会将c1 加载进缓存，两个id同为4的Customer实例在hibernate中不能存在，会报
	// 	org.hibernate.NonUniqueObjectException的错误
	@Test
	public void testMerge4(){
		Customer   c = new Customer()..
		c.setAge...
		c.setBirthday...
		c.setCreateTime new Date....
		c.setEmail...
		c.setLastName...
		
		c.setId(4); // 使c变成游离对象 , 确保数据库中存在id=4的对象
		
		Customer c2= entitymanager.find(Customer.class,4); // 确保数据库中存在id=4的对象
		entityManager.merge(customer);
		
		sysout(c== c2); // false
		
	}
	// 同hibernate中，session.flush()
	@Test
	public void testFlush(){
		Customer c = entityManager.find(Customer.class,1);//确保数据库中已存在id=1的记录
		sysout(c);
		c.setLastName("cc"); // 在不执行flush方法时：这个值在commit时才执行update的SQL，然后数据会被更新到数据库中
		entityManager.flush(); // 在执行flush方法时：会执行update的SQL，执行commit方法时会更新到数据库中
	}
	
	// 同hibernate 中 session的refresh方法
	@Test
	public void testRefresh(){
		Customer c = entityManager.find(Customer.class,1);
		c = entityManager.find(Customer.class,1); // 当不执行refresh方法的情况下，只会查询一次，第二次的查询会从
											// 缓存中获取
		entityManager.refresh(c); // 当执行refresh方法的情况下，会执行两次查询
	
	}

在JPA中，实体也有以下几个状态：

• 新建状态：新创建的对象，尚未拥有持久性主键
• 持久化状态：已经拥有持久性主键并和持久化建立了上下文环境
• 游离状态：拥有持久化主键，但是没有与持久化建立上下文环境
• 删除状态：拥有持久化主键，已经和持久化建立上下文环境，但是从数据库中删除

常用方法：

merge(T entity)	merge()用于处理Entity的同步。即数据库的插入和更新操作 （）
flush()	同步持久上下文环境，即将持久上下文环境的所有未保存实体的状态信息保存到数据库中
setFlushMode(FlushModeType flushMode)	设置持久上下文环境的Flush模式。参数可以取2个枚举
FlushModeType.AUTO自动更新数据库实体，
FlushModeType.COMMIT 直到提交事务时才更新数据库记录
getFlushMode()	获取持久上下文环境的Flush模式。返回 FlushModeType 类的枚举值
refresh(Object entity)	用于数据库实体记录的值更新实体对象的状态，即更新实例的属性值
clear()	清除持久上下文环境，断开所有关联的实体，如果这时还有未提交的更新则会被撤销。
contains(Object entity)	判断一个实例是否属于当前持久上下文环境管理的实体
isOpen()	判断当前的实体管理器是否是打开状态
getTransaction()	返回资源层的事务对象。EntityTransaction实例可以用于开始和提交多个事务
close()	关闭实体管理器。之后若调用实体管理器实例的方法或其派生的查询对象的方法都将会抛出IllegalstateException异常，除了getTransaction()和isOpen方法返回false。不过，当与实体管理器关联的事务处于活动状态时，调用close方法后持久上下文将处于被管理状态，直到事务完成。
createQuery(String qlString)	创建一个查询对象
createNamedQuery(String name)	根据命名的查询语句查询对象。参数为命名的查询语句
createNativeQuery(String sqlString)	使用标准的SQL语句创建查询对象，参数为标准SQL语句字符串
createNativeQuery(String sql,String resultSetMapping)	使用标准SQL语句创建查询对象，并制定返回结果集Map的名称

EntityTransaction类

介绍：

EntityTransaction接口：用来管理资源层实体管理器的事务操作。通过调用实体管理器的getTransaction方法获得其实例

API方法

begin()	用于启动一个事务，伺候的多个数据库操作将作为整体被提交或撤销，若这时事务已启动，则会抛出IllegalStateException
commit()	用于提交当前事务。即将事务启动以后的所有数据库更新操作持久化至数据库中
rollback()	回滚当前事务，即撤销事务启动后的所有数据库更新操作，从而不对数据库产生影响
setRollbackOnly()	使当前事务只能被撤销
getRollbackOnly()	查看当前事务是否设置了只能撤销标识
isActive()	查看当前事务是否是活动的。若返回true则不能调用begin方法，否则抛出IllegalStateException异常；若返回false则不能调用commit、rollback、setRollbackOnly及getRollbackOnly方法，否则抛出IllegalStateException异常

映射关联关系

几个重要属性介绍

1. fetch属性-设置是否懒加载

取值	作用
FetchType.LAZY	采用懒加载策略，也是默认策略
FetchType.EAGER	采用立即加载策略

2. cascade属性

取值	作用
CascadeType.ALL	包含所有；
CascadeType.PERSIST	级联保存：对order对象保存时也对items里的对象也会保存。对应EntityManager的presist方法
CascadeType.MERGE	级联更新：若items属性修改了那么order对象保存时同时修改items里的对象。对应EntityManager的merge方法 （较常用）
CascadeType.REMOVE	级联删除：对order对象删除也对items里的对象也会删除。对应EntityManager的remove方法
CascadeType.REFRESH	级联刷新：获取order对象里也同时也重新获取最新的items时的对象。对应EntityManager的refresh(object)方法有效。即会重新查询数据库里的最新数据
CascadeType.DETACH	级联分离操

单向多对一

步骤
·1. 定义Order类（多的一方）
·2. 定义Customer类（1的一方）
·3. Order类上定义关联关系

// 映射单向多对一的关联关系
// 使用@ManyToOne来映射多对一的关联关系
// 使用@JoinColumn来映射外键
// 可以使用@ManyToOne的fetch属性来修改默认的关联属性的加载策略
@JoinColumn(name="customer_id")
@ManyToOne(fetch=FetchType.LAZY)
public Customer getCustomer() {
	return customer;
}

·4. JPATest.java中继续编写测试类

    @Test
    public void testManyToOneUpdate(){
    	Order order1 = entitymanager.find(Order.class, 2);
    	order1.setOrderName("ssfj");
    }

    // 不能直接删除1的一端，因为有外键约束
    @Test
    public void testManyToOneRemove(){
//    	Order order = entitymanager.find(Order.class, 1);
//    	entitymanager.remove(order);
    	
    	Customer c = entitymanager.find(Customer.class, 304);
    	entitymanager.remove(c); // 删除失败
    }
    
    // 默认情况下，使用左外连接的方式来获取n的一端的对象和其关联的1的一端的对象
    // 可以使用@ManyToOne的fetch属性来修改默认的关联属性的加载策略
    @Test
    public void testManyToOneFind(){
    	Order order1 = entitymanager.find(Order.class, 1);
    	sysout(order1.getOrderName());
    	sysout(order1.getCustomer().getLastName());
    }
    
    // 保存多对一时，建议先保存1的一边，后保存多的一边，这样不会多出额外的update
    @Test
    public void testManyToOnePersist(){
    	Customer c1 = new Customer();
		c1.setAge(21);
		c1.setBirthday(new Date());
		c1.setCreatedTime(new Date());
		c1.setEmail("12345d@qq.com");
		c1.setLastName("舒晓春");
		
		Order o1 = new Order();
		o1.setOrderName("0-ff01");
		Order o2 = new Order();
		o2.setOrderName("0-ff02");
		
		o1.setCustomer(c1);
		o2.setCustomer(c1);
		
		entitymanager.persist(c1);
		entitymanager.persist(o1);
		entitymanager.persist(o2);
    }

1. 定义Order类（多的一方）

@Entity
@Table(name="jpa_orders")
public class Order {

	private Integer id;

	private String orderName;

	private Customer customer;

	@GeneratedValue
	@Id
	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	@Column(name="order_name")
	public String getOrderName() {
		return orderName;
	}

	public void setOrderName(String orderName) {
		this.orderName = orderName;
	}

	// 映射单向多对一的关联关系
	// 使用@ManyToOne来映射多对一的关联关系
	// 使用@JoinColumn来映射外键
	// 可以使用@ManyToOne的fetch属性来修改默认的关联属性的加载策略
	@JoinColumn(name="customer_id")
	@ManyToOne(fetch=FetchType.LAZY)
	public Customer getCustomer() {
		return customer;
	}

	public void setCustomer(Customer customer) {
		this.customer = customer;
	}

	@Override
	public String toString() {
		return "Order [id=" + id + ", orderName=" + orderName + ", customer="
				+ customer + "]";
	}

}

2. Customer类

@Table(name = "JPA_CUSTOMERS")
@Entity
public class Customer {
	private Integer id;
	private String lastName;
	private String email;
	private int age;

	private Date createdTime;// 创建时间

	private Date birthday; // 生日

//	@TableGenerator(name = "ID_GENERATOR", table = "JPA_ID_GENERATOR",
//			pkColumnName = "PK_NAME", pkColumnValue = "CUSTOMER_ID", 
//			valueColumnName = "PK_VALUE", allocationSize = 100)
//	@GeneratedValue(strategy = GenerationType.TABLE, generator = "ID_GENERATOR")
	@GeneratedValue(strategy=GenerationType.AUTO)
	@Id()
	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	@Column(name = "last_name")
	public String getLastName() {
		return lastName;
	}

	public void setLastName(String lastName) {
		this.lastName = lastName;
	}

	public String getEmail() {
		return email;
	}

	public void setEmail(String email) {
		this.email = email;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	// 这是一个工具方法，不能映射为一列
	@Transient
	public String getInfo() {
		return "lastName = " + lastName + ", age = " + age;
	}

	@Temporal(TemporalType.DATE)
	public Date getBirthday() {
		return birthday;
	}

	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}

	@Column(name = "created_time")
	public Date getCreatedTime() {
		return createdTime;
	}

	public void setCreatedTime(Date createdTime) {
		this.createdTime = createdTime;
	}

	@Override
	public String toString() {
		return "Customer [id=" + id + ", lastName=" + lastName + ", email="
				+ email + ", age=" + age + ", createdTime=" + createdTime
				+ ", birthday=" + birthday + "]";
	}
}

3. 编写JPA测试类

public class JPATest {

	private EntityManagerFactory factory;

	private EntityManager entitymanager;

	private EntityTransaction transaction;

	@Before
	public void init() {
		factory = Persistence.createEntityManagerFactory("jpa-01");
		entitymanager = factory.createEntityManager();
		transaction = entitymanager.getTransaction();
		transaction.begin();
	}
    @Test
    public void testManyToOneUpdate(){
    	Order order1 = entitymanager.find(Order.class, 2);
    	order1.setOrderName("ssfj");
    }

    // 不能直接删除1的一端，因为有外键约束
    @Test
    public void testManyToOneRemove(){
//    	Order order = entitymanager.find(Order.class, 1);
//    	entitymanager.remove(order);
    	
    	Customer c = entitymanager.find(Customer.class, 304);
    	entitymanager.remove(c); // 删除失败
    }
    
    // 默认情况下，使用左外连接的方式来获取n的一端的对象和其关联的1的一端的对象
    // 可以使用@ManyToOne的fetch属性来修改默认的关联属性的加载策略
    @Test
    public void testManyToOneFind(){
    	Order order1 = entitymanager.find(Order.class, 1);
    	sysout(order1.getOrderName());
    	sysout(order1.getCustomer().getLastName());
    }
    
    // 保存多对一时，建议先保存1的一边，后保存多的一边，这样不会多出额外的update
    @Test
    public void testManyToOnePersist(){
    	Customer c1 = new Customer();
		c1.setAge(21);
		c1.setBirthday(new Date());
		c1.setCreatedTime(new Date());
		c1.setEmail("12345d@qq.com");
		c1.setLastName("舒晓春");
		
		Order o1 = new Order();
		o1.setOrderName("0-ff01");
		Order o2 = new Order();
		o2.setOrderName("0-ff02");
		
		o1.setCustomer(c1);
		o2.setCustomer(c1);
		
		entitymanager.persist(c1);
		entitymanager.persist(o1);
		entitymanager.persist(o2);
    }

	@After
	public void destroy() {
		transaction.commit();
		entitymanager.close();
		factory.close();
	}

	private void sysout(Object obj) {
		System.out.println(obj);
	}
}

单向一对多

步骤
·1. 定义Customer类，在其中添加多的一方orders

	private Set<Order> orders = new HashSet<>();
	// 映射单向一对多的关联关系
	// 使用OneToMany来映射一对多的关联关系
	// 使用@JoinColumn来映射外键列的名称
	// 可以使用@OneToMany的fetch属性来修改默认的加载策略
	// 可以通过修改OneToMany的cascade属性来修改默认的删除策略
	@JoinColumn(name="CUSTOMER_ID")
	@OneToMany(fetch=FetchType.EAGER,cascade={CascadeType.REMOVE})
	public Set<Order> getOrders() {
		return orders;
	}
	public void setOrders(Set<Order> orders) {
		this.orders = orders;
	}

·2. 定义Order类

·3. 编写测试类

	@Test
	public void testOneToManyUpdate(){
		Customer customer = entitymanager.find(Customer.class, 305);
		customer.getOrders().iterator().next().setOrderName("updatevalue-305");
	}
	
	// 默认情况下，若删除1的一端，则会先把关联的n的一端的外键置空，然后进行删除
	// 可以通过修改OneToMany的cascade属性来修改默认的删除策略
	@Test
	public void testOneToManyRemove(){
		Customer customer = entitymanager.find(Customer.class, 313);
		entitymanager.remove(customer);
	}
	
	// 默认对关联的多的一方，使用懒加载的加载策略
	// 可以使用@OneToMany的fetch属性来修改默认的加载策略
	@Test
	public void testOneToManyFind(){
		Customer customer = entitymanager.find(Customer.class, 314);
		sysout(customer);
		sysout(customer.getOrders().size());
	}
	
	// 单向一对多关联关系执行保存时，一定会多出update语句，因为多的一端，在插入时，不会同时插入外键列
	@Test
	public void testOneToManyPersist() {
		// 保存多对一时，建议先保存1的一边，后保存多的一边，这样不会多出额外的update
		Customer c1 = new Customer();
		c1.setAge(21);
		c1.setBirthday(new Date());
		c1.setCreatedTime(new Date());
		c1.setEmail("1ddwd@qq.com");
		c1.setLastName("舒小雅");

		Order o1 = new Order();
		o1.setOrderName("0-ff01");
		Order o2 = new Order();
		o2.setOrderName("0-ff02");

		c1.getOrders().add(o1);
		c1.getOrders().add(o2);

		// 执行3条插入操作，2条update
		entitymanager.persist(c1);
		entitymanager.persist(o1);
		entitymanager.persist(o2);
	}

1. Customer类

@Table(name = "JPA_CUSTOMERS")
@Entity
public class Customer {
	private Integer id;
	private String lastName;
	private String email;
	private int age;

	private Date createdTime;// 创建时间

	private Date birthday; // 生日
	
	private Set<Order> orders = new HashSet<>();
	// 映射单向一对多的关联关系
	// 使用OneToMany来映射一对多的关联关系
	// 使用@JoinColumn来映射外键列的名称
	// 可以使用@OneToMany的fetch属性来修改默认的加载策略
	// 可以通过修改OneToMany的cascade属性来修改默认的删除策略
	@JoinColumn(name="CUSTOMER_ID")
	@OneToMany(fetch=FetchType.EAGER,cascade={CascadeType.REMOVE})
	public Set<Order> getOrders() {
		return orders;
	}
	public void setOrders(Set<Order> orders) {
		this.orders = orders;
	}
	

//	@TableGenerator(name = "ID_GENERATOR", table = "JPA_ID_GENERATOR",
//			pkColumnName = "PK_NAME", pkColumnValue = "CUSTOMER_ID", 
//			valueColumnName = "PK_VALUE", allocationSize = 100)
//	@GeneratedValue(strategy = GenerationType.TABLE, generator = "ID_GENERATOR")
	@GeneratedValue(strategy=GenerationType.AUTO)
	@Id()
	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	@Column(name = "last_name")
	public String getLastName() {
		return lastName;
	}

	public void setLastName(String lastName) {
		this.lastName = lastName;
	}

	public String getEmail() {
		return email;
	}

	public void setEmail(String email) {
		this.email = email;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	// 这是一个工具方法，不能映射为一列
	@Transient
	public String getInfo() {
		return "lastName = " + lastName + ", age = " + age;
	}

	@Temporal(TemporalType.DATE)
	public Date getBirthday() {
		return birthday;
	}

	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}

	@Column(name = "created_time")
	public Date getCreatedTime() {
		return createdTime;
	}

	public void setCreatedTime(Date createdTime) {
		this.createdTime = createdTime;
	}

	@Override
	public String toString() {
		return "Customer [id=" + id + ", lastName=" + lastName + ", email="
				+ email + ", age=" + age + ", createdTime=" + createdTime
				+ ", birthday=" + birthday + "]";
	}
}

2. Order类

@Entity
@Table(name="jpa_orders")
public class Order {

	private Integer id;

	private String orderName;

//	private Customer customer;
	
	@GeneratedValue
	@Id
	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	@Column(name="order_name")
	public String getOrderName() {
		return orderName;
	}

	public void setOrderName(String orderName) {
		this.orderName = orderName;
	}

	@Override
	public String toString() {
		return "Order [id=" + id + ", orderName=" + orderName + "]";
	}

	// 映射单向多对一的关联关系
	// 使用@ManyToOne来映射多对一的关联关系
	// 使用@JoinColumn来映射外键
	// 可以使用@ManyToOne的fetch属性来修改默认的关联属性的加载策略
//	@JoinColumn(name="customer_id")
//	@ManyToOne(fetch=FetchType.LAZY)
//	public Customer getCustomer() {
//		return customer;
//	}
//
//	public void setCustomer(Customer customer) {
//		this.customer = customer;
//	}

}

3. JPATest类

public class JPATest {

	private EntityManagerFactory factory;

	private EntityManager entitymanager;

	private EntityTransaction transaction;

	@Before
	public void init() {
		factory = Persistence.createEntityManagerFactory("jpa-01");
		entitymanager = factory.createEntityManager();
		transaction = entitymanager.getTransaction();
		transaction.begin();
	}
	@Test
	public void testOneToManyUpdate(){
		Customer customer = entitymanager.find(Customer.class, 305);
		customer.getOrders().iterator().next().setOrderName("updatevalue-305");
	}
	
	// 默认情况下，若删除1的一端，则会先把关联的n的一端的外键置空，然后进行删除
	// 可以通过修改OneToMany的cascade属性来修改默认的删除策略
	@Test
	public void testOneToManyRemove(){
		Customer customer = entitymanager.find(Customer.class, 313);
		entitymanager.remove(customer);
	}
	
	// 默认对关联的多的一方，使用懒加载的加载策略
	// 可以使用@OneToMany的fetch属性来修改默认的加载策略
	@Test
	public void testOneToManyFind(){
		Customer customer = entitymanager.find(Customer.class, 314);
		sysout(customer);
		sysout(customer.getOrders().size());
	}
	
	// 单向一对多关联关系执行保存时，一定会多出update语句，因为多的一端，在插入时，不会同时插入外键列
	@Test
	public void testOneToManyPersist() {
		// 保存多对一时，建议先保存1的一边，后保存多的一边，这样不会多出额外的update
		Customer c1 = new Customer();
		c1.setAge(21);
		c1.setBirthday(new Date());
		c1.setCreatedTime(new Date());
		c1.setEmail("1ddwd@qq.com");
		c1.setLastName("舒小雅");

		Order o1 = new Order();
		o1.setOrderName("0-ff01");
		Order o2 = new Order();
		o2.setOrderName("0-ff02");

		c1.getOrders().add(o1);
		c1.getOrders().add(o2);

		// 执行3条插入操作，2条update
		entitymanager.persist(c1);
		entitymanager.persist(o1);
		entitymanager.persist(o2);
	}
	@After
	public void destroy() {
		transaction.commit();
		entitymanager.close();
		factory.close();
	}

	private void sysout(Object obj) {
		System.out.println(obj);
	}
}

双向多对一（跟双向一对多是一个意思）

步骤

1. 定义Customer类，在其中添加多的一方

	private Set<Order> orders = new HashSet<>();
	// 映射单向一对多的关联关系
	// 使用OneToMany来映射一对多的关联关系
	// 使用@JoinColumn来映射外键列的名称
	// 可以使用@OneToMany的fetch属性来修改默认的加载策略
	// 可以通过修改OneToMany的cascade属性来修改默认的删除策略
	// 注意：若在1的一端的@OneToMany中使用mappedBy属性则@OneToMany端就不能再使用@JoinColumn注解
//	@JoinColumn(name="customer_id")
	@OneToMany(fetch=FetchType.EAGER,cascade={CascadeType.REMOVE},mappedBy="customer")
	public Set<Order> getOrders() {
		return orders;
	}
	public void setOrders(Set<Order> orders) {
		this.orders = orders;
	}

2. 定义Order类，在其中添加1的一方

    private Customer customer;
	// 映射单向多对一的关联关系
	// 使用@ManyToOne来映射多对一的关联关系
	// 使用@JoinColumn来映射外键
	// 可以使用@ManyToOne的fetch属性来修改默认的关联属性的加载策略
	@JoinColumn(name="customer_id")
	@ManyToOne(fetch=FetchType.LAZY)
	public Customer getCustomer() {
		return customer;
	}

	public void setCustomer(Customer customer) {
		this.customer = customer;
	}

3. 编写测试类

	// =============================双向多对一关联关系START==============================/
	// 双向多对一的关联关系，执行保存时，
	// 1. 若先保存n的一端，再保存1的一端，默认情况下会多出4n条update语句
	// 2. 若先保存1的一端，则会多出2n条update语句
	// 在进行双向多对一关联关系时，建议使用n的一方来维护关联关系，而一的一方不维护关联关系，这样会有效的减少SQL语句
	// 注意：若在1的一端的@OneToMany中使用mappedBy属性则@OneToMany端就不能再使用@JoinColumn注解
	@Test
	public void testOneToManyPersist() {
		// 保存多对一时，建议先保存1的一边，后保存多的一边，这样不会多出额外的update
		Customer c1 = new Customer();
		c1.setAge(21);
		c1.setBirthday(new Date());
		c1.setCreatedTime(new Date());
		c1.setEmail("1ddwd@qq.com");
		c1.setLastName("舒小雅");

		Order o1 = new Order();
		o1.setOrderName("0-ff01");
		Order o2 = new Order();
		o2.setOrderName("0-ff02");

		o1.setCustomer(c1);
		o2.setCustomer(c1);
		
		c1.getOrders().add(o1);
		c1.getOrders().add(o2);

		// 执行3条插入操作，2条update
		entitymanager.persist(c1);
		entitymanager.persist(o1);
		entitymanager.persist(o2);
	}

双向一对一

必知
一个部门管理一个经理，一个经理在一个部门
步骤
·1. 创建Manager类

@Entity
@Table(name="JPA_MANAGERS")
public class Manager implements Serializable {
	private static final long serialVersionUID = 1L;

	private Integer id;

	private String mgrName;

	private Department dept;

	@Id
	@GeneratedValue(strategy=GenerationType.AUTO)
	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	@Column(name="mgr_name")
	public String getMgrName() {
		return mgrName;
	}

	public void setMgrName(String mgrName) {
		this.mgrName = mgrName;
	}

	// 对于不维护关联关系，没有外键的地方使用OneToOne来进行映射，建议设置mappedBy="mgr"（可以减少不必要的update语句）
	@OneToOne(mappedBy="mgr")
	public Department getDept() {
		return dept;
	}

	public void setDept(Department dept) {
		this.dept = dept;
	}
}

·2. 创建Department类，并设置一对一映射关系

@Entity
@Table(name="JPA_DEPARTMENTS")
public class Department implements Serializable {

	
	private static final long serialVersionUID = 1L;

	private Integer id;
	
	private String deptName;
	
	private Manager mgr;

	@Id
	@GeneratedValue(strategy=GenerationType.AUTO)
	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	@Column(name="dept_name")
	public String getDeptName() {
		return deptName;
	}

	public void setDeptName(String deptName) {
		this.deptName = deptName;
	}

	// 使用@OneToOne来映射1-1关联关系
	// 若需要在当前数据表中添加主键，则需要使用@JoinColumn来进行映射
	// 注意：1-1关联关系，所以需要添加unique=true
	@JoinColumn(name="MGR_ID",unique = true)
	@OneToOne(fetch=FetchType.LAZY)
	public Manager getMgr() {
		return mgr;
	}

	public void setMgr(Manager mgr) {
		this.mgr = mgr;
	}
   
}

设置一对一映射关系

	// 使用@OneToOne来映射1-1关联关系
	// 若需要在当前数据表中添加主键，则需要使用@JoinColumn来进行映射
	// 注意：1-1关联关系，所以需要添加unique=true
	@JoinColumn(name="MGR_ID",unique = true)
	@OneToOne(fetch=FetchType.LAZY)
	public Manager getMgr() {
		return mgr;
	}

·3. 测试JPATest测试

	// 默认情况下,若获取不维护关联关系的一方，则也会通过左外连接获取其关联的对象
	// 可以通过@OneToOne的fetch属性来修改加载策略，但依然会再发送SQL语句来初始化其关联的对象
	// 这说明不维护关联关系的一方不建议设置修改fetch属性
	@Test
	public void testOneToOneFind2(){
		Manager mgr = entitymanager.find(Manager.class, 1);
		sysout(mgr.getMgrName());
		sysout(mgr.getDept().getClass().getName());
	}
	
	
	// 默认情况下,若获取维护关联关系的一方，则会通过左外连接获取其关联的对象
	// 但可以通过@OneToOne的fetch属性来修改加载策略
	@Test
	public void testOneToOneFind(){
		Department dept = entitymanager.find(Department.class, 1);
		sysout(dept.getDeptName());
		sysout(dept.getMgr().getClass().getName());
		sysout(dept.getMgr());
	}
	
	// 双向一对一的关联关系，建议先保存不维护关联关系的一方，即没有外键的一方，这样不会多出update语句
	@Test
	public void testOneToOnePersist(){
		Manager mgr = new Manager();
		mgr.setMgrName("M-AA");
		
		// 设置关联关系
		Department dept = new Department();
		dept.setDeptName("D-AA");
		dept.setMgr(mgr);
		
		// 执行保存操作
		entitymanager.persist(mgr);// 调转保存方向，将增加一条update语句
		entitymanager.persist(dept);
	}

双向多对多关联关系

知识点
在双向多对多关系中，我们必须指定一个关系维护端，可以通过@ManyToMany注解中指定mappedBy属性来标识其关系维护端

必知
商品--类别是一个多对多关系，一个商品可以有多个类别，一个类别下可以有多种商品

步骤
1. 创建商品Item类，配置维护多对多关联关系

@Table(name = "JPA_ITEMS")
@Entity
public class Item implements Serializable {

	private static final long serialVersionUID = 1L;

	private Integer id;

	private String itemName;

	private Set<Category> categrories = new HashSet<>();

	@Id
	@GeneratedValue
	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	@Column(name = "item_name")
	public String getItemName() {
		return itemName;
	}

	public void setItemName(String itemName) {
		this.itemName = itemName;
	}

	// 使用@ManyToMany注解来映射多对多关联关系
	// 使用@JoinTable来映射中间表
	// 1. name指向中间表的名字
	// 2. joinColumnNames映射当前类所在的表在中间表中的外键
	//   2.1 name指定外键列的列名
	//   2.2 referencedColumnName指定外键列关联当前表的哪一列
	// 3. inverseJoinColumns映射关联的类所在中间表的外键
	//  3.1...3.2...
	@JoinTable(name="ITEM_CATEGORY",
			joinColumns = { @JoinColumn(name = "ITEM_ID", referencedColumnName = "ID") }, 
			inverseJoinColumns = { @JoinColumn(name = "category_id", referencedColumnName = "ID") })
	@ManyToMany()
	public Set<Category> getCategrories() {
		return categrories;
	}

	public void setCategrories(Set<Category> categrories) {
		this.categrories = categrories;
	}
}

2. 创建分类Category类，配置不维护多对多关联关系

@Entity
@Table(name="JPA_CATEGORIES")
public class Category implements Serializable {

	private static final long serialVersionUID = 1L;

	private Integer id;

	private String categoryName;

	private Set<Item> items = new HashSet<>();

	@Id
	@GeneratedValue
	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	@Column(name="category_name")
	public String getCategoryName() {
		return categoryName;
	}

	public void setCategoryName(String categoryName) {
		this.categoryName = categoryName;
	}

	@ManyToMany(mappedBy="categrories")
	public Set<Item> getItems() {
		return items;
	}

	public void setItems(Set<Item> items) {
		this.items = items;
	}
}

3. 测试类JPATest

	// 使用维护关联关系的一方获取还是使用不维护关联关系的一方，SQL语句相同（对称）
	@Test
	public void testManyToManyFind2(){
		Category category = entitymanager.find(Category.class, 1);
		sysout(category.getCategoryName());
		sysout(category.getItems().size());
	}
	
	
	// 对于关联的集合对象，默认使用懒加载的策略
	@Test
	public void testManyToManyFind(){
		Item item = entitymanager.find(Item.class, 1);
		sysout(item.getItemName());
		sysout(item.getCategrories().size());
		
	}
	
	// 多对多的保存
	@Test
	public void testManyToManyPersist(){
		Item i1 = new Item();
		i1.setItemName("i-1");
		
		Item i2 = new Item();
		i2.setItemName("i-2");
		
		Category c1=new Category();
		c1.setCategoryName("c-1");
		Category c2=new Category();
		c2.setCategoryName("c-2");
		
		// 设置关联关系
		i1.getCategrories().add(c1);
		i1.getCategrories().add(c2);
		
		i2.getCategrories().add(c1);
		i2.getCategrories().add(c2);
		
		c1.getItems().add(i1);
		c1.getItems().add(i2);
		
		c2.getItems().add(i1);
		c2.getItems().add(i2);
		
		// 执行保存
		entitymanager.persist(c1);
		entitymanager.persist(c2);
		entitymanager.persist(i1);
		entitymanager.persist(i2);
		
	}

二级缓存

1. 需要引入的jar包

• ehcache-core-2.4.3.jar
• hibernate-ehcache-4.3.8.Final.jar
• slf4j-api-1.6.1.jar

2. 修改persistence.xml，加入二级缓存的配置

<persistence>
	<persistence-unit name="jpa-01">
		<provider>org.hibernate.ejb.HibernatePersistence</provider>
		...
		<class>com.iuie.jpa.entity.Category</class>
		...
			
		<!-- 配置二级缓存的策略
		    ALL:所有的实体类都被缓存
		    NONE:所有的实体都不被缓存
		    ENABLE_SELECTIVE:标识@Cacheable(true)注解的实体类将被缓存
		    DISABLE_SELECTIVE:缓存除标识@Cacheable(false)以外的所有实体类
		    UNSPECIFIED:默认值，JPA产品默认值将被使用
	     -->
	    <shared-cache-mode>ENABLE_SELECTIVE</shared-cache-mode>
		<properties>
			...
			<!-- 二级缓存相关 -->
			<property name="hibernate.cache.use_second_level_cache" value="true"/>
			<property name="hibernate.cache.region.factory_class" value="org.hibernate.cache.ehcache.EhCacheRegionFactory"/>
			<property name="hibernate.cache.use_query_cache" value="true"/>
		</properties>
		...
	</persistence-unit>
</persistence>

二级缓存的策略

值	解释
ALL	所有的实体类都被缓存
NONE	所有的实体都不被缓存
ENABLE_SELECTIVE	标识@Cacheable(true)注解的实体类将被缓存
DISABLE_SELECTIVE	缓存除标识@Cacheable(false)以外的所有实体类
UNSPECIFIED	默认值，JPA产品默认值将被使用

3. 添加ehcache.xml配置文件

<ehcache>

    <!-- Sets the path to the directory where cache .data files are created.

         If the path is a Java System Property it is replaced by
         its value in the running VM.

         The following properties are translated:
         user.home - User's home directory
         user.dir - User's current working directory
         java.io.tmpdir - Default temp file path -->
    <diskStore path="java.io.tmpdir"/>


    <!--Default Cache configuration. These will applied to caches programmatically created through
        the CacheManager.

        The following attributes are required for defaultCache:

        maxInMemory       - Sets the maximum number of objects that will be created in memory
        eternal           - Sets whether elements are eternal. If eternal,  timeouts are ignored and the element
                            is never expired.
        timeToIdleSeconds - Sets the time to idle for an element before it expires. Is only used
                            if the element is not eternal. Idle time is now - last accessed time
        timeToLiveSeconds - Sets the time to live for an element before it expires. Is only used
                            if the element is not eternal. TTL is now - creation time
        overflowToDisk    - Sets whether elements can overflow to disk when the in-memory cache
                            has reached the maxInMemory limit.

        -->
    <defaultCache
        maxElementsInMemory="10000"
        eternal="false"
        timeToIdleSeconds="120"
        timeToLiveSeconds="120"
        overflowToDisk="true"
        />

    <!--Predefined caches.  Add your cache configuration settings here.
        If you do not have a configuration for your cache a WARNING will be issued when the
        CacheManager starts

        The following attributes are required for defaultCache:

        name              - Sets the name of the cache. This is used to identify the cache. It must be unique.
        maxInMemory       - Sets the maximum number of objects that will be created in memory
        eternal           - Sets whether elements are eternal. If eternal,  timeouts are ignored and the element
                            is never expired.
        timeToIdleSeconds - Sets the time to idle for an element before it expires. Is only used
                            if the element is not eternal. Idle time is now - last accessed time
        timeToLiveSeconds - Sets the time to live for an element before it expires. Is only used
                            if the element is not eternal. TTL is now - creation time
        overflowToDisk    - Sets whether elements can overflow to disk when the in-memory cache
                            has reached the maxInMemory limit.

        -->

    <!-- Sample cache named sampleCache1
        This cache contains a maximum in memory of 10000 elements, and will expire
        an element if it is idle for more than 5 minutes and lives for more than
        10 minutes.

        If there are more than 10000 elements it will overflow to the
        disk cache, which in this configuration will go to wherever java.io.tmp is
        defined on your system. On a standard Linux system this will be /tmp"
        -->
    <cache name="sampleCache1"
        maxElementsInMemory="10000"
        eternal="false"
        timeToIdleSeconds="300"
        timeToLiveSeconds="600"
        overflowToDisk="true"
        />

    <!-- Sample cache named sampleCache2
        This cache contains 1000 elements. Elements will always be held in memory.
        They are not expired. -->
    <cache name="sampleCache2"
        maxElementsInMemory="1000"
        eternal="true"
        timeToIdleSeconds="0"
        timeToLiveSeconds="0"
        overflowToDisk="false"
        /> -->

    <!-- Place configuration for your caches following -->

</ehcache>

4. Customer.java 中使用ehcache，添加上@Cacheable(true)的注解

@Cacheable(true)
@Table(name = "JPA_CUSTOMERS")
@Entity
public class Customer {
	...
}

5. 编写测试类JPATest
使用了二级缓存之后，重新打开entitymanager，并做查询，将只会执行一条查询SQL，如果没有配置二级缓存，则会执行两次查询

	@Test
	public void testSecondLevelCache(){
		Customer customer1 = entitymanager.find(Customer.class, 1);
		transaction.commit();
		entitymanager.close();
		
		entitymanager = factory.createEntityManager();
		transaction = entitymanager.getTransaction();
		transaction.begin();
		
		Customer customer2 = entitymanager.find(Customer.class, 1);
	}

JPQL

概述
JPQL:Java Persistence Query Language,JPQL语言的语句可以是select语句、update语句或delete语句，它们都通过Query接口封装执行

欢迎打赏