手写mybatis - 2 源码解析

迷南。 2022-02-15 04:57 279阅读 0赞

# 手写mybatis - 2 源码解析 #

### 文章目录 ###

*  手写mybatis - 2 源码解析
 *  0 缘起
 *  1 mybatis 核心流程
 *  2 源码分析
 *   *  2.1 SqlSessionFactoryBuilder
     *  2.2 XMLConfigBuilder
     *  2.3 Configuration
     *  2.4 SqlSessionFactory
     *  2.5 SqlSession
     *  2.6 Executor & SimpleExecutor
     *  2.7 DefaultSqlSession
     *  2.8 MapperProxy
     *  2.9 dao 的执行
     *  2.10 SimpleStatementHandler
 *  3 拓展

# 0 缘起 #

> 本文接上文 [手写mybatis - 1 概述&代码][mybatis - 1] , 目的是解释下代码的基本组成, 和设计思想，本文代码基于自己手写的 mybatis , 包结构和类名都和 mybatis 高度相似, 相当于一个mybatis 简化版吧。

# 1 mybatis 核心流程 #

mybatis 核心业务流程其实也蛮简单
    
    1 解析 mybatis 系统配置文件，封装成 Configuration
    2 解析 mapper.xml 封装成 MapperStatement 供后面使用
    3 具体的业务代码，调用 dao 的代理类
    4 参数的映射和处理
    5 根据入参 和 MapperStatement 动态生成 执行的 sql 语句
    6 通过 resulthandle 处理结果集合映射, 并且返回结果集

# 2 源码分析 #

//读取mybatis主配置文件
    InputStream is = Resources.getResourceAsStream("MybatisConfig.xml");
    //创建SqlSessionFactoryBuilder
    SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
    //通过构建者设计模式创建工厂
    SqlSessionFactory factory = builder.build(is);
    //通过工厂模式创建sqlSession
    SqlSession sqlSession = factory.openSession();
    //通过动态代理获取对应mapper
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    //调用方法
    List<User> userList = mapper.getUserList();
    //遍历打印结果集
    for (User user : userList) {
        System.out.println(user);
    }

## 2.1 SqlSessionFactoryBuilder ##

> 负责加载并且解析配置文件 返回 SqlSessionFactory

public class SqlSessionFactoryBuilder {
    
        public SqlSessionFactory build(InputStream inputStream) {
            try {
                XMLConfigBuilder parser = new XMLConfigBuilder(inputStream);
                return build(parser.parse());
            } catch (Exception e) {
                e.printStackTrace();
            }
    
            return null;
        }
    
        public SqlSessionFactory build(Configuration config) {
            return new DefaultSqlSessionFactory(config);
        }
    }

## 2.2 XMLConfigBuilder ##

> 具体的解析逻辑 将输入流解析成 Configuration 供后面使用

public class XMLConfigBuilder {
    
        private InputStream inputStream;
    
        public XMLConfigBuilder(InputStream inputStream) {
            this.inputStream = inputStream;
        }
    
        public Configuration parse() {
            return loadXmlConfiguration(inputStream);
        }
    
        /**
         * 读取主配置文件
         *
         * @param inputStream
         * @return
         */
        public static Configuration loadXmlConfiguration(InputStream inputStream) {
            //使用dom4j和xpath解析主配置文件
            SAXReader reader = new SAXReader();
            Configuration config = new Configuration();
            try {
                //将主配置文件二进制流传入，得到document对象
                Document document = reader.read(inputStream);
                //获取property节点集合（用于生成连接对象的四大参数）
                List<Element> list = document.selectNodes("//property");
                for (Element element : list) {
                    String name = element.attributeValue("name");
                    String value = element.attributeValue("value");
                    if (name.equals("username")) config.setUsername(value);
                    if (name.equals("driver")) config.setDriver(value);
                    if (name.equals("password")) config.setPassword(value);
                    if (name.equals("url")) config.setUrl(value);
                }
                //读取主配置文件下的所有mapper映射文件
                List<Element> listMapper = document.selectNodes("//mapper");
                for (Element element : listMapper) {
                    //遍历每个mapper标签，获取resource属性（mapper映射文件的全限类名）
                    String resource = element.attributeValue("resource");
                    //使用dom4j和xpath解析mapper映射文件
                    Map<String, MappedStatement> loadMapper = loadMapper(resource, config);
                    config.setMappedStatements(loadMapper);
                }
            } catch (Exception e) {
                e.printStackTrace();
                throw new RuntimeException();
            }
            return config;
        }
    
