briup_jdbc自建工具类终极版

总结：此次构建工具类，难点在于查询，所需要的功能是 不管是 oracle还是mysql 都可以连接，并且 提供所需要的实体类，都可以将查询内容封装到实体类中去

遇到的难点  连接时，是从prpperties.txt文件中读取驱动url等 时，怎么将它加载进来 此时可以使用类加载器 来加载相应的文件  当前类.class.classloader().getResourceAsStream(文件地址：注意此时不是从src了s 是从 包名 开始写路径)

第二个难点：时在构建查询时，使用的数据库是oracle 查询到的列名是大写的，需要进行转换成小写的

　　　　　　oracle 的 number 类型 在java中会解析成 BigDecimal,需要将它进行转换，然后转换成int

代码：

package com.briup.jdbc;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.lang.reflect.Field;
import java.math.BigDecimal;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map.Entry;
import java.util.Properties;
import java.util.Set;

import oracle.net.aso.l;

public class JDBCUtils3 {
    // 获得链接
    public static Connection getConnection(String str, String filePath) {
        if ("mysql".equals(str)) {
            try {

                Properties properties = new Properties();
                FileInputStream fis = null;
                try {
                    fis = new FileInputStream(new File(filePath));
                } catch (FileNotFoundException e2) {
                    e2.printStackTrace();
                }
　　　　　　　　　  // 自定义输入流可以替代类加载器加载（需要把文件放在包下）
                // InputStream in =
                // JdbcUtils2.class.getClassLoader().getResourceAsStream("com/briup/jdbc/properties.txt");
                try {
                    properties.load(fis);
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
                String driver = (String) properties.get("driver");
                String url = (String) properties.get("url");
                String username = (String) properties.get("username");
                String password = (String) properties.get("password");

                Class.forName(driver);
                try {
                    Connection conn = DriverManager.getConnection(url, username, password);
                    // System.out.println("连接到mysql数据库" + conn);
                    return conn;
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }

        }
        if ("oracle".equals(str)) {
            Properties properties = new Properties();
            FileInputStream fis = null;
            try {
                fis = new FileInputStream(new File(filePath));
            } catch (FileNotFoundException e2) {
                e2.printStackTrace();
            }
            try {
                properties.load(fis);
            } catch (IOException e1) {
                e1.printStackTrace();
            }
            String driver = (String) properties.get("driver");
            String url = (String) properties.get("url");
            String username = (String) properties.get("username");
            String password = (String) properties.get("password");
            try {
                Class.forName(driver);
                try {
                    Connection conn = DriverManager.getConnection(url, username, password);
                    System.out.println("连接到orcle数据库");
                    return conn;
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }

        }
        return null;
    }

    // 通用的查询方法
    public static <T> List<T> query2(Connection conn, String ss,String sql, Object... args) {
        List<T> list = null;
        try {
            // 获取prepareStatement对象
            PreparedStatement prepareStatement = conn.prepareStatement(sql);
            // 通过传进来的参数（占位符），将整个sql语句补充好
            for (int i = 0; i < args.length; i++) {
                // 注：这里需要+1
                prepareStatement.setObject(i + 1, args[i]);
            }
            // 获得结果集
            ResultSet resultSet = prepareStatement.executeQuery();

            // 这里准备获取结果集里面的所有的列名
            List<String> labels = new ArrayList<String>();
            // 获取数据库中列名的全部集合（元数据）
            ResultSetMetaData metaData = resultSet.getMetaData();
            for (int i = 0; i < metaData.getColumnCount(); i++) {
                // 这里同样要加1，从1开始计数的
                labels.add(metaData.getColumnLabel(i + 1));
            }

            // 创建一个map，将查询到的字段名，和它的值存到map中，以便取出
            // key:列名，value：字段的值
            HashMap<String, Object> map = new HashMap<String, Object>();
            // 创建一个list，存储数据
            list = new ArrayList<T>();
            // s是列名
            while (resultSet.next()) {
                map.clear();
                for (String s : labels) {
                    map.put(s, resultSet.getObject(s));
                }
                // 如果map不为空，遍历map，将它的值存到实体类中去
                if (!map.isEmpty()) {
                    Set<Entry<String, Object>> entrySet = map.entrySet();
                    for (Entry<String, Object> entry : entrySet) {
                        System.out.print(entry.getKey()+":"+entry.getValue()+" ");
                        if(entry.getKey().equals(ss)) {
                            System.out.println();
                        }
                    }
                }
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return list;
    }

    // 通用的查询方法
        public static <T> List<T> query(Class<T> tClass, Connection conn, String sql, Object... args) {
            List<T> list = null;
            try {
                // 获取prepareStatement对象
                PreparedStatement prepareStatement = conn.prepareStatement(sql);
                // 通过传进来的参数（占位符），将整个sql语句补充好
                for (int i = 0; i < args.length; i++) {
                    // 注：这里需要+1
                    prepareStatement.setObject(i + 1, args[i]);
                }
                // 获得结果集
                ResultSet resultSet = prepareStatement.executeQuery();

                // 这里准备获取结果集里面的所有的列名
                List<String> labels = new ArrayList<String>();
                // 获取数据库中列名的全部集合（元数据）
                ResultSetMetaData metaData = resultSet.getMetaData();
                for (int i = 0; i < metaData.getColumnCount(); i++) {
                    // 这里同样要加1，从1开始计数的
                    labels.add(metaData.getColumnLabel(i + 1));
                }

                // 创建一个map，将查询到的字段名，和它的值存到map中，以便取出
                // key:列名，value：字段的值
                HashMap<String, Object> map = new HashMap<String, Object>();
                // 创建一个list，存储数据
                list = new ArrayList<T>();
                // s是列名
                while (resultSet.next()) {
                    map.clear();
                    for (String s : labels) {
                        map.put(s, resultSet.getObject(s));
                    }
                    // 如果map不为空，遍历map，将它的值存到实体类中去
                    if (!map.isEmpty()) {
                        try {
                            // 创建一个实例，这里开始利用反射了
                            T newInstance = tClass.newInstance();
                            Set<Entry<String, Object>> entrySet = map.entrySet();
                            for (Entry<String, Object> entry : entrySet) {
                                String name = entry.getKey();
                                Object value = entry.getValue();
                                if(value instanceof BigDecimal) {
                                    value=((BigDecimal) value).intValue();
                                }
                                try {
                                    // 获取属性，给属性赋值
                                    Field field = tClass.getDeclaredField(name.toLowerCase());
                                    field.setAccessible(true);
                                    field.set(newInstance, value);
                                } catch (NoSuchFieldException e) {
                                    e.printStackTrace();
                                } catch (SecurityException e) {
                                    e.printStackTrace();
                                }
                            }
                            list.add(newInstance);

                        } catch (InstantiationException e) {
                            e.printStackTrace();
                        } catch (IllegalAccessException e) {
                            e.printStackTrace();
                        }
                    }
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
            return list;
        }

    // 删除数据
    public static void delete(Connection conn, String sql) {
        try {
            Statement statement = conn.createStatement();
            try {
                statement.execute(sql);
                System.out.println("删除数据成功!");
            } catch (Exception e) {
                System.err.println("出现问题了" + e.getMessage());
                e.printStackTrace();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // 修改一条数据
    public static void Update(Connection conn, String sql) {
        try {
            Statement statement = conn.createStatement();
            try {
                statement.execute(sql);
                System.out.println("修改数据成功");
            } catch (Exception e) {
                System.err.println("出现问题了" + e.getMessage());
                e.printStackTrace();
            } 

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

    // 添加一条数据
    public static void add(Connection conn, String sql) {
        try {
            Statement statement = conn.createStatement();
            try {
                statement.execute(sql);
                System.out.println("插入数据成功!");
            } catch (Exception e) {
                System.err.println("出现问题了" + e.getMessage());
                e.printStackTrace();
            } 

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

    // 关闭连接
    public static void close(Statement st, ResultSet rs, Connection conn) {
        if (st != null) {
            try {
                st.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

    }

}