io.swagger.annotations.SwaggerDefinition#io.swagger.models.parameters.Parameter源码实例Demo

private void fillRequestType(Operation operation, ProtoMethod protoMethod) {
  List<Parameter> parameters = operation.getParameters();
  if (parameters.isEmpty()) {
    addImports(ProtoConst.EMPTY_PROTO);
    protoMethod.setArgTypeName(ProtoConst.EMPTY.getCanonicalName());
    return;
  }

  if (parameters.size() == 1) {
    String type = convertSwaggerType(parameters.get(0));
    if (messages.contains(type)) {
      protoMethod.setArgTypeName(type);
      return;
    }
  }

  String wrapName = StringUtils.capitalize(operation.getOperationId()) + "RequestWrap";
  createWrapArgs(wrapName, parameters);

  protoMethod.setArgTypeName(wrapName);
}
 

@Override
public Object extract(String name, Parameter parameter, RoutingContext context) {
    BodyParameter bodyParam = (BodyParameter) parameter;
    if ("".equals(context.getBodyAsString())) {
        if (bodyParam.getRequired())
            throw new IllegalArgumentException("Missing required parameter: " + name);
        else
            return null;
    }

    try {
        if(bodyParam.getSchema() instanceof ArrayModel) {
            return context.getBodyAsJsonArray();
        } else {
            return context.getBodyAsJson();
        }
    } catch (DecodeException e) {
        return context.getBodyAsString();  
    }
}
 

/**
 * Implemented to allow loading of custom types using PackageClassLoader.
 */
@Override
public void applyImplicitParameters(ReaderContext context, Operation operation, Method method) {
    // copied from io.swagger.servlet.extensions.ServletReaderExtension
    final ApiImplicitParams implicitParams = method.getAnnotation(ApiImplicitParams.class);
    if (implicitParams != null && implicitParams.value().length > 0) {
        for (ApiImplicitParam param : implicitParams.value()) {
            final Parameter p = readImplicitParameter(context.getSwagger(), param);
            if (p != null) {
                if (p instanceof BodyParameter && param.format() != null)
                    p.getVendorExtensions().put("format", param.format());
                operation.parameter(p);
            }
        }
    }
}
 

@SuppressWarnings({"rawtypes", "unchecked"})
private static Map<String, Object> addPrimitiveTypeDefaultValues(Invocation invocation,
    Map<String, Object> swaggerArguments) {
  // proto buffer never serialize default values, put it back in provider
  if (invocation.getOperationMeta().getSwaggerProducerOperation() != null && !invocation.isEdge()) {
    List<Parameter> swaggerParameters = invocation.getOperationMeta().getSwaggerOperation()
        .getParameters();
    for (Parameter parameter : swaggerParameters) {
      if (swaggerArguments.get(parameter.getName()) == null) {
        Type type = invocation.getOperationMeta().getSwaggerProducerOperation()
            .getSwaggerParameterType(parameter.getName());
        if (type instanceof Class) {
          if (((Class) type).isPrimitive()) {
            swaggerArguments.put(parameter.getName(), Defaults.defaultValue((Class) type));
          }
        }
      }
    }
  }
  return swaggerArguments;
}
 

/**
 * EdgeService cannot recognize the map type form body whose value type is String,
 * so there should be this additional setting.
 * @param parameter the swagger information of the parameter
 * @param type the resolved param type
 * @return the corrected param type
 */
private Type correctFormBodyType(Parameter parameter, Type type) {
  if (null != type || !(parameter instanceof BodyParameter)) {
    return type;
  }
  final BodyParameter bodyParameter = (BodyParameter) parameter;
  if (!(bodyParameter.getSchema() instanceof ModelImpl)) {
    return type;
  }
  final Property additionalProperties = ((ModelImpl) bodyParameter.getSchema()).getAdditionalProperties();
  if (additionalProperties instanceof StringProperty) {
    type = RestObjectMapperFactory.getRestObjectMapper().getTypeFactory()
        .constructMapType(Map.class, String.class, String.class);
  }
  return type;
}
 

