hibernate3入门

Hibernate入门

                                ++YONG原创，转载请声明

1.    应用程序的分层体系结构：

1.1.       典型的三层结构：

1.1.1.       表示层：提供数据输入、检验与数据呈现的应用程序组件。(GUI、web页面)。就是与用户打交道的UI界面。

1.1.2.       业务层：提供商业逻辑服务的应用程序组件。

1.1.3.       数据层：负责存放和管理应用的持久性业务数据的持久化存储系统。(Database、XML)，最常见的持久化存储系统就是广泛使用的关系数据库。

1.2.       软件层的特征：

1.2.1.       每个层由一组相关的类或组件构成，共同完成特定的功能。

1.2.2.       层与层之间存在自上而下的依赖关系。即上层组件会访问下层组件的API，而下层组件不应该依赖上层组件。如：表现层依赖于业务逻辑层，而业务逻辑层依赖于数据层。

1.2.3.       每个层对上层公开API，封装实现细节。当某一层的实现发生改变，只要它的API不变，不会影响其他层的实现。

1.3.       软件分层的优点：

1.3.1.       伸缩性强：能支持更多的用户。

1.3.2.       可维护性高：修改软件的某一层的实现，不会影响其他层。

1.3.3.       可扩展性强：增加新功能更容易，每个层中都有扩展点，不会打破应用的整体框架。

1.3.4.       可重用性高：同一程序能满足多种需求。

1.3.5.       可管理性高：工作、管理模块化。

1.4.       四层结构：

由于数据存储方式多样，业务层不仅要负责业务逻辑的处理，还要跟数据层交互，提供对业务数据的CRUD操作(create、retrieve、update、delete)。为了把业务数据访问细节和业务逻辑分开，把业务数据访问作为单独的持久层。因此目前流行的软件分层结构是：

1.         表示层：

2.         业务层：业务逻辑层负责完成应用程序的逻辑功能，包括 调用持久层完成实体对象的存取、安全检查，事务控制等。抽象出业务逻辑层的好处是将应用程序的逻辑功能从表示层中剥离，这样就能复用逻辑层的功能。此外，业务逻辑层也可以看作是对持久层的一个门面模式，简化表示层对这些逻辑功能的调用。

3.         持久层：封装了业务数据访问细节，为业务层提供了面向对象的API。 持久层负责实现所有的数据访问功能，它将上层传入的数据写入到持久化存储系统中，并根据上层的要求读取或修改现有的数据。

4.         数据层：

1.5.       完善的持久层应该达到以下目标：

l 代码可重用性高，能够完成所有的数据访问操作。

l 具有相对独立性，当持久层的实现细节发生变化，不会影响上层的实现。

2.    ORM简介：

1.       ORM(Object-Relation Mapping)对象－关系映射模式指的是在单个组件中负责所有实体域对象的持久化，封装数据访问的细节。

