Hibernate(二)__简单实例入门

首先我们进一步理解什么是对象关系映射模型？

它将对数据库中数据的处理转化为对对象的处理。如下图所示：

入门简单实例：

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;
    }
    
}

注意对象实现了序列化，序列化就是讲对象的字节序列持久化，也能唯一标识一个对象。对于序列化的知识可参考博主孤傲仓狼的文章：

Java基础学习总结——Java对象的序列化和反序列化

对象关系映射文件

作用是用于指定 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数据库

1. 首先我们把  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>