共计 17024 个字符，预计需要花费 43 分钟才能阅读完成。
序
本文主要研究一下 feign 的 Contract
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);
//......
}- Contract 定义了 parseAndValidatateMetadata 方法，该方法返回 List 形式的 MethodMetadata
Contract.BaseContract
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);
}
}- Contract.BaseContract 是个抽象类，它 processAnnotationOnClass、processAnnotationOnMethod、processAnnotationsOnParameter 的抽象方法需要子类去实现；它的 parseAndValidatateMetadata 方法的实现主要是调用了 parseAndValidateMetadata 方法，而该方法会调用 processAnnotationOnClass、processAnnotationOnMethod、processAnnotationsOnParameter 这些方法
Contract.Default
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;
}
}- Contract.Default 继承了 BaseContract，其 processAnnotationOnClass 方法处理 feign.Headers 注解；其 processAnnotationOnMethod 方法处理 feign.RequestLine、feign.Body 注解；其 processAnnotationsOnParameter 方法处理 feign.Param、feign.QueryMap、feign.HeaderMap 注解
SpringMvcContract
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;
}
//......
}- SpringMvcContract 继承了 Contract.BaseContract 并实现了 ResourceLoaderAware 接口；其 setResourceLoader 存储了 resourceLoader
- 其覆盖了父类的 parseAndValidateMetadata 方法，它首先调用父类的 parseAndValidateMetadata 方法，然后对 org.springframework.web.bind.annotation.RequestMapping 注解进行进一步解析
- processAnnotationOnClass 方法处理了 RequestMapping 注解；processAnnotationOnMethod 方法处理了 RequestMapping 注解；processAnnotationsOnParameter 方法处理了 RequestParam、RequestHeader 等注解
小结
- Contract 定义了 parseAndValidatateMetadata 方法，该方法返回 List 形式的 MethodMetadata；它有一个抽象类为 Contract.BaseContract，它 processAnnotationOnClass、processAnnotationOnMethod、processAnnotationsOnParameter 的抽象方法需要子类去实现；它的 parseAndValidatateMetadata 方法的实现主要是调用了 parseAndValidateMetadata 方法，而该方法会调用 processAnnotationOnClass、processAnnotationOnMethod、processAnnotationsOnParameter 这些方法
- Contract.Default 继承了 BaseContract，其 processAnnotationOnClass 方法处理 feign.Headers 注解；其 processAnnotationOnMethod 方法处理 feign.RequestLine、feign.Body 注解；其 processAnnotationsOnParameter 方法处理 feign.Param、feign.QueryMap、feign.HeaderMap 注解
- SpringMvcContract 继承了 Contract.BaseContract 并实现了 ResourceLoaderAware 接口；其 setResourceLoader 存储了 resourceLoader；其覆盖了父类的 parseAndValidateMetadata 方法，它首先调用父类的 parseAndValidateMetadata 方法，然后对 org.springframework.web.bind.annotation.RequestMapping 注解进行进一步解析；processAnnotationOnClass 方法处理了 RequestMapping 注解；processAnnotationOnMethod 方法处理了 RequestMapping 注解；processAnnotationsOnParameter 方法处理了 RequestParam、RequestHeader 等注解
doc
- Contract
正文完