2.       Hibernate就是一个开源的ORM中间件。(官方网站： http://www.hibernate.org/)

3.    Hibernate简介：

2001年未 Hibernate 第一个版本发表，2003年6月8日 Hibernate 2 发表，并于年未获得 Jolt 2004 大奖，后被 JBOSS 收纳而成为其子项目之一，2005年3月 Hibernate 3 正式发表，当中有了一些重大的改变，本文使用的版本为Hibernate 3.2。

4.    配置 hibernate：

4.1.       准备好所需的jar包：

到官方网站： http://www.hibernate.org/6.html 下载(当前版本：Hibernate Core 3.2.3GA )　hibernate包。解开压缩包。在lib目录下找到以下hibernate应用所必须的包(可以查看该目录下的_README.txt文件来确定哪些包是必需的)：

1.       hibernate.jar ：hibernate核心包。必需的。

2.       antlr.jar ：Hibernate使用ANTLR来产生查询分析器，这个类库在运行环境下时也是必需的。

3.       cglib.jar ：CGLIB库，Hibernate用它来实现PO字节码的动态生成，非常核心的库，必需的jar包。

4.       asm.jar ：ASM字节码库，cglib.jar包依赖的包。必需的jar包。

5.       asm-attrs.jar ：ASM字节码库，cglib.jar包依赖的包。必需的jar包。

6.       commons-collections.jar ：Apache Commons包中的一个，包含了一些Apache开发的集合类，功能比java.util.*强大。必须使用的jar包。

7.       commons-logging.jar ：Apache Commons包中的一个，包含了日志功能，必须使用的jar包。这个包本身包含了一个Simple Logger，但是功能很弱。在运行的时候它会先在CLASSPATH找log4j，如果有，就使用log4j，如果没有，就找JDK1.4带的java.util.logging，如果也找不到就用Simple Logger。必需的。

8.       ehcache.jar ：Hibernate可以使用不同cache缓存工具作为二级缓存。EHCache是缺省的cache缓存工具。如果没有其它的可选缓存工具，则为必需的。

9.       jta.jar ：JTA规范，当Hibernate使用JTA的时候需要。必需的。

10.   dom4j.jar ：dom4j是一个Java的XML API，类似于jdom，用来读写XML文件的。Hibernate使用dom4j解析XML配置文件和XML映射元文件。必需的。

11.   log4j.jar ：日志包，可选的。

把以上必需的jar放置到应用程序的类路径中(web应用的WEB-INF/lib目录下)。

4.2.       基本的Hibernate配置文件：

在WEB-INF/classes目录下创建一hibernate.cfg.xml(在官方下载的包etc目录下有样板文件)：

<? xml version = "1.0" encoding = "utf-8" ?> <! DOCTYPE hibernate-configuration PUBLIC     "-//Hibernate/Hibernate Configuration DTD 3.0//EN"     "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd" > < hibernate-configuration >     < session-factory >         <!-- 数据库连接设置 -->         < property name = "connection.driver_class" >             com.mysql.jdbc.Driver         </ property >         < property name = "connection.url" >             jdbc:mysql://localhost:3306/demo         </ property >         < property name = "connection.username" > root </ property >         < property name = "connection.password" > root </ property >         <!-- SQL 方言 -->         < property name = "dialect" > org.hibernate.dialect.MySQLInnoDBDialect </ property >         <!-- 实际操作数据库时是否显示 SQL -->         < property name = "show_sql" > true </ property >          <!-- 将数据库 schema 的 DDL 导出到数据库 --> <!-- property name = "hibernate.hbm2ddl.auto" > create </ property!-- >           <!-- 以下设置对象与数据库表的映像文件 -->         ......     </ session-factory > </ hibernate-configuration >

5.    第一个Hibernate应用程序：

5.1.       创建一个持久化类：

持久化类就是其实例要被持久化到数据库中的类，通常都是实体域类，它是带有一些属性及属性的getters、setters方法的POJO类：

package org.qiujy.demo;   /**   * User 持久化类   * 第一个 Hibernate 示例   * @author Administrator   *   */ public class User {     private Integer id ;     private String name ;     private Integer age ;         public User(){}       public Integer getAge() {         return age ;     }       public void setAge(Integer age) {         this . age = age;     }       public Integer getId() {         return id ;     }       public void setId(Integer id) {         this . id = id;     }       public String getName() {         return name ;     }       public void setName(String name) {         this . name = name;     } }

5.2.       准备好数据库表：

在MySQL中新增一个demo数据库，并建立user表：

CREATE TABLE user (     id INT(11) NOT NULL auto_increment PRIMARY KEY,     name VARCHAR(100) NOT NULL default '',     age INT );

5.3.       创建对象-关系映射文件：

Hibernate需要知道怎样去加载（load）和存储（store）持久化类的对象。这正是Hibernate映射文件发挥作用的地方。映射文件告诉Hibernate应该访问数据库(database)里面的哪个表（table）以及应该使用表里面的哪些字段（column）。

在持久化类所在的包的目录下创建一名为User.hbm.xml的映射文件：

<? xml version = "1.0" encoding = "utf-8" ?> <! DOCTYPE hibernate-mapping PUBLIC         "-//Hibernate/Hibernate Mapping DTD 3.0//EN"         "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >   < hibernate-mapping >     < class name = "org.qiujy.demo.User" table = "user" >         < id name = "id" column = "id" type = "java.lang.Integer" >             < generator class = "native" />         </ id >         < property name = "name" column = "name" type = "java.lang.String" />         < property name = "age" column = "age" type = "java.lang.Integer" />     </ class > </ hibernate-mapping >

5.4.       在Hibernate配置文件hibernate.cfg.xml中指明映射文件的位置：

< session-factory > <!-- 以下设置对象与数据库表的映像文件 -->     < mapping resource = "org/qiujy/demo/User.hbm.xml" /> </ session-factory >

5.5.       使用Hibernate API进行持久化操作：

1.       创建一辅助类：由这个辅助类来创建一个线程安全的、全局的SessoinFactory，SessionFactory可以创建并打开新的单线程的Session。

package org.qiujy.common;   import org.hibernate.HibernateException; import org.hibernate.Session; import org.hibernate.Transaction; import org.hibernate.cfg.Configuration;   /**  * HibernateSession 工厂  */ public class HibernateSessionFactory {       /** Hibernate 的配置文件 hibernate.cfg.xml */     private static String CONFIG_FILE_LOCATION = "/hibernate.cfg.xml";     /** Session 的线程本地变量 */          private static final ThreadLocal threadLocal = new ThreadLocal();          /** transaction 的线程本地变量 */          private static final ThreadLocal txThreadLocal = new ThreadLocal();     private static Configuration configuration = new Configuration();     private static org.hibernate.SessionFactory sessionFactory;     private static String configFile = CONFIG_FILE_LOCATION;       private HibernateSessionFactory() {     }                   /**      * 获得一个线程本地化的 Hibernate session 实例      * @return Session      * @throws HibernateException      */     public static Session getSession() throws HibernateException {         Session session = (Session) threadLocal.get();                      if (session == null || !session.isOpen()) {                             if (sessionFactory == null) {                                      rebuildSessionFactory();                             }                             session = (sessionFactory != null) ? sessionFactory.openSession()                                                : null;                             threadLocal.set(session);                    }           return session;     }            /**      * Rebuild hibernate session factory      */          public static void rebuildSessionFactory() {                    try {                             configuration.configure(configFile);                             sessionFactory = configuration.buildSessionFactory();                    } catch (Exception e) {                             System.err                                                .println("%%%% Error Creating SessionFactory %%%%");                             e.printStackTrace();                    }          }            /**      *  关闭线程化的 Hibernate session 实例      * @throws HibernateException      */     public static void closeSession() throws HibernateException {         Session session = (Session) threadLocal.get();         threadLocal.set(null);           if (session != null) {             session.close();         }     }            /**      * return session factory      *      */          public static org.hibernate.SessionFactory getSessionFactory() {                    return sessionFactory;          }            /**      * return session factory      *      *       session factory will be rebuilded in the next call      */          public static void setConfigFile(String configFile) {                    HibernateSessionFactory.configFile = configFile;                    sessionFactory = null;          }            /**      * return hibernate configuration      *      */          public static Configuration getConfiguration() {                    return configuration;          }                   /**           * 在本地 session 实例上开启事务           */          public static void beginTransaction(){                    Transaction tx = (Transaction)txThreadLocal.get();                    if(tx == null){                             tx = getSession().beginTransaction();                             txThreadLocal.set(tx);                    }          }                   /**           * 在本地 session 实例上提交事务           */          public static void commitTransaction(){                    Transaction tx = (Transaction)txThreadLocal.get();                    if(tx != null && !tx.wasCommitted() && !tx.wasRolledBack()){                             tx.commit();                             txThreadLocal.set(null);                    }          }                   /**           * 在本地 session 实例上回滚事务           */          public static void rollbackTransaction(){                    Transaction tx = (Transaction)txThreadLocal.get();                    txThreadLocal.set(null);                    if(tx != null && !tx.wasCommitted() && !tx.wasRolledBack()){                             tx.rollback();                    }          }   }

 

2.       持久化操作类：

package org.qiujy.dao.impl;   import org.apache.log4j.Logger; import org.hibernate.HibernateException; import org.hibernate.Session; import org.qiujy.common.HibernateSessionFactory; import org.qiujy.domain.User;   public class UseDaoHBImpl {     private static Logger myLogger = Logger.getLogger(UseDaoHBImpl. class );       /**       * 新增一个用户       * @param user 用户对象       */     public void saveUser(User user) {         Session session = HibernateSessionFactory.getSession();         try {             HibernateSessionFactory.beginTransaction();               session.save(user);               HibernateSessionFactory.commitTransaction();         } catch (HibernateException e) {             HibernateSessionFactory.rollbackTransaction();             myLogger .error( " 新增用户失败 " , e);         } finally {             HibernateSessionFactory.closeSession();         }     }         /**       * 根据 ID 删除该用户对象       * @param id 用户 ID       */     public void removeUserByID( int id){         Session session = HibernateSessionFactory.getSession();         try {             HibernateSessionFactory.beginTransaction();                         User user = (User) session.get(User. class , new Integer(id));             session.delete(user);               HibernateSessionFactory.commitTransaction();         } catch (HibernateException e) {             HibernateSessionFactory.rollbackTransaction();             myLogger .error( " 新增用户失败 " , e);         } finally {             HibernateSessionFactory.closeSession();         }     }         /**       * 更新用户的信息       * @param user 用户对象       */     public void updateUser(User user){         Session session = HibernateSessionFactory.getSession();         try {             HibernateSessionFactory.beginTransaction();                         session.saveOrUpdate(user);               HibernateSessionFactory.commitTransaction();         } catch (HibernateException e) {             HibernateSessionFactory.rollbackTransaction();             myLogger .error( " 新增用户失败 " , e);         } finally {             HibernateSessionFactory.closeSession();         }     }       /**       * 根据用户 ID 查询该用户对象       * @param id 用户 ID       * @return User 查询成功返回该用户对象，否则返回 null       */     public User getUserByID( int id) {         User user = null ;         Session session = HibernateSessionFactory.getSession();           try {             //get 与 load 的区别 ?             user = (User) session.get(User. class , new Integer(id));           } catch (HibernateException e) {             myLogger .error( " 查询用户失败 " , e);         } finally {             HibernateSessionFactory.closeSession();         }           return user;     }       public static void main(String[] args) {           User user = new User();         user.setName( " 张三 " );         user.setAge( new Integer(26));           UseDaoHBImpl manager = new UseDaoHBImpl();         // 增         manager.saveUser(user);                 // 查         User user1 = manager.getUserByID(1);         if (user1 != null ){             user1.setName( " 李四 " );             // 改             manager.updateUser(user1);                         // 删             //manager.removeUserByID(user1.getId().intValue());         }     } }

 

3.       运行如上程序，操作成功的话，以数据库就可以看到新插入的数据了。

4.       整个web应用程序的目录结构如下：(我是在eclipse+MyEclispe下构建的)

5.       本例源代码：

6.    Hibernate的核心接口：

所有的Hibernate应用中都会访问Hibernate的5个核心接口：

6.1.       Configuration接口：

此接口的实例用于配置并且根启动Hibernate。Hibernate通过Cofinguration实例来指定对象-关系映射文件的位置或者动态配置Hibernate的属性，然后创建SessionFactory实例。

6.2.       SessionFactory接口：

一个SessionFactory实例对应一个数据存储源。应用程序从SessionFactory中获得Session实例。SessionFactory具有以下特点：

1.       线程安全，即同一个SessionFactory实例可以被应用的多个线程共享。

2.       它是重量级的，因为它需要一个很大的缓存，用来存放预定义的SQL语句以及映射元数据等。所以，如果应用程序只访问一个数据库，则只需要创建一个SessionFactory实例。

6.3.       Session接口：

应用最广泛的接口。Session也被称为持久化管理器，它提供了和持久化相关的操作：如添加、更新、删除、加载和查询对象。session有以下特点：

1.       线程不安全，在设计软件架构时，应该避免多个线程共享同一个Session实例。

2.       Session实例是轻量级的，它的创建和销毁不需要消耗太多的资源。

session有一个缓存，被称为Hibernate的第一级缓存，它存放被当前工作单元加载的对象。

6.4.       Transaction接口：

Transaction接口是Hibernate的数据库事务接口。它对底层的事务接口做了封装，包括：

JDBC API、JTA、CORBA。

Hibernate 应用可通过一致的Transaction接口来声明事务边界，这有助于应用在不同的环境和容器中移植。

6.5.       Query和Criteria接口：

它们是Hibernate的查询接口，用于数据库查询对象以及控制执行查询的过程。Query包装了一个HQL(Hibernate Query Language)查询语句，Criteria接口完全封装了基于字符串形式的查询语句，比Query更加面向对象，Cirteria接口擅长于执行动态查询。