public Map<?, ?> resolve(Invocation inv, ParamMetaData metaData) {
if (StringUtils.isNotEmpty(metaData.getParamName())) {
Class<?>[] genericTypes = (Class[]) metaData.getUserObject(this);
Class<?> keyType = genericTypes[0];
Class<?> valueType = genericTypes[1];
Map<?, ?> toConvert =
WebUtils.getParametersStartingWith(
inv.getRequest(), metaData.getParamName() + MAP_SEPARATOR);
if (toConvert != null) {
if (keyType != String.class || valueType != String.class) {
Map<Object, Object> ret = new HashMap<Object, Object>();
for (Map.Entry<?, ?> entry : toConvert.entrySet()) {
Object key = entry.getKey();
Object value = entry.getValue();
TypeConverter typeConverter = SafedTypeConverterFactory.getCurrentConverter();
if (keyType != String.class) {
key = typeConverter.convertIfNecessary(key, keyType);
}
if (valueType != String.class) {
value = typeConverter.convertIfNecessary(value, valueType);
}
ret.put(key, value);
}
return ret;
}
return toConvert;
}
}
return new HashMap<Object, Object>(2);
}
public Object resolve(Invocation inv, ParamMetaData metaData) {
String toConvert = null;
//
FlashParam flashParam = metaData.getAnnotation(FlashParam.class);
if (flashParam != null) {
toConvert = inv.getFlash().get(flashParam.value());
}
for (String paramName : metaData.getParamNames()) {
if (paramName != null) {
toConvert = inv.getRequest().getParameter(paramName);
if (toConvert != null) {
break;
}
}
}
if (toConvert == null) {
DefValue defValudeAnnotation = metaData.getAnnotation(DefValue.class);
if (defValudeAnnotation != null
&& !DefValue.NATIVE_DEFAULT.equals(defValudeAnnotation.value())) {
toConvert = defValudeAnnotation.value();
}
}
if (toConvert != null) {
SimpleTypeConverter typeConverter = SafedTypeConverterFactory.getCurrentConverter();
return typeConverter.convertIfNecessary(toConvert, metaData.getParamType());
}
if (metaData.getParamType().isPrimitive()) {
// 对这最常用的类型做一下if-else判断，其他类型就简单使用converter来做吧
if (metaData.getParamType() == int.class) {
return Integer.valueOf(0);
} else if (metaData.getParamType() == long.class) {
return Long.valueOf(0);
} else if (metaData.getParamType() == boolean.class) {
return Boolean.FALSE;
} else if (metaData.getParamType() == double.class) {
return Double.valueOf(0);
} else if (metaData.getParamType() == float.class) {
return Float.valueOf(0);
} else {
SimpleTypeConverter typeConverter = SafedTypeConverterFactory.getCurrentConverter();
return typeConverter.convertIfNecessary("0", metaData.getParamType());
}
}
return null;
}
public boolean supports(ParamMetaData metaData) {
if (ClassUtils.isPrimitiveOrWrapper(metaData.getParamType())) {
return true;
}
SimpleTypeConverter simpleTypeConverter = SafedTypeConverterFactory.getCurrentConverter();
return simpleTypeConverter.findCustomEditor(metaData.getParamType(), null) != null
|| simpleTypeConverter.getDefaultEditor(metaData.getParamType()) != null;
}
@SuppressWarnings("unchecked")
private static Object resolveArray(
Invocation inv, ParamMetaData metaData, Class<?> compnentType) {
if (compnentType == MultipartFile.class) {
String filterName = metaData.getParamName();
if (filterName == null) {
filterName = "";
}
if (inv.getRequest() instanceof MultipartRequest) {
List<MultipartFile> files = new LinkedList<MultipartFile>();
MultipartRequest multipartRequest = (MultipartRequest) inv.getRequest();
Iterator<String> names = multipartRequest.getFileNames();
while (names.hasNext()) {
String name = names.next();
if (name.startsWith(filterName)) {
files.add(multipartRequest.getFile(name));
}
}
return files.toArray(new MultipartFile[0]);
} else {
if (logger.isDebugEnabled()) {
logger.debug(
"cann't "
+ "set MultipartFile param to method "
+ ", the request is not a MultipartRequest");
}
}
} else {
Object toConvert = null;
for (String paramName : metaData.getParamNames()) {
if (paramName != null) {
toConvert = inv.getRequest().getParameterValues(paramName);
if (toConvert != null) {
break;
}
}
}
if (toConvert != null) {
if (((String[]) toConvert).length == 1) {
toConvert = ((String[]) toConvert)[0].split(",");
}
Class<?> arrayType;
if (metaData.getParamType().isArray()) {
arrayType = metaData.getParamType();
} else {
arrayType = arrayTypeMap.get(compnentType);
if (arrayType == null) {
arrayType = Array.newInstance((Class<?>) compnentType, 0).getClass();
}
}
TypeConverter typeConverter = SafedTypeConverterFactory.getCurrentConverter();
Object array = typeConverter.convertIfNecessary(toConvert, arrayType);
return array;
}
}
return Array.newInstance((Class<?>) compnentType, 0);
}
public Object[] resolve(final Invocation inv, final ParameterBindingResult parameterBindingResult)
throws Exception {
Object[] parameters = new Object[paramMetaDatas.length];
for (int i = 0; i < resolvers.length; i++) {
if (resolvers[i] == null) {
continue;
}
try {
if (logger.isDebugEnabled()) {
logger.debug(
"Resolves parameter "
+ paramMetaDatas[i].getParamType().getSimpleName()
+ " using "
+ resolvers[i].getClass().getName());
}
parameters[i] = resolvers[i].resolve(inv, paramMetaDatas[i]);
// afterPropertiesSet
if (parameters[i] instanceof InitializingBean) {
((InitializingBean) parameters[i]).afterPropertiesSet();
}
if (parameters[i] == null) {
DefValue defValudeAnnotation = paramMetaDatas[i].getAnnotation(DefValue.class);
if (defValudeAnnotation != null && paramMetaDatas[i].getParamType() == String.class) {
parameters[i] = defValudeAnnotation.value();
}
}
} catch (TypeMismatchException e) {
// 出现这个错误肯定是解析一般参数失败导致的，而非bean里面的某个属性值的解析失败
logger.debug("", e);
// 对简单类型的参数，设置一个默认值给它以支持对该方法的继续调用
if (paramMetaDatas[i].getParamType().isPrimitive()) {
DefValue defValudeAnnotation = paramMetaDatas[i].getAnnotation(DefValue.class);
if (defValudeAnnotation == null
|| DefValue.NATIVE_DEFAULT.equals(defValudeAnnotation.value())) {
// 对这最常用的类型做一下if-else判断，其他类型就简单使用converter来做吧
if (paramMetaDatas[i].getParamType() == int.class) {
parameters[i] = Integer.valueOf(0);
} else if (paramMetaDatas[i].getParamType() == long.class) {
parameters[i] = Long.valueOf(0);
} else if (paramMetaDatas[i].getParamType() == boolean.class) {
parameters[i] = Boolean.FALSE;
} else if (paramMetaDatas[i].getParamType() == double.class) {
parameters[i] = Double.valueOf(0);
} else if (paramMetaDatas[i].getParamType() == float.class) {
parameters[i] = Float.valueOf(0);
} else {
TypeConverter typeConverter = SafedTypeConverterFactory.getCurrentConverter();
parameters[i] =
typeConverter.convertIfNecessary("0", paramMetaDatas[i].getParamType());
}
} else {
TypeConverter typeConverter = SafedTypeConverterFactory.getCurrentConverter();
parameters[i] =
typeConverter.convertIfNecessary(
defValudeAnnotation.value(), paramMetaDatas[i].getParamType());
}
}
//
String paramName = parameterNames[i];
if (paramName == null) {
for (String name : paramMetaDatas[i].getParamNames()) {
if ((paramName = name) != null) {
break;
}
}
}
Assert.isTrue(paramName != null);
FieldError fieldError =
new FieldError( //
"method", // 该出错字段所在的对象的名字；对于这类异常我们统一规定名字为method
paramName, // 出错的字段的名字；取其参数名
inv.getParameter(paramName), // 被拒绝的值
true, // whether this error represents a binding failure (like a type mismatch);
// else, it is a validation failure
new String[] {e.getErrorCode()}, // "typeMismatch"
new String[] {
inv.getParameter(paramName)
}, // the array of arguments to be used to resolve this message
null // the default message to be used to resolve this message
);
parameterBindingResult.addError(fieldError);
} catch (Exception e) {
// 什么错误呢？比如很有可能是构造对象不能成功导致的错误，没有默认构造函数、构造函数执行失败等等
logger.error("", e);
throw e;
}
}
return parameters;
}