        /**
         * 使用dom4j和xpath解析mapper映射文件
         *
         * @param resource
         * @return
         */
        private static Map<String, MappedStatement> loadMapper(String resource, Configuration config) {
            Map<String, MappedStatement> mappers = new HashMap<String, MappedStatement>();
            //利用类加载器将配置文件转换为二进制流
            InputStream inputStream = Resources.getResourceAsStream(resource);
            SAXReader reader = new SAXReader();
            try {
                Document document = reader.read(inputStream);
                //获取根节点对象
                Element rootElement = document.getRootElement();
                //获取根节点的namespace属性值
                String namespace = rootElement.attributeValue("namespace");
                //获取根节点下所有select节点
                List<Element> selectNodes = rootElement.selectNodes("//select");
                //遍历，获取每个select节点的id、resultType以及sql语句等值
                for (Element selectNode : selectNodes) {
                    String id = selectNode.attributeValue("id");
                    String resultType = selectNode.attributeValue("resultType");
                    SqlSource sqlSource = parseDynamicSqlNode(selectNode);
                    //用一个mapper对象存储以上的值
                    MappedStatement mapper = new MappedStatement();
                    mapper.setConfiguration(config);
                    mapper.setId(id);
                    mapper.setResultType(Class.forName(resultType));
                    mapper.setSqlSource(sqlSource);
                    //一个mapper映射文件可以有多个select（statment），不同映射文件里，select的id可以相同
                    //所以将namespace+"."+id作为唯一标志，用于区分，并存入map集合里
                    mappers.put(namespace + "." + id, mapper);
                }
                return mappers;
            } catch (Exception e) {
                e.printStackTrace();
                throw new RuntimeException();
            }
        }
    
        private static SqlSource parseDynamicSqlNode(Element selectNode) {
            String sql = selectNode.getTextTrim();
            StaticSqlSource staticSqlSource = new StaticSqlSource(sql);
            return staticSqlSource;
        }
    }

## 2.3 Configuration ##

> 具体的配置对象, 主要保存了连接信息 和 解析 mapper.xml 生成 的 mappedStatements 映射

private String username;
    
        private String password;
    
        private String url;
    
        private String driver;
    
        protected ExecutorType defaultExecutorType = ExecutorType.SIMPLE;
    
        protected final InterceptorChain interceptorChain = new InterceptorChain();
    
        protected Map<String, MappedStatement> mappedStatements = new HashMap();
    
        public Executor newExecutor(ExecutorType executorType) {
            executorType = executorType == null ? defaultExecutorType : executorType;
    
            Executor executor = null;
            if (ExecutorType.BATCH == executorType) {
            } else if (ExecutorType.REUSE == executorType) {
            } else {
                executor = new SimpleExecutor(this);
            }
            executor = (Executor) interceptorChain.pluginAll(executor);
            return executor;
        }

## 2.4 SqlSessionFactory ##

> 完成配置解析后要根据 Configuration 对象生成会话工厂, 会话工厂有什么用呢， 说白了 就是不断的开启会话

public class DefaultSqlSessionFactory implements SqlSessionFactory {
    
        private Configuration configuration;
    
        public DefaultSqlSessionFactory(Configuration configuration) {
            this.configuration = configuration;
        }
    
        public Configuration getConfiguration() {
            return configuration;
        }
    
        public void setConfiguration(Configuration configuration) {
            this.configuration = configuration;
        }
    
