Hibernate3调用存储过程

[size=medium]一．建表与初始化数据
在mysql的test数据库中建立一张新表：tbl_user,建表语句如下：[/size]

 DROP TABLE IF EXISTS `user`;
CREATE TABLE `tbl_user` (
  `userid` varchar(50) NOT NULL,
  `name` varchar(50) default '',
  `blog` varchar(50) default '',
  PRIMARY KEY (`userid`)
) ENGINE=InnoDB DEFAULT CHARSET=gb2312;

建表成功后，在该表中插入如下4条初始数据，对应的sql语句如下：

INSERT INTO `tbl_user` (`userid`,`name`,`blog`) VALUES ('ant', '蚂蚁', 'http://www.blogjava.net/qixiangnj');
INSERT INTO `tbl_user` (`userid`,`name`,`blog`) VALUES ('beansoft', 'bean', 'http://www.blogjava.net/beansoft');
INSERT INTO `tbl_user` (`userid`,`name`,`blog`) VALUES ('sterning', '似水流年', 'http://www.blogjava.net/sterning');
INSERT INTO `tbl_user` (`userid`,`name`,`blog`) VALUES ('tom', 'tom' , 'http://www.blogjava.net/tom');

[size=medium]二. 建立存储过程
为测试hibernate3.x中存储过程的调用，我们在user表中建立getUserList、createUser、updateUser和deleteUser这四个存储过程，在mysql中建立存储过程的语句如下：
[/size]
1. 获得用户信息列表的存储过程--getUserList

DROP PROCEDURE IF EXISTS `getUserList`;
CREATE PROCEDURE `getUserList`()
begin
     select * from tbl_user;
end;

2. 通过传入的参数创建用户的存储过程--createUser

DROP PROCEDURE IF EXISTS `createUser`;
CREATE PROCEDURE `createUser`(IN userid varchar(50), IN name varchar(50), IN blog varchar(50))

begin
    insert into tbl_user values(userid, name, blog);
end;

3. 通过传入的参数更新用户信息的存储过程--updateUser

DROP PROCEDURE IF EXISTS `updateUser`;
CREATE PROCEDURE `updateUser`(IN nameValue varchar(50), IN blogValue varchar(50), IN useidValue varchar(50))
begin
    update tbl_user set name = nameValue, blog = blogValue where userid = useridValue;
end;

4. 删除用户信息的存储过程--deleteUser

DROP PROCEDURE IF EXISTS `deleteUser`;
CREATE PROCEDURE `deleteUser`(IN useridValue int(11))
begin
    delete from tbl_user where userid = useridValue;
end;

三． 编程前准备工作
1. 建立工程
在进入代码编写前，建立新的java工程proc， 目录结构如下：
proc
-lib
-bin
-src
-com
-amigo
-proc
-model
2. 引入所需包
将hibernate3.0的包以及其相关包放入编译路径中，另注意：还需将mysql的数据库驱动jar包mysql-connector-java-5.0.4-bin.jar放入编译路径中。
四． 编码与测试
在准备工作完成后，进入编码与测试阶段，本例演示了在hibernate3.0中调用mysql的存储过程的方法。
1、hibernate的配置文件
在hibernate的配置文件中包含数据库的连接信息，以及加入OR mapping的xml格式的映射文件，该文件如下（部分内容略）：

……
        <property name="connection.url">jdbc:mysql://localhost:3306/test</property>
        <property name="connection.username">root</property>
        <property name="connection.password">root</property>
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
        <property name="show_sql">true</property>
        <mapping resource="com/amigo/proc/model/User.hbm.xml"/> 
    ……

2、OR Mapping文件

产生的OR Mapping文件有User.java以及其对应的hibernate映射文件User.hbm.xml。其中User.java的内容如下：

package com.amigo.proc.model;
/**
 * 用户信息对象
 */
