BaseDao模板

/********************************************************/

/*************Hibernate封装BaseDao(原生态)*************/

/********************************************************/

概要说明：

Hibernate封装BaseDao主要是通过调用HibernateUtil(这个类也是封 装的)来实现基本的CURD操作;在HibernateUtil中，通过Configuration实例构建 SessionFactory，SessionFactory用来创建Session实例，Configuration实例根据当前的配置信息，构造 SessionFactory实例并返回。一旦SessionFactory构造完毕，即被赋予特定的配置信息。Session是持久层操作的基础，相当 于JDBC的Connection。通过SessionFactory实例构建。Session实例提供的saveOrUpdate、delete和 createQuery方法分别实现了数据库的插入更新、删除和查询操作，简化了数据库的基本操作

代码实例：

*  HibernateUtil：Hibernate工具类,Hibernate映射操作公用类 负责初始化、打开连接、获取连接、关闭连接等操作;

[java]
view plain
copy
print
?

1. /*
2. *Hibernate工具类,Hibernate映射操作公用类
3. *负责初始化、打开连接、获取连接、关闭连接等操作
4. */
5. import org.hibernate.HibernateException;
6. import org.hibernate.Session;
7. import org.hibernate.cfg.Configuration;
8. public class HibernateUtil {
9. private static String CONFIG_FILE_LOCATION = "/hibernate.cfg.xml";//配置文件位置
10. private static final ThreadLocal<Session> threadLocal = new ThreadLocal<Session>();//线程
11. private static Configuration configuration = new Configuration();
12. private static org.hibernate.SessionFactory sessionFactory;//会话工厂
13. private static String configFile = CONFIG_FILE_LOCATION;
14. static {
15. try {
16. configuration.configure(configFile);
17. sessionFactory = configuration.buildSessionFactory();
18. } catch (Exception e) {
19. e.printStackTrace();
20. }
21. }
22. /***
23. * 获得session
24. *
25. * @return
26. * @throws HibernateException
27. */
28. public static Session getSession() throws HibernateException {
29. Session session = (Session) threadLocal.get();
30. if (session == null || !session.isOpen()) {
31. if (sessionFactory == null) {
32. rebuildSessionFactory();
33. }
34. session = (sessionFactory != null) ? sessionFactory.openSession()
35. : null;
36. threadLocal.set(session);
37. }
38. return session;
39. }
40. /*
41. *重新创建SessionFactory
42. */
43. public static void rebuildSessionFactory() {
44. try {
45. configuration.configure(configFile);
46. sessionFactory = configuration.buildSessionFactory();
47. } catch (Exception e) {
48. System.err.println("无法 在 baseDao 中 创建 SessionFactory ");
49. e.printStackTrace();
50. }
51. }
52. /*
53. *获取当前session
54. */
55. public static Session currentSession() throws HibernateException {
56. Session session = sessionFactory.openSession();
57. return session;
58. }
59. /*
60. *关闭session
61. */
62. public static void closeSession(Session session) {
63. Session session = (Session) threadLocal.get();
64. threadLocal.set(null);
65. if (session != null) {
66. session.close();
67. }
68. }
69. /**
70. * return session factory
71. */
72. public static org.hibernate.SessionFactory getSessionFactory() {
73. return sessionFactory;
74. }
75. /**
76. * return session factory
77. * <p/>
78. * session factory will be rebuilded in the next call
79. */
80. public static void setConfigFile(String configFile) {
81. HibernateUtil.configFile = configFile;
82. sessionFactory = null;
83. }
84. /**
85. * return hibernate configuration
86. */
87. public static Configuration getConfiguration() {
88. return configuration;
89. }
90. }

*HibernateBaseDao：调用Hibernate工具类HibernateUtil进行系列CURD操作;

[java]
view plain
copy
print
?

