Hibernate4调用SQL和存储过程

最近使用了新的Struts2.20+spring4.0+hibernate4.0，新框架移除了HibernateSupportDao，所以重写了下Hibernate4对SQL和存储过程的操作，以备后查

以下的sessionFactory 对象是通过spring注入

1 private SessionFactory sessionFactory;
2     public void setSessionFactory(SessionFactory sessionFactory) {
3         this.sessionFactory = sessionFactory;
4     }

 

1、通过SQL查询，以List的方式返回

 1     /**
 2      * 通过SQL查询,结果集不作处理直接返回
 3      * @param queryString 查询字符串
 4      * @param params 参数
 5      * @return
 6      */
 7     @SuppressWarnings("unchecked")
 8     public List<Object> find_sql(String queryString,Object[] params){
 9         Session session = sessionFactory.getCurrentSession();
10         Query query = session.createSQLQuery(queryString);
11         if(null!=params){
12             for(int i=0;i<params.length;i++){
13                 query.setParameter(i, params[i]);
14             }
15         }
16         List<Object> list = query.list();
17         return list;
18     }

2、SQL或存储过程查询，将返回的结果集转换成Map，结果集列名作为键

 1     /**
 2      * 通过SQL查询，将结果集转换成Map对象，列名作为键(适用于有返回结果集的存储过程或查询语句)
 3      * @param queryString
 4      * @param params
 5      * @return
 6      */
 7     @SuppressWarnings("unchecked")
 8     public List<Map<String,Object>> find_sql_toMap(String queryString,Object[] params){
 9         Session session = sessionFactory.getCurrentSession();
10         Query query = session.createSQLQuery(queryString);
11         query.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
12         if(null!=params){
13             for(int i=0;i<params.length;i++){
14                 query.setParameter(i, params[i]);
15             }
16         }
17         List<java.util.Map<String,Object>> list = query.list();
18         return list;
19     }

3、SQL执行增、删、改操作，测试使用该方法执行存储过程会报错

 1 /**
 2      * 通过SQL执行无返回结果的语句，执行修改、删除、添加等(适用于无结果集返回SQL语句，不能用于存储过程)
 3      * @param queryString
 4      * @param params
 5      */
 6     public void executeSql(String queryString,Object[] params){
 7         Session session = sessionFactory.getCurrentSession();
 8         Query query = session.createQuery(queryString);
 9         if(null!=params){
10             for(int i=0;i<params.length;i++){
11                 query.setParameter(i, params[i]);
12             }
13         }
14         query.executeUpdate();
15     }

4、执行无结果集返回的存储过程，是第3点的补充

 1 /**
 2      * 通过SQL执行无返回结果的存储过程(仅限于存储过程)
 3      * @param queryString
 4      * @param params
 5      */
 6     public void executeVoidProcedureSql(final String queryString,final Object[] params) throws Exception{
 7         Session session = sessionFactory.getCurrentSession();
 8         session.doWork(new Work(){
 9           public void execute(Connection conn) throws SQLException {
10             ResultSet rs = null;
11             CallableStatement call = conn.prepareCall("{" + queryString + "}");
12             if (null != params) {
13                 for (int i = 0; i <params.length; i++) {
14                     call.setObject(i+1, params[i]);
15                 }
16             }
17             rs = call.executeQuery();
18             call.close();
19             rs.close();
20           }
21        });
22     }

5、通过存储过程查询，返回的结果集必须为单结果集，与第2点方法效果一致

 1     /**
 2      * 通过存储过程查询(单结果集)
 3      * @param sql 查询sql
 4      * @param params 参数
 5      * @param columnNum 返回的列数
 6      * @return
 7      */
 8     public List<Map<String, Object>> find_procedure(final String sql,final Object[] params){
 9         final List<Map<String, Object>> result = new ArrayList<Map<String, Object>>();
10         try {
11             Session session = sessionFactory.getCurrentSession();
12             session.doWork(new Work(){
13               public void execute(Connection conn) throws SQLException {
14                   CallableStatement cs=null;
15                   ResultSet rs=null;
16                   cs = conn.prepareCall(sql);
17                     for(int i=1;i<=params.length;i++){
18                         cs.setObject(i, params[i-1]);//设置参数
19                     }
20                     rs = cs.executeQuery();
21                     ResultSetMetaData metaData = rs.getMetaData();
22                     int colCount=metaData.getColumnCount();
23                     while(rs.next()){
24                         Map<String, Object> map = new HashMap<String, Object>();
25                         for(int i=1;i<=colCount;i++){
26                             String colName=metaData.getColumnName(i);
27                             map.put(colName, rs.getObject(colName));
28                         }
29                         result.add(map);
30                     }
31                     close( cs, rs);
32               }
33            });
34             return result;
35         } catch (Exception e) {
36             e.printStackTrace();
37         }
38         return null;
39     }

6、通过存储过程查询，适用返回的结果集有一个或多个

 1 /**
 2      * 通过存储过程查询(多结果集)
 3      * @param sql 查询sql
 4      * @param params 参数
 5      * @param columnNum 返回的列数
 6      * @return
 7      */
 8     public List<List<Map<String, Object>>> find_procedure_multi(final String sql,final Object[] params){
 9         final List<List<Map<String, Object>>> result = new ArrayList<List<Map<String, Object>>>();
10         try {
11 //            conn = SessionFactoryUtils.getDataSource(sessionFactory).getConnection();
12             Session session = sessionFactory.getCurrentSession();
13             session.doWork(new Work(){
14                 public void execute(Connection conn) throws SQLException {
15                     CallableStatement cs=null;
16                     ResultSet rs=null;
17                     cs = conn.prepareCall(sql);
18                     for(int i=1;i<=params.length;i++){
19                         cs.setObject(i, params[i-1]);
20                     }
21                     boolean hadResults = cs.execute();
22                     ResultSetMetaData metaData = null;
23                     while(hadResults){//遍历结果集
24                         List<Map<String, Object>> rsList = new ArrayList<Map<String, Object>>();//用于装该结果集的内容
25                         rs = cs.getResultSet();//获取当前结果集
26                         metaData=rs.getMetaData();
27                         int colCount=metaData.getColumnCount();//获取当前结果集的列数
28                         while(rs.next()){
29                             Map<String, Object> map = new HashMap<String, Object>();
30                             for(int i=1;i<=colCount;i++){
31                                 String colName=metaData.getColumnName(i);
32                                 map.put(colName, rs.getObject(colName));
33                             }
34                             rsList.add(map);
35                         }
36                         result.add(rsList);
37                         close(null, rs);//遍历完一个结果集，将其关闭
38                         hadResults=cs.getMoreResults();//移到下一个结果集
39                     }
40                     close(cs, rs);
41                 }
42             });
43             return result;
44         } catch (Exception e) {
45             e.printStackTrace();
46         }
47         return null;
48     }

代码中的close方法，执行doWork的execute方法中不能关闭connection，connection连同session由spring管理

 1 private void close(CallableStatement cs,ResultSet rs){
 2         try {
 3             if(cs!=null){
 4                 cs.close();
 5             }
 6             if(rs!=null){
 7                 rs.close();
 8             }
 9         } catch (Exception e) {
10             e.printStackTrace();
11         }
12     }