Fegin.Builder
// 请求拦截器
private final List<RequestInterceptor> requestInterceptors =
new ArrayList<RequestInterceptor>();
// 日志级别
private Logger.Level logLevel = Logger.Level.NONE;
// 请求的契约信息
private Contract contract = new Contract.Default();
// 客户端
private Client client = new Client.Default(null, null);
// 重试器
private Retryer retryer = new Retryer.Default();
// 日志
private Logger logger = new NoOpLogger();
// encoder
private Encoder encoder = new Encoder.Default();
// decoder
private Decoder decoder = new Decoder.Default();
// 查询map encoder
private QueryMapEncoder queryMapEncoder = new QueryMapEncoder.Default();
// 错误encoder
private ErrorDecoder errorDecoder = new ErrorDecoder.Default();
// 配置参数信息
private Options options = new Options();
// 反射工厂
private InvocationHandlerFactory invocationHandlerFactory =
new InvocationHandlerFactory.Default();
// 404decoder是否启用
private boolean decode404;
// decode后关闭
private boolean closeAfterDecode = true;
// 传播方式
private ExceptionPropagationPolicy propagationPolicy = NONE;
从上面的Builder内部类中我们可以看到配置了拦截器、重试器、客户端、encoder、decoder、参数配置等信息。
target方法
public <T> T target(Class<T> apiType, String url) {
return target(new HardCodedTarget<T>(apiType, url));
}
public <T> T target(Target<T> target) {
return build().newInstance(target);
}
build方法
public Feign build() {
SynchronousMethodHandler.Factory synchronousMethodHandlerFactory =
new SynchronousMethodHandler.Factory(client, retryer, requestInterceptors, logger,
logLevel, decode404, closeAfterDecode, propagationPolicy);
ParseHandlersByName handlersByName =
new ParseHandlersByName(contract, options, encoder, decoder, queryMapEncoder,
errorDecoder, synchronousMethodHandlerFactory);
// 创建ReflectiveFeign子类
return new ReflectiveFeign(handlersByName, invocationHandlerFactory, queryMapEncoder);
}
在build方法中可以看到直接返回了Feign信息。下面需要看下newInstance方法。
public abstract <T> T newInstance(Target<T> target);
newInstance方法是Feign抽象类中的一个抽象方法，上文中我们也看到了直接创建的是ReflectiveFeign子类，所以我们直接看子类中的newInstance方法。
public <T> T newInstance(Target<T> target) {
// 构建元数据
Map<String, MethodHandler> nameToHandler = targetToHandlersByName.apply(target);
// 方法处理器
Map<Method, MethodHandler> methodToHandler = new LinkedHashMap<Method, MethodHandler>();
// 默认方法处理器
List<DefaultMethodHandler> defaultMethodHandlers = new LinkedList<DefaultMethodHandler>();
// 循环方法
for (Method method : target.type().getMethods()) {
// 判断返回类型是否是Object
if (method.getDeclaringClass() == Object.class) {
continue;
// 工具类判断是否是默认方法
} else if (Util.isDefault(method)) {
DefaultMethodHandler handler = new DefaultMethodHandler(method);
defaultMethodHandlers.add(handler);
methodToHandler.put(method, handler);
// 构建方法处理器
} else {
methodToHandler.put(method, nameToHandler.get(Feign.configKey(target.type(), method)));
}
}
// 工厂创建方法处理器
InvocationHandler handler = factory.create(target, methodToHandler);
// 代理出想要的类
T proxy = (T) Proxy.newProxyInstance(target.type().getClassLoader(),
new Class<?>[] {target.type()}, handler);
// 循环绑定
for (DefaultMethodHandler defaultMethodHandler : defaultMethodHandlers) {
defaultMethodHandler.bindTo(proxy);
}
return proxy;
}
apply方法
public Map<String, MethodHandler> apply(Target key) {
// 转换并验证元数据信息
List<MethodMetadata> metadata = contract.parseAndValidatateMetadata(key.type());
// 方法处理器集合
Map<String, MethodHandler> result = new LinkedHashMap<String, MethodHandler>();
// 循环构建方法处理器
for (MethodMetadata md : metadata) {
BuildTemplateByResolvingArgs buildTemplate;
if (!md.formParams().isEmpty() && md.template().bodyTemplate() == null) {
buildTemplate = new BuildFormEncodedTemplateFromArgs(md, encoder, queryMapEncoder);
} else if (md.bodyIndex() != null) {
buildTemplate = new BuildEncodedTemplateFromArgs(md, encoder, queryMapEncoder);
} else {
buildTemplate = new BuildTemplateByResolvingArgs(md, queryMapEncoder);
}
// 方法处理器
result.put(md.configKey(),
factory.create(key, md, buildTemplate, options, decoder, errorDecoder));
}
return result;
}
上文中的contract是通过Contract.Default()创建出来的看下Default中的parseAndValidatateMetadata方法。
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());
}
parseAndValidateMetadata方法
protected MethodMetadata parseAndValidateMetadata(Class<?> targetType, Method method) {
// 创建元数据信息
MethodMetadata data = new MethodMetadata();
// 设置返回值类型
data.returnType(Types.resolve(targetType, targetType, method.getGenericReturnType()));
// 设置configkey的值“classname#method(param,param)”
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;
}
processAnnotationOnClass
static final Pattern REQUEST_LINE_PATTERN = Pattern.compile("^([A-Z]+)[ ]*(.*)$");
@Override
protected void processAnnotationOnClass(MethodMetadata data, Class<?> targetType) {
// 判断类头上是否有Headers注解
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);
}
}
// 处理map
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;
}
processAnnotationOnMethod
protected void processAnnotationOnMethod(MethodMetadata data,
Annotation methodAnnotation,
Method method) {
// 获取注解类型
Class<? extends Annotation> annotationType = methodAnnotation.annotationType();
// 判断方法上注解是否是RequestLine
if (annotationType == RequestLine.class) {
// 获取value
String requestLine = RequestLine.class.cast(methodAnnotation).value();
checkState(emptyToNull(requestLine) != null,
"RequestLine annotation was empty on method %s.", method.getName());
// 正则匹配RequestLine
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());
// 判断注解类型是否是Body
} else if (annotationType == Body.class) {
// 设置body
String body = Body.class.cast(methodAnnotation).value();
checkState(emptyToNull(body) != null, "Body annotation was empty on method %s.",
method.getName());
// 设置body或者bodyTemplate
if (body.indexOf('{') == -1) {
data.template().body(body);
} else {
data.template().bodyTemplate(body);
}
// 判断注解类型是否是Header
} 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());
// 设置header
data.template().headers(toMap(headersOnMethod));
}
}
动态代理invoke
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if ("equals".equals(method.getName())) {
try {
Object otherHandler =
args.length > 0 && args[0] != null ? Proxy.getInvocationHandler(args[0]) : null;
return equals(otherHandler);
} catch (IllegalArgumentException e) {
return false;
}
} else if ("hashCode".equals(method.getName())) {
return hashCode();
} else if ("toString".equals(method.getName())) {
return toString();
}
// 获取执行器，进行invoke
return dispatch.get(method).invoke(args);
}
invoke
public Object invoke(Object[] argv) throws Throwable {
// 创建请求模板
RequestTemplate template = buildTemplateFromArgs.create(argv);
// 设置重试器
Retryer retryer = this.retryer.clone();
// 循环执行
while (true) {
try {
return executeAndDecode(template);
} catch (RetryableException e) {
try {
retryer.continueOrPropagate(e);
} catch (RetryableException th) {
Throwable cause = th.getCause();
if (propagationPolicy == UNWRAP && cause != null) {
throw cause;
} else {
throw th;
}
}
if (logLevel != Logger.Level.NONE) {
logger.logRetry(metadata.configKey(), logLevel);
}
continue;
}
}
}
create
public RequestTemplate create(Object[] argv) {
// 构造请求模板
RequestTemplate mutable = RequestTemplate.from(metadata.template());
// 判断连接信息
if (metadata.urlIndex() != null) {
int urlIndex = metadata.urlIndex();
checkArgument(argv[urlIndex] != null, "URI parameter %s was null", urlIndex);
mutable.target(String.valueOf(argv[urlIndex]));
}
// 定义请求参数
Map<String, Object> varBuilder = new LinkedHashMap<String, Object>();
// 循环获取请求参数
for (Entry<Integer, Collection<String>> entry : metadata.indexToName().entrySet()) {
int i = entry.getKey();
Object value = argv[entry.getKey()];
if (value != null) { // Null values are skipped.
if (indexToExpander.containsKey(i)) {
value = expandElements(indexToExpander.get(i), value);
}
for (String name : entry.getValue()) {
varBuilder.put(name, value);
}
}
}
// 设置请求参数
RequestTemplate template = resolve(argv, mutable, varBuilder);
// 判断请求参数位置是否为空，设置请求参数
if (metadata.queryMapIndex() != null) {
// add query map parameters after initial resolve so that they take
// precedence over any predefined values
Object value = argv[metadata.queryMapIndex()];
Map<String, Object> queryMap = toQueryMap(value);
template = addQueryMapQueryParameters(queryMap, template);
}
if (metadata.headerMapIndex() != null) {
template =
addHeaderMapHeaders((Map<String, Object>) argv[metadata.headerMapIndex()], template);
}
// 返回请求模板
return template;
}
executeAndDecode
Object executeAndDecode(RequestTemplate template) throws Throwable {
// 构建request信息
Request request = targetRequest(template);
if (logLevel != Logger.Level.NONE) {
logger.logRequest(metadata.configKey(), logLevel, request);
}
// 响应信息
Response response;
// 请求开始时间
long start = System.nanoTime();
try {
// 调用client执行,这里面也就是new Client.Default(null, null);
response = client.execute(request, options);
} catch (IOException e) {
if (logLevel != Logger.Level.NONE) {
logger.logIOException(metadata.configKey(), logLevel, e, elapsedTime(start));
}
// 请求异常抛出
throw errorExecuting(request, e);
}
// 执行时间
long elapsedTime = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start);
boolean shouldClose = true;
try {
if (logLevel != Logger.Level.NONE) {
response =
logger.logAndRebufferResponse(metadata.configKey(), logLevel, response, elapsedTime);
}
// 判断返回类型是否是Response
if (Response.class == metadata.returnType()) {
if (response.body() == null) {
return response;
}
if (response.body().length() == null ||
response.body().length() > MAX_RESPONSE_BUFFER_SIZE) {
shouldClose = false;
return response;
}
// 构建body数据
// Ensure the response body is disconnected
byte[] bodyData = Util.toByteArray(response.body().asInputStream());
return response.toBuilder().body(bodyData).build();
}
// 判断响应码是否是在200和300之间
if (response.status() >= 200 && response.status() < 300) {
// 如果返回类型是void，直接rerurn null;
if (void.class == metadata.returnType()) {
return null;
} else {
// decode进行解码
Object result = decode(response);
shouldClose = closeAfterDecode;
return result;
}
// 判断404处理
} else if (decode404 && response.status() == 404 && void.class != metadata.returnType()) {
Object result = decode(response);
shouldClose = closeAfterDecode;
return result;
} else {
throw errorDecoder.decode(metadata.configKey(), response);
}
} catch (IOException e) {
if (logLevel != Logger.Level.NONE) {
logger.logIOException(metadata.configKey(), logLevel, e, elapsedTime);
}
// 判断异常
throw errorReading(request, response, e);
} finally {
if (shouldClose) {
// 处理结果
ensureClosed(response.body());
}
}
}
decode
Object decode(Response response) throws Throwable {
try {
// 返回decode信息
return decoder.decode(response, metadata.returnType());
} catch (FeignException e) {
throw e;
} catch (RuntimeException e) {
throw new DecodeException(response.status(), e.getMessage(), e);
}
}
