您的位置：首页 > 其它

Hibernate3.x调用存储过程

2013-07-14 13:31 411 查看

Connection   con   =   session.connect();

CallableStatement   proc   =   null;

con   =   connectionPool.getConnection();

proc   =   con.prepareCall("{   call   set_death_age(?,   ?)   }");

proc.setString(1,   XXX);

proc.setInt(2,   XXx);

...

proc.execute();

session.close();

在Hibernate中调用存储过程的示范代码- -



如果底层数据库（如Oracle）支持存储过程，也可以通过存储过程来执行批量更新。存储过程直接在数据库中运行，速度更加快。在Oracle数据库中可以定义一个名为batchUpdateStudent()的存储过程，代码如下：

create or replace procedure batchUpdateStudent(p_age in number) as

begin

update STUDENT set AGE=AGE+1 where AGE>p_age;

end;

以上存储过程有一个参数p_age，代表学生的年龄，应用程序可按照以下方式调用存储过程：

tx = session.beginTransaction();

Connection con=session.connection();

String procedure = "{call batchUpdateStudent(?) }";

CallableStatement cstmt = con.prepareCall(procedure);

cstmt.setInt(1,0); //把年龄参数设为0

cstmt.executeUpdate();

tx.commit();

在以上代码中，我用的是Hibernate的 Transaction接口来声明事务，而不是采用JDBC API来声明事务。

存储过程中有一个参数p_age，代表客户的年龄，应用程序可按照以下方式调用存储过程：

代码内容

tx   =   session.beginTransaction();

Connection   con=session.connection();

String   procedure   =   "{call   batchUpdateCustomer(?)   }";

CallableStatement   cstmt   =   con.prepareCall(procedure);

cstmt.setInt(1,0);   //把年龄参数设为0

cstmt.executeUpdate();

tx.commit();

CREATE procedure selectAllUsers

DYNAMIC RESULT SETS 1

BEGIN

      DECLARE temp_cursor1 CURSOR WITH RETURN TO CLIENT FOR

      SELECT * FROM test;

      OPEN temp_cursor1;

END;

映射文件中关于存储过程内容如下

<hibernate-mapping package="com.unmi.vo">

    <class name="Test" table="TEST">

　　　　　............

    </class>

    <sql-query callable="true" name="selectAllUsers">

<return alias="aa" class="Test">

    <return-property name="oborqt" column="OBORQT"/>

    <return-property name="moorqt" column="MOORQT"/>

    <return-property name="roschn" column="ROSCHN"/>

    <return-property name="plandate" column="PLANDATE"/>

</return>

{ ? = call selectAllUsers() }

    </sql-query>

</hibernate-mapping>

{ ? = call selectAllUsers() } 也可以写成{ call selectAllUsers() }，

如果有参数就写成

{ ? = call selectAllUsers(?,?,?) }

代码中对query设置相应位置上的值就OK

Java调用关键代码如下



Session session = HibernateUtil.currentSession();

Query query = session.getNamedQuery("selectAllUsers");

List list = query.list();

System.out.println(list);

要求你的存储过程必须能返回记录集，否则要出错

如果你的存储过程是完成非查询任务就应该在配置文件用以下三个标签

<sql-insert callable="true">{call createPerson (?, ?)}</sql-insert>

<sql-delete callable="true">{? = call deletePerson (?)}</sql-delete>

<sql-update callable="true">{? = call updatePerson (?, ?)}</sql-update>

有一点不好的地方就是调用存储过程获取记录集时，不能对Query使用

setFirstResult(int)和setMaxResults(int)方法来分页

如果底层数据库（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.    建立工程
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.driver_class">com.mysql.jdbc.Driver</property>

<property name="dialect">org.hibernate.dialect.MySQLDialect</property>

……

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">

</id>

</class>

<sql-query name="getUserList" callable="true">

<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中存储过程调用相关的方法来实现存储过程的调用。

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航