Hibernate入门
来源:互联网 发布:如何在手机淘宝付款 编辑:程序博客网 时间:2024/06/11 08:03
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示例 *@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 = (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; publicclass UseDaoHBImpl { privatestatic Logger myLogger = Logger.getLogger(UseDaoHBImpl.class); /** *新增一个用户 *@paramuser 用户对象 */ publicvoid 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删除该用户对象 *@paramid用户ID */ publicvoid 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(); } } /** *更新用户的信息 *@paramuser用户对象 */ publicvoid 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查询该用户对象 *@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) { myLogger.error("查询用户失败", e); } finally { HibernateSessionFactory.closeSession(); } return user; } publicstaticvoid 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接口擅长于执行动态查询。
- Hibernate 入门
- Hibernate 入门
- Hibernate入门
- Hibernate入门
- Hibernate入门
- Hibernate 入门
- Hibernate入门
- Hibernate入门
- Hibernate 入门
- Hibernate入门
- Hibernate入门
- Hibernate入门
- Hibernate入门
- Hibernate入门
- Hibernate入门
- hibernate 入门
- Hibernate入门
- hibernate入门
- 【转】windows命令行下命令与解释
- hibernate3学习系列文章的地址列表
- 操纵持久化对象
- 一个解决VC++程序国际化的类,解决乱码问题
- Hibernate映射的基本操作
- Hibernate入门
- Hibernate缓存管理
- 直线扫描算法
- BOSS:从电信到广电
- 简单的python文件操作。
- viaVoice开发,怎样设置IBM viavoice的语言
- Java中四种XML解析技术之不完全测试
- 广电BOSS系统简介
- 使用 dom4j 解析 XML