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      userRemark137                     ----------- -------------------- ------------------------------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 }