        @Override
        public SqlSession openSession() {
            return openSessionFromDataSource(configuration.getDefaultExecutorType());
        }
    
        private SqlSession openSessionFromDataSource(ExecutorType execType) {
            try {
                final Executor executor = configuration.newExecutor(execType);
                return new DefaultSqlSession(configuration, executor);
            } catch (Exception e) {
                e.printStackTrace();
            }
    
            return null;
        }
    }
    
    // 会话工厂的接口
    public interface SqlSessionFactory {
    
        SqlSession openSession();
    }

## 2.5 SqlSession ##

> 通过 上面生成的会话工厂 可以开启一个会话

SqlSession sqlSession = factory.openSession();
    
    DefaultSqlSessionFactory
    
    ...
    
     @Override
        public SqlSession openSession() {
            return openSessionFromDataSource(configuration.getDefaultExecutorType());
        }
    
        private SqlSession openSessionFromDataSource(ExecutorType execType) {
            try {
                final Executor executor = configuration.newExecutor(execType);
                return new DefaultSqlSession(configuration, executor);
            } catch (Exception e) {
                e.printStackTrace();
            }
    
            return null;
        }

## 2.6 Executor & SimpleExecutor ##

> 执行器，根据上面的 configuration 对象可以生成对应的执行器, 执行器就是具体干活的，负责根据参数和上面解析 MappedStatement，还有ResultSetHandler，解析sql,处理结果并且返回

public interface Executor {
    
        ResultSetHandler NO_RESULT_HANDLER = null;
    
        <E> List<E> query(MappedStatement ms, Object parameter, ResultSetHandler resultSetHandler) throws SQLException;
        
        ...
    
    }
    
    SimpleExecutor 就是 Executor 的简单实现
    
    public class SimpleExecutor implements Executor {
    
        protected Configuration configuration;
    
        public SimpleExecutor(Configuration configuration) {
            this.configuration = configuration;
        }
    
        @Override
        public <E> List<E> query(MappedStatement mappedStatement, Object parameter, ResultSetHandler resultSetHandler) throws SQLException {
            Statement stmt = null;
            Configuration configuration = mappedStatement.getConfiguration();
            StatementHandler handler = new SimpleStatementHandler(mappedStatement, parameter, resultSetHandler);
            return handler.query(stmt, resultSetHandler);
        }
    }

## 2.7 DefaultSqlSession ##

> 有了 执行器和默认的配置对象 我们可以生成默认的会话了， 会话 其实就是负责 增删该查的， 执行器 其实也是调用的 SqlSession 去执行对应的逻辑

public class DefaultSqlSession implements SqlSession {
    
        private final Configuration configuration;
        private final Executor executor;
    
    
        public DefaultSqlSession(Configuration configuration, Executor executor) {
            this.configuration = configuration;
            this.executor = executor;
        }
    
        @Override
        public <T> T selectOne(String statement) throws RuntimeException {
            return this.<T>selectOne(statement, null);
        }
    
        @Override
        public <T> T selectOne(String statement, Object parameter) throws RuntimeException {
            // Popular vote was to return null on 0 results and throw exception on too many.
            List<T> list = this.<T>selectList(statement, parameter);
            if (list.size() == 1) {
                return list.get(0);
            } else if (list.size() > 1) {
                throw new RuntimeException("Expected one result (or null) to be returned by selectOne(), but found: " + list.size());
            } else {
                return null;
            }
        }
    
        @Override
        public <E> List<E> selectList(String statement, Object parameter) throws RuntimeException {
            try {
                MappedStatement ms = configuration.getMappedStatement(statement);
                return executor.query(ms, parameter, Executor.NO_RESULT_HANDLER);
            } catch (Exception e) {
                throw new RuntimeException("Error querying database.  Cause: " + e);
            }
        }
    
        @Override
        public Configuration getConfiguration() {
            return configuration;
        }
    
