JPA
简述
什么是 JPA
JavaEE5.0 的平台的 ORM 标准规范。为应用程序访问持久层提供统一的方式。
JPA 与 Hibernate 的关系
JPA 是规范，Hibernate 是实现。 从功能上来讲，JPA 是 Hibernate 的一个子集。Hibernate 只是 JPA 的一个提供商。类似于JDBC 和 JDBC驱动提供商。
JPA 的优点
JPA 提供了更加简洁的，基于注解的方式来进行映射。
JPA 配置文件
要求
- 必须配置在
META-INF目录下，且配置名字是固定的persistence.xml。 - 顶级节点为
<persistence>，次级节点为<persistence-unit>，JPA 的绝大部分信息配置在<persistence>节点内。<persistence-unit>节点name属性：用来指定这个 persistence单元的名称<persistence-unit>节点transaction-type属性：指定 JPA 的事务处理策略，默认为RESOURCE_LOCAL,数据库级别的事务，只能针对一种数据库，不支持分布式事务。 若需要支持分布式事务，使用 JTA，即：transaction-type="JTA"。
- 如果 JPA 的提供者存在多个的时候，需要在
<provider>节点配置具体使用哪个提供者。需要是javax.persistence.spi.PersistenceProvider的实现类。 - 在
<properties>节点内通过<property>节点配置数据库连接信息。 - 在
<properties>节点内通过<property>节点配置属于具体实现的特性信息。 - 通过
<class>节点来配置映射的实体类。
举例
<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="2.0">
<persistence-unit name="jpa_01" transaction-type="RESOURCE_LOCAL">
<provider>org.hibernate.ejb.HibernatePersistence</provider>
<class>com.solverpeng.jpa.Customer</class>
<class>com.solverpeng.jpa.Orders</class>
<class>com.solverpeng.jpa.Clazz</class>
<class>com.solverpeng.jpa.Student</class>
<properties>
<property name="hibernate.connection.driver_class" value="com.mysql.jdbc.Driver"/>
<property name="hibernate.connection.url" value="jdbc:mysql://localhost:3306/jpa"/>
<property name="hibernate.connection.username" value="root"/>
<property name="hibernate.connection.password" value="123456"/>
<property name="hibernate.dialect" value="org.hibernate.dialect.MySQLInnoDBDialect"/>
<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>
注意事项
- 指定 JPA 实现后，在配置数据库驱动、连接、用户名和密码的时候，需要指定前缀。
- 通过 Intellij Idea 默认生成的实体类，id 没有指定生成方式，需要通过
@GeneratedValue来指定。
实体注解
基本注解
- @Entity：顾名思义，用来映射实体
- @Table：当实体类和数据库表名不一致时，需要通过
@Table的name属性来指定表名，需要和 @Entity 注解同时使用。 - @Id：用来映射主键列。
- @Column：当属性名和列表不一致时，可以通过
@Column的name属性来指定映射的列名。 - @GeneratedValue：用来映射主键生成策略。
- IDENTITY：ID 自增的方式
- AUTO：自动选择一个底层数据库最适合的主键生成策略。
- SEQUENCE：通过序列产生主键。
- TABLE：通过表产生主键。参见：@TableGenerator 注解。
- @Basic：映射一个简单的属性到数据库，可以省略不写。
特殊注解
- @Transient：表示标注的属性不进行映射。
- @Temporal：映射日期时，指定日期精度。
- @TableGenerator：通过表来产生主键，如：
CREATE TABLE id_generators ( id INT(11) PRIMARY KEY NOT NULL AUTO_INCREMENT, pk_name VARCHAR(50), id_value INT(10) );@TableGenerator(name = "id_generator", table = "id_generators", pkColumnName = "pk_name", pkColumnValue = "customer_id", valueColumnName = "id_value", allocationSize = 10) @GeneratedValue(strategy = GenerationType.TABLE, generator = "id_generator")
API
Persistence 接口
主要作用是通过一个静态方法获取 EntityManagerFactory 接口。
EntityManagerFactory 接口
主要作用是获取 EntityManager，类似于 Hibernate 中的 SessionFactory 接口。
EntityManager 接口
- find()：类似于 Hibernate Session接口的 get() 方法。
- getReference()：类似于 Hibernate Session接口的 load() 方法。采用懒加载的策略。
- persist()：类似于 Hibernate Session 接口的 persist() 方法，对一个游离对象执行 persist() 方法时，会抛出异常。
- remove()：和 Hibernate Session 接口的 delete() 方法类似，但是只能删除持久化对象，而不能删除游离对象。
- 四种状态：参见 HIbernate Session。
- flush()：同步一级缓存中数据到数据库。
- refresh()：同步数据库的记录到一级缓存中。
- merge()：
- 若保存的是一个临时对象，则会创建一个新的对象，将临时对象中的属性值复制到新创建的对象，然后对这个新的对象执行保存操作，执行 meger() 方法后返回新的对象的引用。
- 若保存的是一个游离对象，该对象在缓存中不存在对应的记录，在数据库中也不存在对应的记录，则会当成一个临时对象去处理。
- 若保存的是一个游离对象，该对象在缓存不存在对应的记录，在数据库中存在对应的记录，则会从数据库中加载该 OID 对应的对象，将游离对象的属性值赋值给从数据库中加载的对象，执行 UPDATE 操作。
- 若保存的是一个游离对象，该对象在缓存中存在对应的记录，且在数据库中存在对应的记录，则会把游离对象中的属性值赋值到缓存对象中，再执行 UPDATE 操作。
关联关系
单向多对一
以 Customer 和 Orders 为例，Orders 端存有 Customer 端的外键。
建表语句：
CREATE TABLE orders
(
order_id INT(11) PRIMARY KEY NOT NULL AUTO_INCREMENT,
order_name VARCHAR(50),
customer_id_fk INT(11),
CONSTRAINT FK_vgghm8989rfgolmxd1mfw3x8 FOREIGN KEY (customer_id_fk) REFERENCES customer (customer_id)
);
CREATE INDEX FK_vgghm8989rfgolmxd1mfw3x8 ON orders (customer_id_fk);
CREATE TABLE customer
(
customer_id INT(11) PRIMARY KEY NOT NULL AUTO_INCREMENT,
customer_name VARCHAR(50),
birthday DATE
);
生成的实体：
@Entity
public class Orders {
private Integer orderId;
private String orderName;
private Customer customer;
@Id
@GeneratedValue
@Column(name = "order_id")
public Integer getOrderId() {
return orderId;
}
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "customer_id_fk", referencedColumnName = "customer_id")
public Customer getCustomer() {
return customer;
}
}
说明：
- 通过
@JoinColumn注解来指定外键映射，通过其name属性指定映射的外键列名，通过referencedColumnName来指定映射的关联的 1 的一端的哪列。 - 在保存的时候，和 Hibernate 一样，先保存 1 的一端会有助于性能的提升。
- 在获取关联的 1 的一端时，默认是立即加载，可以通过修改
@ManyToOne的fetch属性为FetchType.LAZY来改为懒加载策略。 - 在删除 1 的一端时，若存在关联的记录，则抛出异常。
单向一对多
以 Clazz 和 Student 为例。Clazz 中拥有 Set<Student> 集合，Student 中拥有 Clazz 的外键。
建表语句：
CREATE TABLE student
(
student_id INT(11) PRIMARY KEY NOT NULL AUTO_INCREMENT,
student_name VARCHAR(50),
class_id_fk INT(11),
CONSTRAINT FK_38k5ipq4p5s8k0a2bhqcbvsl8 FOREIGN KEY (class_id_fk) REFERENCES class (class_id)
);
CREATE INDEX FK_38k5ipq4p5s8k0a2bhqcbvsl8 ON student (class_id_fk);
CREATE TABLE class
(
class_id INT(11) PRIMARY KEY NOT NULL AUTO_INCREMENT,
class_name VARCHAR(50)
);
生成的实体：
@Entity
@Table(name = "class", schema = "jpa")
public class Clazz {
private Integer classId;
private String className;
private Set<Student> students = new HashSet<>();
@Id
@GeneratedValue
@Column(name = "class_id")
public Integer getClassId() {
return classId;
}
@JoinColumn(name = "class_id_fk")
@OneToMany(fetch = FetchType.EAGER)
public Set<Student> getStudents() {
return students;
}
}
说明：
- 执行保存的时候，不论是先保存 1 的一端还是先保存 n 的一端，都需要发送额外的 UPDATE 语句用来维护关联关系。
- 执行获取的时候，通过 1 的一端获取 n 的一端，默认采用的是懒加载策略，可以通过修改
@OneToMany的fetch属性为FetchType.EAGER来立即加载。 - 执行删除的时候，若删除的是 1 的一端的对象，默认情况下，会将关联的 n 的一端的相应的记录外键列值为 null。可以通过修改
@OneToMany的cascade属性来达到想要的效果。
双向多对一
以 Family 和 People 为例，Family 中拥有 Set<People> 的集合，People 中有 Customer 类型的成员变量。People 表中有 Family 的外键。
建表语句：
CREATE TABLE family
(
family_id INT(11) PRIMARY KEY NOT NULL AUTO_INCREMENT,
family_name VARCHAR(50)
);
CREATE TABLE people
(
people_id INT(11) PRIMARY KEY NOT NULL AUTO_INCREMENT,
people_name VARCHAR(50),
family_id_fk INT(11)
);
生成的实体：
@Entity
public class People {
private Integer peopleId;
private String peopleName;
private Family family;
@Id
@GeneratedValue
@Column(name = "people_id")
public Integer getPeopleId() {
return peopleId;
}
@ManyToOne
@JoinColumn(name = "family_id_fk", referencedColumnName = "family_id")
public Family getFamily() {
return family;
}
}
@Entity
public class Family {
private Integer familyId;
private String familyName;
private Set<People> people = new HashSet<>();
@Id
@GeneratedValue
@Column(name = "family_id")
public Integer getFamilyId() {
return familyId;
}
@OneToMany(mappedBy = "family")
public Set<People> getPeople() {
return people;
}
}
说明：
- 若在 1 的一端
@OneToMany中使用了mappedBy属性，则@OneToMany属性就不能再添加@JoinColumn的属性了。该属性用来指定这端为被维护端。 - 保存：若先保存 n 的一端，再保存 1 的一端，会多发送 UPDATE 语句，因为关联关系是在 n 的一端维护的。
- 查询：从 1 的一端获取 n 的一端的集合时，采用的延迟检索的策略。从 n 的一端获取 1 的一端的对象时，是采用的立即检索的策略。
- 删除：删除 1 的一端时，因为外键约束，所以会抛出异常。
双向一对一
以 Department 和 Manager 为例。一个部门存在一个经理，一个经理只能属于一个部门。Manger 端维护 Department 的外键。
建表语句：
CREATE TABLE department
(
dept_id INT(11) PRIMARY KEY NOT NULL AUTO_INCREMENT,
dept_name VARCHAR(50)
);
CREATE TABLE manager
(
manager_id INT(11) PRIMARY KEY NOT NULL AUTO_INCREMENT,
manager_name VARCHAR(50),
dept_id_fk INT(11)
);
生成实体：
@Entity
public class Department {
private Integer deptId;
private String deptName;
private Manager manager;
@Id
@GeneratedValue
@Column(name = "dept_id")
public Integer getDeptId() {
return deptId;
}
@OneToOne(mappedBy = "dept")
public Manager getManager() {
return manager;
}
}
@Entity
public class Manager {
private Integer managerId;
private String managerName;
private Department dept;
@Id
@GeneratedValue
@Column(name = "manager_id")
public Integer getManagerId() {
return managerId;
}
@OneToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "dept_id_fk", referencedColumnName = "dept_id")
public Department getDept() {
return dept;
}
}
说明：
- 没有外键列的一端，使用
@OneToOne的mappedBy属性，用来指定自己为被维护的一端。 - 保存：建议先保存 不维护关联关系的一端，这样不会多出 UPDATE 语句。
- 获取：默认情况下，若获取维护关联关系的一方，则会通过立即检索的策略获取其关联的对象。可以通过
@OneToOne的fetch属性来修改加载策略。若获取不维护关联关系的一方，则也会通过左外链接的方式获取其关联的对象，纵然修改了@OneToOne的fetch属性，也不起作用，因为它并不知道谁和它关联着。 - 删除：因为存在在外键约束，所以删除不维护关联关系的一端时，若存在着和其关联的记录。则抛出异常。
双向多对多
以 Categroy 和 Item 为例。创建了一张中间表：categories_items。
建表语句：
CREATE TABLE category
(
cate_id INT(11) PRIMARY KEY NOT NULL AUTO_INCREMENT,
cate_name VARCHAR(50)
);
CREATE TABLE item
(
item_id INT(11) PRIMARY KEY NOT NULL AUTO_INCREMENT,
item_name VARCHAR(50)
);
CREATE TABLE categories_items
(
id INT(11) PRIMARY KEY NOT NULL AUTO_INCREMENT,
cate_id_fk INT(11),
item_id_fk INT(11)
);
生成的实体：
@Entity
public class Category {
private Integer cateId;
private String cateName;
private Set<Item> items = new HashSet<>();
@Id
@GeneratedValue
@Column(name = "cate_id")
public Integer getCateId() {
return cateId;
}
@ManyToMany(mappedBy = "categories")
public Set<Item> getItems() {
return items;
}
}
@Entity
public class Item {
private Integer itemId;
private String itemName;
private Set<Category> categories = new HashSet<>();
@Id
@GeneratedValue
@Column(name = "item_id")
public Integer getItemId() {
return itemId;
}
@ManyToMany
@JoinTable(name = "categories_items", schema = "jpa",
joinColumns = @JoinColumn(name = "item_id_fk", referencedColumnName = "item_id"),
inverseJoinColumns = @JoinColumn(name = "cate_id_fk", referencedColumnName = "cate_id"))
public Set<Category> getCategories() {
return categories;
}
}
说明：
- Category 端放弃维护关联关系。使用
@ManyToMany的mappedBy属性。 - 使用 @JoinTable 来指定中间表。
- name属性：指定中间表名
- joinColumns 属性：指定本类在中间表的外键列名（name ）和本类中与中间表外键对应的主键（referencedColumnName ）
- inverseJoinColumns 属性：指定关联的另一端的类在中间表的外键列名（name）和外键所对应的主键（referencedColumnName ）
- 获取：不论是通过维护关联关系的一端，还是不维护关联关系的一端来获取集合对象，采用的都是懒加载策略。
- 删除：删除不维护关联关系的一端时，若存在与其关联的记录，则抛出异常。而删除维护关联关系的一端则没有问题。
二级缓存
配置举例
<persistence-unit name="jpa_01" transaction-type="RESOURCE_LOCAL">
<provider>org.hibernate.ejb.HibernatePersistence</provider>
<class>com.solverpeng.jpa.Customer</class>
<shared-cache-mode>ENABLE_SELECTIVE</shared-cache-mode>
<properties>
<!-- 配置数据库连接 -->
<!-- 配置 Hibernate 属性 -->
<!-- 配置二级缓存相关 -->
<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>
配置步骤
- 导入缓存相关 Jar 包。
- 在 persistence.xml 文件中配置缓存相关属性以及
<shared-cache-mode>节点。 - 在需要缓存的实体类添加
@Cacheable注解。
<shared-cache-mode> 节点
- 若 JPA 实现支持二级缓存，该节点可以配置在当前持久化单元中是否启用二级缓存，可以配置如下值：
- ALL：所有的实体类都被缓存
- NONE：所有的实体类都不被缓存
- ENABLE_SELECTIVE：标识
@Cacheable(true)注解的实体类将被缓存 - DISABLE_SELECTIVE：标识
@Cacheable(false)注解的实体类将不被缓存
- 需要注意在该节点在配置文件中的位置
JPQL
基本查询
占位符查询
Tribe result = (Tribe) manager.createQuery("from Tribe t where t.tribeId = ?").setParameter(1, 1).getSingleResult();
投影查询
List<Object[]> resultList = manager.createQuery("select t.tribeName, t.member from Tribe t where t.member > ?").setParameter(1, 10).getResultList();
List<Tribe> resultList2 = manager.createQuery("select new Tribe(t.tribeName, t.member) from Tribe t where t.member > ?").setParameter(1, 10).getResultList();
第二种方式需要提供对应的构造器和无参的构造器。
具名查询
String jpql = "from Tribe t where t.tribeName = :tribeName";
Query query = manager.createQuery(jpql).setParameter("tribeName", "dark");
Object singleResult = query.getSingleResult();
System.out.println(singleResult);
命名查询
在对应的实体类上添加如：
@NamedQuery(name = "testNamedQuery", query = "select t from Tribe t where t.member > ?")
Query testNamedQuery = manager.createNamedQuery("testNamedQuery").setParameter(1, 10);
List<Tribe> resultList = testNamedQuery.getResultList();
本地 SQL 查询
Query query = manager.createNativeQuery("select tribe_name from tribe where member > ?").setParameter(1, 10);
List<String> resultList = query.getResultList();
查询缓存
首先需要开启二级缓存，同时在 persistence.xml 添加
<property name="hibernate.cache.use_query_cache" value="true"/>
String jpql = "from Tribe t order by createTime";
manager.createQuery(jpql).setHint(QueryHints.CACHEABLE, true).getResultList();
transaction.commit();
manager.close();
manager = factory.createEntityManager();
transaction = manager.getTransaction();
transaction.begin();
manager.createQuery(jpql).getResultList();
需要对需要进行缓存的 Query 对象调用 setHint() 方法。
分组查询
List<Double> resultList = manager.createQuery("select max(h.agile) from Hero h group by h.tribe having max(h.agile) > ?").setParameter(1, 2.22).getResultList();
关联查询
String jpql = "select h from Hero h left outer join fetch h.tribe where h.heroId = 10";
Object singleResult = manager.createQuery(jpql).getSingleResult();
关于迫切左外链接和左外链接的区别，请参看 Hibernate 的文章。
对于存在物理上的关联关系的关联查询，推荐使用迫切左外链接查询。
对于物理上不存在关联关系的关联查询，使用左外链接和迫切左外链接都可以。
分页查询
int pageNo = 2;
int pageSize = 2;
List<Hero> resultList = manager.createQuery("from Hero h").setFirstResult((pageNo - 1) * pageSize).setMaxResults(pageSize).getResultList();
子查询
String jpql = "from Hero h where h.tribe = (select t from Tribe t where t.tribeId = ?)";
List<Hero> resultList = manager.createQuery(jpql).setParameter(1, 5).getResultList();
内建函数
String jpql = "select upper(h.heroName) from Hero h";
List<String> resultList = manager.createQuery(jpql).getResultList();
更新
String jpql = "update Hero set heroName = ? where heroId = ?";
manager.createQuery(jpql).setParameter(1, "Dark Knight@").setParameter(2, 9).executeUpdate();
注意事项
- 若在查询中对表起了别名，查询的每个字段前都需要添加表的别名。
- setParamter() 的位置是从 1 开始的。
总结
介绍了 JPA 以及具体的配置以及如何使用，关联关系、二级缓存、JPQL，在学习的时候可以对比 Hibernate 来学习。关于具体的 Spring 如何整合 JPA，会在以后单独的章节中进行介绍。没有介绍在 Intellij Idea 下如何使用，具体步骤请参看 Intellij Idea 官方文档。
