是使用注明代替XML映射对象关联的新点子,Hibernate 皇冠现金app只是 JPA 的2个提供商

 

简述

壹、JPA申明的介绍

什么是 JPA

JavaEE五.0 的阳台的 ORAV四M 标准规范。为应用程序访问持久层提供联合的方法。

Hibernate Annotation :是运用表明代替XML映射对象关系的新章程
JPA: Java Persistence API
是EJB叁.0规范中的一部分,专门讲述如何处理持久化的正儿8经

JPA 与 Hibernate 的关系

JPA 是正规,Hibernate 是达成。 从成效上来讲,JPA 是 Hibernate
的1个子集。Hibernate 只是 JPA 的2个提供商。类似于JDBC 和
JDBC驱动提供商。

常用情势:

JPA 的优点

JPA 提供了更为从简的,基于声明的格局来拓展览放映射。

  •  使用JPA的正经注明来做靶子关系映射

JPA 配置文件

  •  使用Hibernate来产生持久化操作。

要求

  1. 总得配备在 META-INF 目录下,且布局名字是一定的 persistence.xml
  2. 一品节点为 <persistence> ,次级节点为 <persistence-unit>,JPA
    的多方面音信配置在 <persistence> 节点内。

    • <persistence-unit> 节点 name 属性:用来钦命那个persistence单元的称呼
    • <persistence-unit> 节点 transaction-type 属性:钦定 JPA
      的事务处理战术,默以为
      RESOURCE_LOCAL,数据库级其他政工,只好针对一种数据库,不扶助分布式事务。
      若要求帮衬分布式事务,使用 JTA,即:transaction-type="JTA"
  3. 倘诺 JPA 的提供者存在四个的时候,须求在 <provider>
    节点配置具体使用哪个提供者。需尽管
    javax.persistence.spi.PersistenceProvider 的达成类。
  4. <properties> 节点内经过 <property> 节点配置数据库连接音信。
  5. <properties> 节点内经过 <property>
    节点配置属于具体完结的特色消息。
  6. 通过 <class> 节点来布局映射的实体类。

JPA的讲明定义放置在javax.persistence包中

举例

<?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>

常用的注释有:

注意事项

  1. 点名 JPA
    实现后,在铺排数据库驱动、连接、用户名和密码的时候,必要钦赐前缀。
  2. 通过 英特尔lij Idea 默许生成的实体类,id 没有点名生成格局,供给通过
    @GeneratedValue 来指定。

  •  @Entity

实体注明

  •  @Table

着力表明

  1. @Entity:顾名思义,用来映射实体
  2. @Table:当实体类和数据库表名不平等时,必要通过 @Tablename
    属性来钦点表名,需求和 @Entity 注脚同时利用。
  3. @Id:用来映射主键列。
  4. @Column:当属性名和列表不平等时,能够因而 @Columnname
    属性来钦赐映射的列名。
  5. @GeneratedValue:用来映射主键生成攻略。
    • IDENTITY:ID 自增的法子
    • AUTO:自动选用1个平底数据库最契合的主键生成战略。
    • SEQUENCE:通过类别发生主键。
    • TABLE:通过表发生主键。参见:@TableGenerator 注脚。
  6. @Basic:映射一个简练的质量到数据库,能够简简单单不写。

  •  @Id

特别申明

  1. @Transient:表示标注的品质不开始展览映射。
  2. @Temporal:映射日期时,钦赐日期精度。
  3. @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")    
    

  •  @Temporal

API

  •  @Basic

Persistence 接口

第2职能是由此二个静态方法获取 EntityManagerFactory 接口。

  •  Column

EntityManagerFactory 接口

重点意义是收获 EntityManager,类似于 Hibernate 中的 SessionFactory
接口。

  •  JPA表明中自俺陶醉锁@Version

