@Override
public boolean innerSupports(ParamMetaData metaData) {
return List.class == metaData.getParamType()
|| Collection.class == metaData.getParamType()
|| (!Modifier.isAbstract(metaData.getParamType().getModifiers())
&& List.class.isAssignableFrom(metaData.getParamType()));
}
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 BindingResult resolve(Invocation inv, ParamMetaData metaData) {
if (metaData.getParamName() != null) {
return inv.getBindingResult(metaData.getParamName());
} else {
return inv.getParameterBindingResult();
}
}
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;
}
@Override
@SuppressWarnings("unchecked")
protected Collection create(ParamMetaData metaData, int len) throws Exception {
if (metaData.getParamType().isInterface()) {
return new HashSet<Object>(len);
} else {
return (Collection<?>) metaData.getParamType().getConstructor().newInstance();
}
}
public boolean supports(ParamMetaData metaData) {
boolean result = metaData.getParamType() == Mvc.class;
if (result) {
if (!metaData.getControllerClass().getName().startsWith("com.sinosoft.one.mvc")) {
throw new IllegalStateException("Mvc is not allowed as a method parameter:" + metaData);
}
}
return result;
}
@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);
}
@SuppressWarnings("unchecked")
public Object resolve(Invocation inv, ParamMetaData metaData) {
for (String paramName : metaData.getParamNames()) {
if (paramName != null) {
String value = inv.getParameter(paramName);
if (value != null) {
return Enum.valueOf((Class<? extends Enum>) metaData.getParamType(), value);
}
}
}
return null;
}
public Date resolve(Invocation inv, ParamMetaData metaData) throws Exception {
String text = null;
for (String paramName : metaData.getParamNames()) {
if (paramName != null) {
text = inv.getParameter(paramName);
if (text != null && (text = text.trim()).length() > 0) {
break;
}
}
}
Date date = resolveUtilDate(text, metaData);
return DatePatterns.changeType(date, metaData.getParamType());
}
public Object resolve(Invocation inv, ParamMetaData metaData) {
Object bean = MvcBeanUtils.instantiateClass(metaData.getParamType());
ServletRequestDataBinder binder;
if (!metaData.isAnnotationPresent(Param.class)) {
binder = new ServletRequestDataBinder(bean);
} else {
binder = new ServletRequestDataBinder(bean, metaData.getParamName());
}
binder.bind(inv.getRequest());
String bindingResultName =
BindingResult.MODEL_KEY_PREFIX + metaData.getParamName() + "BindingResult";
inv.addModel(bindingResultName, binder.getBindingResult());
return bean;
}
public HttpSession resolve(Invocation inv, ParamMetaData metaData) {
boolean create = true;
Create createAnnotation = metaData.getAnnotation(Create.class);
if (createAnnotation != null) {
create = createAnnotation.value();
}
return inv.getRequest().getSession(create);
}
public MultipartFile resolve(Invocation inv, ParamMetaData metaData) {
MultipartFile multipartFile = null;
if (inv.getRequest() instanceof MultipartRequest) {
MultipartRequest multipartRequest = (MultipartRequest) inv.getRequest();
String fileName = metaData.getParamName();
if (StringUtils.isBlank(fileName)) {
@SuppressWarnings("unchecked")
Iterator<String> allFileNames = multipartRequest.getFileNames();
if (allFileNames.hasNext()) {
fileName = allFileNames.next();
}
}
if (StringUtils.isNotBlank(fileName)) {
multipartFile = multipartRequest.getFile(fileName);
}
if (multipartFile == null) {
if (StringUtils.isNotBlank(fileName)) {
if (logger.isDebugEnabled()) {
logger.debug(
"not found multipartFile named "
+ fileName
+ " in this request: "
+ inv.getRequestPath().getUri());
}
} else {
if (logger.isDebugEnabled()) {
logger.debug(
"not found MultipartFile named:"
+ metaData.getParamName()
+ " in this request: "
+ inv.getRequestPath().getUri());
}
}
}
} else {
if (logger.isDebugEnabled()) {
logger.debug(
"cann't set MultipartFile param to method "
+ ", the request is not a MultipartRequest");
}
}
return multipartFile;
}
protected Date resolveUtilDate(String text, ParamMetaData metaData) throws ParseException {
if (StringUtils.isEmpty(text)) {
DefValue defaultValudeAnnotation = metaData.getAnnotation(DefValue.class);
if (defaultValudeAnnotation != null
&& !DefValue.NATIVE_DEFAULT.equals(defaultValudeAnnotation.value())) {
if (StringUtils.isEmpty(defaultValudeAnnotation.value())) {
return new Date(); // 当前时间!
} else {
text = defaultValudeAnnotation.value(); // 改变要被解析的文本!
}
} else {
return null; // 保留null，而非当前时间
}
}
Annotation[] paramAnnotations =
metaData.getMethod().getParameterAnnotations()[metaData.getIndex()];
for (Annotation annotation : paramAnnotations) {
if (annotation instanceof Pattern) {
String[] patterns = Pattern.class.cast(annotation).value();
for (String pattern : patterns) {
// 以long为时间
if ("long".equals(pattern)) {
boolean digit = true;
for (int i = 0; i < text.length(); i++) {
if (!Character.isDigit(text.charAt(i))) {
digit = false;
break;
}
}
if (digit) {
return new Date(Long.parseLong(text));
}
}
// 可以配置多个pattern!! 通过长度匹配
if (text.length() == pattern.length()) {
return new SimpleDateFormat(pattern).parse(text);
}
}
break;
}
}
return DatePatterns.parse(text);
}
@SuppressWarnings("unchecked")
public Object resolve(Invocation inv, ParamMetaData metaData) throws Exception {
Object array = resolveArray(inv, metaData, (Class<?>) metaData.getUserObject(this));
int len = ArrayUtils.getLength(array);
Collection collection = create(metaData, len);
for (int i = 0; i < len; i++) {
collection.add(Array.get(array, i));
}
return collection;
}
public String resolve(Invocation inv, ParamMetaData metaData) {
for (String paramName : metaData.getParamNames()) {
if (paramName != null) {
String value = inv.getParameter(paramName);
if (value != null) {
return value;
}
}
}
return null;
}
public boolean supports(ParamMetaData metaData) {
boolean supports =
Map.class == metaData.getParamType() || HashMap.class == metaData.getParamType();
if (supports) {
Class<?>[] generics =
compileGenericParameterTypesDetail(metaData.getMethod(), metaData.getIndex());
if (generics == null || generics.length == 0) {
throw new IllegalArgumentException(
"please use generic for "
+ metaData.getParamType().getName()
+ " ["
+ metaData.getControllerClass().getName()
+ "."
+ metaData.getMethod().getName()
+ "]");
}
metaData.setUserObject(this, generics);
}
return supports;
}
private static boolean addIndexAliasParamNameIfNeccessary(ParamMetaData metaData) {
Class<?>[] paramTypes = metaData.getMethod().getParameterTypes();
int index = metaData.getIndex(); // index是从0开始的
int uriParamIndex = 0; // uriParamIndex，有效的值是从**1**开始的
int breakIndex = 0; // breakIndex从0开始的
for (; breakIndex < paramTypes.length && breakIndex <= index; breakIndex++) {
Class<?> type = paramTypes[breakIndex];
if (type.isArray()) {
type = type.getComponentType();
} else if (Collection.class.isAssignableFrom(type)) {
Class<?>[] generics = compileGenericParameterTypesDetail(metaData.getMethod(), breakIndex);
if (generics == null) {
return false;
}
Assert.isTrue(generics.length > 0);
type = generics[0];
}
if (ClassUtils.isPrimitiveOrWrapper(type)
|| type == String.class
|| Date.class.isAssignableFrom(type)) {
uriParamIndex++;
}
}
if ((breakIndex - 1) == index && uriParamIndex > 0) {
String alias = "$" + uriParamIndex;
metaData.addAliasParamName(alias);
if (logger.isDebugEnabled()) {
logger.debug(
"add index alias paramName: '"
+ alias
+ "' for "
+ metaData.getControllerClass().getName()
+ "."
+ metaData.getMethod().getName()
+ "(..."
+ metaData.getParamType()
+ "[index="
+ breakIndex
+ "] ...)");
}
return true;
}
return false;
}
public final boolean supports(ParamMetaData metaData) {
if (innerSupports(metaData)) {
Class<?>[] generics =
compileGenericParameterTypesDetail(metaData.getMethod(), metaData.getIndex());
if (generics == null || generics.length == 0) {
throw new IllegalArgumentException(
"please use generic for "
+ metaData.getParamType().getName()
+ " ["
+ metaData.getControllerClass().getName()
+ "."
+ metaData.getMethod().getName()
+ "]");
}
metaData.setUserObject(this, generics[0]);
return true;
}
return false;
}
public boolean supports(ParamMetaData metaData) {
return HttpServletResponse.class == metaData.getParamType()
|| ServletResponse.class == metaData.getParamType();
}
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) {
return HttpSession.class == metaData.getParamType();
}
public boolean supports(ParamMetaData metaData) {
return String.class == metaData.getParamType();
}
public boolean supports(ParamMetaData metaData) {
return MultipartHttpServletRequest.class == metaData.getParamType();
}
public boolean supports(ParamMetaData metaData) {
return Date.class == metaData.getParamType()
|| java.sql.Date.class == metaData.getParamType()
|| java.sql.Time.class == metaData.getParamType()
|| java.sql.Timestamp.class == metaData.getParamType();
}
public boolean supports(ParamMetaData metaData) {
return MultipartFile.class == metaData.getParamType();
}
public boolean supports(ParamMetaData metaData) {
return !Modifier.isAbstract(metaData.getParamType().getModifiers());
}
public boolean supports(ParamMetaData metaData) {
return BindingResult.class == metaData.getParamType()
|| Errors.class == metaData.getParamType();
}
public boolean supports(ParamMetaData metaData) {
return ServletContext.class == metaData.getParamType();
}
public boolean supports(ParamMetaData metaData) {
return metaData.getParamType().isArray();
}
public Object resolve(Invocation inv, ParamMetaData metaData) {
return resolveArray(inv, metaData, metaData.getParamType().getComponentType());
}