private Parameter readParam(Swagger swagger, Type type, Class<?> cls, ApiParam param) {
    PrimitiveType fromType = PrimitiveType.fromType(type);
    final Parameter para = null == fromType ? new BodyParameter() : new QueryParameter();
    Parameter parameter = ParameterProcessor.applyAnnotations(swagger, para, type,
        null == param ? new ArrayList<Annotation>()
            : Collections.<Annotation> singletonList(param));
    if (parameter instanceof AbstractSerializableParameter) {
        final AbstractSerializableParameter<?> p = (AbstractSerializableParameter<?>) parameter;
        if (p.getType() == null) {
            p.setType(null == fromType ? "string" : fromType.getCommonName());
        }
        p.setRequired(p.getRequired() || cls.isPrimitive());
    } else {
        //hack: Get the from data model paramter from BodyParameter
        BodyParameter bp = (BodyParameter) parameter;
        bp.setIn("body");
        Property property = ModelConverters.getInstance().readAsProperty(type);
        final Map<PropertyBuilder.PropertyId, Object> args = new EnumMap<PropertyBuilder.PropertyId, Object>(
            PropertyBuilder.PropertyId.class);
        bp.setSchema(PropertyBuilder.toModel(PropertyBuilder.merge(property, args)));
    }
    return parameter;
}
 

@Override
public void updatePathParameterValue(Parameter parameter, Object example) {
    if (parameter.getName().contains("id")) {
        System.getenv();
    }

    if (example == null)
        return;

    if (path.contains(parameter.getName()))
        path = StringUtils.replace(
                path,
                '{' + parameter.getName() + '}',
                encodeExampleForUrl(example)
        );
}
 

@Override
public ParamValueProcessor create(Parameter parameter, Type genericParamType) {
  Model model = ((BodyParameter) parameter).getSchema();
  JavaType swaggerType = null;
  if (model instanceof ModelImpl) {
    swaggerType = ConverterMgr.findJavaType(((ModelImpl) model).getType(), ((ModelImpl) model).getFormat());
  }
  boolean isString = swaggerType != null && swaggerType.getRawClass().equals(String.class);

  JavaType targetType =
      genericParamType == null ? null : TypeFactory.defaultInstance().constructType(genericParamType);
  boolean rawJson = SwaggerUtils.isRawJsonType(parameter);
  if (rawJson) {
    return new RawJsonBodyProcessor(targetType, (String) parameter.getVendorExtensions()
        .get(SwaggerConst.EXT_JSON_VIEW), isString, parameter.getRequired());
  }

  return new BodyProcessor(targetType, (String) parameter.getVendorExtensions()
      .get(SwaggerConst.EXT_JSON_VIEW), isString, parameter.getRequired());
}
 

/**
 *
 * @param providerParamIdx
 * @param providerParameter processing provider parameter
 * @param parameterName
 * @return true means processed
 */
protected boolean processKnownParameter(int providerParamIdx, java.lang.reflect.Parameter providerParameter,
    String parameterName) {
  Integer swaggerIdx = findSwaggerParameterIndex(parameterName);
  if (swaggerIdx == null) {
    return false;
  }

  // complex scenes
  // swagger: int add(Body x)
  // producer: int add(int x, int y)
  if (bodyParameter != null &&
      !SwaggerUtils.isBean(providerParameter.getType()) &&
      swaggerIdx == swaggerBodyIdx &&
      SwaggerUtils.isBean(bodyParameter.getSchema())) {
    return false;
  }

  ArgumentMapper mapper = createKnownParameterMapper(providerParamIdx, swaggerIdx);
  mappers.add(mapper);
  return true;
}
 

public static boolean isFileParameter(Parameter parameter) {
  if (!(parameter instanceof FormParameter)) {
    return false;
  }

  FormParameter formParameter = (FormParameter) parameter;
  if (FileProperty.isType(formParameter.getType(), formParameter.getFormat())) {
    return true;
  }

  Property property = formParameter.getItems();
  if (!ArrayProperty.isType(formParameter.getType()) || property == null) {
    return false;
  }

  return FileProperty.isType(property.getType(), property.getFormat());
}
 

