hibernate知识回顾

2018-06-27  本文已影响3人  努力努力再努力_y

嗯，又要开始......了

一、前言

1.1 EE 的三层架构
1.2 什么是ORM

ORM：Object Relational Mapping（对象关系映射）。指的是将一个Java中的对象与关系型数据库中的表建立一种映射关系，从而操作对象就可以操作数据库中的表。


二、入门

2.1 版本及目录

Hibernate3.X很多企业使用
Hibernate4.X不需要掌握，过渡版本（结构改变很多）
Hibernate5.X最新版本，配置同3


documentation       :Hibernate开发的文档
lib                 :Hibernate开发包
  >required         :Hibernate开发的必须的依赖包
  >optional         :Hibernate开发的可选的jar包
project             :Hibernate提供的项目
2.2 基本配置
2.3 映射配置
【class标签的配置】
标签用来建立类与表的映射关系
属性：
name        ：类的全路径
table       ：表名（类名与表名一致，table可以省略）
catalog     ：数据库名
【id标签的配置】
标签用来建立类中的属性与表中的主键的对应关系
属性：
name        ：类中的属性名
column      ：表中的字段名（类中的属性名和表中的字段名如果一致，column可以省略）
length      ：长度
type            ：类型
【property标签的配置】
标签用来建立类中的普通属性与表的字段的对应关系
属性：
name        ：类中的属性名
column      ：表中的字段名
length      ：长度
type            ：类型
not-null        ：设置非空
unique      ：设置唯一
2.4 核心配置
必须的配置
  连接数据库的基本的参数
    驱动类
    url路径
    用户名
    密码
    方言
可选的配置
  显示SQL     ：hibernate.show_sql
  格式化SQL    ：hibernate.format_sql
  自动建表  ：hibernate.hbm2ddl.auto
    none        ：不使用hibernate的自动建表
    create      ：如果数据库中已经有表，删除原有表，重新创建，如果没有表，新建表。（测试）
    create-drop ：如果数据库中已经有表，删除原有表，执行操作，删除这个表。如果没有表，新建一个，使用完了删除该表。（测试）
    update      ：如果数据库中有表，使用原有表，如果没有表，创建新表（更新表结构）
    validate        ：如果没有表，不会创建表。只会使用数据库中原有的表。（校验映射和表结构）。
映射文件的引入
<mapping resource="com/tcy/java/Customer.hbm.xml"/>
2.5 Hibernate的配置对象

SessionFactory线程安全

Session非线程安全、不能定义为全局，只可局部

Session代表的是Hibernate与数据库的链接对象。不是线程安全的。与数据库交互桥梁。
1. 保存方法：
Serializable save(Object obj);
2. 查询方法：
T get(Class c,Serializable id);
T load(Class c,Serializable id);

get方法和load方法的区别？
  1. 修改方法：
    void update(Object obj);
  2. 删除方法：
    void delete(Object obj);
  3. 保存或更新：
    void saveOrUpdate(Object obj)
  4. 查询方法：
2.6 事物对象

Hibernate中管理事务的对象。
commit();
rollback();

三、主键缓存及事物

3.1 Hibernate的持久化类的编写规则
3.2 Hibernate的主键生成策略

(1)主键分类

3.3 持久化类的三种状态
3.4 一级缓存
3.5 事务管理

事务：事务指的是逻辑上的一组操作，组成这组操作的各个逻辑单元要么全都成功，要么全都失败

  1. 事务的特性
  1. 如果不考虑隔离性，引发安全性问题
  1. 读问题的解决

  1. hibernate中设置事务的隔离级别


  2. Service层事务
* 必须保证链接对象是同一个
  1. 向下传递 DBUtils
  2. 使用ThreadLocal对象
      将这个连接绑定到当前线程中
      在DAO的方法中，通过当前的线程获得到连接对象
* Hibernate框架内部已经绑定好了ThreadLocal
  1. 早SessionFactory中提供了一个方法getCurrentSession();
  2. 通过一个配置完成。
  3. <property name="hibernate.current_session_context_class">thread</property>
      thread：Session 对象的生命周期与本地线程绑定
      jta：Session 对象的生命周期与JTA事务绑定（跨数据库）
      managed：Hibernate 委托程序来管理 Session 对象的生命周期
  4. 无需session.close(); 线程结束会自动关闭session

3.6 Hibernate的其他的API
  1. Query
  1. Criteria
  1. SQLQuery

四、关系映射

1 一对多关系（双向数据绑定）
<!-- 配置多对一的关系：放置的是一的一方的对象 -->
        <!-- 
            many-to-one标签
                * name      :一的一方的对象的属性名称。
                * class     :一的一方的类的全路径。
                * column    :在多的一方的表的外键的名称。
         -->
        <many-to-one name="customer" cascade="save-update,delete" 
                     class="com.itheima.hibernate.domain.Customer" column="lkm_cust_id" />

<!-- 配置一对多的映射：放置的多的一方的集合 -->
        <!-- 
            set标签 ：
                * name  ：多的一方的对象集合的属性名称。
                * cascade：级联
                * inverse：放弃外键维护权。
        -->
        <set name="linkMans" cascade="save-update,delete" inverse="true">
            <!--
                 key标签
                    * column：多的一方的外键的名称。
             -->
            <key column="lkm_cust_id" />
            <!-- 
                one-to-many标签
                    * class :多的一方的类的全路径
             -->
            <one-to-many class="com.itheima.hibernate.domain.LinkMan" />
        </set>
