通过反射对JDBC简单封装

先看资源包

driverClass=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/javaquanzhan?sueSSL=false&serverTimezone=UTC
username=root
password=123456

  封装的CRUD方法

package reflectionJdbc;

import org.apache.commons.beanutils.BeanUtils;

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

/**
 * 数据库连接类
 */
@SuppressWarnings("all")
public class jdbcUtils {
    private static String driverClass;
    private static String url;
    private static String username;
    private static String password;

    /**
     *
     * 类文件加载阶段执行，而且只执行一次
     */
    static {
        //通过反射Class实例获取类加载器,然后通过类加载器获取数据流对象
        InputStream resourceAsStream = jdbcUtils.class.getClassLoader().getResourceAsStream("jdbc.properties");
        //创建Properties是咧对象， 注：底层是Map键值对
        Properties properties = new Properties();
        //加载配置项文件
        try {
            properties.load(resourceAsStream);
            //将properties中的有效值提取出来
            driverClass = properties.getProperty("driverClass");
            url = properties.getProperty("url");
            username = properties.getProperty("username");
            password = properties.getProperty("password");

            //加载驱动

            try {
                Class.forName(driverClass);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }

            //释放资源吗
            try {
                if (resourceAsStream != null) ;
                resourceAsStream.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(url, username, password);
    }

    /**
     * 封装预处理
     * @param sql
     * @param connection Connection
     * @param parameters 可变参数列表
     * @return 返回预处理语句
     * @throws SQLException
     */
    public static PreparedStatement getPrepareStatement(String sql, Connection connection, Object... parameters) throws SQLException {
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        //获取元数据
        ParameterMetaData parameterMetaData = preparedStatement.getParameterMetaData();
        //获取字符串需要的参数个数
        int parameterCount = parameterMetaData.getParameterCount();
        //判断什么情况才需要给预编译对象赋值
        if (parameterCount != 0 && parameters != null && parameters.length == parameterCount) {
            for (int i = 0; i < parameterCount; i++) {
                preparedStatement.setObject(i + 1, parameters[i]);
            }
        }
        System.out.println("preparedStatement.toString() = " + preparedStatement.toString());
        return preparedStatement;
    }

    /**
     * 数据更新功能
     * @param sql String 自定义sql更新语句
     * @param parameters 可变参数列表(参数列表，更新数据)
     * @return 返回已修改的语句次数
     * @throws SQLException
     */
    public static int update1(String sql, Object... parameters) throws SQLException {
        //获取连接
        Connection connection = jdbcUtils.getConnection();
        //预加载
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        int parameterCount = preparedStatement.getParameterMetaData().getParameterCount();
        //验证是否需要遍历给？赋值
        if (parameterCount != 0 && parameters != null && parameters.length == parameterCount) {

            for (int i = 0; i < parameterCount; i++) {
                preparedStatement.setObject(i + 1, parameters[i]);
            }
        }
        int i = preparedStatement.executeUpdate();
        close(connection, preparedStatement);
        return i;
    }


    /**
     * 1.封装查询 思想，传入一个泛型类，然后将查询结果以指定类的形式返回
     * sql    泛型类   可变参数
     * BeanUtils可以帮助我们把属性封装当JavaBean对象的对应属性中，
     * 比如可以把提交的表单数据封装到一个实体对象中。
     * 封装时要求参数名称和JavaBean的属性明相同
     * @param sql 根据给定的条件参数从表中查询数据
     * @param c 反射对象类
     * @param parameters 查询条件的参数列表
     * @param <T>  传进去的任意类型
     * @return  将查询结果以指定类的形式返回
     * @throws SQLException
     * @throws NoSuchMethodException
     * @throws InvocationTargetException
     * @throws InstantiationException
     * @throws IllegalAccessException
     */
    public static <T> T queryBean(String sql, Class<T> c, Object... parameters)
            throws SQLException,
            NoSuchMethodException, InvocationTargetException,
            InstantiationException, IllegalAccessException {
        //1.查询别要的参数
        Connection connection = null;
        PreparedStatement statement = null;
        ResultSet resultSet = null;
        //获取链接
        connection = jdbcUtils.getConnection();
        statement = getPrepareStatement(sql, connection, parameters);
        //3.执行查询操作，得到resultSet集合
        resultSet = statement.executeQuery();
        //4.根据结果集获取元数据
        ResultSetMetaData metaData = resultSet.getMetaData();
        int columnCount = metaData.getColumnCount();
        T t = null;
        while (resultSet.next()) {
            //实例化泛型约束之后对应的具体数据类型对象
            t = c.getConstructor().newInstance();
            for (int i = 1; i <= columnCount; i++) {
                BeanUtils.setProperty(t, metaData.getColumnName(i), resultSet.getObject(i));
            }

        }
        jdbcUtils.close(connection, statement, resultSet);
        return t;
    }

    /**
     * 思想：传入一个泛型类，以指定集合list形式返回
     * @param sql 根据给定的条件参数从表中查询数据
     * @param c 反射对象类
     * @param parameters 查询条件的参数列表
     * @param <T> 泛型集合形式
     * @return 返回List集合
     */
    public static <T> List<T> queryBeanList(String sql, Class<T> c, Object... parameters) {
        //1.查询别要的参数
        Connection connection = null;
        PreparedStatement prepareStatement = null;
        ResultSet resultSet = null;
        ArrayList<T> list = new ArrayList<>();
        try {
            connection = jdbcUtils.getConnection();
            prepareStatement = getPrepareStatement(sql, connection, parameters);
            resultSet = prepareStatement.executeQuery();
            ResultSetMetaData metaData = resultSet.getMetaData();
            int columnCount = metaData.getColumnCount();
            while (resultSet.next()) {
                T t = c.getConstructor().newInstance();
                for (int i = 0; i < columnCount; i++) {
                    BeanUtils.setProperty(t, metaData.getColumnName(i + 1), resultSet.getObject(i + 1));
                }
                list.add(t);
            }
            jdbcUtils.close(connection, prepareStatement, resultSet);
        } catch (SQLException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        return list;
    }

    /**
     * 返回数据以Map<String,Object>形式返回 String表示sql表项(不可重复)，Object表示每个表项对应的值
     * @param sql
     * @param parameters
     * @return
     */
    public static Map<String, Object> queryMap(String sql, Object... parameters) {

        HashMap<String, Object> map = null;
        try {
            Connection connection = jdbcUtils.getConnection();
            PreparedStatement prepareStatement = getPrepareStatement(sql, connection, parameters);
            ResultSet resultSet = prepareStatement.executeQuery();
            ResultSetMetaData metaData = resultSet.getMetaData();
            int columnCount = metaData.getColumnCount();
            //定义一个Map集合
            map = new HashMap<>();
            while (resultSet.next()) {
                for (int i = 0; i < columnCount; i++) {
                    String columnName = metaData.getColumnName(i + 1);
                    Object object = resultSet.getObject(i + 1);
                    map.put(columnName, object);
                }
            }
            jdbcUtils.close(connection, prepareStatement, resultSet);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return map;
    }

    /**
     * 以List<Map<String,Object>>形式返回
     * @param sql
     * @param parameters
     * @return
     */
    public  static ArrayList<Map> queryMapList(String sql,Object...parameters){

        ArrayList<Map> Listmaps = null;
        try {
            Connection connection = jdbcUtils.getConnection();
            PreparedStatement prepareStatement = getPrepareStatement(sql, connection, parameters);
            ResultSet resultSet = prepareStatement.executeQuery();
            ResultSetMetaData metaData = resultSet.getMetaData();
            int columnCount = metaData.getColumnCount();
            //创建list集合，里面的每个元素都是Map集合形式
            Listmaps = new ArrayList<>();
            while (resultSet.next()){
                HashMap<String, Object> maps = new HashMap<>();
                for (int i = 0; i < columnCount; i++) {
                    maps.put(metaData.getColumnName(i + 1), resultSet.getObject(i + 1));
                }
                Listmaps.add(maps);
            }
            jdbcUtils.close(connection, prepareStatement, resultSet);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return Listmaps;
    }

    /**
     * 结果以list<Object[]>形式返回  list集合中元素都是数组
     * @param sql
     * @param parameters 可变参数列表
     * @return
     */
    public static List<Object[]> queryArrayList(String sql,Object...parameters){
        ArrayList<Object[]> ArrayListobjects = null;
        try {
            Connection connection = jdbcUtils.getConnection();
            PreparedStatement prepareStatement = getPrepareStatement(sql, connection, parameters);
            ResultSet resultSet = prepareStatement.executeQuery();
            ResultSetMetaData metaData = resultSet.getMetaData();
            int columnCount = metaData.getColumnCount();
            ArrayListobjects = new ArrayList<>();
            while (resultSet.next()){
                Object[] objs = new Object[columnCount];
                for (int i = 0; i < columnCount; i++) {
                    objs[i] = resultSet.getObject(i + 1);
                }
                ArrayListobjects.add(objs);
            }
            jdbcUtils.close(connection,prepareStatement,resultSet);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return ArrayListobjects;
    }

    /**
     * 功能:结果以数组形式保存并且返回
     * @param sql 查询的sql
     * @param parameters 参数列表
     * @return 返回 Object[]
     */
    public static Object[] queryArray(String sql,Object...parameters){
        Object[] objs = new Object[0];
        try {
            Connection connection = jdbcUtils.getConnection();
            PreparedStatement prepareStatement = getPrepareStatement(sql, connection, parameters);
            ResultSet resultSet = prepareStatement.executeQuery();
            ResultSetMetaData metaData = resultSet.getMetaData();
            int columnCount = metaData.getColumnCount();
            objs = new Object[columnCount];
            while (resultSet.next()){
                for (int i = 0; i < columnCount; i++) {
                    objs[i] = resultSet.getObject(i + 1);
                }
            }
            jdbcUtils.close(connection,prepareStatement,resultSet);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return objs;
    }
    public static void close(Connection connection) {
        try {
            connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public static void close(Connection connection, PreparedStatement preparedStatement) {
        try {
            preparedStatement.close();
            connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public static void close(Connection connection, PreparedStatement preparedStatement, ResultSet resultSet) {
        try {
            resultSet.close();
            preparedStatement.close();
            connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

        Student时javabean，TestReflection是测试的