Hibernate快速上手

一.Hibernate工作原理
5个核心接口：Configuration接口、SessionFactory接口、Session接口、Transaction接口和用于数据查询的
Query接口。
Hibernate进行持久化操作的主要步骤：
（1）Hibernate初始化：创建Configuration对象。
读取XML配置文件和映射文件的信息到Configuration对象的属性中：
1.从Hibernate配置文件Hibernate.cfg.xml中读取配置信息，存放到Configuration对象（内存）中。
2.根据配置文件中的mapping元素加载所有实体类对应的映射文件到Configuration对象中。
（2）创建SessionFactory实例。
将Configuration对象内的配置信息存入SessionFactory的内存（属性）中。SessionFactory充当数据存储
源的代理，负责创建Session对象。
（3）创建Session实例，建立数据库连接。
Session通过SessionFactory打开，创建一个Session对象就相当于与数据库建立了一个新的连接。Session
对象用来操作实体对象，并把这些操作转换成对数据库中数据的增加、删除、查询和修改操作。
（4）创建Transaction实例，开始一个事务。
Transaction用于事务管理，一个Transaction对象对应的事务可以包括多个操作。使用Hibernate进行增
加、删除、修改操作时必须先创建Transaction对象。
（5）利用Session接口提供的方法进行持久化操作。将实体对象持久化到数据库中。
（6）提交操作结果并结束事务。对实体对象的持久化操作结束后，必须提交事务。
（7）关闭Session，与数据库断开连接。
二.开发Hibernate项目的完整流程
（1）准备开发环境，创建Hibernate项目
（2）数据库中创建所需数据表
（3）创建持久化类(xxx.java)
包括表中的各种字段属性，
（4）设计映射文件（xxx.hbm.xml），使用Hibernate映射文件将POJO对象映射到数据库。

     <hibernate-mapping>
       <!-- name指定持久化类的类名，table指定数据表的表名 -->
       <class name="com.model.xxx" table="user">
         <!-- 标识属性 -->
         <id name="id" type="java.lang.Integer" column="user_id">
         <generator class="increment"></generator>
         </id>
         <property name="name" type="java.lang.String" column="name" length="20"></property>
       </class>   
    </hibernate-mapping>

（5）创建Hibernate的配置文件Hibernate.cfg.xml.

    <hibernate-configuration>
      <session-factory>
        <!-- 方言（数据库类型） -->
        <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
        <!-- 数据库连接URL -->
       <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/mysqldb</property>
       <!-- 数据库用户名 -->
       <property name="hibernate.connection.username">root</property>
       <!-- 数据库密码 -->
       <property name="hibernate.connection.password">xxxxxx</property>
       <!-- 配置数据库JDBC驱动 -->
       <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property> 
       <!-- 数据库连接池（保存的最大数据库连接数） -->
       <property name="connection.pool_size">1</property>
        <!-- 输出运行时生成的sql语句到控制台，（方便调试） -->
       <property name="show_sql">true</property>
       <!-- 列出所有的映射文件 -->
       <mapping resource="包名/xxx.hbm.xml"/>
     </session-factory>
   </hibernate-configuration>

（6）编写辅助工具类HibernateUtil.Java
org.hibernate.SessionFactory是一个线性安全的对象，只能被实例化一次。使用
org.hibernate.SessionFactory可以获得一个或多个org.hibernate.Session实例。
HibernateUtil类的基本实现代码如下：

