【Mybatis源码分析】06-SqlSession执行过程之获取BoundSql代理对象

最新推荐文章于 2024-06-23 15:22:02 发布

smart哥

最新推荐文章于 2024-06-23 15:22:02 发布

阅读量736

点赞数 17

分类专栏： mybatis专题文章标签： mybatis

本文链接：https://blog.csdn.net/smart_an/article/details/138667468

版权

mybatis专题专栏收录该内容

44 篇文章 1 订阅

订阅专栏

作者简介：大家好，我是smart哥，前中兴通讯、美团架构师，现某互联网公司CTO

联系qq：184480602，加我进群，大家一起学习，一起进步，一起对抗互联网寒冬

学习必须往深处挖，挖的越深，基础越扎实！

阶段1、深入多线程

 阶段2、深入多线程设计模式

 阶段3、深入juc源码解析

阶段4、深入jdk其余源码解析

阶段5、深入jvm源码解析

码哥源码部分

码哥讲源码-原理源码篇【2024年最新大厂关于线程池使用的场景题】

码哥讲源码【炸雷啦！炸雷啦！黄光头他终于跑路啦！】

码哥讲源码-【jvm课程前置知识及c/c++调试环境搭建】

码哥讲源码-原理源码篇【揭秘join方法的唤醒本质上决定于jvm的底层析构函数】

码哥源码-原理源码篇【Doug Lea为什么要将成员变量赋值给局部变量后再操作？】

码哥讲源码【你水不是你的错,但是你胡说八道就是你不对了！】

码哥讲源码【谁再说Spring不支持多线程事务，你给我抽他！】

终结B站没人能讲清楚红黑树的历史，不服等你来踢馆！

打脸系列【020-3小时讲解MESI协议和volatile之间的关系，那些将x86下的验证结果当作最终结果的水货们请闭嘴】

上篇文章分析Mapper的查询操作最终都会调用SqlSession的selectList方法，接下来几篇文章分析一下DefaultSqlSession的selectList的执行过程。

    public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
      try {
        MappedStatement ms = configuration.getMappedStatement(statement);
        return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
      } catch (Exception e) {
        throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);
      } finally {
        ErrorContext.instance().reset();
      }
    }

首先调用DefaultSqlSession内的executor对象，如果开启了二级缓存executor就是类CachingExecutor的实例，然后调用executor的query方法其中第二个参数为我们在上篇文章提到过被转换的参数对象可能是null,ParamMap或一个对象，如果这个对象是Collection或数组则会再将这个参数对象转换为一个Map对象。

    private Object wrapCollection(final Object object) {
      if (object instanceof Collection) {
        StrictMap<Object> map = new StrictMap<Object>();
        map.put("collection", object);
        if (object instanceof List) {
          map.put("list", object);
        }
        return map;
      } else if (object != null && object.getClass().isArray()) {
        StrictMap<Object> map = new StrictMap<Object>();
        map.put("array", object);
        return map;
      }
      return object;
    }

回过头来再看CachingExecutor的query方法:

    public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
      BoundSql boundSql = ms.getBoundSql(parameterObject);
      CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);
      return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
    }