1. /*
2. *调用Hibernate工具类HibernateUtil进行系列CURD操作
3. */
4. import java.io.Serializable;
5. import java.util.List;
6. import org.hibernate.Query;
7. import org.hibernate.Session;
8. import org.hibernate.Transaction;
9. import com.juren.util.HibernateUtil;
10. public class HibernateBaseDao  {
11. /**
12. * 添加
13. *
14. * @param obj
15. */
16. public void add(Object obj) {
17. Session session = null;
18. Transaction tx = null;
19. try {
20. session = HibernateUtil.getSession();
21. tx = session.beginTransaction();
22. session.save(obj);
23. tx.commit();
24. } catch (Exception e) {
25. if (tx != null) {
26. tx.rollback();
27. }
28. } finally {
29. if (session != null) {
30. session.close();
31. }
32. }
33. }
34. /**
35. * 删除
36. *
37. * @param obj
38. */
39. public void delete(Object obj) {
40. Session session = null;
41. Transaction tx = null;
42. try {
43. session = HibernateUtil.getSession();
44. tx = session.beginTransaction();
45. session.delete(obj);
46. tx.commit();
47. } catch (Exception e) {
48. if (tx != null) {
49. tx.rollback();
50. }
51. } finally {
52. if (session != null) {
53. session.close();
54. }
55. }
56. }
57. /**
58. * 根据主键删除
59. *
60. * @param clazz
61. * @param id
62. */
63. public void deleteById(Class clazz, Serializable id) {
64. Session session = null;
65. Transaction tx = null;
66. try {
67. session = HibernateUtil.getSession();
68. session.delete(session.get(clazz, id));
69. tx.commit();
70. } catch (Exception e) {
71. if (tx != null) {
72. tx.rollback();
73. }
74. } finally {
75. if (session != null) {
76. session.close();
77. }
78. }
79. }
80. /**
81. * 修改
82. *
83. * @param obj
84. */
85. public void update(Object obj) {
86. Session session = null;
87. Transaction tx = null;
88. try {
89. session = HibernateUtil.getSession();
90. tx = session.beginTransaction();
91. session.update(obj);
92. tx.commit();
93. } catch (Exception e) {
94. if (tx != null) {
95. tx.rollback();
96. }
97. } finally {
98. if (session != null) {
99. session.close();
100. }
101. }
102. }
103. /**
104. * 根据主键查询
105. *
106. * @param clazz
107. * @param id
108. * @return
109. */
110. public Object get(Class clazz, Serializable id) {
111. Session session = null;
112. try {
113. session = HibernateUtil.getSession();
114. Object obj = session.get(clazz, id);
115. return obj;
116. } finally {
117. if (session != null) {
118. session.close();
119. }
120. }
121. }
122. /**
123. * 根据多个属性查询
124. *
125. * @param clazz
126. * @param strs
127. * @return
128. */
129. public Object getByNProperty(Class clazz, String... strs) {
130. if (strs != null && strs.length != 0 && 0 != strs.length % 2) {
131. StringBuffer hql = new StringBuffer("select model from "
132. + clazz.getName() + " as model where ");
133. for (int i = 0; i < strs.length; i += 2) {
134. hql.append(" " + strs[i] + " = " + strs[i + 1]);
135. }
136. Session session = null;
137. try {
138. session = HibernateUtil.getSession();
139. List<Object> objs = session.createQuery(hql.toString()).list();
140. if (objs != null && objs.size() != 0) {
141. return objs.get(0);
142. } else {
143. return null;
144. }
145. } finally {
146. if (session != null) {
147. session.close();
148. }
149. }
150. } else {
151. return null;
152. }
153. }
154. /**
155. * 根据HQL查询
156. *
157. * @param hql
158. * @return
159. */
160. public Object getUniqueByHql(String hql) {
161. Session session = null;
162. try {
163. session = HibernateUtil.getSession();
164. List<Object> objs = session.createQuery(hql).list();
165. if (objs != null && objs.size() != 0) {
166. return objs.get(0);
167. } else {
168. return null;
169. }
170. } finally {
171. if (session != null) {
172. session.close();
173. }
174. }
175. }
176. /**
177. * 根据SQL查询
178. *
179. * @param sql
180. * @param clazz
181. * @return
182. */
183. public Object getUniqueBySql(String sql, Class clazz) {
184. Session session = null;
185. try {
186. session = HibernateUtil.getSession();
187. Query query = session.createSQLQuery(sql).addEntity(clazz);
188. List<Object> objs = query.list();
189. if (objs != null && objs.size() != 0) {
190. return objs.get(0);
191. } else {
192. return null;
193. }
194. } finally {
195. if (session != null) {
196. session.close();
197. }
198. }
199. }
200. /**
201. * 查询所有
202. */
203. public List<Object> getList(Class clazz) {
204. Session session = null;
205. try {
206. session = HibernateUtil.getSession();
207. String hql = "select model from " + clazz.getName() + " as model ";
208. List list = session.createQuery(hql).list();
209. return list;
210. } finally {
211. if (session != null) {
212. session.close();
213. }
214. }
215. }
216. /**
217. * 根据HQL查询 全部
218. *
219. * @param hql
220. * @return
221. */
222. public List<Object> getListByHql(String hql) {
223. Session session = null;
224. try {
225. session = HibernateUtil.getSession();
226. List list = session.createQuery(hql).list();
227. return list;
228. } finally {
229. if (session != null) {
230. session.close();
231. }
232. }
233. }
234. /**
235. * 根据SQL查询全部
236. *
237. * @param sql
238. * @param clazz
239. * @return
240. */
241. public List getListBySql(String sql, Class clazz) {
242. Session session = null;
243. try {
244. session = HibernateUtil.getSession();
245. Query query = session.createSQLQuery(sql).addEntity(clazz);
246. return query.list();
247. } finally {
248. if (session != null) {
249. session.close();
250. }
251. }
252. }
253. }