private Status validatePathParameters(final NormalisedPath requestPath,
                                      final SwaggerOperation swaggerOperation) {
    Status status = null;
    for (int i = 0; i < swaggerOperation.getPathString().parts().size(); i++) {
        if (!swaggerOperation.getPathString().isParam(i)) {
            continue;
        }

        final String paramName = swaggerOperation.getPathString().paramName(i);
        final String paramValue = requestPath.part(i);

        final Optional<Parameter> parameter = swaggerOperation.getOperation().getParameters()
                .stream()
                .filter(p -> p.getIn().equalsIgnoreCase("PATH"))
                .filter(p -> p.getName().equalsIgnoreCase(paramName))
                .findFirst();

        if (parameter.isPresent()) {
            status = parameterValidators.validate(paramValue, parameter.get());
        }
    }
    return status;
}
 

private void validateParameters(List<Parameter> actualOperationParameters,  List<Parameter> expectedOperationParameters, String httpMethod, String path) {
    String message = String.format("Checking parameters of '%s' operation of path '%s'.", httpMethod, path);
    Map<String, Parameter> actualParametersMap = new HashMap<>();
    for (final Parameter parameter : actualOperationParameters) {
        actualParametersMap.put(parameterUniqueKey(parameter), parameter);
    }
    // All expectedParameters must be there and must match.
    for (final Parameter expectedParameter : expectedOperationParameters) {
        final String parameterName = expectedParameter.getName();
        Parameter actualParameter = actualParametersMap.remove(parameterUniqueKey(expectedParameter));
        String actualParameterNotNullMessage = String.format("%s Expected parameter with name='%s' and in='%s' is missing", message, expectedParameter.getName(), expectedParameter.getIn());
        softAssertions.assertThat(actualParameter).as(actualParameterNotNullMessage).isNotNull();
        validateParameter(actualParameter, expectedParameter, parameterName, httpMethod, path);
    }
    // If there are any extra parameters, these are OK, as long as they are optional.
    for (final Parameter extraParameter : actualParametersMap.values()) {
        String extraParameterNotOptionalMessage = String.format("%s Unexpected parameter with name='%s' and in='%s' is missing", message, extraParameter.getName(), extraParameter.getIn());
        softAssertions.assertThat(extraParameter.getRequired()).as(extraParameterNotOptionalMessage).isFalse();
    }
}
 

@Test
public void testContribute() {
  underTest.contribute(swagger);

  assertContributedMap(true);

  Parameter param = PARAMS.iterator().next();
  verify(getOperationPath1).addParameter(param);
  verify(postOperationPath1).addParameter(param);
  verify(getOperationPath2).addParameter(param);
  verify(postOperationPath2).addParameter(param);

  // call it again for short-circuit use case
  reset(getOperationPath1, postOperationPath1, getOperationPath2, postOperationPath2);
  underTest.contribute(swagger);
  verify(getOperationPath1, never()).addParameter(param);
  verify(postOperationPath1, never()).addParameter(param);
  verify(getOperationPath2, never()).addParameter(param);
  verify(postOperationPath2, never()).addParameter(param);
}
 

protected Parameter createParameter(HttpParameterType httpParameterType) {
  switch (httpParameterType) {
    case PATH:
      return new PathParameter();
    case QUERY:
      return new QueryParameter();
    case HEADER:
      return new HeaderParameter();
    case FORM:
      return new FormParameter();
    case COOKIE:
      return new CookieParameter();
    case BODY:
      return new BodyParameter();
    default:
      throw new IllegalStateException("not support httpParameterType " + httpParameterType);
  }
}
 

public static Type collectGenericType(List<Annotation> annotations, Type defaultType) {
  Type genericType = null;
  for (Annotation annotation : annotations) {
    ParameterProcessor<Parameter, Annotation> processor = findParameterProcessors(annotation.annotationType());
    if (processor == null) {
      continue;
    }

    Type type = processor.getGenericType(annotation);
    if (type != null) {
      genericType = type;
    }
  }

  return genericType != null ? genericType : defaultType;
}
 