由于这个query方法比较复杂，这篇我先分析获取BoundSql对象也就是MappedStatement的getBoundSql方法。BoundSql内包含了执行的sql语句和命名参数。

    public class BoundSql {
    
      private final String sql;
      private final List<ParameterMapping> parameterMappings;
      private final Object parameterObject;
      private final Map<String, Object> additionalParameters;
      private final MetaObject metaParameters;

我画了一副时序图来说明获取BoundSql的过程。

下面按时序图的步骤查看源代码。

1.mapperStatement的getBoundSql方法会调用其成员变量sqlSource的getBoundSql方法

    public BoundSql getBoundSql(Object parameterObject) {
      DynamicContext context = new DynamicContext(configuration, parameterObject);
      rootSqlNode.apply(context);
      SqlSourceBuilder sqlSourceParser = new SqlSourceBuilder(configuration);
      Class<?> parameterType = parameterObject == null ? Object.class : parameterObject.getClass();
      SqlSource sqlSource = sqlSourceParser.parse(context.getSql(), parameterType, context.getBindings());
      BoundSql boundSql = sqlSource.getBoundSql(parameterObject);
      for (Map.Entry<String, Object> entry : context.getBindings().entrySet()) {
        boundSql.setAdditionalParameter(entry.getKey(), entry.getValue());
      }
      return boundSql;
    }

DynamicSqlSource会创建一个DynamicContext对象，这个对象作为SqlNode的apply方法的入参，SqlNode每调用一次apply方法，就是将此节点含有的sql片段拼接到context中去,此外还包含了参数对象，通过MetaObject(本文最后介绍)可以使用A.B[0].C的形式

2.DynamicSqlSource所持有的SqlNode为MixedSqlNode，它内部的contents对象就是顶级节点下的兄弟sql片段，依次调用兄弟片段的apply方法拼接sql，当然其中每个兄弟sql片段下还有可能为多个sql片段。假如一个sql片段是一个不含任何可变参数的那么它就是StaticTextSqlNode，静态节点就是单纯的拼接一下sql，当然还有其他种类的SqlNode,譬如WhereSqlNode，看过它的代码我们就可以看出对于where后第一个and或or是不会拼入sql中的，我们这里就不一一列举了。

    public boolean apply(DynamicContext context) {
      for (SqlNode sqlNode : contents) {//MixedSqlNode
        sqlNode.apply(context);
      }
      return true;
    }

    public boolean apply(DynamicContext context) {//StaticTextSqlNode
      context.appendSql(text);
      return true;
    }

3.此时context中已经含有完整的sql语句了只不过还没有替换掉mybatis的变量占位符信息(类似#{prop,jdbcType=...})。下一步通过SqlSourceBuilder的parse方法将sql语句转换为标准的带有Jdbc站位符?的语句，并将变量占位符信息抽像为ParameterMapping。返回一个包含sql和List的StaticSqlSource。

    public SqlSource parse(String originalSql, Class<?> parameterType, Map<String, Object> additionalParameters) {
      ParameterMappingTokenHandler handler = new ParameterMappingTokenHandler(configuration, parameterType, additionalParameters);
      GenericTokenParser parser = new GenericTokenParser("#{", "}", handler);
      String sql = parser.parse(originalSql);
      return new StaticSqlSource(configuration, sql, handler.getParameterMappings());
    }

GenericTokenParser将#{}中的内容过滤出来，使用ParameterMappingTokenHandler将其转换为ParameterMapping对象，然后用?将#{}替换。

4.通过以上步骤将一个DynamicSqlSource转换成了一个含有List的StaticSqlSource，调用getBoundSql方法返回BoundSql对象。

    public BoundSql getBoundSql(Object parameterObject) {
      return new BoundSql(configuration, sql, parameterMappings, parameterObject);
    }

MetaObject介绍

上面第一步中说到MetaObject可以将参数对象对外提供A.B[0].C的访问形式，那么他是怎么做到的呢。

Configuration的newMetaObject方法调用MetaObject.forObject()方法将自身持有的DefaultObjectFactory，DefaultObjectWrapperFactory和DefaultReflectorFactory一并传入。

    public MetaObject newMetaObject(Object object) {
      return MetaObject.forObject(object, objectFactory, objectWrapperFactory, reflectorFactory);
    }

    public static MetaObject forObject(Object object, ObjectFactory objectFactory, ObjectWrapperFactory objectWrapperFactory, ReflectorFactory reflectorFactory) {
      if (object == null) {
        return SystemMetaObject.NULL_META_OBJECT;
      } else {
        return new MetaObject(object, objectFactory, objectWrapperFactory, reflectorFactory);
      }
    }

    private MetaObject(Object object, ObjectFactory objectFactory, ObjectWrapperFactory objectWrapperFactory, ReflectorFactory reflectorFactory) {
      this.originalObject = object;
      this.objectFactory = objectFactory;
      this.objectWrapperFactory = objectWrapperFactory;
      this.reflectorFactory = reflectorFactory;
    
      if (object instanceof ObjectWrapper) {
        this.objectWrapper = (ObjectWrapper) object;
      } else if (objectWrapperFactory.hasWrapperFor(object)) {
        this.objectWrapper = objectWrapperFactory.getWrapperFor(this, object);
      } else if (object instanceof Map) {
        this.objectWrapper = new MapWrapper(this, (Map) object);
      } else if (object instanceof Collection) {
        this.objectWrapper = new CollectionWrapper(this, (Collection) object);
      } else {
        this.objectWrapper = new BeanWrapper(this, object);
      }
    }

然后MetaObject通过构造方法将这些参数保留下来，构造函数对不同的object类型创建不同的ObjectWrapper对象，MetaObject通过ObjectWrapper对object提供了方便的多层级的getter和setter方法。

MetaObject对外提供属性的访问是getValue方法:

    public Object getValue(String name) {
      PropertyTokenizer prop = new PropertyTokenizer(name);
      if (prop.hasNext()) {
        MetaObject metaValue = metaObjectForProperty(prop.getIndexedName());
        if (metaValue == SystemMetaObject.NULL_META_OBJECT) {
          return null;
        } else {
          return metaValue.getValue(prop.getChildren());
        }
      } else {
        return objectWrapper.get(prop);
      }
    }

    public MetaObject metaObjectForProperty(String name) {
      Object value = getValue(name);
      return MetaObject.forObject(value, objectFactory, objectWrapperFactory, reflectorFactory);
    }

1.根据PropertyTokenizer判断是否是一个多层级的属性访问，如果是则先取顶层对象将其重新包裹为一个MetaObject对象，然后对这个对象再次调用getValue方法，这个时候getValue的参数为去除第一层级的字符串了，直到入参name为单层级的字符串也是就不带"."的字符串然后调用objectWrapper的get方法取出name所对应的属性值。这里我们以BeanWrapper为例看看这个方法的实现。

    public Object get(PropertyTokenizer prop) {
      if (prop.getIndex() != null) {
        Object collection = resolveCollection(prop, object);
        return getCollectionValue(prop, collection);
      } else {
        return getBeanProperty(prop, object);
      }
    }

首先判断当前访问的属性是否含有索引值也即是collection[key]这种形式，如果有则先得到这个集合然后在对集合(或Map或数组)按索引取值，如果不是类集合类型则使用metaClass使用getGetInvoker调用对象的getter方法取值。MetaClass内部使用的是反射技术，有兴趣的可以看看这个类的实现。

smart哥

关注

17
点赞
踩
15

收藏

觉得还不错? 一键收藏
0
评论
【Mybatis源码分析】06-SqlSession执行过程之获取BoundSql代理对象

1.根据PropertyTokenizer判断是否是一个多层级的属性访问，如果是则先取顶层对象将其重新包裹为一个MetaObject对象，然后对这个对象再次调用getValue方法，这个时候getValue的参数为去除第一层级的字符串了，直到入参name为单层级的字符串也是就不带"."的字符串然后调用objectWrapper的get方法取出name所对应的属性值。的语句，并将变量占位符信息抽像为ParameterMapping。MetaClass内部使用的是反射技术，有兴趣的可以看看这个类的实现。
复制链接

扫一扫

专栏目录