public class User implements java.io.Serializable {
    private static final long serialVersionUID = 1L;
    /** 用户id*/
    private String userid;
    /** 用户姓名*/
    private String name;
    /** 用户blog*/
    private String blog;
//省略get/set方法
}

User.hbm.xml文件的内容如下：

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.amigo.proc.model">
    <class name="User" table="tbl_user">
        <id name="userid" column="userid">
            <generator class="assigned"/>
        </id>
        <property name="name" column="name" type="string" />
        <property name="blog" column="blog" type="string" />
    </class>
    <sql-query name="getUserList" callable="true">
        <return alias="user" class="User">
            <return-property name="userid" column="userid"/>
            <return-property name="name" column="name"/>
            <return-property name="blog" column="blog" />
        </return>
        {call getUserList()}
    </sql-query>
</hibernate-mapping>

在该文件中需注意<sql-query…></sql-query>中的这段代码，调用的存储过程在其中定义，并定义了调用存储过程后将记录组装成User对象，同时对记录的字段与对象的属性进行相关映射。
3. 管理hibernate的session以及事务的类HibernateSessionFactory
该类包括打开session等方法，主要用于管理hibernate的session和事务。该类的内容如下（部分内容略）：

package com.amigo.proc;
import java.io.ByteArrayOutputStream;
import java.io.OutputStreamWriter;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
/**
 * Hibernate相关控制
 */
public class HibernateSessionFactory {
    /** Hibernate配置文件 */
    private static String CONFIG_FILE_LOCATION = "/hibernate.cfg.xml";
   /** 存储一个单独的session实例 */
    private static final ThreadLocal threadLocal = new ThreadLocal();
    /** Hibernate配置相关的一个实例 */
    private static Configuration configuration = null;
    /** Hibernate SessionFactory的一个实例 */
    private static SessionFactory sessionFactory;
    /** Hibernate的字符编码集*/
    private static String charSet;
    /** 若Hibernate未设置字符编码集时，采用的字符编码集*/
    private static final String encoding = (new OutputStreamWriter(
          new ByteArrayOutputStream())).getEncoding();
    /**
     * 默认构造函数
     */
    public HibernateSessionFactory() {
    }
    /**
     * 打开Hibernate的数据库连接
     */
    public static final synchronized void open() {
        if (sessionFactory != null)
            return;
        try {
            sessionFactory = getConfiguration().buildSessionFactory();
            charSet = configuration.getProperty("hibernate.connection.charSet");
            if (charSet == null)
                charSet = encoding;
            return;
        } catch (Throwable throwable) {
            throw new ExceptionInInitializerError(throwable);
        }
    }
    /**
     * 配置Hibernate数据库,并将其打开
     */
    private static synchronized void configure() throws HibernateException {
        if (sessionFactory == null) {
            if (configuration == null) {
                getConfiguration().configure(CONFIG_FILE_LOCATION);
            }
            open();
        }
    }
    /**
     * 获得配置实例
     */
    public static synchronized final Configuration getConfiguration() {
        if (configuration == null) {
          configuration = new Configuration();
        }
        return configuration;
    }
    /**
     * 功能说明：获得SessionFactory
    */
    public static final SessionFactory getSessionFactory() {
        return sessionFactory;
    }
    /**
     * 功能说明：获得session
     */
    public static final Session getSession() throws HibernateException {
        configure();
        Session session = null;
        if (threadLocal.get() == null) {
            session = getSessionFactory().openSession();
            threadLocal.set(session);
        } else {
            try {
                session = (Session)threadLocal.get();
            } catch(Exception ex) {
                session = getSessionFactory().openSession();
                threadLocal.set(session);
            }
        }
        return session;
    }
    //其余方法略
}

4． hibernate调用存储过程的测试类
本类是该例的核心类，在本类中，以实例清楚地说明了在hibernate中如何调用存储过程，例示了hibernate调用查询、更新、插入和删除这四类存储过程的方法，该类的内容如下：