protected void initMethodParameterGenerators(Map<String, List<Annotation>> methodAnnotationMap) {
  for (java.lang.reflect.Parameter methodParameter : method.getParameters()) {
    Type genericType = ParamUtils.getGenericParameterType(clazz, method, methodParameter);
    ParameterGenerator parameterGenerator = new ParameterGenerator(method, methodAnnotationMap, methodParameter,
        genericType);
    validateParameter(parameterGenerator.getGenericType());
    if (isContextParameter(parameterGenerator.getGenericType())) {
      continue;
    }

    // jaxrs: @BeanParam
    // springmvc: is query, and is bean type
    if (isAggregatedParameter(parameterGenerator, methodParameter)) {
      extractAggregatedParameterGenerators(methodAnnotationMap, methodParameter);
      continue;
    }

    parameterGenerators.add(parameterGenerator);
  }
}
 

private static void populateParametersFromOperation(Operation operation, Map<String, Model> definitions,
        Map<String, String> parameterJsonPathMapping, Map<String, String> queryParameters) {

    List<Parameter> parameters = operation.getParameters();
    for (Parameter parameter : parameters) {
        String name = parameter.getName();
        if (parameter instanceof BodyParameter) {
            Model schema = ((BodyParameter) parameter).getSchema();
            if (schema instanceof RefModel) {
                String $ref = ((RefModel) schema).get$ref();
                if (StringUtils.isNotBlank($ref)) {
                    String defName = $ref.substring("#/definitions/".length());
                    Model model = definitions.get(defName);
                    Example example = ExampleBuilder.fromModel(defName, model, definitions, new HashSet<String>());

                    String jsonExample = Json.pretty(example);
                    try {
                        org.json.JSONObject json = new org.json.JSONObject(jsonExample);
                        SequenceUtils.listJson(json, parameterJsonPathMapping);
                    } catch (JSONException e) {
                        log.error("Error occurred while generating json mapping for the definition: " + defName, e);
                    }
                }
            }
        }
        if (parameter instanceof QueryParameter) {
            String type = ((QueryParameter) parameter).getType();
            queryParameters.put(name, type);
        }
    }
}
 

@Override
public ParamValueProcessor create(Parameter parameter, Type genericParamType) {
  JavaType targetType =
      genericParamType == null ? null : TypeFactory.defaultInstance().constructType(genericParamType);

  if (isPart(parameter)) {
    return new PartProcessor((FormParameter) parameter, genericParamType);
  }
  return new FormProcessor((FormParameter) parameter, targetType);
}
 

/**
 * Ensures the parameters are all resolved and return just the list of parameters that are fully
 * resolved by the swagger core parser.
 */
private static ImmutableList<Parameter> getResolvedParameters(
    final DiagCollector diagCollector,
    ImmutableList<Parameter> parameters,
    final Location location) {
  ImmutableList<Parameter> resolvedParameters =
      FluentIterable.from(parameters)
          .filter(
              new Predicate<Parameter>() {
                @Override
                public boolean apply(Parameter parameter) {
                  if (parameter instanceof RefParameter) {
                    /*
                     * This is an invalid state. Reference parameters should automatically get
                     * resolved into parameter objects by the swagger core parser, because only
                     * references that are allowed are to parameters that are defined at the
                     * Swagger Object's parameters which are in the same file. If we reach here
                     * it would mean the reference cannot be resolved and nothing this converter
                     * can do.
                     */
                    diagCollector.addDiag(
                        Diag.warning(
                            location,
                            "Reference %s cannot be resolved",
                            ((RefParameter) parameter).get$ref()));
                    return false;
                  } else {
                    return true;
                  }
                }
              })
          .toList();
  return resolvedParameters;
}
 

private String li_missingParam(Parameter param) {
    StringBuffer sb = new StringBuffer("");
    sb.append("Delete ").append(param.getName())
            .append(null == param.getDescription() ? ""
                    : (" //" + param.getDescription()));
    return sb.toString();
}
 