        @Override
        public <T> T getMapper(Class<T> clazz){
            try {
                T proxyObj = (T) Proxy.newProxyInstance(clazz.getClassLoader(), new Class[]{clazz}, new MapperProxy(this, clazz));
    
                return proxyObj;
            } catch (Exception e) {
                e.printStackTrace();
            }
    
            return null;
        }
    }

## 2.8 MapperProxy ##

> MapperProxy 就是 mapper 对象的一个代理, 说白了 就是你定义 dao 的接口，用 jdk 动态代理生成的一个代理对象

> //通过动态代理获取对应mapper
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    
    ...
    
     public <T> T getMapper(Class<T> clazz){
            try {
                T proxyObj = (T) Proxy.newProxyInstance(clazz.getClassLoader(), new Class[]{clazz}, new MapperProxy(this, clazz));
    
                return proxyObj;
            } catch (Exception e) {
                e.printStackTrace();
            }
    
            return null;
        }
    
    MapperProxy 其实zu
    
    public class MapperProxy implements InvocationHandler {
        private SqlSession sqlSession;
        private Class mapperInterface;
    
        public MapperProxy(SqlSession sqlSession, Class mapperInterface) {
            this.sqlSession = sqlSession;
            this.mapperInterface = mapperInterface;
        }
    
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            //如果返回值是一个List集合才执行如下代码
            Class<?> returnType = method.getReturnType();
            if (returnType == List.class) {
                //代理对象调用任何方法，都会在这执行
                //真正执行Sql语句
                //执行Sql语句的工作:sqlSession对象的selectList(),也就是说咱在这要调用那个方法
                //key是"Mapper接口的全限定名"+"."+方法名
                String methodName = method.getName();//方法名
                Class<?> clazz = method.getDeclaringClass();
                String clazzName = clazz.getName();//获取接口的全限定名
                String key = clazzName + "." + methodName;
                List<Object> list = sqlSession.selectList(key, args);
                return list;
            }else {
                return null;
            }
        }

## 2.9 dao 的执行 ##

> dao方法调用的时候 其实执行的是代理对象的 invoke 方法

