org.springframework.cloud.openfeign.AnnotatedParameterProcessor Java Examples

@Override
protected boolean processAnnotationsOnParameter(MethodMetadata data, Annotation[] annotations, int paramIndex) {
    boolean isHttpAnnotation = false;

    AnnotatedParameterProcessor.AnnotatedParameterContext context =
        new OpenFeignSpringMvcContract.SimpleAnnotatedParameterContext(data, paramIndex);
    Method method = this.processedMethods.get(data.configKey());
    for (Annotation parameterAnnotation : annotations) {
        AnnotatedParameterProcessor processor =
            this.annotatedArgumentProcessors.get(parameterAnnotation.annotationType());
        if (processor != null) {
            Annotation processParameterAnnotation;

            processParameterAnnotation =
                synthesizeWithMethodParameterNameAsFallbackValue(parameterAnnotation, method, paramIndex);
            isHttpAnnotation |= processor.processArgument(context, processParameterAnnotation, method);
        }
    }
    if (isHttpAnnotation && data.indexToExpander().get(paramIndex) == null
        && this.conversionService.canConvert(method.getParameterTypes()[paramIndex], String.class)) {
        data.indexToExpander().put(paramIndex, this.expander);
    }
    return isHttpAnnotation;
}
 

@Bean
public OpenFeignSpringMvcContract feignSpringMvcContract(
    @Autowired(required = false) List<AnnotatedParameterProcessor> parameterProcessors,
    List<ConversionService> conversionServices) {
    if (conversionServices.size() == 0) {
        throw new IllegalStateException("ConversionService can not be NULL");
    }
    ConversionService conversionService = null;
    if (conversionServices.size() == 1) {
        conversionService = conversionServices.get(0);
    } else {
        // 如果有多个实例，优先使用找到的第一个DefaultFormattingConversionService，如果没有，则使用FormattingConversionService
        conversionService = conversionServices.stream().filter(c -> c instanceof DefaultFormattingConversionService)
            .findFirst().orElseGet(() -> conversionServices.stream()
                .filter(c -> c instanceof FormattingConversionService).findFirst().get());
    }
    if (null == parameterProcessors) {
        parameterProcessors = new ArrayList<>();
    }
    return new OpenFeignSpringMvcContract(parameterProcessors, conversionService);
}
 

public VenusSpringMvcContract(
        List<AnnotatedParameterProcessor> annotatedParameterProcessors,
        ConversionService conversionService) {
    Assert.notNull(annotatedParameterProcessors,
            "Parameter processors can not be null.");
    Assert.notNull(conversionService, "ConversionService can not be null.");

    List<AnnotatedParameterProcessor> processors;
    if (!annotatedParameterProcessors.isEmpty()) {
        processors = new ArrayList<>(annotatedParameterProcessors);
    }
    else {
        processors = getDefaultAnnotatedArgumentsProcessors();
    }
    this.annotatedArgumentProcessors = toAnnotatedArgumentProcessorMap(processors);
    this.conversionService = conversionService;
    this.expander = new org.springframework.cloud.openfeign.support.SpringMvcContract.ConvertingExpander(conversionService);
}
 

public OpenFeignSpringMvcContract(List<AnnotatedParameterProcessor> annotatedParameterProcessors,
    ConversionService conversionService) {
    Assert.notNull(annotatedParameterProcessors, "Parameter processors can not be null.");
    Assert.notNull(conversionService, "ConversionService can not be null.");

    List<AnnotatedParameterProcessor> processors;
    if (!annotatedParameterProcessors.isEmpty()) {
        processors = new ArrayList<>(annotatedParameterProcessors);
    } else {
        processors = getDefaultAnnotatedArgumentsProcessors();
    }
    this.annotatedArgumentProcessors = toAnnotatedArgumentProcessorMap(processors);
    this.conversionService = conversionService;
    this.expander = new SpringMvcContract.ConvertingExpander(conversionService);
}
 

@Bean
public VenusSpringMvcContract feignSpringMvcContract(@Autowired(required = false) List<AnnotatedParameterProcessor> parameterProcessors,
                                                     ConversionService conversionService) {
    if (null == parameterProcessors) {
        parameterProcessors = new ArrayList<>();
    }
    return new VenusSpringMvcContract(parameterProcessors, conversionService);
}
 

private Map<Class<? extends Annotation>, AnnotatedParameterProcessor> toAnnotatedArgumentProcessorMap(
        List<AnnotatedParameterProcessor> processors) {
    Map<Class<? extends Annotation>, AnnotatedParameterProcessor> result = new HashMap<>();
    for (AnnotatedParameterProcessor processor : processors) {
        result.put(processor.getAnnotationType(), processor);
    }
    return result;
}
 

@Override
protected boolean processAnnotationsOnParameter(MethodMetadata data,
                                                Annotation[] annotations, int paramIndex) {
    boolean isHttpAnnotation = false;

    AnnotatedParameterProcessor.AnnotatedParameterContext context = new VenusSpringMvcContract.SimpleAnnotatedParameterContext(
            data, paramIndex);
    Method method = this.processedMethods.get(data.configKey());
    for (Annotation parameterAnnotation : annotations) {
        AnnotatedParameterProcessor processor = this.annotatedArgumentProcessors
                .get(parameterAnnotation.annotationType());
        if (processor != null) {
            Annotation processParameterAnnotation;
            // synthesize, handling @AliasFor, while falling back to parameter name on
            // missing String #value():
            processParameterAnnotation = synthesizeWithMethodParameterNameAsFallbackValue(
                    parameterAnnotation, method, paramIndex);
            isHttpAnnotation |= processor.processArgument(context,
                    processParameterAnnotation, method);
        }
    }
    if (isHttpAnnotation && data.indexToExpander().get(paramIndex) == null
            && this.conversionService.canConvert(
            method.getParameterTypes()[paramIndex], String.class)) {
        data.indexToExpander().put(paramIndex, this.expander);
    }
    return isHttpAnnotation;
}
 

