JDBC工具类

import java.lang.reflect.Field;
import java.sql.*;
import java.util.*;

/**
 * 工具类
 * @author shanyang.liu
 */
public class JDBCUtil {
	
	public static String getJdbcUrl(){
        String url = "jdbc:oracle:thin:@192.53.20.17:1521:orcl";
		//String url = "jdbc:sqlserver://192.168.1.1:1433;DatabaseName=power_manager";
        //String url = "jdbc:mysql://192.168.1.222:3306/asawms?autoReconnect=true&useUnicode=true&characterEncoding=utf-8";
		return url;
	}
	
	public static String getJdbcUser(){
		String user = "root";
		return user;
	}
	
	public static String getJdbcPassword(){
		String password = "root";
		return password;
	}
	
    //这里可以设置数据库名称
    private final static String URL = getJdbcUrl();
    private static final String USER = getJdbcUser();
    private static final String PASSWORD = getJdbcPassword();

    private static Connection conn = null;
    // 静态代码块（将加载驱动、连接数据库放入静态块中）
    static {
        // 判断是否正常，默认为连接池是连接的
        boolean flag = true;
        // 判断是sql语句异常还是断连引发的异常
        boolean result = false;
        try {
            // 1.加载驱动程序(以 oracle 为列：则加载 oracle 的驱动)
            Class.forName("oracle.jdbc.driver.OracleDriver");
            //Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
            //Class.forName("com.mysql.jdbc.Driver");
            // 2.获得数据库的连接
            conn = (Connection) DriverManager.getConnection(URL, USER, PASSWORD);
            if (conn == null) {
                result = false;
                close();
            } else {
                result = true;
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            result = false;
            close();
        } catch (SQLException e) {
            e.printStackTrace();
            result = false;
            close();
        }
        if (!result) {
        	System.out.println("数据库连接已经断开，请检查数据库服务器!");
            // 重连 ...
            do {
                try {
                    conn = (Connection) DriverManager.getConnection(URL, USER, PASSWORD);
                    if (conn == null) {
                        flag = false;
                        close();
                    } else {
                        flag = true;
                    }
                } catch (SQLException e) {
                    flag = false;
                }
                if (!flag) {
                    try {
                        Thread.sleep(300000L); // 连接断开时,每隔5分钟尝试重连一次
                    } catch (InterruptedException e) {
                        System.out.println(e.getMessage());
                    }
                }
                System.out.println("尝试重连中...");
            } while (flag);
            System.out.println("数据库连接已恢复!");
        }
    }

    // 对外提供一个方法来获取数据库连接
    public static Connection getJdbcConnection() {
        return conn;
    }

    /**
     * 关闭资源
     */
    public static void close() {
        try {
            if (conn != null) {
                conn.close();
                conn = null;
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * 插入语句
     * @param sql
     * @param params
     */
    public static boolean insertBySql(String sql, Object params[]) throws Exception {
        int count = 0;
        try {
            // 预编译sql
            PreparedStatement ps = conn.prepareStatement(sql);
            for (int i = 0; i < params.length; i++) {
                // 给sql语句占位符赋值
                ps.setObject(i + 1, params[i]);
            }
            count = ps.executeUpdate();
            System.out.println("数据表插入" + count + "条");
        } catch (SQLException e) {
            e.printStackTrace();
            throw  new Exception(e);
        }
        return count == 0 ? false : true;
    }

    /**
     * 删除语句
     * @param sql
     * @param params
     */
    public static boolean deleteBySql(String sql, Object params[]) {
        int count = 0;
        try {
            // 预编译sql
            PreparedStatement ps = conn.prepareStatement(sql);
            for (int i = 0; i < params.length; i++) {
                // 给sql语句占位符赋值
                ps.setObject(i + 1, params[i]);
            }
            count = ps.executeUpdate();
            System.out.println("数据表删除" + count + "条");
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return count == 0 ? false : true;
    }

    /**
     * 更新语句
     * @param sql
     * @param params
     */
    public static boolean updateBySql(String sql, Object params[]) {
        int count = 0;
        try {
            // 预编译sql
            PreparedStatement ps = conn.prepareStatement(sql);
            for (int i = 0; i < params.length; i++) {
                // 给sql语句占位符赋值
                ps.setObject(i + 1, params[i]);
            }
            count = ps.executeUpdate();
            System.out.println("数据表更新" + count + "条");
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return count == 0 ? false : true;
    }

    /**
     * 查询语句
     * @param sql sql语句
     * @param params sql语句传参
     */
    public static List<Map<String,Object>> queryBySql(String sql, Object params[])
            throws Exception {
        List<Map<String,Object>> list = new ArrayList();
        try {
            // 预编译sql
            PreparedStatement ps = conn.prepareStatement(sql);
            for (int i = 0; i < params.length; i++) {
                // 给sql语句占位符赋值
                ps.setObject(i + 1, params[i]);
            }
            ResultSet rs = ps.executeQuery();
            // 结果集 中列的名称和类型的信息
            ResultSetMetaData rsmd = rs.getMetaData();
            int colNumber = rsmd.getColumnCount();
            // 遍历每条记录
            while (rs.next()) {
                // 取出每一个字段进行赋值
                Map<String,Object> map = new HashMap<String,Object>();
                for (int i = 1; i <= colNumber; i++) {
                    String columnName = rsmd.getColumnName(i);
                    Object columnValue = rs.getObject(i);
                    map.put(columnName,columnValue);
                }
                list.add(map);
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw new Exception(e.getMessage());
        }
        System.out.println("数据表查询到"+list.size()+"条");
        return list;
    }

    /**
     * 查询语句（返回实体对象的List）
     * 强制要求：实体对象的字段名与数据库表的字段名完全相同，区分大小写。
     * @param clazz 实体对象映射类
     * @param sql sql语句
     */
    public static List queryByClassSql(Class clazz, String sql, Object params[])
            throws Exception {
        List list = new ArrayList();
        try {
            // 预编译sql
            PreparedStatement ps = conn.prepareStatement(sql);
            for (int i = 0; i < params.length; i++) {
                // 给sql语句占位符赋值
                ps.setObject(i + 1, params[i]);
            }
            ResultSet rs = ps.executeQuery();
            // 结果集 中列的名称和类型的信息
            ResultSetMetaData rsmd = rs.getMetaData();
            int colNumber = rsmd.getColumnCount();
            //获得某个类的所有字段，包括父类中的字段。
            Field[] fields = getFieldsByClass(clazz);
            // 遍历每条记录
            while (rs.next()) {
                // 实例化对象
                Object obj = clazz.newInstance();
                // 取出每一个字段进行赋值
                for (int i = 1; i <= colNumber; i++) {
                    Object columnName = rsmd.getColumnName(i);
                    Object columnValue = rs.getObject(i);
                    // 匹配实体类中对应的属性
                    for (int j = 0; j < fields.length; j++) {
                        Field f = fields[j];
                        Object fName = f.getName();
                        if (fName.equals(columnName)) {
                            boolean flag = f.isAccessible();
                            f.setAccessible(true);
                            f.set(obj, columnValue);
                            f.setAccessible(flag);
                            break;
                        }
                    }
                }
                list.add(obj);
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw new Exception(e.getMessage());
        }
        System.out.println("数据表查询到"+list.size()+"条");
        return list;
    }

    /**
     * 获得某个类的所有字段，包括父类中的字段。
     */
    public static Field[] getFieldsByClass(Class tempClass){
        //getFields()：获得某个类的所有的公共（public）的字段，包括父类中的字段。
        //getDeclaredFields()：获得某个类的所有声明的字段，即包括public、private和proteced，但是不包括父类的申明字段。
        //同样类似的还有getConstructors()和getDeclaredConstructors()、getMethods()和getDeclaredMethods()，这两者分别表示获取某个类的方法、构造函数。
        List<Field> fieldList = new ArrayList<>() ;
        //当父类为null的时候说明到达了最上层的父类(Object类).
        while (tempClass != null) {
            fieldList.addAll(Arrays.asList(tempClass.getDeclaredFields()));
            //得到父类,然后赋给自己
            tempClass = tempClass.getSuperclass();
        }
        Field[] fields = new Field[fieldList.size()];
        for(int i = 0; i < fieldList.size(); i++){
            fields[i] = fieldList.get(i);
        }
        return fields;
    }

    // 测试
    public static void main(String[] args) throws Exception {
        // 插入语句 (参数用?表示，相当于占位符)
        String insertSql = "insert into table (id,code) values (?,?)";
        insertBySql(insertSql, new Object[] { 1L, "0010" });
        // 删除语句 (参数用?表示，相当于占位符)
        String deleteSql = "delete from table where code = ?";
        deleteBySql(deleteSql, new Object[] { "0010" });
        // 更新语句 (参数用?表示，相当于占位符)
        String updateSql = "update table set code = ? where code = ?";
        updateBySql(updateSql, new Object[] { "0020", "0010" });
        // 查询语句1(参数用?表示，相当于占位符)
        String querySql1 = "select * from table where code = ?";
        List<Map<String,Object>> queryList = queryBySql(querySql1,new Object[] {"0001"});
        for(Map<String,Object> map : queryList){
            for(String mapKey : map.keySet()){
                System.out.println(mapKey+":"+map.get(mapKey));
            }
        }
        // 查询语句2(参数用?表示，相当于占位符)
        String querySql2 = "select * from table where code = ?";
        //List<Ware> list = queryByClassSql(Ware.class, querySql2, new Object[] {});
        System.out.println("111");
    }

}