另外一种常见的封装是继承Spring的HibernateDaoSupport，也就是

org.springframework.orm.hibernate3.support.HibernateDaoSupport;

概要说明：

Spring为Hibernate 的整合提供了很好的支持，Spring的 DAO 支持类是:HiberanteDaoSupport; 继承HibernateDaoSupport类,使用HibernateTemplate来持久化，HibernateTemplate是 Hibernate Session的轻量级封装; 该类只需要传入一个 SessionFactory 引用，即可得到一个HibernateTemplate实例，该实例功能非常强大，数据库的大部分操作也很容易实现。所有的 DAO类都继承HibernateDaoSupport，并实现相应的DAO 接口。而业务逻辑对象则面向接口编程，无须关心DAO 的实现细节。通过这种方式，可以让应用在不同的持久化技术之间切换;

代码实例：

* HibernateBaseDao：继承Spring的HibernateDaoSupport

[java]
view plain
copy
print
?

1. import java.io.Serializable;
2. import java.util.List;
3. import org.hibernate.Query;
4. import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
5. /*
6. * 继承Spring的HibernateDaoSupport
7. */
8. public abstract class HibernateBaseDao extends HibernateDaoSupport {
9. @SuppressWarnings("unchecked")
10. public abstract Class getEntityClass();
11. public abstract String getEntityType();
12. //添加对象操作
13. public void save(Serializable entity) {
14. getHibernateTemplate().save(entity);
15. }
16. //修改对象操作
17. public void update(Serializable entity) {
18. getHibernateTemplate().update(entity);
19. }
20. //删除对象操作
21. public void delete(int objId){
22. getHibernateTemplate().delete(getHibernateTemplate().load(getEntityClass(), objId));
23. }
24. //查询对象列表
25. @SuppressWarnings("unchecked")
26. public List getAll(int count, int start) {
27. String hql = "from " + getEntityType() + " m ";
28. Query q = getHibernateTemplate().getSessionFactory()
29. .openSession().createQuery(hql);
30. q.setMaxResults(count);
31. q.setFirstResult(start);
32. return q.list();
33. }
34. }

/********************************************************/

/***************Ibatis封装BaseDao(原生态)**************/

/********************************************************/

概要说明(个人测试)：

Ibatis封装BaseDao主要是通过调用IbatisUtil(这个类也是封装的)来实现基本的CURD操作;

关于IbatisUtil：SQLMap组件封装了iBATIS SQLMap相关SqlMapClient等内容，总共由两个接口、三个类组成。其中DaoTransaction接口、 DaoTransactionManager接口和ConnectionDaoTransaction接口是通用接口，也是外部调用的API接口。 SqlMapDao TransactionManager类实现DaoTransactionManager接口并关联iBATIS

SQLMap的SqlMapClient接口，同时它也依赖SqlMapDaoTransaction类。 SqlMapDaoTransaction类实现ConnectionDaoTransaction接口（该接口继承DaoTransaction接口） 并关联iBATIS SQLMap的SqlMapClient接口

SQLMap事务管理实现说明：

（1）初始化时，SqlMapDaoTransactionManager对象创建SqlMapClient对象。

