需求

使用反射来封装对MySQL数据库的增删改查操作，封装更通用的方法。

代码实现

第一步，创建数据库连接。

设置数据库连接参数，获取Connection。注意，改成自己数据库的连接参数。

/**
 * 获取数据库连接的工具类，注意在该类设置数据库连接参数
 */
class JDBCUtil {
    /**
     * 获取数据库连接
     *
     * @return 数据库连接对象
     */
    public static Connection getConnection() {
        Connection connection = null;
        try {
            Class.forName("com.mysql.jdbc.Driver");
            String url = "jdbc:mysql://localhost/test";
            String user = "root";
            String password = "root";
            connection = DriverManager.getConnection(url, user, password);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return connection;
    }
}

第二步，创建BaseMapper接口。

该接口中定义了众多增删改查的默认方法。

public interface BaseMapper<T> {

    // --------------------------------------插入操作------------------------------------------

    /**
     * 向数据库内插入一条记录。
     * 插入SQL语句如例：insert into user(id,username,password,phone,email,memo,insert_time) values(20,'刘三刀','123456','1008611','1008611@','我是一名用户','2021-08-10 21:28:35')
     *
     * @param t 带插入的实体类对象
     * @return 返回受影响行数
     * @throws IllegalAccessException
     * @throws SQLException
     */
    default int insert(T t) throws IllegalAccessException, SQLException {
        // 使用泛型参数，是因为不清楚会传什么实体类，所以使用泛型
        // 获取输入参数t的Class类对象
        Class<?> tClass = t.getClass();
        // 使用StringBuilder来存放SQL语句
        StringBuilder sb = new StringBuilder();
        // 插入SQL语句的头部"insert into "
        sb.append("insert into ");
        // 获取类名，但需要将类名转换成小写，虽然在MySQL中不区分大小写
        sb.append(tClass.getSimpleName().toLowerCase());
        sb.append("(");
        // 获取属性数组，即获取t所表示的实体类中的所有属性，而不是该类中的所有方法
        Field[] fields = tClass.getDeclaredFields();
        int i = 0;
        for (Field field : fields) {
            sb.append(field.getName());// 添加属性名
            sb.append(",");
            i++;
        }
        // 除去最后一个逗号，添加一个右括号
        String s = sb.substring(0, sb.length() - 1) + ")";
        StringBuilder result = new StringBuilder(s);
        result.append(" values(");
        for (int j = 0; j < i; j++) {
            result.append("?,");
        }
        // 到这一步，一个完整的SQL语句完成了，只是没有传入参数
        // 例如：insert into user(phone,username,insert_time,email,memo,id,password) values(?,?,?,?,?,?,?)
        String sql = result.substring(0, result.length() - 1) + ")";

        // 接下来就是进行插入操作
        // 获取数据库连接
        Connection connection = JDBCUtil.getConnection();
        // 根据Connection创建PreparedStatement对象
        PreparedStatement ps = connection.prepareStatement(sql);
        // 该参数表示是第几个待传入的参数，在PreparedStatement类中设置参数对应值的方法的序号是从1开始的
        int j = 1;
        for (Field field : fields) {
            field.setAccessible(true);
            ps.setObject(j, field.get(t));
            j++;
        }
        // 可以打印完整的SQL语句
        System.out.println(ps);
        // 执行SQL插入操作
        return ps.executeUpdate();
    }

    // --------------------------------------更新操作------------------------------------------

