我要手撕mybatis源码

我要手撕mybatis源码

传统的JDBC编程中的一般 *** 作：

• 1、注册数据库驱动类，指定数据库的URL地址、数据库用户名、密码等连接信息
• 2、通过DriverManager打开数据库连接
• 3、通过数据库连接创建Statement对象。
• 4、通过State对象执行SQL语句，得到ResultSet对象。
• 5、通过ResultSet读取数据，将数据转换成JavaBean对象
• 6、关闭连接、释放资源

ORM（Object Relational Mapping) 对象—关系映射。用于实现面向对象编程语言里 不同类型系统的数据 之间的转换。

1、源码分析 1、先读取配置文件中的信息

经过多次追踪、找到这个getResourceAsStream核心方法，以下是该方法的源码

该方法的参数不仅有传入的文件路径还有类加载器。类加载的主要作用是将名称转化为文件名，读取外部资源。

作为debug的入口

跟踪到核心源码部分

这里完成两个 *** 纵：

• 在这里生成了一个XMLConfigBuilder的对象，并且调用了其parse()方法。返回解析好的configuration对象信息。
• 调用了SqlSessionFactoryBuilder自身的build()方法，传入的参数为上一步得到的Configuration对象。

先追踪XMLConfigBuilder对象的parse()方法

这里的parsed保证只加载一次，这里的/configuration是整个配置文件的根节点、是解析整个配置文件的入口。然后调用parseConfiguration方法，继续追踪

查看root的传入的值，实际上就是configuration下的各个节点

查看environment下的信息、继续追踪，到environmentsElement方法，

查看传入的context的值，这里就是解析的信息。也就是url、username、password 、驱动的信息。和上一个的信息是不一样的

通过进入每个子方法可以看出来，Configuration类中保存了配置文件的所有配置信息。

通过调用SqlSessionFactoryBuilder自身的build()方法，返回了SqlSessionFactory对象。


小结
初始化阶段、MyBatis主要完成以下几项工作

• 根据配值文件的位置，获取它的输入流InputStream
• 从配置文件的根节点开始，逐层解析配置问价，也包括相应的映射文件。解析过程不断将解析结果放入Configuration对象
• 以配置好的Configuration对象作为参数，获取一个SqlSessionFactory对象

2、数据读写阶段追踪 2.1 获得sqlsession

追踪openSession方法

进入openSessionFromDataSource方法内部，这里是生成SqlSession的核心源码

进入DefaultSqlSession类中，类里提供了查询、增加、更新、删除、提交、回滚等大量的方法

执行完new DefaultSqlSession(this.configuration, executor, autoCommit);后就返回了一个SqlSession对象

2.2 映射接口文件与映射文件的绑定

通过 *** 作Configuration的getMapper方法最终进入MapperRegistry类的getMapper方法。

2.3 映射接口的代理

session.getMapper(UserMapper.class)得到的是mapperProxyFactory.newInstance(sqlSession)返回的对象，追踪此方法得到

返回的是基于反射的动态代理对象，找到MapperProxy类的invoke方法，被代理对象的方法会被代理对象的invoke方法拦截、直接到 MapperProxy类的invoke方法拦截，

在invoke打上断点，当执行userMapper.queryUserBySchoolName(userParam);会自动进入断点invoke内

然后会触发MapperMethod对象的execute方法

进入该方法

    public Object execute(SqlSession sqlSession, Object[] args) {
        Object result;
        Object param;
        switch(this.command.getType()) {
        case INSERT:
            param = this.method.convertArgsToSqlCommandParam(args);
            result = this.rowCountResult(sqlSession.insert(this.command.getName(), param));
            break;
        case UPDATe:
            param = this.method.convertArgsToSqlCommandParam(args);
            result = this.rowCountResult(sqlSession.update(this.command.getName(), param));
            break;
        case DELETE:
            param = this.method.convertArgsToSqlCommandParam(args);
            result = this.rowCountResult(sqlSession.delete(this.command.getName(), param));
            break;
        case SELECT:
            if (this.method.returnsVoid() && this.method.hasResultHandler()) {
                this.executeWithResultHandler(sqlSession, args);
                result = null;
            } else if (this.method.returnsMany()) {
                result = this.executeForMany(sqlSession, args);
            } else if (this.method.returnsMap()) {
                result = this.executeForMap(sqlSession, args);
            } else if (this.method.returnsCursor()) {
                result = this.executeForCursor(sqlSession, args);
            } else {
                param = this.method.convertArgsToSqlCommandParam(args);
                result = sqlSession.selectOne(this.command.getName(), param);
                if (this.method.returnsOptional() && (result == null || !this.method.getReturnType().equals(result.getClass()))) {
                    result = Optional.ofNullable(result);
                }
            }
            break;
        case FLUSH:
            result = sqlSession.flushStatements();
            break;
        default:
            throw new BindingException("Unknown execution method for: " + this.command.getName());
        }

        if (result == null && this.method.getReturnType().isPrimitive() && !this.method.returnsVoid()) {
            throw new BindingException("Mapper method '" + this.command.getName() + " attempted to return null from a method with a primitive return type (" + this.method.getReturnType() + ").");
        } else {
            return result;
        }
    }

