本文主要研究一下feign的Contract
feign-core-10.2.3-sources.jar!/feign/Contract.java
public interface Contract { /** * Called to parse the methods in the class that are linked to HTTP requests. * * @param targetType {@link feign.Target#type() type} of the Feign interface. */ // TODO: break this and correct spelling at some point List<MethodMetadata> parseAndValidatateMetadata(Class<?> targetType); //...... }
feign-core-10.2.3-sources.jar!/feign/Contract.java
abstract class BaseContract implements Contract { @Override public List<MethodMetadata> parseAndValidatateMetadata(Class<?> targetType) { checkState(targetType.getTypeParameters().length == 0, "Parameterized types unsupported: %s", targetType.getSimpleName()); checkState(targetType.getInterfaces().length <= 1, "Only single inheritance supported: %s", targetType.getSimpleName()); if (targetType.getInterfaces().length == 1) { checkState(targetType.getInterfaces()[0].getInterfaces().length == 0, "Only single-level inheritance supported: %s", targetType.getSimpleName()); } Map<String, MethodMetadata> result = new LinkedHashMap<String, MethodMetadata>(); for (Method method : targetType.getMethods()) { if (method.getDeclaringClass() == Object.class || (method.getModifiers() & Modifier.STATIC) != 0 || Util.isDefault(method)) { continue; } MethodMetadata metadata = parseAndValidateMetadata(targetType, method); checkState(!result.containsKey(metadata.configKey()), "Overrides unsupported: %s", metadata.configKey()); result.put(metadata.configKey(), metadata); } return new ArrayList<>(result.values()); } /** * @deprecated use {@link #parseAndValidateMetadata(Class, Method)} instead. */ @Deprecated public MethodMetadata parseAndValidatateMetadata(Method method) { return parseAndValidateMetadata(method.getDeclaringClass(), method); } /** * Called indirectly by {@link #parseAndValidatateMetadata(Class)}. */ protected MethodMetadata parseAndValidateMetadata(Class<?> targetType, Method method) { MethodMetadata data = new MethodMetadata(); data.returnType(Types.resolve(targetType, targetType, method.getGenericReturnType())); data.configKey(Feign.configKey(targetType, method)); if (targetType.getInterfaces().length == 1) { processAnnotationOnClass(data, targetType.getInterfaces()[0]); } processAnnotationOnClass(data, targetType); for (Annotation methodAnnotation : method.getAnnotations()) { processAnnotationOnMethod(data, methodAnnotation, method); } checkState(data.template().method() != null, "Method %s not annotated with HTTP method type (ex. GET, POST)", method.getName()); Class<?>[] parameterTypes = method.getParameterTypes(); Type[] genericParameterTypes = method.getGenericParameterTypes(); Annotation[][] parameterAnnotations = method.getParameterAnnotations(); int count = parameterAnnotations.length; for (int i = 0; i < count; i++) { boolean isHttpAnnotation = false; if (parameterAnnotations[i] != null) { isHttpAnnotation = processAnnotationsOnParameter(data, parameterAnnotations[i], i); } if (parameterTypes[i] == URI.class) { data.urlIndex(i); } else if (!isHttpAnnotation) { checkState(data.formParams().isEmpty(), "Body parameters cannot be used with form parameters."); checkState(data.bodyIndex() == null, "Method has too many Body parameters: %s", method); data.bodyIndex(i); data.bodyType(Types.resolve(targetType, targetType, genericParameterTypes[i])); } } if (data.headerMapIndex() != null) { checkMapString("HeaderMap", parameterTypes[data.headerMapIndex()], genericParameterTypes[data.headerMapIndex()]); } if (data.queryMapIndex() != null) { if (Map.class.isAssignableFrom(parameterTypes[data.queryMapIndex()])) { checkMapKeys("QueryMap", genericParameterTypes[data.queryMapIndex()]); } } return data; } private static void checkMapString(String name, Class<?> type, Type genericType) { checkState(Map.class.isAssignableFrom(type), "%s parameter must be a Map: %s", name, type); checkMapKeys(name, genericType); } private static void checkMapKeys(String name, Type genericType) { Class<?> keyClass = null; // assume our type parameterized if (ParameterizedType.class.isAssignableFrom(genericType.getClass())) { Type[] parameterTypes = ((ParameterizedType) genericType).getActualTypeArguments(); keyClass = (Class<?>) parameterTypes[0]; } else if (genericType instanceof Class<?>) { // raw class, type parameters cannot be inferred directly, but we can scan any extended // interfaces looking for any explict types Type[] interfaces = ((Class) genericType).getGenericInterfaces(); if (interfaces != null) { for (Type extended : interfaces) { if (ParameterizedType.class.isAssignableFrom(extended.getClass())) { // use the first extended interface we find. Type[] parameterTypes = ((ParameterizedType) extended).getActualTypeArguments(); keyClass = (Class<?>) parameterTypes[0]; break; } } } } if (keyClass != null) { checkState(String.class.equals(keyClass), "%s key must be a String: %s", name, keyClass.getSimpleName()); } } /** * Called by parseAndValidateMetadata twice, first on the declaring class, then on the target * type (unless they are the same). * * @param data metadata collected so far relating to the current java method. * @param clz the class to process */ protected abstract void processAnnotationOnClass(MethodMetadata data, Class<?> clz); /** * @param data metadata collected so far relating to the current java method. * @param annotation annotations present on the current method annotation. * @param method method currently being processed. */ protected abstract void processAnnotationOnMethod(MethodMetadata data, Annotation annotation, Method method); /** * @param data metadata collected so far relating to the current java method. * @param annotations annotations present on the current parameter annotation. * @param paramIndex if you find a name in {@code annotations}, call * {@link #nameParam(MethodMetadata, String, int)} with this as the last parameter. * @return true if you called {@link #nameParam(MethodMetadata, String, int)} after finding an * http-relevant annotation. */ protected abstract boolean processAnnotationsOnParameter(MethodMetadata data, Annotation[] annotations, int paramIndex); /** * links a parameter name to its index in the method signature. */ protected void nameParam(MethodMetadata data, String name, int i) { Collection<String> names = data.indexToName().containsKey(i) ? data.indexToName().get(i) : new ArrayList<String>(); names.add(name); data.indexToName().put(i, names); } }
feign-core-10.2.3-sources.jar!/feign/Contract.java
class Default extends BaseContract { static final Pattern REQUEST_LINE_PATTERN = Pattern.compile("^([A-Z]+)[ ]*(.*)$"); @Override protected void processAnnotationOnClass(MethodMetadata data, Class<?> targetType) { if (targetType.isAnnotationPresent(Headers.class)) { String[] headersOnType = targetType.getAnnotation(Headers.class).value(); checkState(headersOnType.length > 0, "Headers annotation was empty on type %s.", targetType.getName()); Map<String, Collection<String>> headers = toMap(headersOnType); headers.putAll(data.template().headers()); data.template().headers(null); // to clear data.template().headers(headers); } } @Override protected void processAnnotationOnMethod(MethodMetadata data, Annotation methodAnnotation, Method method) { Class<? extends Annotation> annotationType = methodAnnotation.annotationType(); if (annotationType == RequestLine.class) { String requestLine = RequestLine.class.cast(methodAnnotation).value(); checkState(emptyToNull(requestLine) != null, "RequestLine annotation was empty on method %s.", method.getName()); Matcher requestLineMatcher = REQUEST_LINE_PATTERN.matcher(requestLine); if (!requestLineMatcher.find()) { throw new IllegalStateException(String.format( "RequestLine annotation didn't start with an HTTP verb on method %s", method.getName())); } else { data.template().method(HttpMethod.valueOf(requestLineMatcher.group(1))); data.template().uri(requestLineMatcher.group(2)); } data.template().decodeSlash(RequestLine.class.cast(methodAnnotation).decodeSlash()); data.template() .collectionFormat(RequestLine.class.cast(methodAnnotation).collectionFormat()); } else if (annotationType == Body.class) { String body = Body.class.cast(methodAnnotation).value(); checkState(emptyToNull(body) != null, "Body annotation was empty on method %s.", method.getName()); if (body.indexOf('{') == -1) { data.template().body(body); } else { data.template().bodyTemplate(body); } } else if (annotationType == Headers.class) { String[] headersOnMethod = Headers.class.cast(methodAnnotation).value(); checkState(headersOnMethod.length > 0, "Headers annotation was empty on method %s.", method.getName()); data.template().headers(toMap(headersOnMethod)); } } @Override protected boolean processAnnotationsOnParameter(MethodMetadata data, Annotation[] annotations, int paramIndex) { boolean isHttpAnnotation = false; for (Annotation annotation : annotations) { Class<? extends Annotation> annotationType = annotation.annotationType(); if (annotationType == Param.class) { Param paramAnnotation = (Param) annotation; String name = paramAnnotation.value(); checkState(emptyToNull(name) != null, "Param annotation was empty on param %s.", paramIndex); nameParam(data, name, paramIndex); Class<? extends Param.Expander> expander = paramAnnotation.expander(); if (expander != Param.ToStringExpander.class) { data.indexToExpanderClass().put(paramIndex, expander); } data.indexToEncoded().put(paramIndex, paramAnnotation.encoded()); isHttpAnnotation = true; if (!data.template().hasRequestVariable(name)) { data.formParams().add(name); } } else if (annotationType == QueryMap.class) { checkState(data.queryMapIndex() == null, "QueryMap annotation was present on multiple parameters."); data.queryMapIndex(paramIndex); data.queryMapEncoded(QueryMap.class.cast(annotation).encoded()); isHttpAnnotation = true; } else if (annotationType == HeaderMap.class) { checkState(data.headerMapIndex() == null, "HeaderMap annotation was present on multiple parameters."); data.headerMapIndex(paramIndex); isHttpAnnotation = true; } } return isHttpAnnotation; } private static Map<String, Collection<String>> toMap(String[] input) { Map<String, Collection<String>> result = new LinkedHashMap<String, Collection<String>>(input.length); for (String header : input) { int colon = header.indexOf(':'); String name = header.substring(0, colon); if (!result.containsKey(name)) { result.put(name, new ArrayList<String>(1)); } result.get(name).add(header.substring(colon + 1).trim()); } return result; } }
spring-cloud-openfeign-core-2.2.0.M1-sources.jar!/org/springframework/cloud/openfeign/support/SpringMvcContract.java
public class SpringMvcContract extends Contract.BaseContract implements ResourceLoaderAware { private static final String ACCEPT = "Accept"; private static final String CONTENT_TYPE = "Content-Type"; private static final TypeDescriptor STRING_TYPE_DESCRIPTOR = TypeDescriptor .valueOf(String.class); private static final TypeDescriptor ITERABLE_TYPE_DESCRIPTOR = TypeDescriptor .valueOf(Iterable.class); private static final ParameterNameDiscoverer PARAMETER_NAME_DISCOVERER = new DefaultParameterNameDiscoverer(); private final Map<Class<? extends Annotation>, AnnotatedParameterProcessor> annotatedArgumentProcessors; private final Map<String, Method> processedMethods = new HashMap<>(); private final ConversionService conversionService; private final ConvertingExpanderFactory convertingExpanderFactory; private ResourceLoader resourceLoader = new DefaultResourceLoader(); public SpringMvcContract() { this(Collections.emptyList()); } public SpringMvcContract( List<AnnotatedParameterProcessor> annotatedParameterProcessors) { this(annotatedParameterProcessors, new DefaultConversionService()); } 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; if (!annotatedParameterProcessors.isEmpty()) { processors = new ArrayList<>(annotatedParameterProcessors); } else { processors = getDefaultAnnotatedArgumentsProcessors(); } this.annotatedArgumentProcessors = toAnnotatedArgumentProcessorMap(processors); this.conversionService = conversionService; this.convertingExpanderFactory = new ConvertingExpanderFactory(conversionService); } //...... @Override public void setResourceLoader(ResourceLoader resourceLoader) { this.resourceLoader = resourceLoader; } @Override public MethodMetadata parseAndValidateMetadata(Class<?> targetType, Method method) { this.processedMethods.put(Feign.configKey(targetType, method), method); MethodMetadata md = super.parseAndValidateMetadata(targetType, method); RequestMapping classAnnotation = findMergedAnnotation(targetType, RequestMapping.class); if (classAnnotation != null) { // produces - use from class annotation only if method has not specified this if (!md.template().headers().containsKey(ACCEPT)) { parseProduces(md, method, classAnnotation); } // consumes -- use from class annotation only if method has not specified this if (!md.template().headers().containsKey(CONTENT_TYPE)) { parseConsumes(md, method, classAnnotation); } // headers -- class annotation is inherited to methods, always write these if // present parseHeaders(md, method, classAnnotation); } return md; } @Override protected void processAnnotationOnClass(MethodMetadata data, Class<?> clz) { if (clz.getInterfaces().length == 0) { RequestMapping classAnnotation = findMergedAnnotation(clz, RequestMapping.class); if (classAnnotation != null) { // Prepend path from class annotation if specified if (classAnnotation.value().length > 0) { String pathValue = emptyToNull(classAnnotation.value()[0]); pathValue = resolve(pathValue); if (!pathValue.startsWith("/")) { pathValue = "/" + pathValue; } data.template().uri(pathValue); } } } } @Override protected void processAnnotationOnMethod(MethodMetadata data, Annotation methodAnnotation, Method method) { if (!RequestMapping.class.isInstance(methodAnnotation) && !methodAnnotation .annotationType().isAnnotationPresent(RequestMapping.class)) { return; } RequestMapping methodMapping = findMergedAnnotation(method, RequestMapping.class); // HTTP Method RequestMethod[] methods = methodMapping.method(); if (methods.length == 0) { methods = new RequestMethod[] { RequestMethod.GET }; } checkOne(method, methods, "method"); data.template().method(Request.HttpMethod.valueOf(methods[0].name())); // path checkAtMostOne(method, methodMapping.value(), "value"); if (methodMapping.value().length > 0) { String pathValue = emptyToNull(methodMapping.value()[0]); if (pathValue != null) { pathValue = resolve(pathValue); // Append path from @RequestMapping if value is present on method if (!pathValue.startsWith("/") && !data.template().path().endsWith("/")) { pathValue = "/" + pathValue; } data.template().uri(pathValue, true); } } // produces parseProduces(data, method, methodMapping); // consumes parseConsumes(data, method, methodMapping); // headers parseHeaders(data, method, methodMapping); data.indexToExpander(new LinkedHashMap<Integer, Param.Expander>()); } @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 (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; } //...... }