【Mybatis源码学习】参数解析

【Mybatis源码学习】参数解析

  • 一、几种入参形式
    • 1.单个入参
    • 2.多个入参
    • 3.入参为实体对象
    • 4.入参为Map
  • 二、mybatis执行入口
  • 三、参数解析流程
  • 四、总结

一、几种入参形式

这里只分析带有入参的方法。

1.单个入参

UserInfo selectByPrimaryKey(String id);

2.多个入参

List<UserInfo> getByOpenIdAndUsername2(@Param("openid") String openId, @Param("username") String username);

3.入参为实体对象

List<UserInfo> getByOpenIdAndUsername3(UserInfo userInfo);

4.入参为Map

List<UserInfo> getByOpenIdAndUsername(Map<String, Object> params);

二、mybatis执行入口

还是以之前的一个例子来进入我们今天的正题。

@Test
// 快速入门
public void quickStart() throws IOException {
    //--------------------第二阶段---------------------------
    // 2.获取sqlSession
    SqlSession sqlSession = sqlSessionFactory.openSession();
    // 3.获取对应mapper
    UserInfoMapper mapper = sqlSession.getMapper(UserInfoMapper.class);
    //--------------------第三阶段---------------------------
    // 4.执行查询语句并返回单条数据
    UserInfo user = mapper.selectByPrimaryKey("1");
    System.out.println(user);
}

当我们执行到这一行时,

UserInfoMapper mapper = sqlSession.getMapper(UserInfoMapper.class);

通过调试我们可以看到,这个mapper其实是通过MapperProxy代理执行的。我们拿到的其实就是个动态代理对象。如下图:
【Mybatis源码学习】参数解析_第1张图片
当我们执行查询时,进入MapperProxy动态代理过程。
【Mybatis源码学习】参数解析_第2张图片
最终交由MapperMethod类的execute()方法执行,源代码如下:

//三步翻译在此完成
public Object execute(SqlSession sqlSession, Object[] args) {
  Object result;
  //第一步 根据sql语句类型以及接口返回的参数选择调用不同的方法
  switch (command.getType()) {
    case INSERT: {
  	Object param = method.convertArgsToSqlCommandParam(args);
      result = rowCountResult(sqlSession.insert(command.getName(), param));
      break;
    }
    case UPDATE: {
      Object param = method.convertArgsToSqlCommandParam(args);
      result = rowCountResult(sqlSession.update(command.getName(), param));
      break;
    }
    case DELETE: {
      Object param = method.convertArgsToSqlCommandParam(args);
      result = rowCountResult(sqlSession.delete(command.getName(), param));
      break;
    }
    case SELECT:
      if (method.returnsVoid() && method.hasResultHandler()) {//返回值为void
        executeWithResultHandler(sqlSession, args);
        result = null;
      } else if (method.returnsMany()) {//返回值为集合或者数组
        result = executeForMany(sqlSession, args);
      } else if (method.returnsMap()) {//返回值为map
        result = executeForMap(sqlSession, args);
      } else if (method.returnsCursor()) {//返回值为游标
        result = executeForCursor(sqlSession, args);
      } else {//处理返回为单一对象的情况
        //通过参数解析器解析解析参数
        Object param = method.convertArgsToSqlCommandParam(args);//第三步翻译,将入参转化成Map
        result = sqlSession.selectOne(command.getName(), param);
        if (method.returnsOptional() &&
            (result == null || !method.getReturnType().equals(result.getClass()))) {
          result = OptionalUtil.ofNullable(result);
        }
      }
      break;
    case FLUSH:
      result = sqlSession.flushStatements();
      break;
    default:
      throw new BindingException("Unknown execution method for: " + command.getName());
  }
  if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid()) {
    throw new BindingException("Mapper method '" + command.getName()
        + " attempted to return null from a method with a primitive return type (" + method.getReturnType() + ").");
  }
  return result;
}

所以,本章参数解析的过程,我们重点关注这个方法即可,这个方法就是convertArgsToSqlCommandParam。它其实是方法的参数解析器ParamNameResolver的getNamedParams()方法完成的。
【Mybatis源码学习】参数解析_第3张图片
而这个ParamNameResolver则是在MapperProxy获取mapperMethod时(先不说从cache中取)进行初始化的,
【Mybatis源码学习】参数解析_第4张图片
【Mybatis源码学习】参数解析_第5张图片
【Mybatis源码学习】参数解析_第6张图片
而ParamNameResolver实例化时,主要工作就是进行初步的映射关系存储,其字段names是一个SortedMap,存储了参数名的顺序映射。

/**
   * 

* The key is the index and the value is the name of the parameter.
* The name is obtained from {@link Param} if specified. When {@link Param} is not specified, * the parameter index is used. Note that this index could be different from the actual index * when the method has special parameters (i.e. {@link RowBounds} or {@link ResultHandler}). *

*
    *
  • aMethod(@Param("M") int a, @Param("N") int b) -> {{0, "M"}, {1, "N"}}
  • *
  • aMethod(int a, int b) -> {{0, "0"}, {1, "1"}}
  • *
  • aMethod(int a, RowBounds rb, int b) -> {{0, "0"}, {2, "1"}}
  • *
*/
private final SortedMap<Integer, String> names;

继续看getNamedParams()方法。

//将多个参数封装成MAP
public Object getNamedParams(Object[] args) {
  final int paramCount = names.size();
  if (args == null || paramCount == 0) {
    return null;
  } else if (!hasParamAnnotation && paramCount == 1) {
    return args[names.firstKey()];
  } else {
    final Map<String, Object> param = new ParamMap<>();
    int i = 0;
    for (Map.Entry<Integer, String> entry : names.entrySet()) {
      param.put(entry.getValue(), args[entry.getKey()]);
      // add generic param names (param1, param2, ...)
      final String genericParamName = GENERIC_NAME_PREFIX + String.valueOf(i + 1);
      // ensure not to overwrite parameter named with @Param
      if (!names.containsValue(genericParamName)) {
        param.put(genericParamName, args[entry.getKey()]);
      }
      i++;
    }
    return param;
  }
}