会根据不同的 *** 作类型调用不同的处理方法、这里执行的是查询 *** 作、所以就调用这个方法

进入executeForMany方法，在这个方法中，MyBatis已经开始通过SqlSession对象的selectList方法开展后续的查询工作。

2.4 sql语句的查找

继续追踪到DefaultSqlSession中的selectList方法，源码如下

每个MappedStatement对象对应设置的一个数据库 *** 作节点，主要定义了数据库 *** 作语句、输入/输出参数等信息。this.configuration.getMappedStatement(statement)语句将要执行的MappedStatement对象从Configuration对象存储的映射文件信息中找了出来。

2.5 查询缓存

其中的query方法是Executor中的抽象方法，实现有两个、一个是查询数据库、一个是查询缓存

直接在抽象方法上打一个断点、查看执行哪边、这里执行的是CachingExecutor中的方法、源码如下

其中的BoundSql是经过层层转化后去掉if、where、等标签的sql语句，CacheKey是为该此次查询 *** 作计算出来的缓存建。

继续追踪代码流程到这里

查看当前的查询 *** 作是否名中缓存，如果是从缓存中获取数据值、如果不是则调用delegate调用query方法。随后将此次查询的结果放入缓存中。

2.6 数据库查询

再次调用了executor接口中的抽象方法

继续追踪代码流向

最终进入了baseExecutor中的query方法上，源码如下

    public  List query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
        ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
        if (this.closed) {
            throw new ExecutorException("Executor was closed.");
        } else {
            if (this.queryStack == 0 && ms.isFlushCacheRequired()) {
                this.clearLocalCache();
            }

            List list;
            try {
                ++this.queryStack;
                list = resultHandler == null ? (List)this.localCache.getObject(key) : null;
                if (list != null) {
                    this.handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
                } else {
                    list = this.queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
                }
            } finally {
                --this.queryStack;
            }

            if (this.queryStack == 0) {
                Iterator var8 = this.deferredLoads.iterator();

                while(var8.hasNext()) {
                    baseExecutor.DeferredLoad deferredLoad = (baseExecutor.DeferredLoad)var8.next();
                    deferredLoad.load();
                }

                this.deferredLoads.clear();
                if (this.configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
                    this.clearLocalCache();
                }
            }

            return list;
        }
    }

其中的关键部分、开始调用数据库展开查询 *** 作

queryFromDatabase的源代码如下

首先在缓存中放置一个占位符，然后调用doQuery方法实际执行，最后，将缓存中的占位符替换成真正的查询结果。

doQuery方法是baseExecutor中的抽象方法，实际运行的最终实现代码

生成了Statement对象，是java.sql包中的类，Statement类能够执行静态SQL语句并返回结果。

获得了一个StatementHandler对象handler,然后将查询 *** 作交给StatementHandler执行，StatementHandler是一个语句处理器，其中封装了很多的语句 *** 作方法。，继续追踪代码流向。

handler.query(stmt,resultHandler)调用的是StatementHandler接口中的抽象方法

接续追踪代码走向、进入PreparedStatementHandler中，调用方法、源码如下

这里，ps.execute()真正执行了SQL语句，然后把执行结果交给ResulHandler对象处理。

流程梳理

• 1、先查缓存，如果一定要查数据库、则查询数据库后需要将结果也放入缓存中
• 2、SQL语句经过多次转化，经过了MappedStatement对象、Statement对象和PreparedStatement对象，最后才执行
• 最后将查询的结果交给ResultHandler对象处理

2.7 处理结果集

查询到的结果集并没有直接返回，而是交给ResultHandler对象处理，ResultHandler是结果处理器，用来接受查询结果的方法是该接口中的抽象方法handleResultSets

继续代码追踪，最终的执行方法是DefaultResultSetHandler类中的handleResultSets方法

public List