（2）当调用SqlMapDaoTransactionManager对象的startTransaction方法时， 该SqlMapClient对象为参数实例化一个SqlMapDaoTransaction对象，并调用SqlMapClient对象的 startTransaction方法。

（3）当对SqlMapDaoTransactionManager对象进行commitTransaction、 rollbackTransaction等业务操作，SqlMapDaoTransactionManager对象转移给 SqlMapDaoTransaction对象的commit和rollback等方法。而SqlMapDaoTransaction对象也是最后转换给 SqlMapClient对象的commitTransaction或endTransaction等方法进行处理的，完成处理后调用 SqlMapClient对象的endTransaction方法，结束当前事务处理；

SQLMap事务处理的序列如图：

其实现步骤说明：

SqlMapDaoTransactionManager和SqlMapDaoTransaction

第1步骤：外部调用SqlMapDaoTransactionManager对象的configure方法，并把配置信息参数传递进来。

第1.1步骤：SqlMapDaoTransactionManager对象调用Resources的静态方法getUrlAsReader方法，获得Reader对象。

第1.2步骤：SqlMapDaoTransactionManager对象调用SqlMapClientBuilder对象的静态方法buildSqlMapClient，生成SqlMapClient对象。

第2步骤：外部调用SqlMapDaoTransactionManager对象的startTransaction方法。

第2.1步骤：SqlMapDaoTransactionManager对象创建SqlMapDaoTransaction对象，并把参数SqlMapClient对象传递过去。

第2.1.1步骤：SqlMapDaoTransaction对象调用SqlMapClient对象的startTransaction方法。

第3步骤：外部调用SqlMapDaoTransactionManager对象的commitTransaction方法。

第3.1步骤：SqlMapDaoTransactionManager对象调用SqlMapDaoTransaction对象的commit方法。

第3.1.1步骤：SqlMapDaoTransaction对象调用SqlMapClient对象的commitTransaction方法。

第3.1.2步骤：SqlMapDaoTransaction对象调用SqlMapClient对象的endTransaction方法，关闭SQLMap的当前事务。

第4步骤：外部调用SqlMapDaoTransactionManager对象的commitTransaction方法。

第4.1步骤：SqlMapDaoTransactionManager对象调用SqlMapDaoTransaction对象的commit方法。

第4.1.1步骤：SqlMapDaoTransaction对象调用SqlMapClient对象的endTransaction方法，关闭SQLMap的当前事务。

代码实例：

* IbatisUtil :Ibatis工具类,Ibatis操作公用类、负责初始化SqlMapClient操作

[java]
view plain
copy
print
?

1. import com.ibatis.sqlmap.client.SqlMapClient;
2. import com.ibatis.sqlmap.client.SqlMapClientBuilder;
3. /*
4. *Ibatis工具类,Ibatis操作公用类
5. *负责初始化SqlMapClient操作
6. */
7. public class IbatisUtil {
8. // 首先初始化iBatis获得一个SqlMapClient对象
9. private static String CONFIG_FILE_LOCATION = "/SqlMapConfig.xml";
10. private static SqlMapClient sqlMap = null;
11. private static String configFile = CONFIG_FILE_LOCATION;
12. static {
13. try {
14. java.io.Reader reader = com.ibatis.common.resources.Resources
15. .getResourceAsReader(configFile);
16. sqlMap = SqlMapClientBuilder.buildSqlMapClient(reader);
17. } catch (Exception e) {
18. e.printStackTrace();
19. }
20. }
21. //获取SqlMapClient
22. public static SqlMapClient getSqlMap(){
23. return sqlMap;
24. }
25. }

* IbatisBaseDao:调用Ibatis工具类IbatisUtil进行系列CURD操作

[java]
view plain
copy
print
?