2 多对多关系
<!-- 
            set标签
                * name      ：对方的集合的属性名称。
                * table     ：多对多的关系需要使用中间表，放的是中间表的名称。
         -->
        <set name="roles" table="sys_user_role" cascade="save-update,delete">
            <!-- 
                key标签：
                    * column    ：当前的对象对应中间表的外键的名称。
             -->
            <key column="user_id"/>
            <!-- 
                many-to-many标签：
                    * class     ：对方的类的全路径
                    * column    ：对方的对象在中间表中的外键的名称。
             -->
            <many-to-many class="com.itheima.hibernate.domain.Role" column="role_id"/>
        </set>

<!-- 
            set标签
                * name      ：对方的集合的属性名称。
                * table     ：多对多的关系需要使用中间表，放的是中间表的名称。
         -->
        <set name="users" table="sys_user_role" inverse="true" cascade="save-update,delete">
            <!-- 
                key标签：
                    * column    ：当前的对象对应中间表的外键的名称。
             -->
            <key column="role_id"/>
            <!-- 
                many-to-many标签：
                    * class     ：对方的类的全路径
                    * column    ：对方的对象在中间表中的外键的名称。
             -->
            <many-to-many class="com.itheima.hibernate.domain.User" column="user_id"/>
        </set>

注意：
// 保存操作:多对多建立了双向的关系必须有一方放弃外键维护。
// 一般是被动方放弃外键维护权。

五、查询方式及抓取策略（结）

1 OID查询

OID检索：Hibernate根据对象的OID（主键）进行检索

Customer customer = session.get(Customer.class,1l);
Customer customer = session.load(Customer.class,1l);
2 对象导航检索

对象导航检索：Hibernate根据一个已经查询到的对象，获得其关联的对象的一种查询方式。

LinkMan linkMan = session.get(LinkMan.class,1l);
Customer customer  = linkMan.getCustomer();

Customer customer = session.get(Customer.class,2l);
Set<LinkMan> linkMans = customer.getLinkMans();
3 HQL检索（取对象名与属性，跟表无关）

HQL查询：Hibernate Query Language，Hibernate的查询语言，是一种面向对象的方式的查询语言，语法类似SQL。通过session.createQuery()，用于接收一个HQL进行查询方式。

1.连接查询
  交叉连接：笛卡尔积
    select * from A,B;
  内连接   :inner join (inner 可以省略)
    隐式内连接：
      select * from A,B where A.id = B.aid;
    显示内连接：
      select * from A inner join B on A.id = B.aid;
  外连接   :
    左外连接:left outer join(outer 可以省略)
      select * from A left outer join B on A.id= B.aid;
    右外连接:right outer join(outer 可以省略)
      select * from A right outer join B on A.id = B.aid;
2.子查询

HQL的多表查询

连接查询
  交叉连接
  内连接
    显示内连接
    隐式内连接
    迫切内连接
  外连接
    左外连接
    右外连接
    迫切左外连接
4 QBC检索

QBC查询：Query By Criteria，条件查询。是一种更加面向对象化的查询的方式。

5 SQL检索

SQL查询：通过使用sql语句进行查询


6 延迟加载

延迟加载：lazy（懒加载）。执行到该行代码的时候，不会发送语句去进行查询，在真正使用这个对象的属性的时候才会发送SQL语句进行查询。

类级别的延迟加载
  指的是通过load方法查询某个对象的时候，是否采用延迟。session.load(Customer.class,1l);
  类级别延迟加载通过<class>上的lazy进行配置，如果让lazy失效
    将lazy设置为false
    将持久化类使用final修饰
    Hibernate. Initialize()
关联级别的延迟加载
  指的是在查询到某个对象的时候，查询其关联的对象的时候，是否采用延迟加载。
  Customer customer = session.get(Customer.class,1l);
  customer.getLinkMans();----通过客户获得联系人的时候，联系人对象是否采用了延迟加载，称为是关联级别的延迟。
  抓取策略往往会和关联级别的延迟加载一起使用，优化语句。
7 抓取策略

通过一个对象抓取到关联对象需要发送SQL语句，SQL语句如何发送，发送成什么样格式通过策略进行配置。
通过<set>或者<many-to-one>上通过fetch属性进行设置
fetch和这些标签上的lazy如何设置优化发送的SQL语句

  fetch：抓取策略，控制SQL语句格式
    select      ：默认值，发送普通的select语句，查询关联对象
    join            ：发送一条迫切左外连接查询关联对象
    subselect       ：发送一条子查询查询其关联对象
  lazy：延迟加载，控制查询关联对象的时候是否采用延迟
    true            ：默认值，查询关联对象的时候，采用延迟加载
    false           ：查询关联对象的时候，不采用延迟加载
    extra       ：及其懒惰。
  在实际开发中，一般都采用默认值。如果有特殊的需求，可能需要配置join。


  fetch ：抓取策略，控制SQL语句格式。
    select  ：默认值，发送普通的select语句，查询关联对象。
    join        ：发送一条迫切左外连接。
  lazy  ：延迟加载，控制查询关联对象的时候是否采用延迟。
    proxy   ：默认值，proxy具体的取值，取决于另一端的<class>上的lazy的值。
    false       ：查询关联对象，不采用延迟。
    no-proxy    ：（不会使用）
  在实际开发中，一般都采用默认值。如果有特殊的需求，可能需要配置join。
8 批量抓取

一批关联对象一起抓取，batch-size


上一篇 下一篇

猜你喜欢

热点阅读