package com.amigo.proc;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.util.List;
import com.amigo.proc.model.User;
import org.hibernate.Session;
import org.hibernate.Transaction;
/**
 * hibernate调用存储过程
 * @author Amigo Xie(xiexingxing1121@126.com)
 * @since 2007/04/30
 */
public class ProcTest {
    /**
     * @param args
     */
    public static void main(String[] args) throws Exception {
       ProcTest proc = new ProcTest();
        Session session = HibernateSessionFactory.getSession();
        proc.testProcQuery(session);
        proc.testProcUpdate(session);
        System.out.println("update successfully");
        proc.testProcInsert(session);
        System.out.println("insert successfully");
        proc.testProcDelete(session);
        System.out.println("delete successfully");
        session.close();
    }
    /**
     * 测试实现查询的存储过程
     * @throws Exception
     */
    private void testProcQuery(Session session) throws Exception {
        //查询用户列表
        List list = session.getNamedQuery("getUserList").list();
        for (int i = 0; i < list.size(); i++) {
            User user = (User) list.get(i);    
            System.out.print("序号: " + (i+1));
            System.out.print(", userid: " + user.getUserid());
            System.out.print(", name: " + user.getName());
            System.out.println(", blog: " + user.getBlog());
        }
    }
    /**
     * 测试实现更新的存储过程
     * @throws Exception
     */
    private void testProcUpdate(Session session) throws Exception {
        //更新用户信息
        Transaction tx = session.beginTransaction(); 
        Connection con = session.connection(); 
        String procedure = "{call updateUser(?, ?, ?)}"; 
        CallableStatement cstmt = con.prepareCall(procedure); 
        cstmt.setString(1, "陈xx");
        cstmt.setString(2, "http://www.blogjava.net/sterningChen");
        cstmt.setString(3, "sterning");
        cstmt.executeUpdate(); 
        tx.commit();
    }
    /**
     * 测试实现插入的存储过程
     * @throws Exception
     */
    private void testProcInsert(Session session) throws Exception {
        //创建用户信息
        session.beginTransaction();
        PreparedStatement st = session.connection().prepareStatement("{call createUser(?, ?, ?)}");
        st.setString(1, "amigo");
        st.setString(2, "阿蜜果");
        st.setString(3, "http://www.wblogjava.net/amigoxie");
        st.execute();
        session.getTransaction().commit(); 
    }
    /**
     * 测试实现删除的存储过程
     * @throws Exception
     */
    private void testProcDelete(Session session) throws Exception {
        //删除用户信息
        session.beginTransaction();
        PreparedStatement st = session.connection().prepareStatement("{call deleteUser(?)}");
        st.setString(1, "amigo");
        st.execute();
        session.getTransaction().commit();
    }
}

在本类中，调用查询类存储过程时，调用session.getNamedQuery("…")方法来获得User.hbm.xml中配置的查询存储过程。在其余的存储过程调用的测试中，首先通过hibernate的session获得connection，然后调用connection对象的相应方法来实现存储过程的调用。
该类的执行结果如下：
Hibernate: {call getUserList()}
序号: 1, userid: ant, name: 蚂蚁, blog: http://www.blogjava.net/qixiangnj
序号: 2, userid: beansoft, name: bean, blog: http://www.blogjava.net/beansoft
序号: 3, userid: sterning, name: 似水流年, blog: http://www.blogjava.net/sterning
序号: 4, userid: tom, name: tom, blog: http://www.blogjava.net/tom
update successfully
insert successfully
delete successfully
五．总结
本例提出了在hibernate3中调用mysql的存储过程的实现方案，从本例可以看出，hibernate提供了在*.hbm.xml中配置调用存储过程，并通过向用户提供session.getNamedQuery(“…”)方法来调用配置的调用查询相关的存储过程的方法，另外，hibernate还提供了取得sql的connection的方法，从而能够通过connection中存储过程调用相关的方法来实现存储过程的调用。