zoukankan html css js c++ java

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 官方文档。

查看全文

相关阅读:
net应用程序池自动关闭的解决方法
 asp.net 多个txt压缩导出下载
 asp.net 对象转XML,XML转对象
 asp.net Cache缓存的用法
 oracle 增加大字段项
 asp.net简繁体转换
 asp.net 根据连接地址保存文件，图片
 SpringSide从系统全局里面取值
 SpringSide dml操作
 一张表里面形成的树，固定初始化数据

原文地址：https://www.cnblogs.com/solverpeng/p/5994341.html

JPA

简述

什么是 JPA

JPA 与 Hibernate 的关系

JPA 的优点

JPA 配置文件

要求

举例

注意事项

实体注解

基本注解

特殊注解

API

Persistence 接口

EntityManagerFactory 接口

EntityManager 接口

关联关系

单向多对一

单向一对多

双向多对一

双向一对一

双向多对多

二级缓存

配置举例

配置步骤

<shared-cache-mode> 节点

JPQL

基本查询

查询缓存

分组查询

关联查询

分页查询

子查询

内建函数

更新

注意事项

总结

`<shared-cache-mode>` 节点