`

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.       完善的持久层应该达到以下目标:
代码可重用性高,能够完成所有的数据访问操作。
具有相对独立性,当持久层的实现细节发生变化,不会影响上层的实现。
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>
         <!--将数据库schemaDDL导出到数据库 -->
<!--property name="hibernate.hbm2ddl.auto">create </property!-->
 
        <!-- 以下设置对象与数据库表的映像文件 -->
        ......
    </session-factory>
</hibernate-configuration>
5.    第一个Hibernate应用程序:
5.1.       创建一个持久化类:
持久化类就是其实例要被持久化到数据库中的类,通常都是实体域类,它是带有一些属性及属性的getters、setters方法的POJO类:
package org.qiujy.demo;
 
/**
 *User持久化类
 *第一个Hibernate示例
 *@authorAdministrator
 *
 */
publicclass User {
    private Integer id;
    private String name;
    private Integer age;
   
    public User(){}
 
    public Integer getAge() {
        returnage;
    }
 
    publicvoid setAge(Integer age) {
        this.age = age;
    }
 
    public Integer getId() {
        returnid;
    }
 
    publicvoid setId(Integer id) {
        this.id = id;
    }
 
    public String getName() {
        returnname;
    }
 
    publicvoid 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
分享到:
评论

相关推荐

    hibernate3 入门

    **Hibernate3 入门** Hibernate 是一款开源的对象关系映射(ORM)框架,它允许Java开发者将数据库操作转化为面向对象的方式进行,极大地提高了开发效率。Hibernate3 是 Hibernate 的第三个主要版本,相较于之前的...

    Hibernate3入门例子

    《Hibernate3入门实战详解》 Hibernate3是一款强大的Java对象关系映射(ORM)框架,它为开发者提供了在Java应用中操作数据库的强大工具。本入门例子适用于初学者,旨在通过具体的实践,帮助理解Hibernate3的基本...

    Hibernate 3 入门

    **Hibernate 3 入门** Hibernate 是一个开源的Java对象关系映射(ORM)框架,它简化了数据库操作,使得开发者可以使用面向对象的方式处理数据。在Hibernate 3 中,这个框架提供了许多改进和增强的功能,使其成为...

    hibernate3完整入门示例含jar包

    **标题:“Hibernate3完整入门示例含jar包”** Hibernate是一个强大的Java库,它作为对象关系映射(ORM)框架,使得开发人员可以更轻松地处理数据库操作。在这个压缩包中,包含的是Hibernate3的入门示例,以及必要...

    Hibernate入门到精通

    "Hibernate入门到精通" Hibernate 是一个基于Java的ORM(Object-Relational Mapping,对象关系映射)框架,它提供了一种简洁高效的方式来访问和操作关系数据库。下面是 Hibernate 的主要知识点: Hibernate 简介 ...

    Hibernate3 入门教程(纯Eclipse版)

    Hibernate是一个不依赖其他平台的轻量级的中间件,现在到处充斥着通过各种工具使用Hibernate进行开发的教程,如 MyEclipse, Ant, Maven等等,但是去掉这些工具,事实上,Hibernate仍然可以使用的。下面的讲解就是...

    Hibernate入门案例源码

    【Hibernate入门案例源码】是针对初学者设计的一份教程,旨在帮助理解并掌握Java持久化框架Hibernate的基础应用。Hibernate是一个强大的ORM(对象关系映射)框架,它简化了数据库与Java对象之间的交互,使开发者可以...

    MyEclipse+Hibernate快速入门中文版

    ### MyEclipse+Hibernate快速入门知识点详解 #### 一、前言 本文档旨在通过一个简单易懂的方式,介绍如何在MyEclipse环境下配置并使用Hibernate框架。这是一份非常适合初学者使用的指南,特别是对于那些希望快速...

    MyEclipse Hibernate 快速入门中文版

    《MyEclipse Hibernate 快速入门中文版》是专为初学者设计的指南,旨在帮助开发者迅速掌握在MyEclipse集成开发环境中使用Hibernate框架的基本操作和应用。此资源包括一个HTML文档(MyEclipse_Hibernate_Quickstart_...

    初学hibernate,hibernate入门

    **初学Hibernate,Hibernate入门** Hibernate是一个开源的对象关系映射(ORM)框架,它为Java开发者提供了方便的数据持久化服务。在Java应用中,通过Hibernate,开发者可以将数据库操作抽象成对象模型,使得代码...

    Hibernate入门jar包

    本压缩包提供的是Hibernate入门所需的jar包,包括了Hibernate的核心库以及与之配合使用的相关组件。让我们深入探讨一下这些jar包以及它们在Hibernate中的作用。 1. Hibernate核心库: - `hibernate-core.jar`:这...

    Hibernate从入门到精通1

    Hibernate从入门到精通1

    hibernate官方入门教程 (转载)

    标题“hibernate官方入门教程 (转载)”表明这是一份关于Hibernate框架的基础教学资源,可能是从官方文档或者其他可靠来源整理而来的,适合初学者了解和学习Hibernate。 描述中提到的“NULL”意味着没有具体的描述...

    Hibernate快速入门

    本资源介绍了Hibernate组织架构,工作原理,配置方法、开发步骤,以及Configuration、SessionFactory、Session、Query、Transaction在Hibernate中的主要作用和使用方法,并资源以一个具体的例子贯穿所有内容;...

    Hibernate快速入门.doc

    Hibernate快速入门.doc Hibernate快速入门.doc Hibernate快速入门.doc

    Hibernate入门

    ### Hibernate入门知识点详解 #### Hibernate概述与ORM思想 - **定义**:Hibernate是一个开源的、轻量级的对象关系映射(Object-Relational Mapping,简称ORM)框架,它主要应用于JavaEE架构中的DAO(Data Access ...

Global site tag (gtag.js) - Google Analytics