sql数据库通用类

/**
 * 
 */
package com.hotel.util;
 
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
 
import com.hotel.constant.Constants;
 
/**
 * 数据库连接通用类
 * 连接数据库的步骤:
 * 1. 导入驱动包
 * 2. 加载驱动
 * 3. 通过驱动管理器类获取数据库连接
 * 4. 通过连接对象创建预编译对象
 * 5. 通过编译对象执行SQL指令并处理返回结果
 * 6. 关闭相关操作对象
 *
 */
public class DBUtil {
     
     
     
    /**
     * 定义获取连接对象的方法
     * 
     */
    private static Connection getConn() {
         
        // 定义连接对象句柄
        Connection conn = null;
         
        try {
            // 加载驱动
            Class.forName(Constants.DRIVER_NAME);
            // 通过驱动管理器类获取数据库连接
            conn = DriverManager.getConnection(Constants.URL, Constants.USERNAME, Constants.PASSWORD);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return conn;
    }
     
    /**
     * 定义执行简单SQL的增,删,改指令
     * @param sql 调用传入的SQL指令
     * @param objects 执行SQL指令需要的参数
     * @return int 返回方法操作后受影响的行数
     */
    public static int executeMyUpdate(String sql,Object... objects) {
         
        // 定义接受受影响行数的变量
        int row = 0;
        // 定义连接对象句柄
        Connection conn = null;
        // 定义编译对象句柄
        PreparedStatement pst = null;
         
        // 通过调用本类中的获取连接对象
        conn = getConn();
         
        try {
            // 通过连接对象创建编译对象
            pst = conn.prepareStatement(sql);
            // 设置SQL命令所需的参数
            if(objects != null) {
                for(int i =0 ;i<objects.length;i++) {
                    pst.setObject(i+1, objects[i]);
                }
            }
             
            // 执行SQL指令并处理返回结果
            row = pst.executeUpdate();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            closeObjects(pst,conn);
        }
         
        // 返回受影响行数
        return row;
    }
     
    /**
     * 定义执行简单查询语句的通用方法
     * @param sql 调用传入查询的ＳＱＬ指令
     * @param objects　查询所需参数
     * @return　List<Map<String,Object>> 返回查询构建集合对象
     */
    public static List<Map<String,Object>> executeQuery(String sql,Object...objects) {
        // 定义表集合对象
        List<Map<String,Object>> table = new ArrayList<Map<String,Object>>();
        // 定义连接对象句柄
        Connection conn = null;
        // 定义编译对象句柄
        PreparedStatement pst = null;
        // 定义结果集句柄
        ResultSet rs = null;
         
        // 通过调用本类中的获取连接对象
        conn = getConn();
         
        try {
            // 通过连接对象创建预编译对象
            pst = conn.prepareStatement(sql);
            // 为查询编译对象设置参数
            if(objects != null) {
                for(int i=0;i<objects.length;i++) {
                    pst.setObject(i+1, objects[i]);
                }
            }
            // 通过编译对象执行ＳＱＬ命令
            rs = pst.executeQuery();
             
            // 判断结果是否为空
            if(rs != null) {
                // 把得到结果集转化为一张虚拟表
                ResultSetMetaData rsd = rs.getMetaData();
                // 得到查询表有多少个字段（列）
                int count = rsd.getColumnCount();
                 
                // 得到当前遍历的行Map(key,value)
                while(rs.next()) {
                    // 定义存储行的Map集合对象
                    Map<String,Object> row = new HashMap<String,Object>();
                    // 循环列
                    /* userId(key)      userName             userPass      userRemark
                    ----------- -------------------- ------------------------------
                       10002 (value)    normal               123           normal   */
                    /*
                     * rsd.getColumnName(i+1)  得到当前遍历行对应列的名称
                     */
                    for(int i=0;i<count;i++) {
                        row.put(rsd.getColumnName(i+1), rs.getObject(rsd.getColumnName(i+1)));
                    }
                     
                    // 把每次遍历的行存储到表集合中
                    table.add(row);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            closeObjects(rs,pst,conn);
        }
         
        return table;
    }
     
    /**
     * 释放操作对象的方法
     * @param objects 需要释放对象的列表
     */
    private static void closeObjects(Object...objects) {
        if(objects != null) {
            for(Object param : objects) {
                try {
                    if(param instanceof ResultSet) {
                        ((ResultSet)param).close();
                    }
                     
                    if(param instanceof PreparedStatement) {
                        ((PreparedStatement)param).close();
                    }
                     
                    if(param instanceof Connection) {
                        Connection conn = ((Connection)param);
                        if(!conn.isClosed()) {
                            conn.close();
                            conn = null;
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
     
}