Java MethodParameter.getParameterAnnotation方法代码示例

import org.springframework.core.MethodParameter; //导入方法依赖的package包/类
@Override
public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {

    HttpServletRequest servletRequest = webRequest.getNativeRequest(HttpServletRequest.class);
    MultipartHttpServletRequest multipartRequest = WebUtils.getNativeRequest(servletRequest, MultipartHttpServletRequest.class);

    ExcelRequestBody annotation = parameter.getParameterAnnotation(ExcelRequestBody.class);
    if (multipartRequest != null) {
        List<Object> result = new ArrayList<>();
        List<MultipartFile> files = multipartRequest.getFiles(annotation.name());
        for (MultipartFile file : files) {
            if (converters.supportsExcelType(annotation.type())) {
                List<?> part = converters.fromExcel(annotation, file.getInputStream());
                result.addAll(part);
            }
        }
        return result;
    }
    return null;

}
 

import org.springframework.core.MethodParameter; //导入方法依赖的package包/类
@Override
public void contributeMethodArgument(MethodParameter parameter, Object value,
		UriComponentsBuilder builder, Map<String, Object> uriVariables, ConversionService conversionService) {

	Class<?> paramType = parameter.getParameterType();
	if (Map.class.isAssignableFrom(paramType) || MultipartFile.class.equals(paramType) ||
			"javax.servlet.http.Part".equals(paramType.getName())) {
		return;
	}

	RequestParam annot = parameter.getParameterAnnotation(RequestParam.class);
	String name = StringUtils.isEmpty(annot.value()) ? parameter.getParameterName() : annot.value();

	if (value == null) {
		builder.queryParam(name);
	}
	else if (value instanceof Collection) {
		for (Object element : (Collection<?>) value) {
			element = formatUriValue(conversionService, TypeDescriptor.nested(parameter, 1), element);
			builder.queryParam(name, element);
		}
	}
	else {
		builder.queryParam(name, formatUriValue(conversionService, new TypeDescriptor(parameter), value));
	}
}
 

import org.springframework.core.MethodParameter; //导入方法依赖的package包/类
@Override
public void contributeMethodArgument(MethodParameter parameter, Object value, UriComponentsBuilder builder, Map<String, Object> uriVariables, ConversionService conversionService) {
    Class<?> paramType = parameter.getNestedParameterType();
    if (Map.class.isAssignableFrom(paramType)) {
        return;
    }
    WxApiParam wxApiParam = parameter.getParameterAnnotation(WxApiParam.class);
    String name = (wxApiParam == null || StringUtils.isEmpty(wxApiParam.name()) ? parameter.getParameterName() : wxApiParam.name());
    WxAppAssert.notNull(name, "请添加编译器的-parameter或者为参数添加注解名称");
    if (value == null) {
        if (wxApiParam != null) {
            if (!wxApiParam.required() || !wxApiParam.defaultValue().equals(ValueConstants.DEFAULT_NONE)) {
                return;
            }
        }
        builder.queryParam(name);
    } else if (value instanceof Collection) {
        for (Object element : (Collection<?>) value) {
            element = formatUriValue(conversionService, TypeDescriptor.nested(parameter, 1), element);
            builder.queryParam(name, element);
        }
    } else {
        builder.queryParam(name, formatUriValue(conversionService, new TypeDescriptor(parameter), value));
    }
}
 

import org.springframework.core.MethodParameter; //导入方法依赖的package包/类
@Override
protected NamedValueInfo createNamedValueInfo(MethodParameter parameter) {
	RequestParam annotation = parameter.getParameterAnnotation(RequestParam.class);
	return (annotation != null) ?
			new RequestParamNamedValueInfo(annotation) :
			new RequestParamNamedValueInfo();
}
 

import org.springframework.core.MethodParameter; //导入方法依赖的package包/类
@Override
public boolean supportsParameter(MethodParameter parameter) {
	RequestParam requestParamAnnot = parameter.getParameterAnnotation(RequestParam.class);
	if (requestParamAnnot != null) {
		if (Map.class.isAssignableFrom(parameter.getParameterType())) {
			return !StringUtils.hasText(requestParamAnnot.value());
		}
	}
	return false;
}
 

