源码解析之 Mybatis 对 Integer 参数做了什么手脚？

DefaultSqlSession#select

@Override
public void select(String statement, Object parameter, RowBounds rowBounds, ResultHandler handler) {
    try {
        MappedStatement ms = configuration.getMappedStatement(statement);
        executor.query(ms, wrapCollection(parameter), rowBounds, handler);
    } catch (Exception e) {
        throw ExceptionFactory.wrapException("Error querying database. Cause: " + e, e);
    } finally {
        ErrorContext.instance().reset();
    }
}

BaseExecutor#query

@Override
public List
     query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    return query(ms, parameter, rowBounds, resultHandler, key, boundSql, 0);
}

MappedStatement#getBoundSql

public BoundSql getBoundSql(Object parameterObject) {
    BoundSql boundSql = sqlSource.getBoundSql(parameterObject);
    List
    
      parameterMappings = boundSql.getParameterMappings();
    if (parameterMappings == null || parameterMappings.isEmpty()) {
        boundSql = new BoundSql(configuration, boundSql.getSql(), parameterMap.getParameterMappings(), parameterObject);
    }
    for (ParameterMapping pm : boundSql.getParameterMappings()) {
        String rmId = pm.getResultMapId();
        if (rmId != null) {
            ResultMap rm = configuration.getResultMap(rmId);
            if (rm != null) {
                hasNestedResultMaps |= rm.hasNestedResultMaps();
            }
        }
    }
    return boundSql;
}
    

SqlSource#getBoundSql

public interface SqlSource {
    BoundSql getBoundSql(Object parameterObject);
}

DynamicSqlSource#getBoundSql

@Override
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);
    context.getBindings().forEach(boundSql::setAdditionalParameter);
    return boundSql;
}

SqlNode#apply

public interface SqlNode {
    boolean apply(DynamicContext context);
}

IfSqlNode#apply

@Override
public boolean apply(DynamicContext context) {
    if (evaluator.evaluateBoolean(test, context.getBindings())) {
        contents.apply(context);
        return true;
    }
    return false;
}

ExpressionEvaluator#evaluateBoolean

public boolean evaluateBoolean(String expression, Object parameterObject) {
    Object value = OgnlCache.getValue(expression, parameterObject);
    if (value instanceof Boolean) {
        return (Boolean) value;
    }
    if (value instanceof Number) {
        return new BigDecimal(String.valueOf(value)).compareTo(BigDecimal.ZERO) != 0;
    }
    return value != null;
}

OgnlCache#getValue

public static Object getValue(String expression, Object root) {
    try {
        Map context = Ognl.createDefaultContext(root, MEMBER_ACCESS, CLASS_RESOLVER, null);
        return Ognl.getValue(parseExpression(expression), context, root);
    } catch (OgnlException e) {
        throw new BuilderException("Error evaluating expression '" + expression + "'. Cause: " + e, e);
    }
}

Ognl#getValue

public static Object getValue(Object tree, Map context, Object root) throws OgnlException {
    return getValue(tree, context, root, null);
}

TypeConverter#convertValue

public interface TypeConverter {
    public Object convertValue(Map context, Object target, Member member, String propertyName, Object value, Class toType);
}

DefaultTypeConverter#convertValue

public Object convertValue(Map context, Object value, Class toType) {
    return OgnlOps.convertValue(value, toType);
}

OgnlOps#convertValue

public static Object convertValue(Object value, Class toType) {
    return convertValue(value, toType, false);
}

OgnlOps#convertValue

public static Object convertValue(Object value, Class toType, boolean preventNulls) {
    Object result = null;
    if (value != null && toType.isAssignableFrom(value.getClass())) {
        return value;
    }
    if (value != null) {
        if (value.getClass().isArray() && toType.isArray()) {
            result = Array.newInstance(toType.getComponentType(), Array.getLength(value));
            for (int i = 0, icount = Array.getLength(value); i < icount; i++) {
                Array.set(result, i, convertValue(Array.get(value, i), toType.getComponentType()));
            }
        } else if (value.getClass().isArray() && !toType.isArray()) {
            return convertValue(Array.get(value, 0), toType);
        } else if (!value.getClass().isArray() && toType.isArray()) {
            if (toType.getComponentType() == Character.TYPE) {
                result = stringValue(value).toCharArray();
            } else if (toType.getComponentType() == Object.class) {
                if (value instanceof Collection) {
                    return ((Collection) value).toArray(new Object[0]);
                } else {
                    return new Object[] { value };
                }
            }
        }
        if ((toType == Integer.class) || (toType == Integer.TYPE)) {
            result = new Integer((int) longValue(value));
        }
        if ((toType == Double.class) || (toType == Double.TYPE)) {
            result = new Double(doubleValue(value));
        }
        if ((toType == Boolean.class) || (toType == Boolean.TYPE)) {
            result = booleanValue(value) ? Boolean.TRUE : Boolean.FALSE;
        }
        if ((toType == Byte.class) || (toType == Byte.TYPE)) {
            result = new Byte((byte) longValue(value));
        }
        if ((toType == Character.class) || (toType == Character.TYPE)) {
            result = new Character((char) longValue(value));
        }
        if ((toType == Short.class) || (toType == Short.TYPE)) {
            result = new Short((short) longValue(value));
        }
        if ((toType == Long.class) || (toType == Long.TYPE)) {
            result = new Long(longValue(value));
        }
        if ((toType == Float.class) || (toType == Float.TYPE)) {
            result = new Float(doubleValue(value));
        }
        if (toType == BigInteger.class) {
            result = bigIntValue(value);
        }
        if (toType == BigDecimal.class) {
            result = bigDecValue(value);
        }
        if (toType == String.class) {
            result = stringValue(value);
        }
    } else {
        if (toType.isPrimitive()) {
            result = OgnlRuntime.getPrimitiveDefaultValue(toType);
        } else if (preventNulls && toType == Boolean.class) {
            result = Boolean.FALSE;
        } else if (preventNulls && Number.class.isAssignableFrom(toType)) {
            result = OgnlRuntime.getNumericDefaultValue(toType);
        }
    }
    if (result == null && preventNulls) {
        return value;
    }
    if (value != null && result == null) {
        throw new IllegalArgumentException("Unable to convert type " + value.getClass().getName() + " of " + value + " to type of " + toType.getName());
    }
    return result;
}

OgnlOps#longValue

public static long longValue(Object value) throws NumberFormatException {
    if (value == null) return 0L;
    Class c = value.getClass();
    if (c.getSuperclass() == Number.class) return ((Number) value).longValue();
    if (c == Boolean.class) return ((Boolean) value).booleanValue() ? 1 : 0;
    if (c == Character.class) return ((Character) value).charValue();
    return Long.parseLong(stringValue(value, true));
}