EntityManager 接口

  1. find():类似于 Hibernate Session接口的 get() 方法。
  2. getReference():类似于 Hibernate Session接口的 load()
    方法。采取懒加载的国策。
  3. persist():类似于 Hibernate Session 接口的 persist()
    方法,对一个游离对象试行 persist() 方法时,会抛出非凡。
  4. remove():和 Hibernate Session 接口的 delete()
    方法类似,然则只好删除持久化对象,而不能去除游离对象。
  5. 三种意况:参见 H伊比rnate Session。
  6. flush():同步顶级缓存中多少到数据库。
  7. refresh():同步数据库的记录到拔尖缓存中。
  8. merge():
    • 若保存的是1个一时对象,则会成立二个新的对象,将一时对象中的属性值复制到新成立的目的,然后对这几个新的靶子试行保存操作,推行meger() 方法后重回新的对象的引用。
    • 若保存的是三个游离对象,该对象在缓存中不存在对应的笔录,在数据库中也不设有对应的记录,则会当成2个暂且对象去处理。
    • 若保存的是二个游离对象,该目的在缓存不设有对应的记录,在数据库中留存对应的笔录,则会从数据库中加载该
      OID
      对应的靶子,将游离对象的属性值赋值给从数据库中加载的目的,推行UPDATE 操作。
    • 若保存的是三个游离对象,该指标在缓存中留存对应的记录,且在数据库中设有对应的记录,则会把游离对象中的属性值赋值到缓存对象中,再实行UPDATE 操作。

 皇冠现金app 1

论及关系

皇冠现金app 2a

单向多对一

以 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;
    }
}

说明:

  1. 通过 @JoinColumn 表明来钦命外键映射,通过其 name
    属性钦定映射的外键列名,通过 referencedColumnName
    来钦赐映射的关系的 1 的一端的哪列。
  2. 在保留的时候,和 Hibernate 一样,先保存 1 的1端会促进品质的进级。
  3. 在收获涉及的 一 的一端时,默许是及时加载,能够因此改变 @ManyToOne
    fetch 属性为 FetchType.LAZY 来改为懒加载战术。
  4. 在剔除 壹 的一端时,若存在涉嫌的笔录,则抛出特别。

编写制定实体育项目检查评定试类:

单向一对多

以 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 语句用来维护关系关系。
  2. 实行获取的时候,通过 一 的一端获取 n
    的单方面,暗中认可使用的是懒加载战略,能够经过更换 @OneToManyfetch
    属性为 FetchType.EAGER 来立即加载。
  3. 进行删除的时候,若删除的是 一 的壹端的对象,私下认可意况下,会将涉嫌的 n
    的壹端的相应的笔录外键列值为 null。能够透过修改 @OneToMany
    cascade 属性来完毕想要的效果。

皇冠现金app 3

双向多对一

以 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. 若在 1 的一端 @OneToMany 中使用了 mappedBy 属性,则 @OneToMany
    属性就不能够再增加 @JoinColumn
    的品质了。该属性用来钦定这端为被维护端。
  2. 保留:若先保存 n 的壹方面,再保存 壹 的1边,会多发送 UPDATE
    语句,因为涉嫌关系是在 n 的一端维护的。
  3. 询问:从 一 的一端获取 n 的一端的集合时,采纳的推移检索的计划。从 n
    的1端获取 1 的一端的对象时,是选取的当即搜索的攻略。
  4. 去除:删除 壹 的一端时,因为外键约束,所以会抛出13分。

 

双向一对一

以 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;
    }

}

说明:

  1. 不曾外键列的一面,使用 @OneToOnemappedBy
    属性,用来内定本人为被爱抚的另1方面。
  2. 保留:提议先保存 不爱慕关系关系的一方面,那样不会多出 UPDATE 语句。
  3. 得到:暗中同意意况下,若赢得维护关系关系的一方,则会经过立时搜索的攻略获取其关系的指标。能够透过
    @OneToOnefetch
    属性来修改加载战略。若赢得不爱抚关系关系的一方,则也会通过左外链接的方法得到其关联的靶子,纵然修改了
    @OneToOnefetch
    属性,也不起成效,因为它并不知道什么人和它涉及着。
  4. 删除:因为存在在外键约束,所以删除不维护关系关系的壹端时,若存在着和其涉嫌的笔录。则抛出万分。

贰、基于JPA注明的目的关联映射

双向多对多

以 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;
    }

}

