手写简易的Mybatis

亦凉 2024-04-17 16:58 134阅读 0赞

# 手写简易的Mybatis #

--------------------

此篇文章用来记录今天花个五个小时写出来的简易版mybatis，主要实现了基于注解方式的增删查改，目前支持List，Object类型的查找，参数都是基于Map集合的，可以先看一下接口：

public interface StudentInterface { 
    
        @Select(value = " select * from student where age > #{age}")
        List<StudentMeBatis> getList(Map<String, Object> map);
    
        @Select(value = " select * from student where age = #{age}")
        StudentMeBatis get(Map<String, Object> map);
    
        @Insert(value = " insert into student values (#{age}, #{name}, #{year})")
        boolean insert (Map<String, Object> map);
    
        @Delete(value = " delete from student where name = #{name} ")
        boolean delete (Map<String, Object> map);
    
        @Update(value = " update student set age = #{age}, year = #{year} where name = #{name} ")
        boolean update (Map<String, Object> map);
    }

测试效果：

public static void main(String[] args){ 
    
        StudentInterface studentInterface = MapperProxyUtil.newProxyInstance(StudentInterface.class);
        Map<String, Object> params = new HashMap<>();
        params.put("age",  15);
        params.put("name", 15);
        params.put("year", 1996);
        System.out.println(studentInterface.getList(params));
        System.out.println(studentInterface.get(params));
        System.out.println(studentInterface.insert(params));
    }
    
    
    响应数据：
    2019-08-29 00:24:57.311 DEBUG [main] mebatis.sqlsession.DBUtil (55) getConnection - Connection is ready. consume time is: 132ms
    2019-08-29 00:24:57.335 INFO  [main] mebatis.sqlsession.SqlRunner (102) select - SQL Execute successful, sql is:  select * from student where age > ?, params is: [15]
    [Student{ age='22', name='张三', year='1996'}, Student{ age='19', name='李四', year='1998'}]
    2019-08-29 00:24:57.387 INFO  [main] mebatis.sqlsession.SqlRunner (102) select - SQL Execute successful, sql is:  select * from student where age = ?, params is: [15]
    Student{ age='15', name='15', year='1996'}
    2019-08-29 00:24:57.391 INFO  [main] mebatis.sqlsession.SqlRunner (119) baseMethod - SQL Execute successful, sql is:  insert into student values (?, ?, ?), params is: [15, 15, 1996], result is: true
    true

> 必要知识储备：
> 
> 1.  基于Java的Mysql应用 -> JDBC
> 2.  JDK 动态代理技术
> 3.  Java 自定义注解的使用
> 4.  Java 正则表达式
> 5.  Java 反射相关知识
> 6.  FastJson

先来梳理结构，如果我们想做一个类似mybatis，基于注解实现的增删查改，需要有哪些步骤呢？

第一步：肯定需要增删查改四个注解

第二步：接口是没有方法体，无法执行的，我们怎么让它可以执行呢？动态代理技术，即第二步的核心就是让接口可以被代理

第三步：接口代理之后，可以拿到一个个方法的注解，拿到里面的value 和 方法参数，但是如何把参数和sql合起来呢，毕竟什么\#\{name\} 什么的，sql是不认的，因此我们需要根据sql字符串（包含特殊字符），和方法的参数进行解析构建最终的执行语句

第四步：语句拿到了，参数拿到了，也可以执行了，怎么确定返回结果呢？这时候需要对方法的返回值做一个处理，拿到方法的返回结果，根据其返回值动态的构建到底是什么类型的返回结果，通过JDBC和FastJson去处理类型

第五步：万事俱备，只欠东风，构建最终的执行单元，去执行即可，到了这一步基本就是水到渠成（其实到第三步的时候所有思路就已经很清晰了）

## 第一步：构建注解 ##

@Documented
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.METHOD)
    public @interface Select { 
        // sql
        String value();
    }

## 第二步：代理接口 ##

/** * ****************************** * author： 柯贤铭 * createTime: 2019/8/28 10:31 * description: MapperProxyUtil 核心代理类 * version: V1.0 * ****************************** */
    public class MapperProxyUtil implements InvocationHandler { 
    
        /** * 代理指定的接口 * @param tClass 接口class * @param <T> 接口类型 */
        public static  <T> T newProxyInstance(Class<T> tClass) { 
            return ProxyUtil.newProxyInstance(new MapperProxyUtil(), tClass);
        }
    
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
    
            // 获取CRUD方法对应的基本SQL及参数,返回结果 (初始化版本)
            AnotationMsg detail = AnotationUtil.getAnotationDetail(method, args, method.getGenericReturnType());
    
            // sql 解析,参数替换等 -> SQL | PARAMS | RESULT_TYPE (可运行版本)
            SqlFactoryUtil.Runner sqlRunner = SqlFactoryUtil.executeRunner(detail);
    
            // 返回执行结果
            return SqlRunner.execute(sqlRunner);
        }
    }
    
    // 调用
    StudentInterface studentInterface = MapperProxyUtil.newProxyInstance(StudentInterface.class);

