（Hibernate进阶）Hibernate搭建开发环境+简单实例（二）

hibernate是非常典型的持久层框架，持久化的思想是非常值得我们学习和研究的。这篇博文，我们主要以实例的形式学习Hibernate，不深究Hibernate的思想和原理，否则，一味追求，苦学思想和原理，到最后可能什么也学不会，从实践入手，熟能生巧，思想和原理自然而然领悟。

上篇博文：【SSH进阶之路】Hibernate基本原理，我们介绍了Hibernate的基本概念、Hibernate的核心以及Hibernate的执行原理，可以很好帮助我们认识Hibernate，再看这篇博客之前，请先回顾上篇博文内容。这篇博文，我们从实践角度，动手搭建一个简单的Hibernate实例。

一、开发环境

Win8 + jdk1.7 + MyEclipse + Tomcat5.0 + MySQL

说明：其实Hibernate是非常独立的框架，根本不需要MyEclipse，Eclipse，Tomcat，Log4J等，他们只不过是能满足我们其他的需求，才把他们引进来的。

二、下载文件

你需要JavaSDK、 Hibernate包、和JDBC Driver。
 
1、Hibernate包下载地址:
http://prdownloads.sourceforge.net/hibernate/?sort_by=date&sort=desc

2、JDBC Driver根据你的数据库来定，一般database官网都有。Hibernate支持常用的数据库，比如 MySQL， Oracle等等。这两个数据库是现在比较常用的，都有JDBC Driver：

Oracle JDBC Driver下载地址(下载前必须同意Oracle协议书)
http://otn.oracle.com/software/htdocs/distlic.html?/software/tech/java/sqlj_jdbc/htdocs/jdbc9201.html

MySQL JDBC Driver下载地址
http://dev.mysql.com/downloads/connector/j/3.0.html

三、所需jar包

hibernate3.jar                                             Hibernate的核心包

dom4j-1.6.1.jar                                            dom4j读取xml文件包

mysql-connector-Java-3.1.13-bin.jar        MySQL的jdbc驱动包

Hibernate的作用：让我们以面向对象的方式或思维来考虑怎么向关系型数据库存取数据。它需要与相应的数据库打交道，所以需要相应的jdbc驱动。我们的database用的是MySQL，所以需要引入MySQL的jdbc驱动。

log4j-1.2.11.jar                                           记录日志框架

由于log4j的记录日志比jdk自带的记录日志功能更加美观，简单，易配置日志级别，便于调试，我们选择使用log4j。

必须要引入的jar：

commons-logging-1.0.4.jar                       抽象的日志记录框架

本身并没有实现真正的写日志能力（看包结构即可知道）而是结合其它的日志系统如Log4j或者java本身的java.util.logging作为日志输出组件，来实现日志记录的功能。

commons-collections-2.1.1jar                各种集合类和集合工具类的封装

cglib-2.1.3.jar                                            动态代理，Hibernate用它来实现PO字节码的动态生成

asm.jar                                                      cglib需要依赖的jar，ASM字节码库

注：作为初学者不提倡这种做法，只需要将hibernate所要依赖的第三方jar包都引入即可，否则做其他实例时会报NoClassDefFoundError的错误，解决方案：只需将对应jar引入即可。由于这是一个简单实例，仅仅需要引入这些jar。

四、代码展示

1、在IDE中创建java项目（比较简单不再演示）

2、创建source folder，命名为Hibernate3，在Hibernate下载文件中找到我们所需要的三个配置文件和所有jar包，拷贝所需jar文件，构建依赖包

3、提供hibernate.cfg.xml文件，完成基本配置

4、写代码

（1）建立实体类User.java

1. package com.liang.hibernate;
2. import java.util.Date;
3. public class User {
4. private String id;
5. private String name;
6. private String password;
7. private Date createTime;
8. private Date expireTime;
9. public String getId() {
10. return id;
11. }
12. public void setId(String id) {
13. this.id = id;
14. }
15. public String getName() {
16. return name;
17. }
18. public void setName(String name) {
19. this.name = name;
20. }
21. public String getPassword() {
22. return password;
23. }
24. public void setPassword(String password) {
25. this.password = password;
26. }
27. public Date getCreateTime() {
28. return createTime;
29. }
30. public void setCreateTime(Date createTime) {
31. this.createTime = createTime;
32. }
33. public Date getExpireTime() {
34. return expireTime;
35. }
36. public void setExpireTime(Date expireTime) {
37. this.expireTime = expireTime;
38. }
39. }

（2）提供User.hbm.xml文件，完成实体类映射

