原文出处：http://tech.it168.com/j/d/ 2007-05-14 /200705141007843.shtml
说明：该文不得转载
摘要：本文以详尽的实例展示了hibernate3.x中调用存储过程各步骤，从建立测试表、存储过程的建立、工程的建立以及类的编写和测试一步一步引导用户学习hibernate3.x中调用存储过程的方法.
如果底层数据库（eg. Oracle、mysql、sqlserver）等支持存储过程，可通过存储过程执行批量删除、更新等操作。本文以实例说明在hibernate3.x中如何调用存储过程。
说明：本例hibernate所用版本为3.0，mysql所用版本为5.0，所用数据库驱动为mysql-connector-java- 5.0.4 -bin.jar。
一． 建表与初始化数据
在mysql的test数据库中建立一张新表：tbl_user,建表语句如下：
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');
二． 建立存储过程
为测试hibernate3.x中存储过程的调用，我们在user表中建立getUserList、createUser、updateUser和deleteUser这四个存储过程，在mysql中建立存储过程的语句如下：
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([email protected]) * @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中存储过程调用相关的方法来实现存储过程的调用。