@Override
public boolean check(List<Parameter> params, Map<String, Response> responses) {
    Optional<Parameter> p = params.stream().filter(ParameterUtils.equalsParam(name, in)).findFirst();
    if (p.isPresent()) {
        String val = SwaggerSpecificationProcessor.extractValue(p.get());
        currentValue.add(val);
    }

    return true;
}
 

@BeforeClass
public static void beforeClass() {
  Parameter hp = new HeaderParameter();
  hp.setName("header");
  RestParam restParam = new RestParam(hp, int.class);

  restOperation = Mockito.mock(RestOperationMeta.class);
  //        clientRequest = Mockito.mock(RestClientRequest.class);
  paramList = new ArrayList<>();


  paramList.add(restParam);
  when(restOperation.getParamList()).thenReturn(paramList);
  when(restOperation.getParamByName("test")).thenReturn(restParam);
}
 

@Override
public Condition processParameter(Parameter parameter) {
    List<String> enumValues = SwaggerSpecificationProcessor.extractEnum(parameter);

    if (enumValues != null && !enumValues.isEmpty()) {
        ConditionPredicate predicate = new ParameterValueConditionPredicate(parameter.getName(), parameter.getIn(), enumValues);
        return new SinglePredicateCondition(
                String.format("%s «%s» contains all values from enum %s", parameter.getIn(), parameter.getName(), enumValues),
                "",
                predicate
        );
    }

    return null;
}
 

@Test
public void testExtractParametersReturnsRetrievedParameters() {
    List<Parameter> parameters = new JaxrsParameterExtension().extractParameters(
            Lists.newArrayList(getTestAnnotation("get", QueryParam.class)),
            String.class,
            Sets.<Type>newHashSet(),
            Lists.<SwaggerExtension>newArrayList().iterator());

    assertFalse(parameters.isEmpty());
    assertEquals(parameters.size(), 1);
}
 

@Override
public Condition processParameter(Parameter parameter) {
    if (parameter instanceof HeaderParameter) {
        ConditionPredicate predicate = new DefaultParameterConditionPredicate(true, parameter.getName(), parameter.getIn());
        return new SinglePredicateCondition(
                String.format("header «%s» is empty", parameter.getName()),
                "",
                predicate
        );
    }

    return null;
}
 

protected void init(Parameter parameter, Type genericParamType) {
  String paramType = parameter.getIn();
  ParamValueProcessorCreator creater =
      ParamValueProcessorCreatorManager.INSTANCE.ensureFindValue(paramType);

  this.setParamProcessor(creater.create(parameter, genericParamType));
}
 

private static void postAndPutModelDoc(Swagger swagger, StringBuilder builder, List<Parameter> parameters) {
    AtomicReference<Model> backModel = new AtomicReference<>();

    if(parameters != null && !parameters.isEmpty()){
        parameters.forEach(parameter -> {
            if(parameter instanceof BodyParameter){
                BodyParameter bop = (BodyParameter)parameter;

                if(bop.getSchema() instanceof RefModel){
                    RefModel refModel = (RefModel)bop.getSchema();
                    String simpleRef = refModel.getSimpleRef();
                    log.info(simpleRef);

                    Model model1 = definitions.get(simpleRef);
                    String s = SwaggerUtils.definitionsDocumentGenerateMd(swagger, simpleRef, model1);
                    builder.append(StringUtils.replace(s, "name=", "id="));
                    modelDoc(swagger,builder,model1);
                }

                if(bop.getSchema() instanceof ModelImpl){
                    ModelImpl model = (ModelImpl)bop.getSchema();
                    modelDocAddJdd(swagger,builder,backModel,model.getProperties());
                }


                if(bop.getSchema() instanceof ArrayModel){
                    ArrayModel arrayModel = (ArrayModel)bop.getSchema();
                    modelDocAdd(swagger,builder,backModel,arrayModel.getItems());

                    if(null != backModel.get()){
                        modelDoc(swagger,builder,backModel.get());
                    }
                }

            }
        });
    }
}
 

