首先我们进一步理解什么是对象关系映射模型？
它将对数据库中数据的处理转化为对对象的处理。如下图所示：
入门简单实例：
hiberante 可以用在 j2se 项目，也可以用在 j2ee (web项目中)，而struts是web框架,所以用在 web项目。
hibernate开发方式的主要两种方式:
1.由Domain object -> mapping->db。(更加符合面向对象的编程方式,从对象入手来通过映射生成表)
2.由DB开始，用工具生成mapping和Domain object。(往往更加习惯从表的构建入手，使用更多)
我们首先用从对象映射出表，到后面再使用第二种。
步骤：
1.创建一个工程
2.引入Hibernate相关包，引入数据库驱动包（对于sql server数据库需要三个包msbase.jar mssqlserver.jar msutil.jar）。
除了hibernate.jar核心包还需要其他相关的库。
3.配置hibernate.cfg.xml文件
4.开发domain对象和对象关系映射文件
5.测试
domain对象
//要序列化，唯一标识对象
public class Employee implements java.io.Serializable{ private static final long serialVersionUID = 1L;
private Integer id;
private String name;
private String email;
private java.util.Date hiredate;
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;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public java.util.Date getHiredate() {
return hiredate;
}
public void setHiredate(java.util.Date hiredate) {
this.hiredate = hiredate;
} }
注意对象实现了序列化，序列化就是讲对象的字节序列持久化，也能唯一标识一个对象。对于序列化的知识可参考博主孤傲仓狼的文章：
对象关系映射文件
作用是用于指定 domain对象和表的映射关系.,该文件的取名有规范：domain对象.hbm.xml,一般我们放在 和domain对象同一个文件夹下(包下)
对主键增长策略比较讲究，对于不同的数据库，有相应的方式。
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> <hibernate-mapping package="com.xidian.domain">
<class name="Employee" table="employee">
<id name="id" column="id" type="java.lang.Integer">
<!-- id设置自增长 -->
<generator class="identity"></generator>
</id>
<!-- 对其它属性还有配置 -->
<property name="name" type="java.lang.String">
<column name="name" length="500" not-null="false" /> //length的默认长度是255
</property>
<property name="email" type="java.lang.String" >
<column name="email" not-null="false"/>
</property>
<property name="hiredate" type="java.util.Date">
<column name="hiredate" not-null="false" />
</property>
</class> </hibernate-mapping>
对象关系文件中，有些属性是可以不配，hibernate会采用默认机制，比如
<class table=”?” > table 值不配，则以类的小写做表名
<property type=”?”> type不配置，则hibernate会根据类的属性类型，选择一个适当的类型
hibernate.cfg.xml文件(默认是放在src文件夹下面，也可放在子文件夹下面，不过就要使用重载函数加载读取)
该文件用于配置 连接的数据库的类型，driver，用户名，密码 ,url ....同时管理对象关系映射文件 ,该文件的名称我们一般不修改.
<?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>
<!-- hibernate 设计者，给我们提供了一写常用的配置 -->
<!-- 配置使用的driver -->
<property name="connection.driver_class">com.microsoft.jdbc.sqlserver.SQLServerDriver
</property>
<property name="connection.username">sa</property>
<property name="connection.password">dba</property>
<property name="connection.url">jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=test</property>
<!-- 配置dialect方言,明确告诉hibernate连接是哪种数据库 -->
<property name="dialect">org.hibernate.dialect.SQLServerDialect</property>
<!-- 显示出sql -->
<property name="show_sql">true</property>
<property name="format_sql">true</property>
<!-- 配置可以使用getCurrentSession -->
<property name="current_session_context_class">thread</property>
<!-- 让hibernate给我们自动创建表 create :如果没有该表则创建.如果有表则删除后再创建
update:如果没有表则创建新表，如果有表则看表结构有没有变化 ，有变化则会创建新表 -->
<property name="hbm2ddl.auto">update</property>
<!-- 指定管理的对象映射文件 -->
<mapping resource="com/xidian/domain/Employee.hbm.xml"/>
</session-factory>
</hibernate-configuration>
测试：
package com.hsp.view;
import com.hsp.util.*;
import java.util.Date;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.*; import com.hsp.domain.Employee;
public class TestMain { public static void main(String[] args) {
//查询[load]->hql语句(hibernate query language)
} public static void addEmployee() {
//我们使用hibernate完成crud操作[这里我们只见对象，不见表]
//现在我们不是用service ,直接测试.
//1.创建Configuration,该对象用于读取hibernate.cfg.xml,并完成初始化
Configuration configuration=new Configuration().configure();
//2.创建SessoinFactory[这是一个会话工厂，是一个重量级的对象（非常费内存，要只创建一个）]
SessionFactory sessionFactory=configuration.buildSessionFactory();
//3.创建Sessoin 相当于jdbc Connection[ servelt HttpSession ,不是 jsp session]
Session session=sessionFactory.openSession();
//4.对hiberate而言，要求程序员，在进行 增加，删除，修改的时候使用事务提交，查询可以不用事务
Transaction transaction = session.beginTransaction();
//添加一个雇员
Employee employee=new Employee();
employee.setName("xkj");
employee.setEmail("xkj@sohu.com");
employee.setHiredate(new Date());
//insert .............
//保存
session.save(employee);//save employee就是持久化该对象 (把对象保存到了数据库中称为一条记录)
//==>insert into ....[被hiberante封装]
//提交
transaction.commit();
session.close();
} public static void delEmp() {
//删除
//获取一个session
Session session=MySessionFactory.getSessionFactory().openSession();
Transaction ts=session.beginTransaction();
//删除1.先获取该雇员，然后删除
Employee emp=(Employee) session.load(Employee.class, 3);
session.delete(emp);
ts.commit();
session.close();
} Hibernate执行update语句会先查询，如果查询到数据库中的数据和对象数据不一致则会指定update语句，如果查询到没有更改则只做查询，没有update语句
public static void updateEmp() {
// TODO Auto-generated method stub
//修改用户
//获取一个会话
Session session=MySessionFactory.getSessionFactory().openSession(); /*Transaction ts=session.beginTransaction();
//修改用户1. 获取要修改的用户，2.修改
//load是通过主键属性，获取该对象实例.<--->表的记录对应
Employee emp=(Employee) session.load(Employee.class, 3);
emp.setName("xkj8");//update...
emp.setEmail("abc@sohu.com");
ts.commit();
session.close();*/ //如何在hibernate中回滚事务
Transaction ts=null;
try {
ts=session.beginTransaction();
Employee emp=(Employee) session.load(Employee.class, 1);
emp.setName("xkj");
emp.setEmail("xkj@sohu.com");
int i=9/0;
ts.commit(); } catch (Exception e) {
if(ts!=null){
ts.rollback();
}
throw new RuntimeException(e.getMessage());
}finally{
if(session!=null&session.isOpen()){
session.close();
}
} }
需要强调的是在用hibernate进行添加、修改、删除的操作的时候一定要进行事务提交，否则不提交操作请求。使用查询的时候是不必用事务的。
由图可以看出，我在前四项纪录，都用了事务提交，在第五项的时候没有使用事务，没有成功添加纪录，下一次事务添加则直接从第六项开始。后面第九项也一样。
这表明虽然没有使用事务提交不能成功对纪录进行操作，但是主键序列还是一直在变化。
在使用hibernate开发项目的时候一定要保证只有一个sessionFactory，一个数据库对应一个SessionFactory对象，我们用单例模式创建sessionFactory
final public class MySessionFactory {
private static SessionFactory sessionFactory=null;
private MySessionFactory(){
}
static {
sessionFactory=new Configuration().configure().buildSessionFactory();
}
public static SessionFactory getSessionFactory(){
return sessionFactory;
}
}
运行测试代码后在数据库中可看见生成了employee表。
现在我们体验一下hibernate切换数据库的优势。切换数据库之后，只需要更改配置，而不需要修改主程序的业务代码。
切换mysql数据库
- 首先我们把 hibernate.cfg.xml文件重新配置.
<?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>
<!-- hibernate 设计者，给我们提供了一写常用的配置 -->
<!-- 配置使用的driver -->
<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="connection.username">root</property>
<property name="connection.password">root</property>
<property name="connection.url">jdbc:mysql:/localhost:3306/test</property>
<!-- 配置dialect方言,明确告诉hibernate连接是哪种数据库 -->
<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
<!-- 显示出对于sql -->
<property name="show_sql">true</property>
<!-- 让hibernate给我们自动创建表 create :如果没有该表则创建. -->
<property name="hbm2ddl.auto">create</property>
<!-- 指定管理的对象映射文件 -->
<mapping resource="com/hsp/domain/Employee.hbm.xml"/>
</session-factory>
</hibernate-configuration>
2.对对象映射文件，做了相应的修改.
<!-- 对主键生成策略我们做了修改 -->
<id name="id" column="id" type="java.lang.Integer">
<generator class="increment"></generator>
</id>
切换oracle数据库
<?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>
<!-- hibernate 设计者，给我们提供了常用的配置在文档project--etc--hibernate.property 中可以查找到配置信息-->
<!-- 配置使用的driver -->
<property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
<property name="connection.username">scott</property>
<property name="connection.password">tiger</property>
<property name="connection.url">jdbc:oracle:thin:@127.0.0.1:1521:orclhsp</property>
<!-- 配置dialect方言,明确告诉hibernate连接是哪种数据库 -->
<property name="dialect">org.hibernate.dialect.OracleDialect</property>
<!-- 显示出对于sql -->
<property name="show_sql">true</property>
<!-- 指定管理的对象映射文件 -->
<mapping resource="com/hsp/domain/Employee.hbm.xml"/>
</session-factory>
</hibernate-configuration>
2.对对象映射文件，做了相应的修改.
<!-- id元素用于指定主键属性 -->
<id name="id" column="id" type="java.lang.Integer">
<!-- 该元素用于指定主键值生成策略hilo native increment sequence uuid -->
<generator class="sequence">
<param name="sequence">emp_seq</param>
</generator>
</id>