Hibernate入门

Hibernate简介

Hibernate的创始人Gavin King
EJB 3.0专家委员会成员
JBoss核心成员之一
《Hibernate in Action》的作者
优秀的Java持久化层解决方案
主流的对象-关系映射工具

Hibernate的优缺点

Hibernate的优点:
1.简化了JDBC 繁琐的编码
​ 例如：

Session session = HiberanteUtil.currentSession();
Query query = session.createQuery("from User");
List<User> users = (List<User>) query.list();

2.对面向对象特性支持良好
3.可移植性好
4.框架开源免费，具有可扩展性

Hibernate的缺点
不适合需要使用数据库的特定优化机制的情况
不适合大规模的批量数据处理

与MyBatis的比较

1.相对于MyBatis的“SQL-Mapping”的ORM实现，Hibernate的ORM实现更加完善，提供了对象状态管理、级联操作等功能
2.完全面向对象，语句与数据库无关，开发者无需关注SQL的生成，开发简单，便于修改，数据库移植性好
3.由于直接使用SQL，MyBatis使用自由度较高

Hibernate环境搭建 Maven项目

将oracle驱动包引入到maven项目中：
https://blog.csdn.net/qq_38000902/article/details/82759268
hibernate依赖：

<!--hibernate依赖-->
    <!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-core -->
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-core</artifactId>
      <version>3.6.10.Final</version>
    </dependency>
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.16</version>
    </dependency>

    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-nop</artifactId>
      <version>1.6.4</version>
    </dependency>

    <!-- 添加javassist -->
    <dependency>
      <groupId>javassist</groupId>
      <artifactId>javassist</artifactId>
      <version>3.12.0.GA</version>
    </dependency>
    <dependency>
      <groupId>com.oracle</groupId>
      <artifactId>ojdbc6</artifactId>
      <version>11.2.0.1.0</version>
      <scope>test</scope>
    </dependency>

创建Hibernate配置文件的hibernate.cfg.xml ：

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
	<session-factory>
		<property name="connection.url">jdbc:oracle:thin:@localhost:1521:ORCL</property>
		<property name="connection.driver_class">oracle.jdbc.OracleDriver</property>
		<property name="connection.username">scott</property>
		<property name="connection.password">tiger</property>
		<!--数据库方言-->
		<property name="dialect">org.hibernate.dialect.Oracle10gDialect</property>
		<!--指定session范围为当前线程-->
		<property name="current_session_context_class">thread</property>
		<!--将执行的sql显示在日志记录中-->
		<property name="show_sql">true</property>
		<!--格式化sql-->
		<property name="format_sql">true</property>

        <!--加载映射文件-->
		<mapping resource="mapper/Dept.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

创建持久化类和映射文件：
1）定义持久化类（也称实体类），实现java.io.Serializable 接口，添加默认构造 方法

java.io.Serializable 接口 表示序列化，是一个空接口，也就是说这个接口没有声明任何的方法，所以实现这个接口的类也就不需要实现任何的方法。

public class Dept implements Serializable {
    private Integer depttno;
    private String dname;
    ......
}

2）配置映射文件（*.hbm.xml）

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="cn.bdqn.pojo.Dept" table="dept">
       <!--name是属性名；column是数据库字段名-->
        <id name="depttno" column="deptno" type="java.lang.Integer">
            <generator class="assigned"/>
        </id>
        <property name="dname" column="dname"  type="java.lang.String"/>
        <property name="location" column="loc" type="java.lang.String"/>
    </class>
</hibernate-mapping>          

使用Hibernate完成持久化操作

使用Hibernate操作数据库七个步骤
1）读取并解析配置文件及映射文件

 Configuration conf = new Configuration().configure();   

2）依据配置文件和映射文件中的信息，创建SessionFactory对象

    SessionFactory sf = conf.buildSessionFactory();   

3）打开session

  Session session = sf.getCurrentSession();     

4）开始一个事务

Transaction tx = session.beginTransaction();   

5）持久化操作

Dept dept = new Dept(); session.save(dept);   

6）提交或回滚事务

  tx.commit(); 或 tx.rollback();   

7）若使用openSession()开启会话，则需关闭

 session.close(); 

在项目开发中，通常使用工具类来管理SessionFactory和Session如下：

package cn.bdqn.util;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtil {
    private  static SessionFactory sessionFactory;
    private static Configuration configuration;
    //初始化SessionFactory和Configuration
    static {
        try {
            configuration=new Configuration().configure();  //读取并解析配置文件及映射文件
            sessionFactory=configuration.buildSessionFactory();//依据配置文件和映射文件中的信息，创建SessionFactory对象
        }catch (Exception e){
            throw new ExceptionInInitializerError(e);
        }
    }
    //获取Session对象
    public static Session getSession(){
        return sessionFactory.getCurrentSession();//打开session
    }
}

使用Hibernate实现查询操作

1）通过主键值加载指定类型的实例

方 法	区别一
Object get(Class clazz,Serializable id )	若数据不存在，返回null
Object load(Class clazz,Serializable id )	若数据不存在，使用时抛出ObjectNotFoundException

2）使用Hibernate实现数据库的增，删，改，查操作
增加：方法：save()
修改：方法：merge()
删除：delete()
查询：get()或load()

hibernate中Java对象的三种状态

1）瞬时状态：又称临时状态，就是Java对象在数据库中没有相关联的记录，此时Java对象状态为瞬时状态（new 出来的Java对象就是瞬时状态）

2）持久状态：当对象与session关联，被session管理时，就处于持久状态（new的Java对象通过执行增加或修改方法后就变为持久状态）

3）游离状态：又称脱管状态，处于持久状态的对象脱离与其关联的session的管理后，对象就处于游离状态（与数据库断开连接或清除数据后对象就变为游离状态）
三种状态之间的转换
1）瞬时状态转持久状态：使用session的save(),saveOrUpdate()等方法保存对象后，该对象由瞬时状态转持久状态 ; 使用session的get()或load()方法获取对象，该对象状态是持久状态

2）持久状态转瞬时状态：执行session的delete()方法后，该对象由持久状态转瞬时状态，此时该对象没与任何数据库数据关联

3）持久状态转游离状态：执行session的evict(),clear().close()方法，对象由持久状态转游离状态

4）游离状态转持久状态：执行session的update()或saveOrUpdate()方法，对象由游离状态转持久状态，该对象再次与当前session相关联

5）游离状态转瞬时状态：执行session的delete方法，对象由游离状态转瞬时状态

注意：瞬时状态或游离状态的对象不会被其他对象引用，会被Java虚拟机按垃圾回收机制处理

脏检查及刷新缓存机制

1.脏检查：数据前后发生变化的对象称为脏对象，判断数据前后是否发生变化，称为脏检查

2.刷新缓存机制：刷新缓存就是将数据库同步为与Session缓存一致，刷新缓存时会执行脏检查

1）当刷新缓存（调用Session的flush()方法）时，Hiberante会对Session中持久状态的对象进行检测，判断对象的数据是否发生了改变
2）commit()方法会首先刷新缓存

Session会在以下时间点刷新缓存：
1）调用Session的flush()方法:(执行脏检查)
2）调用Transaction的commit()方法：（刷新缓存）