自己封装jdbc

import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.sql.*;
import java.util.*;

/**
 * 自己封装jdbc
 */
public class DBUtils {
    public static String driver;//驱动
    public static String url;//数据库地址
    public static String username;//用户名称
    public static String password;//密码

    //使用一个游离块来加载配置文件
    //以保证我们的连接能够正常进行
    static {
        try {
            //读取属性文件使用输入流
            //get 获取 Resource:资源 Stream:流
            InputStream is = DBUtils.class.getResourceAsStream("jdbc.properties");
            //创建一个Properties对象
            Properties properties = new Properties();
            //将读取到的信息加载在对象,对象中有get方法能够用来读取到文件的配置
            properties.load(is);
            //获取属性的时候获取的时候属性名
            driver = properties.getProperty("jdbc.driver");
            url = properties.getProperty("jdbc.url");
            username = properties.getProperty("jdbc.username");
            password = properties.getProperty("jdbc.password");
            //加载驱动
            Class.forName(driver);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    //获取连接
    public static Connection getConn(){
        try {
            return DriverManager.getConnection(url,username,password);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

    //关闭资源
    public static void close(Statement statement,Connection connection,ResultSet rs){
        try {
            if(statement != null){statement.close();}
            if(connection != null){connection.close();}
            if(rs != null){rs.close();}
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    //封装一个通用的更新操作,对所有的更新(insert update delete)有关的操作都能够
    //通过这个方法进行实现
    public static boolean exeUpdate(String sql,Object... obj){
        Connection connection = null;
        PreparedStatement ps = null;
        try {
            //获取连接
            connection = getConn();
            ps = connection.prepareStatement(sql);
            for(int i = 0; i < obj.length; i++){
                //i + 1:指sql语句中的第几个问号
                //obj[i]:从参数的数组中拿到值,然后放在问号相应的位置
                ps.setObject(i + 1,obj[i]);
            }
            return ps.executeUpdate() > 0;
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            close(ps,connection,null);
        }
        return false;
    }

    //封装一个查询单个对象的方法
    public static <T>T queryOne(Class<T> t,String sql,Object... params){
        //首先创建一个对象用来存储从数据库中获取到的值
        T obj  = null;
        //创建一个连接对象
        Connection connection = null;
        //创建预处理平台
        PreparedStatement statement = null;

        ResultSet set = null;
        try {
            connection = getConn();//从上面调用方法获取数据库连接
            statement = connection.prepareStatement(sql);//对数据库语句进行预处理
            //statement对象需要找到sql语句中的?,并且将可变参数的值放在问号的位置
            for (int i= 0; i < params.length; i++){
                //将值放在对应的问号的位置
                statement.setObject(i + 1,params[i]);
            }
            //将处理好的sql语句拿到数据库中进行数据查询,查询到之后返回结果集
            set = statement.executeQuery();
            //检索此 ResultSet对象的列的数量，类型和属性。
            ResultSetMetaData rsmd = set.getMetaData();
            //获取到下一条数据
            if(set.next()){
                //创建上面T的构造函数
                obj = t.newInstance();
                //通过从数据库中获取到的列的数量,对列进行遍历将值取出来
                for(int  i = 0; i < rsmd.getColumnCount();i++){
                    //获取指定列的名称
                    String cname = rsmd.getColumnName(i + 1);
                    //获取列中的值
                    Object value = set.getObject(cname);
                    //判断我们获取到的值是否为空
                    if(Objects.nonNull(value)){
                        //根据列名称获取java类的属性名
                        //(要求表中的列名称必须与类中的属性名保持一致)
                        Field field = t.getDeclaredField(cname);
                        //将字段设置为可访问状态
                        field.setAccessible(true);
                        //为字段设置属性值
                        field.set(obj,value);
                    }
                }
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }finally {
            close(statement,connection,set);
        }
        return obj;
    }

    //jdbc封装通用的查询多条语句的操作
    //泛型,集合框架,反射
    public static <T> List<T> queryList(Class<T> t, String sql, Object... params){
        //创建一个用来接收信息并返回信息的集合
        List<T> list = new ArrayList<T>();
        //集合中需要存储对象
        T obj = null;
        Connection connection = null;
        PreparedStatement statement = null;
        ResultSet set = null;
        try {
            connection = getConn();
            statement = connection.prepareStatement(sql);
            for(int i = 0; i < params.length; i++){
                statement.setObject(i + 1,params[i]);
            }

            set = statement.executeQuery();
            ResultSetMetaData rsmd = set.getMetaData();
            //声明一个map集合,用于临时存储查询到的一条数据(key:列名 value:列值)
            Map<String,Object> map = new HashMap<String,Object>();

            //遍历结果集
            while (set.next()){
                //防止你的对象中缓存了上一个对象
                map.clear();
                //遍历所有的列
                for(int i = 0; i < rsmd.getColumnCount(); i++){
                    //获取列名
                    String cname = rsmd.getColumnName(i + 1);
                    //获取列的值
                    Object value = set.getObject(cname);
                    //将列名与列值存储到map中
                    map.put(cname,value);
                }
                //利用反射将map中的数据注入到java对象中,并将对象存入到集合中
                if(!map.isEmpty()){
                    //获取到map集合中的键集(列名的集合)
                    Set<String> columnNames = map.keySet();
                    //创建对象
                    obj = t.newInstance();
                    for(String column : columnNames){
                        //根据键来获取到值
                        Object value = map.get(column);
                        //当数据对象不为空的时候,才注入到数据的属性中
                        if(Objects.nonNull(value)){
                            //获取属性的对象
                            Field f = t.getDeclaredField(column);
                            //设置属性为可以访问的状态
                            f.setAccessible(true);
                            //为属性进行赋值
                            f.set(obj,value);
                        }
                    }
                    //将对象放在集合中
                    list.add(obj);
                }
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }finally {
            close(statement,connection,set);
        }
        return list;
    }

    public static void main(String[] args) {
        System.out.println(driver);
        System.out.println(url);
        System.out.println(username);
        System.out.println(password);

        System.out.println(DBUtils.getConn());//com.mysql.jdbc.JDBC4Connection@7de26db8
    }
}