## 第三步：解析原始SQL及参数 ##

public class SqlFactoryUtil { 
    
        // 组装最终执行单元 -> SQL | PARAMS | RESULT_TYPE
        //******************************************************
        // SQL -> "SQL";
        // PARAMS -> "PARAMS";
        // RESULT_TYPE -> "RESULT_TYPE";
        //******************************************************
    
        /***
         * 生成执行单元
         */
        public static Runner executeRunner (AnotationMsg anotationMsg) throws MapperExeception { 
            if (anotationMsg == null || StringUtils.isBlank(anotationMsg.getSql()) || anotationMsg.getMap() == null) { 
                throw MapperExeception.errorSql(" -> " + anotationMsg);
            }
    
            // 参数集合
            List<Object> params = new ArrayList<>();
    
            // 转换参数 - 获取值
            Pattern p = Pattern.compile("#\\{.+?}");
            Matcher m = p.matcher(anotationMsg.getSql());
            while(m.find()){ 
                String key = m.group();
                key = key.replaceAll("#\\{", "");
                key = key.replaceAll("}", "");
    
                if (!anotationMsg.getMap().containsKey(key)) { 
                    throw MapperExeception.errorParams("do not have key -> " + key);
                }
    
                // 添加参数
                params.add(anotationMsg.getMap().get(key));
            }
    
            // 执行sql
            String finalSQL = m.replaceAll("?");
    
            // 返回 runner
            Runner result = new Runner();
            result.setSql(finalSQL);
            result.setParams(params);
            result.setResultType(anotationMsg.getResultType());
            return result;
        }
    
        public static class Runner { 
            // 执行sql
            private String       sql;
    
            // 参数
            private List<Object> params;
    
            // 返回参数
            private Type         resultType;
    
            public String getSql() { 
                return sql;
            }
    
            public void setSql(String sql) { 
                this.sql = sql;
            }
    
            public List<Object> getParams() { 
                return params;
            }
    
            public void setParams(List<Object> params) { 
                this.params = params;
            }
    
            public Type getResultType() { 
                return resultType;
            }
    
            public void setResultType(Type resultType) { 
                this.resultType = resultType;
            }
    
            @Override
            public String toString() { 
                return "Runner{" +
                        "sql='" + sql + '\'' +
                        ", params=" + params +
                        ", resultType=" + resultType +
                        '}';
            }
        }
    }

## 第四步：执行JDBC ##

public static Object execute(SqlFactoryUtil.Runner runner) throws Exception { 
        // 返回值类型
        Type resultType = runner.getResultType();
    
        // 返回值类型为 boolean
        if (resultType.getTypeName().toLowerCase().equals(BOOLEAN)) { 
            return baseMethod(runner.getSql(), runner.getParams());
        }
    
        // 查询类型需要特殊处理
        ResultSet resultSet = select(runner.getSql(), runner.getParams());
    
        // 返回值
        Class type = getResultType(resultType);
    
        if (resultType.getTypeName().contains("java.util.List")) { 
            return listHandle(resultSet, type);
        }
    
        return beanHandle(resultSet, type);
    }

## 第五步：根据返回值类型构建最终结果 ##

/*** * List 类型handle * @param resultSet resultSet * @param resultType 返回值类型 * @return List * @throws SQLException SQLException */
    private static List listHandle (ResultSet resultSet, Class resultType) throws SQLException { 
    
        // 返回结果
        List result = new ArrayList();
    
        ResultSetMetaData metaData = resultSet.getMetaData();
        int columnCount = metaData.getColumnCount();
        String[] columnNames = new String[columnCount];
        for (int i = 0; i < columnCount; i++) { 
            columnNames[i] = metaData.getColumnName(i + 1);
        }
        while (resultSet.next()) { 
            JSONObject object = new JSONObject();
            for (String columnName : columnNames) { 
                Object columnValue = resultSet.getObject(columnName);
                object.put(columnName, columnValue);
            }
    
            result.add(object.toJavaObject(resultType));
        }
        return result;
    }

> 总结：以上代码都是按照此思路截取的一部分，其实按照思路来，自己攻略到第二步，第三步，慢慢的就都摸清了，关键就是如何让接口被代理，剩下的都是水到渠成，遇到一个问题解决一个问题即可.
> 
> 全部代码可见GitHub：https://github.com/kkzhilu/KerwinTools/tree/master/src/main/java/mebatis