1. <span style="font-size:12px;"><?xml version="1.0"?>
2. <!DOCTYPE hibernate-mapping PUBLIC
3. "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
4. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
5. <hibernate-mapping>
6. <!--生成默认为user的数据库表-->
7. <class name="com.liang.hibernate.User">
8. <id name="id">
9. <!-- 算法的核心思想是结合机器的网卡、当地时间、一个随机数来生成GUID -->
10. <generator class="uuid"></generator>
11. </id>
12. <property name="name"></property>
13. <property name="password"></property>
14. <property name="createTime" type="date"></property>
15. <property name="expireTime" type="date"></property>
16. </class>
17. </hibernate-mapping></span>

（3）将User.hbm.xml文件加入到hibernate.cfg.xml文件中

1. <!DOCTYPE hibernate-configuration PUBLIC
2. "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
3. "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
4. <hibernate-configuration>
5. <session-factory>
6. <!-- 设置数据库驱动 -->
7. <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
8. <!-- 设置数据库URL -->
9. <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate_first</property>
10. <!-- 数据库用户名 -->
11. <property name="hibernate.connection.username">root</property>
12. <!-- 数据库密码 -->
13. <property name="hibernate.connection.password">123456</property>
14. <!-- 指定对应数据库的方言，hibernate为了更好适配各种关系数据库，针对每种数据库都指定了一个方言dialect -->
15. <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
16. <!-- 映射文件 -->
17. <mapping resource="com/liang/hibernate/User.hbm.xml"/>
18. </session-factory>
19. </hibernate-configuration>

（4）编写工具类ExportDB.java，将hbm生成ddl,也就是hbm2ddl

1. package com.liang.hibernate;
2. import org.hibernate.cfg.Configuration;
3. import org.hibernate.tool.hbm2ddl.SchemaExport;
4. /**
5. * 将hbm生成ddl
6. * @author liang
7. *
8. */
9. public class ExportDB{
10. public static void main(String[]args){
11. //默认读取hibernate.cfg.xml文件
12. Configuration cfg = new Configuration().configure();
13. ////生成并输出sql到文件（当前目录）和数据库
14. SchemaExport export = new SchemaExport(cfg);
15. export.create(true, true);
16. }
17. }

测试之前，要提前建立数据库hibernate_first，测试如下：

控制台打印的SQL语句：

1. drop table if exists User
2. create table User (id varchar(255) not null, name varchar(255), password varchar(255), createTime date, expireTime date, primary key (id))

数据库表结构：

（5）建立客户端类Client，添加用户数据到mySQL

1. package com.liang.hibernate;
2. import java.util.Date;
3. import org.hibernate.Session;
4. import org.hibernate.SessionFactory;
5. import org.hibernate.cfg.Configuration;
6. public class Client {
7. public static void main(String[]args){
8. //读取hibernate.cfg.xml文件
9. Configuration cfg = new Configuration().configure();
10. //建立SessionFactory
11. SessionFactory factory =cfg.buildSessionFactory();
12. //取得session
13. Session session = null;
14. try{
15. //开启session
16. session = factory.openSession();
17. //开启事务
18. session.beginTransaction();
19. User user = new User();
20. user.setName("jiuqiyuliang");
21. user.setPassword("123456");
22. user.setCreateTime(new Date());
23. user.setExpireTime(new Date());
24. //保存User对象
25. session.save(user);
26. //提交事务
27. session.getTransaction().commit();
28. }catch(Exception e){
29. e.printStackTrace();
30. //回滚事务
31. session.getTransaction().rollback();
32. }finally{
33. if(session != null){
34. if(session.isOpen()){
35. //关闭session
36. session.close();
37. }
38. }
39. }
40. }
41. }

右键debug运行，测试完成之后，我们查询一下测试结果：

5、为了在调试过程中能观察到Hibernate的日志输出，最好加入log4j.properties配置文件、在CLASSPATH中新建log4j.properties配置文件或将该配置文件拷贝到src下，便于程序调试。

内容如下：

1. <span style="font-size:12px;">### direct log messages to stdout ###
2. log4j.appender.stdout=org.apache.log4j.ConsoleAppender
3. log4j.appender.stdout.Target=System.out
4. log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
5. log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
6. ### direct messages to file hibernate.log ###
7. #log4j.appender.file=org.apache.log4j.FileAppender
8. #log4j.appender.file.File=hibernate.log
9. #log4j.appender.file.layout=org.apache.log4j.PatternLayout
10. #log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
11. ### set log levels - for more verbose logging change 'info' to 'debug' ###
12. log4j.rootLogger=warn, stdout</span>

配置完成后，项目结构如下图所示：

五、最后

自己动手丰衣足食，实践出真理，纸上得来终觉浅，绝知此事要躬行。虽然这个实例非常简单，但是我们踏进了持久层框架的大门。

从上面的简单实例可以看到，我们只是使用Hibernate对User这一个实体进行了映射，比较简单，但是完全不符合实际。如何像关系型数据库一样表示多种关联关系，例如：一对一，一对多，多对多等等，我们还需要深入。下篇博文，我们介绍Hibernate的基本映射原理以及关联关系映射。

转：http://blog.****.net/jiuqiyuliang/article/details/39380465