1. /*
2. *调用Ibatis工具类IbatisUtil进行系列CURD操作
3. */
4. import java.sql.SQLException;
5. import java.util.List;
6. import com.ibatis.sqlmap.client.SqlMapClient;
7. public class IbatisBaseDao {
8. /**
9. * 添加对象操作
10. * @param obj 对象实例 sqlMapId SqlMap配置文件中所对应的id
11. * 备注：修改对象操作与之类似
12. */
13. public void save(Object obj,String sqlMapId) {
14. SqlMapClient sqlMap = IbatisUtil.getSqlMap();
15. try {
16. sqlMap.startTransaction();
17. sqlMap.update(sqlMapId, obj);
18. sqlMap.commitTransaction();
19. } catch (SQLException e) {
20. e.printStackTrace();
21. } finally {
22. try {
23. sqlMap.endTransaction();
24. } catch (SQLException e) {
25. e.printStackTrace();
26. }
27. }
28. }
29. /*
30. * 删除对象操作
31. * @param objId sqlMapId SqlMap配置文件中所对应的id
32. * 备注：objId可以为String类型，根据不同的数据库设计决定传参类型
33. */
34. public void delete(Integer objId,String sqlMapId) {
35. SqlMapClient sqlMap = IbatisUtil.getSqlMap();
36. try {
37. sqlMap.startTransaction();
38. sqlMap.update(sqlMapId, objId);
39. sqlMap.commitTransaction();
40. } catch (SQLException e) {
41. e.printStackTrace();
42. } finally {
43. try {
44. sqlMap.endTransaction();
45. } catch (SQLException e) {
46. e.printStackTrace();
47. }
48. }
49. }
50. /*
51. * 获取对象List列表（包含分页）
52. * @param start 分页参数 sqlMapId SqlMap配置文件中所对应的id
53. * 备注：不同数据库支持sql分页的语句可能不一样
54. */
55. @SuppressWarnings("unchecked")
56. public List<Object> getAll(int start,String sqlMapId) {
57. SqlMapClient sqlMap = IbatisUtil.getSqlMap();
58. List<Object> res =  new ArrayList();
59. try {
60. sqlMap.startTransaction();
61. res = sqlMap.queryForList(sqlMapId, start);
62. sqlMap.commitTransaction();
63. } catch (SQLException e) {
64. e.printStackTrace();
65. } finally {
66. try {
67. sqlMap.endTransaction();
68. } catch (SQLException e) {
69. e.printStackTrace();
70. }
71. }
72. return res;
73. }
74. }

另外一种常见的封装是继承Spring的SqlMapClientDaoSupport，也就是

org.springframework.orm.ibatis.support.SqlMapClientDaoSupport;

代码实例：

* IbatisBaseDao：继承Spring的SqlMapClientDaoSupport

[java]
view plain
copy
print
?

1. import java.io.Serializable;
2. import java.sql.SQLException;
3. import java.util.List;
4. import org.springframework.orm.ibatis.support.SqlMapClientDaoSupport;
5. /**
6. * IBatis Dao的泛型基类.
7. * 继承于Spring的SqlMapClientDaoSupport
8. */
9. @SuppressWarnings("unchecked")
10. public class IBatisBaseDao1 extends SqlMapClientDaoSupport {
11. public static final String POSTFIX_INSERT = ".insert";
12. public static final String POSTFIX_UPDATE = ".update";
13. public static final String POSTFIX_DELETE = ".delete";
14. public static final String POSTFIX_DELETE_PRIAMARYKEY = ".deleteByPrimaryKey";
15. public static final String POSTFIX_SELECT = ".select";
16. /**
17. * 根据ID获取对象
18. *
19. * @throws BaseException
20. * @throws SQLException
21. */
22. public <T> T get(Class<T> entityClass, Serializable id) throws SQLException {
23. T o = (T) getSqlMapClient().queryForObject(entityClass.getName() + POSTFIX_SELECT, id);
24. return o;
25. }
26. /**
27. * 新增对象
28. *
29. * @throws SQLException
30. */
31. public void insert(Object o) throws SQLException {
32. getSqlMapClient().insert(o.getClass().getName() + POSTFIX_INSERT, o);
33. }
34. /**
35. * 保存对象
36. *
37. * @throws SQLException
38. */
39. public int update(Object o) throws SQLException {
40. return getSqlMapClient().update(o.getClass().getName() + POSTFIX_UPDATE, o);
41. }
42. /**
43. * 删除对象
44. *
45. * @throws SQLException
46. */
47. public int remove(Object o) throws SQLException {
48. return getSqlMapClient().delete(o.getClass().getName() + POSTFIX_DELETE, o);
49. }
50. /**
51. * 根据ID删除对象
52. *
53. * @throws SQLException
54. */
55. public <T> int removeById(Class<T> entityClass, Serializable id) throws SQLException {
56. return getSqlMapClient().delete(entityClass.getName() + POSTFIX_DELETE_PRIAMARYKEY, id);
57. }
58. /**
59. * 获取全部对象
60. * @throws SQLException
61. */
62. public <T> List<T> getAll(Class<T> entityClass) throws SQLException {
63. return getSqlMapClient().queryForList(entityClass.getName() + POSTFIX_SELECT, null);
64. }
65. }

