hibernate入门实例代码

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//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <!--<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql://192.168.1.133:3306/crabman_queue</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">891220</property>
        <property name="hibernate.show_sql">true</property>
        <!– DB schema will be updated if needed –>
        <!– <property name="hbm2ddl.auto">update</property> –>

        <mapping resource=""></mapping>-->

        <!-- 数据库连接设置 -->
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="connection.url">jdbc:mysql://localhost:3306/test</property>
        <property name="connection.username">root</property>
        <property name="connection.password">123456</property>
        <!-- SQL方言 -->
        <property name="dialect">org.hibernate.dialect.MySQLInnoDBDialect</property>
        <!--实际操作数据库时是否显示SQL -->
        <property name="show_sql">true</property>

        <mapping resource="com/xiaochen/domain/User.hbm.xml"/>
    </session-factory>

</hibernate-configuration>

5.第一个Hibernate应用程序：

5.1.创建一个持久化类：

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

package com.xiaochen.domain;

/**
 * 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="com.xiaochen.domain.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 com.xiaochen.factory;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

/**
 * Created with IntelliJ IDEA.
 * User: Administrator
 * Date: 13-2-16
 * Time: 下午3:48
 * 修改描述
 */
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
     * <p/>
     * 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();
        }
    }

    public static void main(String[] args)
    {
        Session session = getSession();
        System.out.println(session == null);
        System.out.println(session);
    }
}

2.持久化操作类：

package com.xiaochen.domain.impl;

import com.xiaochen.domain.User;
import com.xiaochen.factory.HibernateSessionFactory;
import org.hibernate.HibernateException;
import org.hibernate.Session;

/**
 * Created with IntelliJ IDEA.
 * User: Administrator
 * Date: 13-2-16
 * Time: 下午3:51
 * 修改描述
 */
public class UseDaoHBImpl
{

    /**
     * 新增一个用户
     *
     * @paramuser 用户对象
     */
    public void saveUser(User user)
    {
        Session session = HibernateSessionFactory.getSession();
        try
        {
            HibernateSessionFactory.beginTransaction();

            session.save(user);

            HibernateSessionFactory.commitTransaction();
        } catch (HibernateException e)
        {
            HibernateSessionFactory.rollbackTransaction();
        } finally
        {
            HibernateSessionFactory.closeSession();
        }
    }

    /**
     * 根据ID删除该用户对象
     *
     * @paramid用户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();
        } finally
        {
            HibernateSessionFactory.closeSession();
        }
    }

    /**
     * 更新用户的信息
     *
     * @paramuser用户对象
     */
    public void updateUser(User user)
    {
        Session session = HibernateSessionFactory.getSession();
        try
        {
            HibernateSessionFactory.beginTransaction();

            session.saveOrUpdate(user);

            HibernateSessionFactory.commitTransaction();
        } catch (HibernateException e)
        {
            HibernateSessionFactory.rollbackTransaction();
        } finally
        {
            HibernateSessionFactory.closeSession();
        }
    }

    /**
     * 根据用户ID查询该用户对象
     *
     * @paramid 用户ID
     * @returnUser查询成功返回该用户对象，否则返回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)
        {
        } 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());
        }
    }
}

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接口擅长于执行动态查询。

评论

1 楼 yong3773 2013-05-30  

写的很好，学习了。谢谢。