JDBC连接SQLServer数据库（增强封装版）

package dao;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class BaseDAO {

    // 驱动类全名（包名.类名）
    private static final String DRIVER = "com.microsoft.sqlserver.jdbc.SQLServerDriver";
    // 连接的URL
    private static final String URL = "jdbc:sqlserver://localhost\sqlexpress:1433;DatabaseName=bookdb";
    // 登录SQLserver用户名和密码
    private static final String USERNAME = "sa";
    private static final String PWD = "ghp418512";

    // 数据库对象声明
    private Connection con = null;
    private PreparedStatement pst = null;
    private ResultSet rs = null;

    /**
     * 加载驱动,建立连接
     * 
     * @throws ClassNotFoundException
     * @throws SQLException
     */
    private void getConnection() throws ClassNotFoundException, SQLException {
        // 加载驱动
        Class.forName(DRIVER);
        // 建立连接
        con = DriverManager.getConnection(URL, USERNAME, PWD);
    }

    /**
     * 执行查询
     * 
     * @param sql
     *            执行的参数化SQL语句 select * from where name=? and pwd=?
     * @param params
     *            Object数组，封装所有SQL语句参数，顺序与SQL语句的参数顺序一致,new Object[]{name,pwd}
     * @return ResultSet 返回执行后的结果集
     */
    public ResultSet execQuery(String sql, Object[] params) {
        try {
            getConnection();

            pst = con.prepareStatement(sql);

            setPrepareStatementParams(params);

            rs = pst.executeQuery();

        } catch (SQLException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return rs;
    }

    /**
     * 执行SQL查询语句，并返回泛型集合List<T> 调用示例：<br/>
     * String sql="select * from book"; <br />
     * List<Book> bookList=super.execQueryAndPackagingList(sql, null, new
     * Book());
     * 
     * @param sql
     *            要执行的SQL查询语句，必须有结果返回，并与实体类型T匹配
     * @param params
     *            SQL语句的参数
     * @param t
     *            封装的实体类型对象
     * @return 泛型集合List<T>
     */
    public <T> List<T> execQueryAndPackagingList(String sql, Object[] params,
            T t) {
        rs = execQuery(sql, params);
        List<T> tlist = null;
        try {

            tlist = setAllSetters(t, rs);

        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            closeAll();
        }
        return tlist;
    }

    /**
     * 执行增加、删除、修改SQL操作
     * 
     * @param sql
     *            执行的参数化SQL语句
     * @param params
     *            Object数组，封装所有SQL语句参数
     * @return int 受影响的行数，-1表示出现异常
     */
    public int execUpdate(String sql, Object[] params) {

        try {
            getConnection();
            pst = con.prepareStatement(sql);

            setPrepareStatementParams(params);

            int affectedRows = pst.executeUpdate();
            return affectedRows;
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            closeAll();
        }
        return -1;

    }

    /**
     * 为PrepareStatement设置参数
     * 
     * @param params
     *            参数数组
     * @throws SQLException
     */
    private void setPrepareStatementParams(Object[] params) throws SQLException {
        if (params != null) {
            for (int i = 0; i < params.length; i++) {
                pst.setObject(i + 1, params[i]);
            }
        }
    }

    /**
     * 关闭Connection,PrepareStatement,Result
     */
    public void closeAll() {
        try {

            if (rs != null) {
                rs.close();
            }
            if (pst != null) {
                pst.close();
            }
            if (con != null) {
                con.close();
            }

        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * 将查询结果(ResultSet)自动封装为泛型集合（List<T>）
     * 
     * @param ob
     *            封装的实体，其属性名必须与数据字段名一致，并提供有set***,get***方法
     * @param rs
     *            要封装的ResultSet
     * @return 泛型List集合（List<T>
     * @throws SQLException
     *             此方法可能抛出SQLException异常
     */
    private <T> List<T> setAllSetters(T ob, ResultSet rs) throws SQLException {

        Class cls = ob.getClass();
        List<T> tlist = new ArrayList<T>();
        T t = null;

        while (rs.next()) {

            try {
                t = (T) ob.getClass().newInstance();
            } catch (InstantiationException e1) {

                e1.printStackTrace();
            } catch (IllegalAccessException e1) {

                e1.printStackTrace();
            }

            for (Field field : cls.getDeclaredFields()) {
                for (Method method : cls.getMethods()) {
                    if ((method.getName().startsWith("set"))
                            && (method.getName().length() == (field.getName()
                                    .length() + 3))) {
                        if (method.getName().toLowerCase()
                                .endsWith(field.getName().toLowerCase())) {
                            try {
                                method.setAccessible(true);
                                if (field.getType().getSimpleName()
                                        .toLowerCase().endsWith("integer"))
                                    method.invoke(t, rs.getInt(field.getName()
                                            .toLowerCase()));
                                else if (field.getType().getSimpleName()
                                        .toLowerCase().endsWith("long"))
                                    method.invoke(t, rs.getLong(field.getName()
                                            .toLowerCase()));
                                else if (field.getType().getSimpleName()
                                        .toLowerCase().endsWith("string"))
                                    method.invoke(t, rs.getString(field
                                            .getName().toLowerCase()));
                                else if (field.getType().getSimpleName()
                                        .toLowerCase().endsWith("boolean"))
                                    method.invoke(t, rs.getBoolean(field
                                            .getName().toLowerCase()));
                                else if (field.getType().getSimpleName()
                                        .toLowerCase().endsWith("timestamp"))
                                    method.invoke(t, rs.getTimestamp(field
                                            .getName().toLowerCase()));
                                else if (field.getType().getSimpleName()
                                        .toLowerCase().endsWith("date"))
                                    method.invoke(t, rs.getDate(field.getName()
                                            .toLowerCase()));
                                else if (field.getType().getSimpleName()
                                        .toLowerCase().endsWith("double"))
                                    method.invoke(t, rs.getDouble(field
                                            .getName().toLowerCase()));
                                else if (field.getType().getSimpleName()
                                        .toLowerCase().endsWith("float"))
                                    method.invoke(t, rs.getFloat(field
                                            .getName().toLowerCase()));
                                else if (field.getType().getSimpleName()
                                        .toLowerCase().endsWith("time"))
                                    method.invoke(t, rs.getTime(field.getName()
                                            .toLowerCase()));
                                else
                                    method.invoke(t, rs.getObject(field
                                            .getName().toLowerCase()));
                            } catch (Exception e) {
                                e.printStackTrace();
                                ;
                            }
                        }
                    }
                }
            }
            tlist.add(t);
        }
        return tlist;
    }
}