说明:

  1. Category 端扬弃维护关系关系。使用 @ManyToManymappedBy 属性。
  2. 运用 @JoinTable 来钦点中间表。
    • name属性:钦命中间表名
    • joinColumns 属性:钦点本类在中间表的外键列名(name
      )和本类中与中间表外键对应的主键(referencedColumnName )
    • inverseJoinColumns
      属性:内定关联的另一端的类在中间表的外键列名(name)和外键所对应的主键(referencedColumnName
  3. 得到:不论是由此维护关系关系的壹边,照旧不维护关系关系的一端来获得集合对象,选取的都以懒加载战术。
  4. 去除:删除不珍重关系关系的1端时,若存在与其关系的笔录,则抛出10分。而删除维护关系关系的1端则尚未难题。

  JPA注明中涉及映射的应用:

二级缓存

  1、一对多(@OneToMany)

安顿举例

<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>

  2、一对一(@OneToOne)

配置步骤

  1. 导入缓存相关 Jar 包。
  2. 在 persistence.xml 文件中布局缓存相关属性以及 <shared-cache-mode>
    节点。
  3. 在供给缓存的实体类增加 @Cacheable注解。

  3、多对多(@ManyToMany)

<shared-cache-mode> 节点

  1. 若 JPA
    完成协理二级缓存,该节点能够铺排在近年来持久化单元中是或不是启用二级缓存,能够配备如下值:

    • ALL:全体的实体类都被缓存
    • NONE:全部的实体类都不被缓存
    • ENABLE_SELECTIVE:标识 @Cacheable(true) 申明的实体类将被缓存
    • DISABLE_SELECTIVE:标识 @Cacheable(false)
      申明的实体类将不被缓存
  2. 亟待专注在该节点在布署文件中的地点

 

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();

 种类Category和制品Product是1对多的涉嫌。产品和花色则是多对一的涉及。

查询缓存

首先供给敞开二级缓存,同时在 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() 方法。

先在1端既Category类下布署 一对多的笺注,

分组查询

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();

皇冠现金app 4

关系查询

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();

mappedBy表示维护关系的反转,相当于property_ref,维护关系的反转,交给另1端来保安关系。

子查询

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();

皇冠现金app 5

更新

String jpql = "update Hero set heroName = ? where heroId = ?";
manager.createQuery(jpql).setParameter(1, "Dark Knight@").setParameter(2, 9).executeUpdate();

//那里配置关系,并且规定关系维护端和被维护端。mappBy表示关系被维护端,只有关系端有权去立异外键。那里还有注意OneToMany默许的加载格局是赖加载。当看到设置关系中最后三个单词是Many,那么该加载默以为懒加载  

注意事项

  1. 若在查询中对表起了别称,查询的每种字段前都亟需增加表的外号。
  2. setParamter() 的职位是从 一 开首的。

那里设置JoinColum设置了外键的名字,在那边,Product表示是关联 维护端,Category代表关系被维护端。

总结

介绍了 JPA
以及现实的布局以及怎么样选用,关联关系、二级缓存、JPQL,在上学的时候能够对照
Hibernate 来读书。关于切实的 Spring 怎样构成
JPA,会在随后单独的章节中张开介绍。未有介绍在 速龙lij Idea
下怎么样行使,具体步骤请参考 英特尔lij Idea
官方文书档案

一对一:

  二、基于主键的一对一映射:

    不会平常用,那几个意思是说,五个表中央银行使同一的主键,使用Hibernate自定义主键生成计谋,由@GenericGenerator完毕。引用myfor.

皇冠现金app 6

皇冠现金app 7

基于外键的一对1则相对轻易些

  皇冠现金app 8

皇冠现金app 9

  3、多对多:

  大家以Student和Course类为例,学生和科目是多对多的涉嫌 

 

皇冠现金app 10

 

JoinTable,我们创制了壹在那之中间表,作为四个表之间的涉及。配置好Student端后,Course端配置 就很简短了,直接动用@ManyToMany就足以了。

皇冠现金app 11

 

辉映命名查询

  •  NameQueries

  •  NameQuery**

皇冠现金app 12

皇冠现金app 13

 

相关文章