(1).Contract$Default
public interface Contract {
// 解析targetType的所有Method,并返回:List<MethodMetadata>
List<MethodMetadata> parseAndValidatateMetadata(Class<?> targetType);
}
(2).Contract$BaseContract
abstract class BaseContract implements Contract {
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()) {
// 针对静态方法和Object对象,跳过该方法处理
if (method.getDeclaringClass() == Object.class ||
(method.getModifiers() & Modifier.STATIC) != 0 ||
Util.isDefault(method)) {
continue;
}
// ***************************************************
// 交给子类,进行:parseAndValidateMetadata
// ***************************************************
MethodMetadata metadata = parseAndValidateMetadata(targetType, method);
checkState(!result.containsKey(metadata.configKey()), "Overrides unsupported: %s",
metadata.configKey());
result.put(metadata.configKey(), metadata);
} //end for
return new ArrayList<>(result.values());
} // end
// @RequestLine("GET /hello4/{name}/{age}")
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));
// 如果targetType实现了多个接口
if (targetType.getInterfaces().length == 1) { // false
processAnnotationOnClass(data, targetType.getInterfaces()[0]);
}
// ***********************************************************
// 交给子类:Contract$Default解析targetType类上的注解@Headers
// ***********************************************************
processAnnotationOnClass(data, targetType);
// 解析"方法"上的注解
for (Annotation methodAnnotation : method.getAnnotations()) {
// ***********************************************************
// 交给子类:Contract$Default解析targetType上"方法"的所有注解:
// @RequestLine / @Body / @Headers
// ***********************************************************
processAnnotationOnMethod(data, methodAnnotation, method);
}
checkState(data.template().method() != null,
"Method %s not annotated with HTTP method type (ex. GET, POST)",
method.getName());
// @RequestLine("GET /hello4/{name}/{age}")
// String hello4(@Param("name") String name, @Param("age") Integer age);
// 获得方法上的所有入参类型 parameterTypes= [ String.class,Integer.class ]
Class<?>[] parameterTypes = method.getParameterTypes();
// genericParameterTypes = [String.class,Integer.class]
// Type包含有泛型
Type[] genericParameterTypes = method.getGenericParameterTypes();
// 获取方法上所有入参的注解
Annotation[][] parameterAnnotations = method.getParameterAnnotations();
// count = 2
int count = parameterAnnotations.length;
for (int i = 0; i < count; i++) {
boolean isHttpAnnotation = false;
if (parameterAnnotations[i] != null) {
// ***********************************************************
// 交给子类:Contract$Default解析targetType上"方法"的所有"入参"注解:
// 设置:indexToName/formParams/indexToExpanderClass/indexToEncoded/
// ***********************************************************
isHttpAnnotation = processAnnotationsOnParameter(data, parameterAnnotations[i], i);
}
if (parameterTypes[i] == URI.class) { // 设置参数为:URI
// 设置urlIndex
data.urlIndex(i);
} else if (!isHttpAnnotation) {
// processAnnotationsOnParameter(...) 方法没有解析到注解的话,
// 则设置bodyIndex/bodyType
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]));
} //end else if
} //end for
// 如果有配置注解@HeaderMap,则需要判断是否为HashMap
if (data.headerMapIndex() != null) {
checkMapString("HeaderMap", parameterTypes[data.headerMapIndex()],
genericParameterTypes[data.headerMapIndex()]);
}
// 如果有配置注解@QueryMap,则需要判断:标注的类型是否为:Map
if (data.queryMapIndex() != null) {
if (Map.class.isAssignableFrom(parameterTypes[data.queryMapIndex()])) {
checkMapKeys("QueryMap", genericParameterTypes[data.queryMapIndex()]);
}
}
return data;
} //end parseAndValidateMetadata
}
(3).Contract$Default
class Default extends BaseContract {
static final Pattern REQUEST_LINE_PATTERN = Pattern.compile("^([A-Z]+)[ ]*(.*)$");
// 解析类上的注解@Header
// @Header( value={ "X-Ping: {token}" } )
protected void processAnnotationOnClass(MethodMetadata data, Class<?> targetType) {
// 如果类上标注有:@Header
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);
// 把MethodMetadata里已经存的headers与刚解析的headers进行合并
headers.putAll(data.template().headers());
// 把MethodMetadata的headers进行清空
data.template().headers(null); // to clear
// 重新设置成新的:headers
data.template().headers(headers);
}
} //end processAnnotationOnClass
// 解析方法上的注解
// @Headers / @Body / @RequestLine
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 {
// @RequestLine("GET /hello4/{name}/{age}")
// 解析请求的方法(GET)
data.template().method(HttpMethod.valueOf(requestLineMatcher.group(1)));
// 解析请求的URL(/hello4/{name}/{age})
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));
}
} //end processAnnotationOnMethod
// 解析方法上的入参
// @Param / @QueryMap / @HeaderMap
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;
// name = name
String name = paramAnnotation.value();
checkState(emptyToNull(name) != null, "Param annotation was empty on param %s.",
paramIndex);
// 往MethodMetadata的下标[paramIndex]增加name
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)) {
//向MethodMetadata中添加:formParams变量
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;
}// end processAnnotationsOnParameter
protected void nameParam(MethodMetadata data, String name, int i) {
// 判断下标[i]是否存在,如果存在:则返回下标对应的Collection
// 如果不存在,则创建一个新的Collection,并把下标和Collections增加到MethoMetaData
Collection<String> names =
data.indexToName().containsKey(i) ?
data.indexToName().get(i) : new ArrayList<String>();
// 往集合中添加元数
names.add(name);
// 往MethodMetadata的指定下标[i],增加Collection
data.indexToName().put(i, names);
} //end nameParam
// input= ["X-Ping: {token}"]
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(':');
// name = "X-Ping"
String name = header.substring(0, colon);
// 如果名称不存在,则给对应的name创建一个Collection
// 一个Header是可以包含多个value
if (!result.containsKey(name)) {
result.put(name, new ArrayList<String>(1));
}
// value = 从":"的位置("{token}")
result.get(name).add(header.substring(colon + 1).trim());
}
return result;
} //end toMap
}
(4).MethodMetadata 模型结构
public final class MethodMetadata implements Serializable {
private String configKey;
private transient Type returnType;
private Integer urlIndex;
private Integer bodyIndex;
private Integer headerMapIndex;
private Integer queryMapIndex;
private boolean queryMapEncoded;
private transient Type bodyType;
// @RequestLine/@Headers/@Body 解析后的内容存储
// method/url/body/headers...
private RequestTemplate template = new RequestTemplate();
private List<String> formParams = new ArrayList<String>();
private Map<Integer, Collection<String>> indexToName =
new LinkedHashMap<Integer, Collection<String>>();
private Map<Integer, Class<? extends Expander>> indexToExpanderClass =
new LinkedHashMap<Integer, Class<? extends Expander>>();
private Map<Integer, Boolean> indexToEncoded = new LinkedHashMap<Integer, Boolean>();
private transient Map<Integer, Expander> indexToExpander;
}
(5).总结
Contract主要是针对注解进行解析,并转换成模型:MethodMetadata