private List<AnnotatedParameterProcessor> getDefaultAnnotatedArgumentsProcessors() {

		List<AnnotatedParameterProcessor> annotatedArgumentResolvers = new ArrayList<>();

		annotatedArgumentResolvers.add(new MatrixVariableParameterProcessor());
		annotatedArgumentResolvers.add(new PathVariableParameterProcessor());
		annotatedArgumentResolvers.add(new RequestParamParameterProcessor());
		annotatedArgumentResolvers.add(new RequestHeaderParameterProcessor());
		annotatedArgumentResolvers.add(new QueryMapParameterProcessor());
		annotatedArgumentResolvers.add(new RequestPartParameterProcessor());

		return annotatedArgumentResolvers;
	}
 

private Map<Class<? extends Annotation>, AnnotatedParameterProcessor> toAnnotatedArgumentProcessorMap(
		List<AnnotatedParameterProcessor> processors) {
	Map<Class<? extends Annotation>, AnnotatedParameterProcessor> result = new HashMap<>();
	for (AnnotatedParameterProcessor processor : processors) {
		result.put(processor.getAnnotationType(), processor);
	}
	return result;
}
 

@Override
protected boolean processAnnotationsOnParameter(MethodMetadata data,
		Annotation[] annotations, int paramIndex) {
	boolean isHttpAnnotation = false;

	AnnotatedParameterProcessor.AnnotatedParameterContext context = new SimpleAnnotatedParameterContext(
			data, paramIndex);
	Method method = this.processedMethods.get(data.configKey());
	for (Annotation parameterAnnotation : annotations) {
		AnnotatedParameterProcessor processor = this.annotatedArgumentProcessors
				.get(parameterAnnotation.annotationType());
		if (processor != null) {
			Annotation processParameterAnnotation;
			// synthesize, handling @AliasFor, while falling back to parameter name on
			// missing String #value():
			processParameterAnnotation = synthesizeWithMethodParameterNameAsFallbackValue(
					parameterAnnotation, method, paramIndex);
			isHttpAnnotation |= processor.processArgument(context,
					processParameterAnnotation, method);
		}
	}

	if (!isMultipartFormData(data) && isHttpAnnotation
			&& data.indexToExpander().get(paramIndex) == null) {
		TypeDescriptor typeDescriptor = createTypeDescriptor(method, paramIndex);
		if (this.conversionService.canConvert(typeDescriptor,
				STRING_TYPE_DESCRIPTOR)) {
			Param.Expander expander = this.convertingExpanderFactory
					.getExpander(typeDescriptor);
			if (expander != null) {
				data.indexToExpander().put(paramIndex, expander);
			}
		}
	}
	return isHttpAnnotation;
}
 

public SpringMvcContract(
		List<AnnotatedParameterProcessor> annotatedParameterProcessors,
		ConversionService conversionService) {
	Assert.notNull(annotatedParameterProcessors,
			"Parameter processors can not be null.");
	Assert.notNull(conversionService, "ConversionService can not be null.");

	List<AnnotatedParameterProcessor> processors = getDefaultAnnotatedArgumentsProcessors();
	processors.addAll(annotatedParameterProcessors);

	this.annotatedArgumentProcessors = toAnnotatedArgumentProcessorMap(processors);
	this.conversionService = conversionService;
	this.convertingExpanderFactory = new ConvertingExpanderFactory(conversionService);
}
 

protected Map<Class<? extends Annotation>, AnnotatedParameterProcessor>
    toAnnotatedArgumentProcessorMap(List<AnnotatedParameterProcessor> processors) {
    Map<Class<? extends Annotation>, AnnotatedParameterProcessor> result = new HashMap<>();
    for (AnnotatedParameterProcessor processor : processors) {
        result.put(processor.getAnnotationType(), processor);
    }
    return result;
}
 

public VenusSpringMvcContract(
        List<AnnotatedParameterProcessor> annotatedParameterProcessors) {
    this(annotatedParameterProcessors, new DefaultConversionService());
}
 

public SpringMvcContract(
		List<AnnotatedParameterProcessor> annotatedParameterProcessors) {
	this(annotatedParameterProcessors, new DefaultConversionService());
}
 

public OpenFeignSpringMvcContract(List<AnnotatedParameterProcessor> annotatedParameterProcessors) {
    this(annotatedParameterProcessors, new DefaultConversionService());
}
 

public BladeSpringMvcContract(List<AnnotatedParameterProcessor> annotatedParameterProcessors, ConversionService conversionService) {
	super(annotatedParameterProcessors, conversionService);
}
 

protected List<AnnotatedParameterProcessor> getDefaultAnnotatedArgumentsProcessors() {

        List<AnnotatedParameterProcessor> annotatedArgumentResolvers = new ArrayList<>();

        annotatedArgumentResolvers.add(new PathVariableParameterProcessor());
        annotatedArgumentResolvers.add(new RequestParamParameterProcessor());
        annotatedArgumentResolvers.add(new RequestHeaderParameterProcessor());

        return annotatedArgumentResolvers;
    }
 

private List<AnnotatedParameterProcessor> getDefaultAnnotatedArgumentsProcessors() {

        List<AnnotatedParameterProcessor> annotatedArgumentResolvers = new ArrayList<>();

        annotatedArgumentResolvers.add(new PathVariableParameterProcessor());
        annotatedArgumentResolvers.add(new RequestParamParameterProcessor());
        annotatedArgumentResolvers.add(new RequestHeaderParameterProcessor());

        return annotatedArgumentResolvers;
    }