@Override
public void preprocessSwagger(Swagger swagger) {
    // need vendor extensions for x-swagger-router-controller
    Map<String, Path> paths = swagger.getPaths();
    if(paths != null) {
        for(String pathname : paths.keySet()) {
            Path path = paths.get(pathname);
            Map<HttpMethod, Operation> operationMap = path.getOperationMap();
            if(operationMap != null) {
                for(HttpMethod method : operationMap.keySet()) {
                    Operation operation = operationMap.get(method);
                    String tag = "default";
                    if(operation.getTags() != null && operation.getTags().size() > 0) {
                        tag = operation.getTags().get(0);
                    }
                    String operationId = operation.getOperationId();
                    if(operationId == null) {
                        operationId = getOrGenerateOperationId(operation, pathname, method.toString());
                    }
                    operation.setOperationId(toOperationId(operationId));
                    if(operation.getVendorExtensions().get("x-swagger-router-controller") == null) {
                        operation.getVendorExtensions().put(
                                "x-swagger-router-controller",
                                controllerPackage + "." + toApiFilename(tag)
                        );
                    }
                    for (Parameter param: operation.getParameters()) {
                        // sanitize the param name but don't underscore it since it's used for request mapping
                        String name = param.getName();
                        String paramName = sanitizeName(name);
                        if (!paramName.equals(name)) {
                            LOGGER.warn(name + " cannot be used as parameter name with flask-connexion and was sanitized as " + paramName);
                        }
                        param.setName(paramName);
                    }
                }
            }
        }
    }
}
 

@Override
public void preprocessSwagger(Swagger swagger) {
    if (swagger == null || swagger.getPaths() == null){
        return;
    }
    for (String pathname : swagger.getPaths().keySet()) {
        Path path = swagger.getPath(pathname);
        if (path.getOperations() == null){
            continue;
        }
        for (Operation operation : path.getOperations()) {
            boolean hasFormParameters = false;
            boolean hasBodyParameters = false;
            for (Parameter parameter : operation.getParameters()) {
                if (parameter instanceof FormParameter) {
                    hasFormParameters = true;
                }
                if (parameter instanceof BodyParameter) {
                    hasBodyParameters = true;
                }
            }
            if (hasBodyParameters || hasFormParameters){
                String defaultContentType = hasFormParameters ? "application/x-www-form-urlencoded" : "application/json";
                String contentType =  operation.getConsumes() == null || operation.getConsumes().isEmpty() ? defaultContentType : operation.getConsumes().get(0);
                operation.setVendorExtension("x-contentType", contentType);
            }
            String accepts = getAccept(operation);
            operation.setVendorExtension("x-accepts", accepts);
        }
    }
}
 

/**
 * Generate additional model definitions from query parameters
 *
 * @param swagger
 */
@Override
public void preprocessSwagger(Swagger swagger) {
    super.preprocessSwagger(swagger);
    for (String pathKey : swagger.getPaths().keySet())
    {
        Path path = swagger.getPath(pathKey);
        Map<HttpMethod, Operation> operations = path.getOperationMap();
        for (HttpMethod method : operations.keySet())
        {
            Operation operation = operations.get(method);
            Map<String, Property> properties = new HashMap<>();
            for (Parameter parameter : operation.getParameters())
            {
                Property property = convertParameterToProperty(parameter);
                if (property != null)
                {
                    properties.put(property.getName(), property);
                }
            }
            if (!properties.isEmpty())
            {
                Model model = new ModelImpl();
                String operationId = getOrGenerateOperationId(operation, pathKey, method.name());
                model.setDescription("Query parameters for " + operationId);
                model.setProperties(properties);
                model.getVendorExtensions().put(VEN_FROM_QUERY, Boolean.TRUE);
                String definitionName = generateUniqueDefinitionName(operationId + "QueryData", swagger);
                swagger.addDefinition(definitionName, model);
                String definitionModel = "\\" + modelPackage + "\\" + toModelName(definitionName);
                operation.getVendorExtensions().put(VEN_QUERY_DATA_TYPE, definitionModel);
                operation.getVendorExtensions().put(VEN_HAS_QUERY_DATA, Boolean.TRUE);
            }
        }
    }
}