@VisibleForTesting @SuppressWarnings("squid:S1872") boolean isOptional(ResolvedMethodParameter methodParameter) { return "java.util.Optional".equals(methodParameter.getParameterType().getErasedType().getName()); }
public static <T extends Annotation> Optional<T> annotationFromParameter( ParameterContext context, Class<T> annotationType) { ResolvedMethodParameter methodParam = context.resolvedMethodParameter(); return methodParam.findAnnotation(annotationType); }
@Override public List<ResolvedMethodParameter> apply(ResolvedMethod input) { List<ResolvedMethodParameter> parameters = newArrayList(); MethodParameter[] methodParameters = methodToResolve.getMethodParameters(); for (int i = 0; i < input.getArgumentCount(); i++) { parameters.add(new ResolvedMethodParameter( discoveredName(methodParameters[i]).or(String.format("param%s", i)), methodParameters[i], input.getArgumentType(i))); } return parameters; } };
@Override protected int doHash(ResolvedMethodParameter self) { return Objects.hashCode( self.defaultName(), self.getParameterIndex(), self.getParameterType()); } }
public static String findParameterType(ParameterContext parameterContext) { ResolvedMethodParameter resolvedMethodParameter = parameterContext.resolvedMethodParameter(); ResolvedType parameterType = resolvedMethodParameter.getParameterType(); parameterType = parameterContext.alternateFor(parameterType); return "form"; if (resolvedMethodParameter.hasParameterAnnotation(PathVariable.class)) { return "path"; } else if (resolvedMethodParameter.hasParameterAnnotation(RequestBody.class)) { return "body"; } else if (resolvedMethodParameter.hasParameterAnnotation(RequestPart.class)) { return "formData"; } else if (resolvedMethodParameter.hasParameterAnnotation(RequestParam.class)) { return determineScalarParameterType( parameterContext.getOperationContext().consumes(), parameterContext.getOperationContext().httpMethod()); } else if (resolvedMethodParameter.hasParameterAnnotation(RequestHeader.class)) { return "header"; } else if (resolvedMethodParameter.hasParameterAnnotation(ModelAttribute.class)) { LOGGER.warn("@ModelAttribute annotated parameters should have already been expanded via " + "the ExpandedParameterBuilderPlugin"); if (!resolvedMethodParameter.hasParameterAnnotations()) { return determineScalarParameterType( parameterContext.getOperationContext().consumes(),
@Override public void apply(ParameterContext context) { Optional<ApiParam> apiParam = context.resolvedMethodParameter().findAnnotation(ApiParam.class); context.parameterBuilder() .allowableValues(allowableValues( context.alternateFor(context.resolvedMethodParameter().getParameterType()), apiParam.transform(toAllowableValue()).or(""))); if (apiParam.isPresent()) { ApiParam annotation = apiParam.get(); context.parameterBuilder().name(emptyToNull(annotation.name())) .description(emptyToNull(descriptions.resolve(annotation.value()))) .parameterAccess(emptyToNull(annotation.access())) .defaultValue(emptyToNull(annotation.defaultValue())) .allowMultiple(annotation.allowMultiple()) .allowEmptyValue(annotation.allowEmptyValue()) .required(annotation.required()) .scalarExample(new Example(annotation.example())) .complexExamples(examples(annotation.examples())) .hidden(annotation.hidden()) .collectionFormat(annotation.collectionFormat()) .order(SWAGGER_PLUGIN_ORDER); } }
private void collectParameters(RequestMappingContext context) { LOG.debug("Reading parameters models for handlerMethod |{}|", context.getName()); List<ResolvedMethodParameter> parameterTypes = context.getParameters(); for (ResolvedMethodParameter parameterType : parameterTypes) { if (parameterType.hasParameterAnnotation(RequestBody.class) || parameterType.hasParameterAnnotation(RequestPart.class)) { ResolvedType modelType = context.alternateFor(parameterType.getParameterType()); LOG.debug("Adding input parameter of type {}", resolvedTypeSignature(modelType).or("<null>")); context.operationModelsBuilder().addInputParam(modelType); } } LOG.debug("Finished reading parameters models for handlerMethod |{}|", context.getName()); } }
Optional<RequestParam> requestParam = methodParameter.findAnnotation(RequestParam.class); if (requestParam.isPresent()) { requiredSet.add(!optional && isRequired(requestParam.get())); Optional<RequestHeader> requestHeader = methodParameter.findAnnotation(RequestHeader.class); if (requestHeader.isPresent()) { requiredSet.add(!optional && requestHeader.get().required()); Optional<PathVariable> pathVariable = methodParameter.findAnnotation(PathVariable.class); if (pathVariable.isPresent()) { String paramName = MoreObjects.firstNonNull( emptyToNull(pathVariable.get().name()), methodParameter.defaultName().orNull()); Optional<RequestBody> requestBody = methodParameter.findAnnotation(RequestBody.class); if (requestBody.isPresent()) { requiredSet.add(!optional && requestBody.get().required()); Optional<RequestPart> requestPart = methodParameter.findAnnotation(RequestPart.class); if (requestPart.isPresent()) { requiredSet.add(!optional && requestPart.get().required());
@Override public void apply(ParameterContext context) { String name = findParameterNameFromAnnotations(context.resolvedMethodParameter()); if (isNullOrEmpty(name)) { Optional<String> discoveredName = context.resolvedMethodParameter().defaultName(); name = discoveredName.isPresent() ? discoveredName.get() : format("param%s", context.resolvedMethodParameter().getParameterIndex()); } context.parameterBuilder() .name(name) .description(name); }
@Override public boolean apply(Class input) { return parameter.hasParameterAnnotation(input); } };
@Override public void apply(ParameterContext parameterContext) { ResolvedMethodParameter parameter = parameterContext.resolvedMethodParameter(); List<Annotation> annotations = parameter.getAnnotations(); //判断是否已有RequestParam RequestBody RequestAttribute注解,若有则不变,若没有则默认改为RequestParam(form表单类型) boolean isChoose = false; for (Annotation annotation : annotations) { Class<? extends Annotation> type = annotation.annotationType(); if (type == PathVariable.class || type == RequestParam.class || type == RequestBody.class || type == RequestAttribute.class) { isChoose = true; if (type == PathVariable.class) { parameterContext.parameterBuilder().required(true); } break; } if (type == ApiParam.class) { ApiParam api = (ApiParam) annotation; if (StringUtil.notEmpty(api.type())) { isChoose = true; } } } if (!isChoose && swaggerProperties.getDefaultApiParamType() != null) { parameterContext.parameterBuilder().parameterType(swaggerProperties.getDefaultApiParamType()); } }
@Override protected boolean doEquivalent(ResolvedMethodParameter a, ResolvedMethodParameter b) { return Objects.equal(a.defaultName(), b.defaultName()) && Objects.equal(a.getParameterIndex(), b.getParameterIndex()) && Objects.equal(a.getParameterType(), b.getParameterType()); }
@Override public void apply(ParameterContext context) { ResolvedMethodParameter methodParameter = context.resolvedMethodParameter(); ResolvedType parameterType = methodParameter.getParameterType(); parameterType = context.alternateFor(parameterType); ModelReference modelRef = null; if (methodParameter.hasParameterAnnotation(PathVariable.class) && treatAsAString(parameterType)) { parameterType = resolver.resolve(String.class); modelRef = new ModelRef("string"); } else if (methodParameter.hasParameterAnnotation(RequestParam.class) && isMapType(parameterType)) { modelRef = new ModelRef("", new ModelRef("string"), true); } else if (methodParameter.hasParameterAnnotation(RequestParam.class) && treatRequestParamAsString(parameterType)) { parameterType = resolver.resolve(String.class); modelRef = new ModelRef("string"); if (!methodParameter.hasParameterAnnotations()) { String typeName = typeNameFor(parameterType.getErasedType()); if (isBaseType(typeName)) {
private boolean shouldExpand(final ResolvedMethodParameter parameter, ResolvedType resolvedParamType) { return !parameter.hasParameterAnnotation(RequestBody.class) && !parameter.hasParameterAnnotation(RequestPart.class) && !parameter.hasParameterAnnotation(RequestParam.class) && !parameter.hasParameterAnnotation(PathVariable.class) && !isBaseType(typeNameFor(resolvedParamType.getErasedType())) && !enumTypeDeterminer.isEnum(resolvedParamType.getErasedType()) && !isContainerType(resolvedParamType) && !isMapType(resolvedParamType); }
private boolean handlerMethodHasFileParameter(OperationContext context) { List<ResolvedMethodParameter> methodParameters = context.getParameters(); for (ResolvedMethodParameter resolvedMethodParameter : methodParameters) { if (MultipartFile.class.isAssignableFrom(resolvedMethodParameter.getParameterType().getErasedType())) { return true; } } return false; }
private String findAnnotatedDefaultValue(ResolvedMethodParameter methodParameter) { Optional<RequestParam> requestParam = methodParameter.findAnnotation(RequestParam.class); if (requestParam.isPresent()) { return descriptions.resolve(requestParam.get().defaultValue()); } Optional<RequestHeader> requestHeader = methodParameter.findAnnotation(RequestHeader.class); if (requestHeader.isPresent()) { return descriptions.resolve(requestHeader.get().defaultValue()); } return null; } }
@Override public void apply(ParameterContext context) { ResolvedType parameterType = context.resolvedMethodParameter().getParameterType(); context.parameterBuilder().allowMultiple(isCollectionType(parameterType)); }
private String findParameterNameFromAnnotations(ResolvedMethodParameter methodParameter) { return methodParameter.findAnnotation(PathVariable.class).transform(pathVariableValue()) .or(methodParameter.findAnnotation(ModelAttribute.class).transform(modelAttributeValue())) .or(methodParameter.findAnnotation(RequestParam.class).transform(requestParamValue())) .or(methodParameter.findAnnotation(RequestHeader.class).transform(requestHeaderValue())) .or(methodParameter.findAnnotation(RequestPart.class).transform(requestPartValue())) .orNull(); }
private List<Parameter> readParameters(final OperationContext context) { List<ResolvedMethodParameter> methodParameters = context.getParameters(); List<Parameter> parameters = newArrayList(); for (ResolvedMethodParameter methodParameter : methodParameters) { ResolvedType alternate = context.alternateFor(methodParameter.getParameterType()); if (!shouldIgnore(methodParameter, alternate, context.getIgnorableParameterTypes())) { ParameterContext parameterContext = new ParameterContext(methodParameter, new ParameterBuilder(), context.getDocumentationContext(), context.getGenericsNamingStrategy(), context); if (shouldExpand(methodParameter, alternate)) { parameters.addAll( expander.expand( new ExpansionContext("", alternate, context))); } else { parameters.add(pluginsManager.parameter(parameterContext)); } } } return FluentIterable.from(parameters).filter(not(hiddenParams())).toList(); }
@Override public void apply(OperationContext context) { List<Parameter> parameters = newArrayList(); for (ResolvedMethodParameter methodParameter : context.getParameters()) { ResolvedType resolvedType = methodParameter.getParameterType(); if (pageableType.equals(resolvedType)) { ParameterContext parameterContext = new ParameterContext(methodParameter, new ParameterBuilder(), context.getDocumentationContext(), context.getGenericsNamingStrategy(), context); parameters.add(createPageParameter(parameterContext)); parameters.add(createSizeParameter(parameterContext)); parameters.add(createSortParameter(parameterContext)); context.operationBuilder().parameters(parameters); } } }