import org.springframework.core.MethodParameter; //导入方法依赖的package包/类
@Override
public Object resolveArgument(MethodParameter parameter,
                              RestRequest request, RestDelegate handler) throws Exception {
    Class<?> type = parameter.getParameterType();
    RequestParam annotation = parameter
            .getParameterAnnotation(RequestParam.class);
    String value = annotation.value();

    JSONObject operationInput = new JSONObject(request.getOperationInput());
    Object param = operationInput.opt(value);
    return objectMapper.readValue(param != null ? param.toString() : null,
            type);
}
 

import org.springframework.core.MethodParameter; //导入方法依赖的package包/类
@Override
public Object resolveArgument(MethodParameter parameter,
                              RestRequest request, RestDelegate handler) throws Exception {
    Class<?> type = parameter.getParameterType();
    BeanParam annotation = parameter
            .getParameterAnnotation(BeanParam.class);
    if (annotation != null) {
        return objectMapper.readValue(request.getOperationInput(), type);
    }
    return null;
}
 

import org.springframework.core.MethodParameter; //导入方法依赖的package包/类
@Override
public void contributeMethodArgument(MethodParameter parameter, Object value,
                                     UriComponentsBuilder builder, Map<String, Object> uriVariables, ConversionService conversionService) {
    if (Map.class.isAssignableFrom(parameter.nestedIfOptional().getNestedParameterType())) {
        return;
    }
    WxApiPath wx = parameter.getParameterAnnotation(WxApiPath.class);
    String name = (wx != null && !StringUtils.isEmpty(wx.value()) ? wx.value() : parameter.getParameterName());
    WxAppAssert.notNull(name, "请添加编译器的-parameter或者为参数添加注解名称");
    value = formatUriValue(conversionService, new TypeDescriptor(parameter.nestedIfOptional()), value);
    uriVariables.put(name, value);
}
 

import org.springframework.core.MethodParameter; //导入方法依赖的package包/类
@Override
protected NamedValueInfo createNamedValueInfo(MethodParameter parameter) {
	Value annotation = parameter.getParameterAnnotation(Value.class);
	return new ExpressionValueNamedValueInfo(annotation);
}
 

import org.springframework.core.MethodParameter; //导入方法依赖的package包/类
@Override
protected NamedValueInfo createNamedValueInfo(MethodParameter parameter) {
	RequestHeader annotation = parameter.getParameterAnnotation(RequestHeader.class);
	return new RequestHeaderNamedValueInfo(annotation);
}
 

import org.springframework.core.MethodParameter; //导入方法依赖的package包/类
@Override
protected NamedValueInfo createNamedValueInfo(MethodParameter parameter) {
	CookieValue annotation = parameter.getParameterAnnotation(CookieValue.class);
	return new CookieValueNamedValueInfo(annotation);
}
 

import org.springframework.core.MethodParameter; //导入方法依赖的package包/类
@Override
public boolean resolves(MethodParameter parameter) {
    return parameter.getParameterAnnotation(RequestParam.class) != null;
}
 

import org.springframework.core.MethodParameter; //导入方法依赖的package包/类
@Override
public boolean resolves(MethodParameter parameter) {
    return parameter.getMethodAnnotation(RequestMapping.class) != null
            && parameter.getParameterAnnotation(PathVariable.class) != null;
}
 

import org.springframework.core.MethodParameter; //导入方法依赖的package包/类
@Override
public boolean resolves(MethodParameter parameter) {
    return parameter.getParameterAnnotation(BeanParam.class) != null;
}
 

import org.springframework.core.MethodParameter; //导入方法依赖的package包/类
/**
 * Derives the model attribute name for a method parameter based on:
 * <ol>
 * 	<li>The parameter {@code @ModelAttribute} annotation value
 * 	<li>The parameter type
 * </ol>
 * @return the derived name; never {@code null} or an empty string
 */
public static String getNameForParameter(MethodParameter parameter) {
	ModelAttribute annot = parameter.getParameterAnnotation(ModelAttribute.class);
	String attrName = (annot != null) ? annot.value() : null;
	return StringUtils.hasText(attrName) ? attrName :  Conventions.getVariableNameForParameter(parameter);
}