/********************************************************/

/*****************jdbctemplate封装BaseDao****************/

/********************************************************/

第一：概要说明：

1，Spring JDBC抽象框架所带来的价值将在以下几个方面得以体现：（注：使用了Spring JDBC抽象框架之后，应用开发人员只需要完成斜体字部分的编码工作。）

指定数据库连接参数

打开数据库连接

声明SQL语句

预编译并执行SQL语句

遍历查询结果（如果需要的话）

处理每一次遍历操作

处理抛出的任何异常

处理事务

关闭数据库连接

Spring将替我们完成所有单调乏味的JDBC底层细节处理工作

2，Spring JDBC包结构

Spring JDBC抽象框架由四个包构成：core、 dataSource、object以及support。

org.springframework.jdbc.core包由JdbcTemplate类以及相关的回调接口（callback interface）和类组成。

org.springframework.jdbc.datasource包由一些用来简化DataSource访问的工具类，以及各种 DataSource接口的简单实现(主要用于单元测试以及在J2EE容器之外使用JDBC)组成。工具类提供了一些静态方法，诸如通过JNDI获取数据 连接以及在必要的情况下关闭这些连接。它支持绑定线程的连接，比如被用于DataSourceTransactionManager的连接。

接下来，org.springframework.jdbc.object包由封装了查询、更新以及存储过程的类组成，这些类的对象都是线程安全并且可重 复使用的。它们类似于JDO，与JDO的不同之处在于查询结果与数据库是“断开连接”的。它们是在 org.springframework.jdbc.core包的基础上对JDBC更高层次的抽象。

最后，org.springframework.jdbc.support包提供了一些SQLException的转换类以及相关的工具类。

在JDBC处理过程中抛出的异常将被转换成org.springframework.dao包中定义的异常。因此使用Spring JDBC进行开发将不需要处理JDBC或者特定的RDBMS才会抛出的异常。所有的异常都是unchecked exception，这样我们就可以对传递到调用者的异常进行有选择的捕获。

3，JDBC核心类实现JDBC的基本操作和错误处理

可参考：JDBC核心类实现JDBC的基本操作和错误处理

4，注意事项：

1) jdbcTemplate有很多的ORM化回调操作将返回结果转为对象列表，但很多时候还是需要返回ResultSet，Spring有提供一个类似ResultSet的 Spring SqlRowSet对象。

2) 注意jdbcTemplate尽量只执行查询操作，莫要进行更新，否则很容易破坏Hibernate的二级缓存体系。

//ibatisDao

package com.test.dao;

import java.util.List;

import org.springframework.orm.ibatis.support.SqlMapClientDaoSupport;
public class BaseDAO<E> extends SqlMapClientDaoSupport{
    //查询多条信息
    @SuppressWarnings("unchecked")
protected List<E> select(String statementName,E Objectparameter) throws Exception{
        List<E> list ;
        list = this.getSqlMapClientTemplate().queryForList(statementName,Objectparameter);
        return list;
    }
    //查询一条信息
    protected int selectSingle (String statementName,E Objectparameter) throws Exception{
       Object obj = this.getSqlMapClientTemplate().queryForObject(statementName,Objectparameter);
       int max =0;
       if(obj != null) {
           max = (Integer) obj;
       }
        return max;
    }
   
    //删除信息
    protected int delete(String statementName,E parameterObject) throws Exception{
        int flag = 0;
        flag = this.getSqlMapClientTemplate().delete(statementName, parameterObject);
        return flag;
    }
   
    //增加信息
    protected int insert(String statementName, E parameterObject)throws Exception{
     
        int flag = 0;
        Object obj = this.getSqlMapClientTemplate().insert(statementName, parameterObject);
        if(obj != null){
            flag = (Integer) obj;
        }
        return flag;
    }
    //更新信息
    protected int update(String statementName,E parameterObject) throws Exception{
        int flag = 0;
        flag = this.getSqlMapClientTemplate().update(statementName, parameterObject);
        return flag;
    }
   
}