//调用方法
    List<User> userList = mapper.getUserList();
    
    --> MapperProxy --> invoke
    
    --> sqlSession-->selectList
    
    DefaultSqlSession
    
    ...
    
    @Override
        public <E> List<E> selectList(String statement, Object parameter) throws RuntimeException {
            try {
                MappedStatement ms = configuration.getMappedStatement(statement);
                return executor.query(ms, parameter, Executor.NO_RESULT_HANDLER);
            } catch (Exception e) {
                throw new RuntimeException("Error querying database.  Cause: " + e);
            }
        }
        
    我们看看 executor 的 query
    
    SimpleExecutor
    
    ...
    
    @Override
        public <E> List<E> query(MappedStatement mappedStatement, Object parameter, ResultSetHandler resultSetHandler) throws SQLException {
            Statement stmt = null;
            Configuration configuration = mappedStatement.getConfiguration();
            StatementHandler handler = new SimpleStatementHandler(mappedStatement, parameter, resultSetHandler);
            return handler.query(stmt, resultSetHandler);
        }
    
    StatementHandler
    
    看了这么久终于看到原生 jdbc 的东西了。
    
    ...
    
    public class SimpleStatementHandler implements StatementHandler {
    
        private MappedStatement mappedStatement;
    
        private ResultSetHandler resultHandler;
    
        private Object parameter;
    
        public SimpleStatementHandler(MappedStatement mappedStatement, Object parameter, ResultSetHandler resultHandler) {
            this.mappedStatement = mappedStatement;
            this.resultHandler = resultHandler;
            this.parameter = parameter;
        }
    
        @Override
        public <E> List<E> query(Statement statement, ResultSetHandler resultHandler) throws SQLException {
            Connection conn = null;
            PreparedStatement preparedStatement = null;
            try {
                conn = getConnection();
                preparedStatement = conn.prepareStatement(mappedStatement.getBoundSql(parameter).getSql());
                ParameterHandler parameterHandler = new DefaultParameterHandler(parameter);
                parameterHandler.setParameters(preparedStatement);
                preparedStatement.execute();
                resultHandler = new DefaultResultSetHandler(mappedStatement.getResultType(), preparedStatement.getResultSet());
                return resultHandler.handleResultSets();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    if (preparedStatement != null) {
                        preparedStatement.close();
                    }
                    if (conn != null) {
                        conn.close();
                    }
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            return null;
        }
    
        private Connection getConnection() throws SQLException, ClassNotFoundException {
            Configuration configuration = mappedStatement.getConfiguration();
            Class.forName(configuration.getDriver());
            return DriverManager.getConnection(configuration.getUrl(), configuration.getUsername(), configuration.getPassword());
        }
    }

## 2.10 SimpleStatementHandler ##

> 就是和 jdbc 打交道的，通过 ParameterHandler 处理参数，ResultSetHandler 处理返回结果并且返回

DefaultParameterHandler
    
    public class DefaultParameterHandler implements ParameterHandler {
    
        private Object parameter;
    
        public DefaultParameterHandler(Object parameter) {
            this.parameter = parameter;
        }
    
        @Override
        public void setParameters(PreparedStatement psmt) throws SQLException {
            try {
                Object[] parameters = (Object[]) parameter;
    
                if (parameters != null && parameters.length > 0) {
                    for (int i = 0; i < parameters.length; i++) {
                        if (parameters[i] instanceof Integer) {
                            psmt.setInt(i + 1, (Integer) parameters[i]);
                        } else if (parameters[i] instanceof Long) {
                            psmt.setLong(i + 1, (Long) parameters[i]);
                        } else if (parameters[i] instanceof String) {
                            psmt.setString(i + 1, String.valueOf(parameters[i]));
                        } else if (parameters[i] instanceof Boolean) {
                            psmt.setBoolean(i + 1, (Boolean) parameters[i]);
                        } else {
                            psmt.setString(i + 1, String.valueOf(parameters[i]));
                        }
                    }
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
    
    
    DefaultResultSetHandler
    
    ...
    
    public class DefaultResultSetHandler<E> implements ResultSetHandler {
    
        private Class type;
        private ResultSet resultSet;
    
        public DefaultResultSetHandler(Class type, ResultSet resultSet) {
            this.type = type;
            this.resultSet = resultSet;
        }
    
        @Override
        public <E> List<E> handleResultSets() {
            try {
                ArrayList<E> resultList = new ArrayList<>();
                Object resultObject = null;
                while (resultSet.next()) {
                    resultObject = new DefaultObjectFactory().create(type);
                    for (Field field : resultObject.getClass().getDeclaredFields()) {
                        setValue(resultObject, field, resultSet);
                    }
    
                    resultList.add( (E) resultObject);
                }
    
                return resultList;
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    if (resultSet != null) {
                        resultSet.close();
                    }
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            return null;
        }
    
        public void setValue(Object resultObject, Field field, ResultSet resultSet) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException, SQLException {
            Method method = type.getMethod("set" + upperCapital(field.getName()), field.getType());
            method.invoke(resultObject, getResult(field, resultSet));
        }
    
        public Object getResult(Field field, ResultSet rs) throws SQLException {
            Class<?> type = field.getType();
            if (Integer.class == type) {
                return rs.getInt(field.getName());
            } else if (String.class == type) {
                return rs.getString(field.getName());
            } else if (Long.class == type) {
                return rs.getLong(field.getName());
            } else {
                return rs.getString(field.getName());
            }
        }
    
        private String upperCapital(String name) {
            String first = name.substring(0, 1);
            String tail = name.substring(1);
            return first.toUpperCase() + tail;
        }
    }

# 3 拓展 #

> mybatis 的核心逻辑到这里就告一段落了，但是mybatis 远不止这些东西，比如 sql 动态生成， 插件机制，缓存机制，事务机制， 这些东西博主以后会专门写文章介绍的。尽情期待。

[mybatis - 1]: https://blog.csdn.net/qq_35704236/article/details/89365270