MyBatis中Mapper接口参数的包装与映射

  public ParamNameResolver(Configuration config, Method method) {
    this.useActualParamName = config.isUseActualParamName();
    final Class<?>[] paramTypes = method.getParameterTypes();
    // 获取方法参数中的注解集合
    final Annotation[][] paramAnnotations = method.getParameterAnnotations();
    final SortedMap<Integer, String> map = new TreeMap<>();
    // 获取注解集合的长度
    int paramCount = paramAnnotations.length;
    for (int paramIndex = 0; paramIndex < paramCount; paramIndex++) {
      if (isSpecialParameter(paramTypes[paramIndex])) {
        continue;
      }
      String name = null;
      for (Annotation annotation : paramAnnotations[paramIndex]) {
      // 循环注解集合，如果有@Param类型的注解，将注解的value赋值给name变量
        if (annotation instanceof Param) {
          hasParamAnnotation = true;
          name = ((Param) annotation).value();
          break;
        }
      }
      // 如果name == null，则证明没有@Param类型的注解
      if (name == null) {
      // 如果允许使用方法签名中的名称作为语句参数名称，则将参数名称赋值给name
        if (useActualParamName) {
          name = getActualParamName(method, paramIndex);
        }
        // 如果useActualParamName为false，则使用数组下标作为name使用
        if (name == null) {
          name = String.valueOf(map.size());
        }
      }
      // 将参数下标和name值映射起来
      map.put(paramIndex, name);
    }
    names = Collections.unmodifiableSortedMap(map);
  }

  public Object getNamedParams(Object[] args) {
    final int paramCount = names.size();
    // 判断参数个数，如果数量为0，则没有入参
    if (args == null || paramCount == 0) {
      return null;
    } else if (!hasParamAnnotation && paramCount == 1) {
    // 如果只有一个入参，则从入参列表中根据下标直接出去参数
      Object value = args[names.firstKey()];
      // 如果集合类型，则进行集合类型的包装
      return wrapToMapIfCollection(value, useActualParamName ? names.get(0) : null);
    } else {
    // 如果有多个入参，则将参数封装到Map中，
      final Map<String, Object> param = new ParamMap<>();
      int i = 0;
      for (Map.Entry<Integer, String> entry : names.entrySet()) {
// 将names中的value作为key，key作为列表的下标进行取出后作为value放到map中
        param.put(entry.getValue(), args[entry.getKey()]);
        final String genericParamName = GENERIC_NAME_PREFIX + (i + 1);
        if (!names.containsValue(genericParamName)) {
          param.put(genericParamName, args[entry.getKey()]);
        }
        i++;
      }
      return param;
    }
  }

  @Override
  public void setParameters(PreparedStatement ps) {
    ErrorContext.instance().activity("setting parameters").object(mappedStatement.getParameterMap().getId());
    // 将XML映射文件中#{}标识的参数获取到
    List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
    if (parameterMappings != null) {
    // 循环遍历
      for (int i = 0; i < parameterMappings.size(); i++) {
      // 取出其中的一个ParameterMapping对象
        ParameterMapping parameterMapping = parameterMappings.get(i);
        if (parameterMapping.getMode() != ParameterMode.OUT) {
          Object value;
          String propertyName = parameterMapping.getProperty();
          if (boundSql.hasAdditionalParameter(propertyName)) { // issue #448 ask first for additional params
            value = boundSql.getAdditionalParameter(propertyName);
          } else if (parameterObject == null) {
            value = null;
          } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
            // 如果是单个参数，直接赋值给value
            value = parameterObject;
          } else {
          // 如果是多个参数，转换成MetaObject对象
            MetaObject metaObject = configuration.newMetaObject(parameterObject);
            value = metaObject.getValue(propertyName);
          }
          TypeHandler typeHandler = parameterMapping.getTypeHandler();
          JdbcType jdbcType = parameterMapping.getJdbcType();
          if (value == null && jdbcType == null) {
            jdbcType = configuration.getJdbcTypeForNull();
          }
          try {
          // 最后通过TypeHandler找到对应的类型处理器设置参数
            typeHandler.setParameter(ps, i + 1, value, jdbcType);
          } catch (TypeException | SQLException e) {
            throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);
          }
        }
      }
    }
  }