import org.hibernate.*;
import org.hibernate.cfg.*;
public class HibernateUtil {
private static SessionFactory sessionFactory;
//一个代码只创建一个Configuration实例
private  static Configuration configuration = new Configuration();   
//创建线程局部变量threadLocal，用来保存Hibernate的Session
private static final ThreadLocal<Session> threadLocal = new ThreadLocal<Session>();
//使用静态代码块初始化Hibernate，只在类被加载时执行一次
static {
try {
Configuration cfg=new Configuration().configure();      //读取配置文件  hibernate.cfg.xml
sessionFactory=cfg.buildSessionFactory();           //创建SessionFactory
} catch (Throwable ex) {
throw new ExceptionInInitializerError(ex);
}
}
//获得SessionFactory实例
public static SessionFactory getSessionFactory() {
return sessionFactory;
}
//获得ThreadLocal 对象管理的Session实例.  
public static Session getSession() throws HibernateException {                
    Session session = (Session) threadLocal.get();
    if (session == null || !session.isOpen()) {
        if (sessionFactory == null) {

            rebuildSessionFactory();
        }
        //通过SessionFactory对象创建Session对象
        session = (sessionFactory != null) ? sessionFactory.openSession(): null;
            //将新打开的Session实例保存到线程局部变量threadLocal中
        threadLocal.set(session);
        }
        return session;
}
//关闭Session实例
public static void closeSession() throws HibernateException {
//从线程局部变量threadLocal中获取之前存入的Session实例
Session session = (Session) threadLocal.get();
        threadLocal.set(null);
        if (session != null) {
            session.close();
        }
    }
//重建SessionFactory
public static void rebuildSessionFactory() {
    try {
    configuration.configure("/hibernate.cfg.xml");      //读取配置文件hibernate.cfg.xml
        sessionFactory = configuration.buildSessionFactory();       //创建SessionFactory
        } catch (Exception e) {
            System.err.println("Error Creating SessionFactory ");
            e.printStackTrace();
        }
}
//关闭缓存和连接池
public static void shutdown() {
getSessionFactory().close();
}
}

代码解说：
  创建Configuration实例的作用
  1.读取hibernate.cfg.xml配置文件信息

        new Configuration().configure();
        或
        Configuration configuration = new Configuration();
        configuration.configure();

   (1)new Configuration()方法被调用时，查找classpath根目录下的hibernate.properties文件(总是位于类路
   径的根目录下)。
   (2)configure()方法被调用时，查找classpath根目录下的hibernate.cfg.xml文件,找不到，则抛出
   HibernateException。
   Configure接口的一个带参数的方法：

       //configFile指定了hibernate.cfg.xml文件的位置
       public Configuration configure(File configFile) throws HibernateException{}

  2.创建SessionFactory实例

        new Configuration().configure().buildSessionFactory();
        或
        sessionFactory = configuration.buildSessionFactory();

    !!只有当应用中存在多个数据源时，才为每个数据源创建一个SessionFactory实例。
    获取Session实例的代码：

        Session session = sessionFactory.openSession();

   Session并不是线程安全的，常用的管理方案是使用ThreadLocal模式。
   ThreadLocal指线程局部变量，功能是为每个使用变量X的线程提供一个X的副本。
   ThreadLocal类中提供了一个Map,ThreadLocal使用这个Map来存储每一个线程中的变量副本。

（7）编写DAO层类
DAO指的是数据库访问对象，将底层数据访问逻辑与上层的业务逻辑隔离开。

      //四个方法：插入、删除、查找、更新
      public void save(User user)|delete(User user)|update(User user){
        Session session = HibernateUtil.getSession(); //创建Session实例
        Transaction tx = session.beginTransaction();  //创建Transaction实例
        try{
                //     插入               删除                 更新
            session.save(user)|session.delete(user)|session.update(user);
            tx.commit();        //提交事务
        }catch(Exception e){
            e.printStackTrace();
            tx.rollback();
        }finally{
            HibernateUtil.closeSession();   //关闭Session实例
        }
    }
    //查找用户
    public User findById(int id){
        User user = null;
        Session session = HibernateUtil.getSession(); //创建Session实例
        Transaction tx = session.beginTransaction();  //创建Transaction实例
        try{
            user = (User)session.get(User.class, id);
            tx.commit();        //提交事务
        }catch(Exception e){
            e.printStackTrace();
            tx.rollback();
        }finally{
            HibernateUtil.closeSession();
        }
        return user;
    }

三、进阶：
如果没有提供DAO工厂类，则必须要创建DAO实现类的实例来完成数据库的操作，这对于后期的代码重用和维护都非常
不便。（若将操作Mysql数据库的DAO实现类改为操作Oracle数据库的DAO实现类，则必须修改所有使用DAO实现类的
那些代码）
可通过DAO工厂类提供的一个静态方法来获取DAO实现类的实例，当需要替换DAO实现类时，只需在该DAO工厂中修
改静态方法的代码。

   public class DAOFactory{
        //返回UserDao实现类的实例
        public static UserDao getUserDaoInstance(){
               return new UserDaoimpl();
        }
   }
   //通过Dao工厂来获得Dao实现类的实例
   UserDao userDao = DAOFactory.getUserDaoInstance();