    /**
     * 通过id字段更新记录
     * SQL语句如：update user set username='王五' where id=6;
     *
     * @param t 待更新的信息，都是封装在实体类中的，包括id信息
     * @return 返回受影响行数
     */
    default int updateById(T t) throws SQLException, IllegalAccessException {
        // 1.获取字段
        // 获取t所表示类的Class对象
        Class<?> tClass = t.getClass();
        // 获取该类的所有属性
        Field[] fields = tClass.getDeclaredFields();
        // 过滤掉空值的字段
        // 将Field数组转换成Field流
        Stream<Field> stream = Arrays.stream(fields);
        // 过滤掉空属性，因为待更新的字段必须是有值的属性
        Stream<Field> fieldStream = stream.filter((field) -> {
            field.setAccessible(true);
            try {
                // 只保留不为空的字段
                return field.get(t) != null;
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
            return false;
        });

        // 2.组装SQL语句
        StringBuilder sb = new StringBuilder();
        sb.append("update ");
        sb.append(tClass.getSimpleName().toLowerCase());// 表名
        sb.append(" set ");
        // 循环遍历要更新的字段
        List<Field> fieldList = new ArrayList<>();
        fieldStream.forEach((field -> {
            // 将字段添加到List集合中
            fieldList.add(field);
            if (!"id".equals(field.getName())) {
                sb.append(field.getName().toLowerCase());
                sb.append("=");
                sb.append("?");
                sb.append(",");
            }
        }));
        // 去除最后一个逗号","
        String where = sb.substring(0, sb.length() - 1);
        // 设置where后面的条件子句，即"where id=?;"
        StringBuilder sql = new StringBuilder(where);
        sql.append(" where ");
        sql.append("id=?;");
        String updateSql = sql.toString();

        // 3.执行SQL语句返回结果
        Connection connection = JDBCUtil.getConnection();
        PreparedStatement ps = connection.prepareStatement(updateSql);
        // 调用PreparedStatement类的setObject()方法的参数序号，从1开始
        int parameterIndex = 1;
        // id字段对应的值
        Object id = -1;
        for (Field field : fieldList) {
            if (!"id".equals(field.getName())) {
                field.setAccessible(true);
                ps.setObject(parameterIndex, field.get(t));
                parameterIndex++;
            } else {
                // 将id字段的值保存到局部变量中
                id = field.get(t);
            }
        }
        // 设置id字段的值，即最后一个问号的值
        ps.setObject(parameterIndex, id);
        System.out.println(ps);
        // 执行更新操作，返回受影响行数
        return ps.executeUpdate();
    }

    /**
     * 通过条件查询更新记录。
     * SQL语句如：update user set username='李四',password='abcd' where id=23 and username='王五' and email='10086@';
     *
     * @param t          待更新的信息
     * @param conditions where子句后面的条件
     * @return 返回受影响的行数
     * @throws SQLException
     * @throws IllegalAccessException
     */
    default int update(T t, Map<String, Object> conditions) throws SQLException, IllegalAccessException {
        // 1.获取字段
        // 获取t所表示类的Class对象
        Class<?> tClass = t.getClass();
        // 获取该类的所有属性
        Field[] fields = tClass.getDeclaredFields();
        // 过滤掉空值的字段
        // 将Field数组转换成Field流
        Stream<Field> stream = Arrays.stream(fields);
        // 过滤掉空属性，因为待更新的字段必须是有值的属性
        Stream<Field> fieldStream = stream.filter((field) -> {
            field.setAccessible(true);
            try {
                // 只保留不为空的字段
                // 注意：如果是基本数据类型如int，那么会有一个默认值，会通过!=null判断，导致出现问题
                // 所以在实体类中尽量使用引用数据类型，而不是基本数据类型
                return field.get(t) != null;
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
            return false;
        });

        // 2.组装SQL语句
        StringBuilder sb = new StringBuilder();
        sb.append("update ");
        sb.append(tClass.getSimpleName().toLowerCase());// 表名
        sb.append(" set ");
        // 循环遍历要更新的字段
        List<Field> fieldList = new ArrayList<>();
        fieldStream.forEach((field -> {
            // 将字段添加到List集合中
            fieldList.add(field);
            sb.append(field.getName().toLowerCase());
            sb.append("=");
            sb.append("?");
            sb.append(",");
        }));
        // 去除最后一个逗号","
        String where = sb.substring(0, sb.length() - 1);
        // 设置where后面的条件子句，即"where username='xxx' and password='xxx';"
        StringBuilder sql = new StringBuilder(where);
        sql.append(" where ");
        for (String key : conditions.keySet()) {
            sql.append(key);
            sql.append("=?");
            sql.append(" and ");
        }
        String updateSql = sql.substring(0, sql.lastIndexOf("and"));

        // 3.执行SQL语句返回结果
        Connection connection = JDBCUtil.getConnection();
        PreparedStatement ps = connection.prepareStatement(updateSql);
        // 调用PreparedStatement类的setObject()方法的参数序号，从1开始
        int parameterIndex = 1;
        // 设置set子句后面的参数
        for (Field field : fieldList) {
            field.setAccessible(true);
            ps.setObject(parameterIndex, field.get(t));
            parameterIndex++;
        }
        // 设置where子句后面的参数
        for (String key : conditions.keySet()) {
            ps.setObject(parameterIndex, conditions.get(key));
            parameterIndex++;
        }
        System.out.println(ps);
        // 执行更新操作，返回受影响行数
        return ps.executeUpdate();
    }

    // --------------------------------------删除操作------------------------------------------

    /**
     * 通过id字段删除某条记录。
     * SQL语句如：delete from user where id=2;
     *
     * @param clazz 实体类，如User.class
     * @param id    待删除的id字段值
     * @return 返回受影响行数
     * @throws SQLException
     */
    default int deleteById(Class<?> clazz, Serializable id) throws SQLException {
        // 1.拼接SQL语句
        StringBuilder sql = new StringBuilder();
        sql.append("delete from ");
        sql.append(clazz.getSimpleName().toLowerCase());
        sql.append(" where ");
        sql.append("id=?;");
        String deleteSql = sql.toString();

        // 2.执行SQL语句
        Connection connection = JDBCUtil.getConnection();
        PreparedStatement ps = connection.prepareStatement(deleteSql);
        ps.setObject(1, id);
        return ps.executeUpdate();
    }

    /**
     * 多条件删除。
     * SQL语句如：delete from user where username='zhangsan' and password='123456';
     *
     * @param clazz      实体类，如User.class
     * @param conditions where子句后面跟着的条件
     * @return 返回受影响行数
     * @throws SQLException
     */
    default int deleteByMap(Class<?> clazz, Map<String, Object> conditions) throws SQLException {
        // 1.拼接SQL语句
        StringBuilder sql = new StringBuilder();
        sql.append("delete from ");
        sql.append(clazz.getSimpleName().toLowerCase());
        sql.append(" where ");
        // 从conditions集合中读取条件参数
        for (String key : conditions.keySet()) {
            sql.append(key);
            sql.append("=");
            sql.append("?");
            sql.append(" and ");
        }
        String deleteSql = sql.substring(0, sql.lastIndexOf("and"));

        // 2.执行SQL语句
        Connection connection = JDBCUtil.getConnection();
        PreparedStatement ps = connection.prepareStatement(deleteSql);
        int parameterIndex = 1;
        for (String key : conditions.keySet()) {
            ps.setObject(parameterIndex, conditions.get(key));
            parameterIndex++;
        }
        return ps.executeUpdate();
    }

    /**
     * 根据实体类中的字段进行条件删除。
     * SQL语句如：delete from user where username='zhangsan' and password='123456';
     *
     * @param t 实体类对象
     * @return 返回受影响行数
     * @throws SQLException
     * @throws IllegalAccessException
     */
    default int delete(T t) throws SQLException, IllegalAccessException {
        // 1.获取条件字段，过滤掉空字段
        Field[] fields = t.getClass().getDeclaredFields();
        // 使用Stream流进行初步过滤
        Stream<Field> stream = Arrays.stream(fields);
        Stream<Field> fieldStream = stream.filter((field -> {
            field.setAccessible(true);
            try {
                // 只保留设置了值的字段
                return field.get(t) != null;
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
            return false;
        }));

        // 2.组装SQL语句
        StringBuilder sql = new StringBuilder();
        sql.append("delete from ");
        sql.append(t.getClass().getSimpleName().toLowerCase());
        sql.append(" where ");
        List<Field> fieldList = new ArrayList<>();
        fieldStream.forEach((field -> {
            fieldList.add(field);
            field.setAccessible(true);
            sql.append(field.getName().toLowerCase());
            sql.append("=");
            sql.append("?");
            sql.append(" and ");
        }));
        String deleteSql = sql.substring(0, sql.lastIndexOf("and"));

        // 3.执行SQL语句，返回删除结果
        Connection connection = JDBCUtil.getConnection();
        PreparedStatement ps = connection.prepareStatement(deleteSql);
        int parameterIndex = 1;
        for (Field field : fieldList) {
            ps.setObject(parameterIndex, field.get(t));
            parameterIndex++;
        }
        return ps.executeUpdate();
    }

    // --------------------------------------查询操作------------------------------------------

    /**
     * 通过id查询某条记录。
     * SQL语句如：select * from user where id=2;
     *
     * @param clazz 实体类，如User.class
     * @param id    主键id
     * @return 返回查询结果
     * @throws SQLException
     * @throws InstantiationException
     * @throws IllegalAccessException
     * @throws InvocationTargetException
     */
    default T selectById(Class<?> clazz, Serializable id) throws SQLException, InstantiationException, IllegalAccessException, InvocationTargetException {
        // 1.组装SQL语句
        StringBuilder sql = new StringBuilder();
        sql.append("select * from ");
        sql.append(clazz.getSimpleName().toLowerCase());
        sql.append(" where id=?");
        String selectSql = sql.toString();

        // 2.执行SQL语句获取查询结果集
        Connection connection = JDBCUtil.getConnection();
        PreparedStatement ps = connection.prepareStatement(selectSql);
        ps.setObject(1, id);
        ResultSet rs = ps.executeQuery();

        // 3.封装查询结果集到实体类对象中并返回
        // 利用反射创建实例对象
        Object t = clazz.newInstance();
        Method[] methods = t.getClass().getDeclaredMethods();
        if (rs.next()) {
            // 循环遍历方法数组，将数据封装到实体类对象中
            for (Method method : methods) {
                // 过滤setXXX方法，设置属性的值
                if (method.getName().startsWith("set")) {
                    // 设置属性的值，通过rs.getObject(String columnLabel)方法获取指定列的值
                    method.invoke(t, rs.getObject(method.getName().substring(3)));
                }
            }
        }
        // 如果还有下一条记录，表示查询结果有多个，那么不应该
        if (rs.next()) {
            throw new IllegalArgumentException("查询结果有多个，请输入合法参数：" + id);
        }
        return (T) t;
    }

    /**
     * 通过批量id查询多条记录。
     * SQL语句如：select * from user where id in (1,2,3,4,5);
     *
     * @param clazz  实体类，如User.class
     * @param idList 主键id列表
     * @return 返回查询结果集
     * @throws SQLException
     * @throws InstantiationException
     * @throws IllegalAccessException
     * @throws InvocationTargetException
     */
    default List<T> selectBatchIds(Class<?> clazz, List<? extends Serializable> idList) throws SQLException, InstantiationException, IllegalAccessException, InvocationTargetException {
        // 1.组装SQL语句
        StringBuilder sql = new StringBuilder();
        sql.append("select * from ");
        sql.append(clazz.getSimpleName().toLowerCase());
        sql.append(" where id in(");
        for (int i = 0; i < idList.size(); i++) {
            sql.append("?");
            if (i != idList.size() - 1) {
                sql.append(",");
            }
        }
        sql.append(")");
        String selectSql = sql.toString();

        // 2.执行SQL语句获取查询结果集
        Connection connection = JDBCUtil.getConnection();
        PreparedStatement ps = connection.prepareStatement(selectSql);
        int parameterIndex = 1;
        for (Serializable id : idList) {
            ps.setObject(parameterIndex, id);
            parameterIndex++;
        }
        ResultSet rs = ps.executeQuery();

        // 3.封装查询结果集到实体类对象中并返回
        List<T> tList = new ArrayList<>();
        while (rs.next()) {
            // 利用反射创建实例对象
            Object t = clazz.newInstance();
            // 获取该类的所有声明的方法
            Method[] methods = t.getClass().getDeclaredMethods();
            // 循环遍历方法数组，将数据封装到实体类对象中
            for (Method method : methods) {
                // 过滤setXXX方法，设置属性的值
                if (method.getName().startsWith("set")) {
                    // 设置属性的值，通过rs.getObject(String columnLabel)方法获取指定列的值
                    method.invoke(t, rs.getObject(method.getName().substring(3)));
                }
            }
            tList.add((T) t);
        }
        return tList;
    }

    /**
     * 多条件查询唯一一条记录。
     * SQL语句如：select * from user where username='zhangsan' and password='123456';
     *
     * @param clazz      实体类，如User.class
     * @param conditions where子句后面的条件集合
     * @return 返回查询结果
     * @throws SQLException
     * @throws InstantiationException
     * @throws IllegalAccessException
     * @throws InvocationTargetException
     */
    default T selectOne(Class<?> clazz, Map<String, Object> conditions) throws SQLException, InstantiationException, IllegalAccessException, InvocationTargetException {
        // 1.组装SQL语句
        StringBuilder sql = new StringBuilder();
        sql.append("select * from ");
        sql.append(clazz.getSimpleName().toLowerCase());
        // where子句后面的条件
        sql.append(" where ");
        for (String key : conditions.keySet()) {
            sql.append(key);
            sql.append("=");
            sql.append("?");
            sql.append(" and ");
        }
        String selectSql = sql.substring(0, sql.lastIndexOf("and"));

        // 2.执行SQL语句获取查询结果集
        Connection connection = JDBCUtil.getConnection();
        PreparedStatement ps = connection.prepareStatement(selectSql);
        int parameterIndex = 1;
        for (String key : conditions.keySet()) {
            ps.setObject(parameterIndex, conditions.get(key));
            parameterIndex++;
        }
        ResultSet rs = ps.executeQuery();

        // 3.封装查询结果集到实体类对象中并返回
        // 利用反射创建实例对象
        Object t = clazz.newInstance();
        Method[] methods = t.getClass().getDeclaredMethods();
        if (rs.next()) {
            // 循环遍历方法数组，将数据封装到实体类对象中
            for (Method method : methods) {
                // 过滤setXXX方法，设置属性的值
                if (method.getName().startsWith("set")) {
                    // 设置属性的值，通过rs.getObject(String columnLabel)方法获取指定列的值
                    method.invoke(t, rs.getObject(method.getName().substring(3)));
                }
            }
        }
        // 如果还有下一条记录，表示查询结果有多个，那么不应该
        if (rs.next()) {
            throw new IllegalArgumentException("查询结果有多个，请输入合法参数。");
        }
        return (T) t;
    }

    /**
     * 指定条件下的记录总条数。
     * SQL语句如：select count(*) from user where password='123456';
     *
     * @param clazz      实体类，如User.class
     * @param conditions where子句后面的条件集合
     * @return 返回记录总条数
     * @throws SQLException
     * @throws InstantiationException
     * @throws IllegalAccessException
     * @throws InvocationTargetException
     */
    default Integer selectCount(Class<?> clazz, Map<String, Object> conditions) throws SQLException, InstantiationException, IllegalAccessException, InvocationTargetException {
        // 1.组装SQL语句
        StringBuilder sql = new StringBuilder();
        sql.append("select count(*) from ");
        sql.append(clazz.getSimpleName().toLowerCase());
        // where子句后面的条件
        sql.append(" where ");
        for (String key : conditions.keySet()) {
            sql.append(key);
            sql.append("=");
            sql.append("?");
            sql.append(" and ");
        }
        String selectSql = sql.substring(0, sql.lastIndexOf("and"));

        // 2.执行SQL语句获取查询结果集
        Connection connection = JDBCUtil.getConnection();
        PreparedStatement ps = connection.prepareStatement(selectSql);
        int parameterIndex = 1;
        for (String key : conditions.keySet()) {
            ps.setObject(parameterIndex, conditions.get(key));
            parameterIndex++;
        }
        ResultSet rs = ps.executeQuery();

        // 3.封装查询结果集到实体类对象中并返回
        // 记录的总条数
        int count = 0;
        if (rs.next()) {
            count = rs.getInt(1);
        }
        return count;
    }

    /**
     * 多条件下查询多条记录。
     * SQL语句如下：select * from user where username='zhangsan' and password='123456';
     *
     * @param clazz      实体类，如User.class
     * @param conditions where子句后面的条件集合
     * @return 返回查询结果集
     * @throws SQLException
     * @throws InstantiationException
     * @throws IllegalAccessException
     * @throws InvocationTargetException
     */
    default List<T> selectList(Class<?> clazz, Map<String, Object> conditions) throws SQLException, InstantiationException, IllegalAccessException, InvocationTargetException {
        // 1.组装SQL语句
        StringBuilder sql = new StringBuilder();
        sql.append("select * from ");
        sql.append(clazz.getSimpleName().toLowerCase());
        // where子句后面的条件
        sql.append(" where ");
        for (String key : conditions.keySet()) {
            sql.append(key);
            sql.append("=");
            sql.append("?");
            sql.append(" and ");
        }
        String selectSql = sql.substring(0, sql.lastIndexOf("and"));

        // 2.执行SQL语句获取查询结果集
        Connection connection = JDBCUtil.getConnection();
        PreparedStatement ps = connection.prepareStatement(selectSql);
        int parameterIndex = 1;
        for (String key : conditions.keySet()) {
            ps.setObject(parameterIndex, conditions.get(key));
            parameterIndex++;
        }
        ResultSet rs = ps.executeQuery();

        // 3.封装查询结果集到实体类对象中并返回
        List<T> tList = new ArrayList<>();
        while (rs.next()) {
            // 利用反射创建实例对象
            Object t = clazz.newInstance();
            Method[] methods = t.getClass().getDeclaredMethods();
            // 循环遍历方法数组，将数据封装到实体类对象中
            for (Method method : methods) {
                // 过滤setXXX方法，设置属性的值
                if (method.getName().startsWith("set")) {
                    // 设置属性的值，通过rs.getObject(String columnLabel)方法获取指定列的值
                    method.invoke(t, rs.getObject(method.getName().substring(3)));
                }
            }
            tList.add((T) t);
        }
        return tList;
    }

    /**
     * 多条件下分页查询多条记录。
     * SQL语句如下：select * from user where username='zhangsan' limit 0,5;
     *
     * @param clazz      实体类，如User.class
     * @param limit      分页查询中的起始索引，从0开始
     * @param size       该页条数
     * @param conditions where子句后面的条件集合
     * @return 返回查询结果集
     * @throws SQLException
     * @throws InstantiationException
     * @throws IllegalAccessException
     * @throws InvocationTargetException
     */
    default List<T> selectPage(Class<?> clazz, int limit, int size, Map<String, Object> conditions) throws SQLException, InstantiationException, IllegalAccessException, InvocationTargetException {
        // 1.组装SQL语句
        StringBuilder sql = new StringBuilder();
        sql.append("select * from ");
        sql.append(clazz.getSimpleName().toLowerCase());
        // where子句后面的条件，注意处理空条件的问题
        sql.append(" where ");
        for (String key : conditions.keySet()) {
            sql.append(key);
            sql.append("=");
            sql.append("?");
            sql.append(" and ");
        }
        String selectSql = sql.substring(0, sql.lastIndexOf("and"));
        selectSql = selectSql + " limit " + limit + "," + size;

        // 2.执行SQL语句获取查询结果集
        Connection connection = JDBCUtil.getConnection();
        PreparedStatement ps = connection.prepareStatement(selectSql);
        int parameterIndex = 1;
        for (String key : conditions.keySet()) {
            ps.setObject(parameterIndex, conditions.get(key));
            parameterIndex++;
        }
        ResultSet rs = ps.executeQuery();

        // 3.封装查询结果集到实体类对象中并返回
        List<T> tList = new ArrayList<>();
        while (rs.next()) {
            // 利用反射创建实例对象
            Object t = clazz.newInstance();
            Method[] methods = t.getClass().getDeclaredMethods();
            // 循环遍历方法数组，将数据封装到实体类对象中
            for (Method method : methods) {
                // 过滤setXXX方法，设置属性的值
                if (method.getName().startsWith("set")) {
                    // 设置属性的值，通过rs.getObject(String columnLabel)方法获取指定列的值
                    method.invoke(t, rs.getObject(method.getName().substring(3)));
                }
            }
            tList.add((T) t);
        }
        return tList;
    }

    /**
     * 查询该表的所有记录。
     * SQL语句如下：select * from user;
     *
     * @param tClass 实体类，如User.class
     * @return 返回查询结果集
     * @throws SQLException
     * @throws InstantiationException
     * @throws IllegalAccessException
     * @throws InvocationTargetException
     */
    default List<T> selectAll(Class<T> tClass) throws SQLException, InstantiationException, IllegalAccessException, InvocationTargetException {
        // 设置查询所有记录的SQL语句
        String sql = "select * from " + tClass.getSimpleName().toLowerCase();
        // 创建存放结果的集合
        List<T> lists = new ArrayList<>();
        // 获取数据库连接并创建PreparedStatement对象，执行查询操作获取结果集
        Connection connection = JDBCUtil.getConnection();
        PreparedStatement ps = connection.prepareStatement(sql);
        ResultSet rs = ps.executeQuery();
        while (rs.next()) {
            // 根据实体类创建实例对象
            T t = tClass.newInstance();
            // 获取t所表示的实体类的所有方法，其实主要是获取setXXX方法，设置属性的值
            Method[] methods = t.getClass().getDeclaredMethods();
            // 循环遍历方法数组
            for (Method method : methods) {
                // 过滤setXXX方法，设置属性的值
                if (method.getName().startsWith("set")) {
                    // 设置属性的值，通过rs.getObject(String columnLabel)方法获取指定列的值
                    method.invoke(t, rs.getObject(method.getName().substring(3)));
                }
            }
            // 将设置成功的实例对象添加到集合中
            lists.add(t);
        }
        return lists;
    }

}

第三步，创建对应实体类。

创建对应的实体类，该类中的属性名和对应表中的字段名一一对应，注意属性名和字段名必须完全对应，不能将下划线转换成驼峰命名。

class User {
    private Long id;
    private String username;
    private String password;
    private String phone;
    private String email;
    private String memo;
    private java.util.Date insert_time;

    public User() {
    }

    public User(String username, String password, String phone, String email, String memo, java.util.Date insert_time) {
        this.username = username;
        this.password = password;
        this.phone = phone;
         = email;
        this.memo = memo;
        this.insert_time = insert_time;
    }

    public User(Long id, String username, String password, String phone, String email, String memo, java.util.Date insert_time) {
        this.id = id;
        this.username = username;
        this.password = password;
        this.phone = phone;
         = email;
        this.memo = memo;
        this.insert_time = insert_time;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
         = email;
    }

    public String getMemo() {
        return memo;
    }

    public void setMemo(String memo) {
        this.memo = memo;
    }

    public java.util.Date getInsert_time() {
        return insert_time;
    }

    public void setInsert_time(Date insert_time) {
        this.insert_time = insert_time;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", phone='" + phone + '\'' +
                ", email='" + email + '\'' +
                ", memo='" + memo + '\'' +
                ", insert_time=" + insert_time +
                '}';
    }
}

第四步，创建UserMapper类实现BaseMapper<User>接口。

由于定义了默认方法，所以只需要实现BaseMapper接口，不需要自定义任何方法。

class UserMapper implements BaseMapper<User> {

}

第五步，测试方法。

class Test {
    public static void main(String[] args) throws SQLException, IllegalAccessException, InvocationTargetException, InstantiationException {
        UserMapper userMapper = new UserMapper();
        Map<String, Object> map = new HashMap<>();
        map.put("username", "张三");
        map.put("password", "123456");
        System.out.println(userMapper.selectPage(User.class, 2, 4, map));
    }
}

存在的问题

上面封装的BaseMapper<T>接口实际上是存在很多问题的，很难在实际中使用。下面列举些常见的问题：

• 1.属性名和字段名必须一模一样。
• 2.主键id字段的插入字段存在问题。
• 3.conditions条件必须匹配，即至少存在一个条件。
• 4.只能处理相等的条件，不能处理更复杂的条件查询如大于条件等。
• 5.实体类中的属性名必须是使用引用数据类型，否则可能会引发异常。