sql数据库通用类

  1 /**
  2  * 
  3  */
  4 package com.hotel.util;
  5  
  6 import java.sql.Connection;
  7 import java.sql.DriverManager;
  8 import java.sql.PreparedStatement;
  9 import java.sql.ResultSet;
 10 import java.sql.ResultSetMetaData;
 11 import java.util.ArrayList;
 12 import java.util.HashMap;
 13 import java.util.List;
 14 import java.util.Map;
 15  
 16 import com.hotel.constant.Constants;
 17  
 18 /**
 19  * 数据库连接通用类
 20  * 连接数据库的步骤:
 21  * 1. 导入驱动包
 22  * 2. 加载驱动
 23  * 3. 通过驱动管理器类获取数据库连接
 24  * 4. 通过连接对象创建预编译对象
 25  * 5. 通过编译对象执行SQL指令并处理返回结果
 26  * 6. 关闭相关操作对象
 27  *
 28  */
 29 public class DBUtil {
 30      
 31      
 32      
 33     /**
 34      * 定义获取连接对象的方法
 35      * 
 36      */
 37     private static Connection getConn() {
 38          
 39         // 定义连接对象句柄
 40         Connection conn = null;
 41          
 42         try {
 43             // 加载驱动
 44             Class.forName(Constants.DRIVER_NAME);
 45             // 通过驱动管理器类获取数据库连接
 46             conn = DriverManager.getConnection(Constants.URL, Constants.USERNAME, Constants.PASSWORD);
 47         } catch (Exception e) {
 48             e.printStackTrace();
 49         }
 50         return conn;
 51     }
 52      
 53     /**
 54      * 定义执行简单SQL的增,删,改指令
 55      * @param sql 调用传入的SQL指令
 56      * @param objects 执行SQL指令需要的参数
 57      * @return int 返回方法操作后受影响的行数
 58      */
 59     public static int executeMyUpdate(String sql,Object... objects) {
 60          
 61         // 定义接受受影响行数的变量
 62         int row = 0;
 63         // 定义连接对象句柄
 64         Connection conn = null;
 65         // 定义编译对象句柄
 66         PreparedStatement pst = null;
 67          
 68         // 通过调用本类中的获取连接对象
 69         conn = getConn();
 70          
 71         try {
 72             // 通过连接对象创建编译对象
 73             pst = conn.prepareStatement(sql);
 74             // 设置SQL命令所需的参数
 75             if(objects != null) {
 76                 for(int i =0 ;i<objects.length;i++) {
 77                     pst.setObject(i+1, objects[i]);
 78                 }
 79             }
 80              
 81             // 执行SQL指令并处理返回结果
 82             row = pst.executeUpdate();
 83         } catch (Exception e) {
 84             e.printStackTrace();
 85         } finally {
 86             closeObjects(pst,conn);
 87         }
 88          
 89         // 返回受影响行数
 90         return row;
 91     }
 92      
 93     /**
 94      * 定义执行简单查询语句的通用方法
 95      * @param sql 调用传入查询的ＳＱＬ指令
 96      * @param objects　查询所需参数
 97      * @return　List<Map<String,Object>> 返回查询构建集合对象
 98      */
 99     public static List<Map<String,Object>> executeQuery(String sql,Object...objects) {
100         // 定义表集合对象
101         List<Map<String,Object>> table = new ArrayList<Map<String,Object>>();
102         // 定义连接对象句柄
103         Connection conn = null;
104         // 定义编译对象句柄
105         PreparedStatement pst = null;
106         // 定义结果集句柄
107         ResultSet rs = null;
108          
109         // 通过调用本类中的获取连接对象
110         conn = getConn();
111          
112         try {
113             // 通过连接对象创建预编译对象
114             pst = conn.prepareStatement(sql);
115             // 为查询编译对象设置参数
116             if(objects != null) {
117                 for(int i=0;i<objects.length;i++) {
118                     pst.setObject(i+1, objects[i]);
119                 }
120             }
121             // 通过编译对象执行ＳＱＬ命令
122             rs = pst.executeQuery();
123              
124             // 判断结果是否为空
125             if(rs != null) {
126                 // 把得到结果集转化为一张虚拟表
127                 ResultSetMetaData rsd = rs.getMetaData();
128                 // 得到查询表有多少个字段（列）
129                 int count = rsd.getColumnCount();
130                  
131                 // 得到当前遍历的行Map(key,value)
132                 while(rs.next()) {
133                     // 定义存储行的Map集合对象
134                     Map<String,Object> row = new HashMap<String,Object>();
135                     // 循环列
136                     /* userId(key)      userName             userPass      userRemark
137                     ----------- -------------------- ------------------------------
138                        10002 (value)    normal               123           normal   */
139                     /*
140                      * rsd.getColumnName(i+1)  得到当前遍历行对应列的名称
141                      */
142                     for(int i=0;i<count;i++) {
143                         row.put(rsd.getColumnName(i+1), rs.getObject(rsd.getColumnName(i+1)));
144                     }
145                      
146                     // 把每次遍历的行存储到表集合中
147                     table.add(row);
148                 }
149             }
150         } catch (Exception e) {
151             e.printStackTrace();
152         } finally {
153             closeObjects(rs,pst,conn);
154         }
155          
156         return table;
157     }
158      
159     /**
160      * 释放操作对象的方法
161      * @param objects 需要释放对象的列表
162      */
163     private static void closeObjects(Object...objects) {
164         if(objects != null) {
165             for(Object param : objects) {
166                 try {
167                     if(param instanceof ResultSet) {
168                         ((ResultSet)param).close();
169                     }
170                      
171                     if(param instanceof PreparedStatement) {
172                         ((PreparedStatement)param).close();
173                     }
174                      
175                     if(param instanceof Connection) {
176                         Connection conn = ((Connection)param);
177                         if(!conn.isClosed()) {
178                             conn.close();
179                             conn = null;
180                         }
181                     }
182                 } catch (Exception e) {
183                     e.printStackTrace();
184                 }
185             }
186         }
187     }
188      
189 }