本例子中,由于无@Param注解,所以在第二个else if那里就返回了。

三、参数解析流程

以下面的代码为例,其他形式的入参大同小异。

@Test
public void testManyParamQuery() {
    // 2.获取sqlSession
    SqlSession sqlSession = sqlSessionFactory.openSession();
    // 3.获取对应mapper
    UserInfoMapper mapper = sqlSession.getMapper(UserInfoMapper.class);
    String username = "zyx";
    String openId = "zyxelva";

    // 第一种方式使用map
    Map<String, Object> params = new HashMap<>();
    params.put("username", username);
    params.put("openid", openId);
    List<UserInfo> list1 = mapper.getByUsernameAndOpenId(params);
    System.out.println(list1);
}

对应的mapper.xml方法

<select id="getByUsernameAndOpenId" resultMap="BaseResultMap">
   select
    <include refid="Base_Column_List"/>
    from user_info 
    where username=#{username} and openid=#{openid}
select>

我们从方法

List<UserInfo> list1 = mapper.getByUsernameAndOpenId(params);

开始断点调试。我们看到,进入到了MapperProxy的动态代理过程。直接进入mapperMethod.execute(sqlSession, args);

【Mybatis源码学习】参数解析_第7张图片
来到MapperMethod中的execute方法中。由于我们的例子是查询操作,故进入Select。又例子的返回类型是List,故进入第二个if语句中。
【Mybatis源码学习】参数解析_第8张图片
【Mybatis源码学习】参数解析_第9张图片
进入方法executeForMany(). 没有分页,所以进入else语句中。而convertArgsToSqlCommandParam方法我们在二中已经分析了,这里不再具体梳理。
【Mybatis源码学习】参数解析_第10张图片
进入DefaultSQLSession的selectList方法中。可以看下statement实际形式是namespace+id,就可以从MappedStatement中获取。
【Mybatis源码学习】参数解析_第11张图片
而MappedStatement也有很多信息,主要是标签以及该节点其他重要的属性。
【Mybatis源码学习】参数解析_第12张图片
而sql的实际执行者,则为Executor. 代理对象执行方法被拦截器拦截,执行以下方法。
【Mybatis源码学习】参数解析_第13张图片
先看看getBoundSql干了啥:
【Mybatis源码学习】参数解析_第14张图片
【Mybatis源码学习】参数解析_第15张图片
进入RawSqlSource,因例子的sql无${},无动态SQL节点。
【Mybatis源码学习】参数解析_第16张图片
先看看RawSqlSource的构造方法,看看#{}是怎么替换成?的,发现主要是SqlSourceBuilder在干活儿。
【Mybatis源码学习】参数解析_第17张图片
【Mybatis源码学习】参数解析_第18张图片
主要看GenericTokenParser.parse().该方法主要完成占位符的定位工作,然后把占位符的替换工作交给与其关联的 TokenHandler 处理.
【Mybatis源码学习】参数解析_第19张图片
TokenHandler有四个小弟,
【Mybatis源码学习】参数解析_第20张图片
BindingTokenParser:该对象的handleToken方法会取出占位符中的变量,然后使用该变量作为键去上下文环境中寻找对应的值。之后,会用找到的值替换占位符。因此,该对象可以完成占位符的替换工作;
DynamicCheckerTokenParser:该对象的 handleToken 方法会置位成员属性isDynamic。因此该对象可以记录自身是否遇到过占位符。
ParameterMappingTokenHandler:将DynamicSqlSource和RawSqlSource中的“#{}”符号替换掉,从而将他们转化为StaticSqlSource;
VariableTokenHandler:handleToken方法中传入输入参数后,该方法会以输入参数为键尝试从variables属性中寻找对应的值返回。
【Mybatis源码学习】参数解析_第21张图片
到此BoundSql的解析过程基本结束。getBoundSql方法执行完后,我们再看看一级缓存的key生成策略。
【Mybatis源码学习】参数解析_第22张图片
【Mybatis源码学习】参数解析_第23张图片

可以看出,cacheKey由namespace的id,分页参数,sql语句,入参以及节点的信息组成。
回到查询过程,实际执行的方法为
【Mybatis源码学习】参数解析_第24张图片
而首次查询不会进入if语句,调用BaseExecutor的方法:
【Mybatis源码学习】参数解析_第25张图片
本地缓存没有结果,故需要查询数据库,进入queryFromDatabase().
【Mybatis源码学习】参数解析_第26张图片
doQuery()则调用的为SimpleExecutor的方法。
【Mybatis源码学习】参数解析_第27张图片
看看newStatementHandler()。
在这里插入图片描述
【Mybatis源码学习】参数解析_第28张图片
由于我们的例子当中sql带有#{},故进入PREPARED,生成PreparedStatementHandler。
执行完语句后,放入一级缓存。
【Mybatis源码学习】参数解析_第29张图片
后续就是结果映射执行过程,这里不再赘述,后续跟上。

四、总结

本章主要讲述了mybatis参数解析的过程,重点跟踪了执行sql时,变量占位符${}以及参数占位符#{}的替换和解析过程。实际开发过程中,要注意这两者的区别,能用#{}的地方尽量用#。而${}主要用于order by语句、原生jdbc、表名作参数。

你可能感兴趣的:(MyBatis,源码,mybatis)