JPA 与 Hibernate 的关系.doc

JPA 与 Hibernate 的关系什么是 JPAJavaEE5.0 的平台的 ORM 标准规范。为应用程序访问持久层提供统一的方式。JPA 是规范，Hibernate 是实现。 从功能上来讲，JPA 是 Hibernate 的一个子集。Hibernate 只是 JPA 的一个提供商。类似于JDBC 和 JDBC驱动提供商。JPA 的优点JPA 提供了更加简洁的，基于注解的方式来进行映射。JPA 配置文件要求必须配置在 META-INF 目录下，且配置名字是固定的 persistence.xml。顶级节点为 ，次级节点为 ，JPA 的绝大部分信息配置在 节点内。 节点 name 属性：用来指定这个 persistence单元的名称 节点 transaction-type 属性：指定 JPA 的事务处理策略，默认为 RESOURCE_LOCAL,数据库级别的事务，只能针对一种数据库，不支持分布式事务。 若需要支持分布式事务，使用 JTA，即：transaction-type=JTA。如果 JPA 的提供者存在多个的时候，需要在 节点配置具体使用哪个提供者。需要是 javax.persistence.spi.PersistenceProvider 的实现类。在 节点内通过 节点配置数据库连接信息。在 节点内通过 节点配置属于具体实现的特性信息。通过 节点来配置映射的实体类。举例 org.hibernate.ejb.HibernatePersistence com.solverpeng.jpa.Customer com.solverpeng.jpa.Orders com.solverpeng.jpa.Clazz com.solverpeng.jpa.Student 注意事项指定 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) APIPersistence 接口主要作用是通过一个静态方法获取 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);生成的实体：Entitypublic 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 中拥有 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);生成的实体：EntityTable(name = class, schema = jpa)public class Clazz private Integer classId; private String className; private Set 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 getStudents() return students; 说明：执行保存的时候，不论是先保存 1 的一端还是先保存 n 的一端，都需要发送额外的 UPDATE 语句用来维护关联关系。执行获取的时候，通过 1 的一端获取 n 的一端，默认采用的是懒加载策略，可以通过修改 OneToMany 的 fetch 属性为 FetchType.EAGER 来立即加载。执行删除的时候，若删除的是 1 的一端的对象，默认情况下，会将关联的 n 的一端的相应的记录外键列值为 null。可以通过修改 OneToMany 的 cascade 属性来达到想要的效果。双向多对一以 Family 和 People 为例，Family 中拥有 Set 的集合，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);生成的实体：Entitypublic 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; Entitypublic class Family private Integer familyId; private String familyName; private Set people = new HashSet(); Id GeneratedValue Column(name = family_id) public Integer getFamilyId() return familyId; OneToMany(mappedBy = family) public Set 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);生成实体：Entitypublic 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; Entitypublic 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);生成的实体：Entitypublic class Category private Integer cateId; private String cateName; private Set items = new HashSet(); Id GeneratedValue Column(name = cate_id) public Integer getCateId() return cateId; ManyToMany(mappedBy = categories) public Set getItems() return items; Entitypublic class Item private Integer itemId; private String itemName; private Set 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 getCategories() return categories; 说明：Category 端放弃维护关联关系。使用 ManyToMany 的 mappedBy 属性。使用 JoinTable 来指定中间表。name属性：指定中间表名joinColumns 属性：指定本类在中间表的外键列名（name ）和本类中与中间表外键对应的主键（referencedColumnName ）inverseJoinColumns 属性：指定关联的另一端的类在中间表的外键列名（name）和外键所对应的主键（referencedColumnName ）获取：不论是通过维护关联关系的一端，还是不维护关联关系的一端来获取集合对象，采用的都是懒加载策略。删除：删除不维护关联关系的一端时，若存在与其关联的记录，则抛出异常。而删除维护关联关系的一端则没有问题。二级缓存配置举例 org.hibernate.ejb.HibernatePersistence com.solverpeng.jpa.Customer ENABLE_SELECTIVE 配置步骤导入缓存相关 Jar 包。在 persistence.xml 文件中配置缓存相关属性以及 节点。在需要缓存的实体类添加 Cacheable注解。 节点若 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 resultList = manager.createQuery(select t.tribeName, t.member from Tribe t where t.member ?).setParameter(1, 10).getResultList();List 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 resultList = testNamedQuery.getResultList();本地 SQL 查询Query query = manager.createNativeQuery(select tribe_name from tribe where member ?).setParameter(1, 10);List resultList = query.getResultList();查询缓存首先需要开启二级缓存，同时在 persistence.xml 添加String jpql = from Tribe t order by createTime;manager.createQuery(jpql).setHint(QueryHints.CACHEABLE, true).getResultList();mit();manager.close();manager = factory.createEntityManager();transaction = manager.getTransaction();Tbegin();manager.createQuery(jpql).getResultList();需要对需要进行缓存的 Query 对象调用 setHint() 方法。分组查询List resultList = manager.createQuery(select max(h.agile) from Hero h group by h.tribe having