javascript
SpringCloud之Feign源码分析
啟動時Feign的處理
啟動類上使用了@EnableFeignClients注解，我們來看下這個注解在哪里使用了，使用idea只要在EnableFeignClients類上按住command同時點擊類名就可以查看到這個類在哪里使用了，發現除了啟動類，只在FeignClientsRegistrar類中引用了EnableFeignClients。
debug可以發現，當應用啟動時會首先調用FeignClientsRegistrar的registerBeanDefinitions()方法。
@Override
public void registerBeanDefinitions(AnnotationMetadata metadata,
BeanDefinitionRegistry registry) {
//注冊默認配置信息
registerDefaultConfiguration(metadata, registry);
//注冊每個聲明為Feign Client的類
registerFeignClients(metadata, registry);
}
主要看下registerFeignClients()方法。
public void registerFeignClients(AnnotationMetadata metadata,
BeanDefinitionRegistry registry) {
//獲取掃描classpath下component組件的掃描器
ClassPathScanningCandidateComponentProvider scanner = getScanner();
scanner.setResourceLoader(this.resourceLoader);
Set basePackages;
//獲取啟動類上配置的@EnableFeignClients注解的屬性
Map<String, Object> attrs = metadata
.getAnnotationAttributes(EnableFeignClients.class.getName());
AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(
FeignClient.class);
//從剛才獲取的@EnableFeignClients注解的屬性中獲取clients屬性配置的值
final Class<?>[] clients = attrs == null ? null
: (Class<?>[]) attrs.get(“clients”);
if (clients == null || clients.length == 0) {
//如果clients沒配置
//掃描器增加要掃描的過濾器(掃描被@FeignClient注解修飾的類)
scanner.addIncludeFilter(annotationTypeFilter);
//獲取配置的掃描包的路徑，如果沒配置，默認為啟動類的包路徑
basePackages = getBasePackages(metadata);
}
else {
final Set clientClasses = new HashSet<>();
basePackages = new HashSet<>();
for (Class<?> clazz : clients) {
//如果啟動類配置了clients屬性的值，將配置的client所在的包名加到掃描器掃描的包中
basePackages.add(ClassUtils.getPackageName(clazz));
clientClasses.add(clazz.getCanonicalName());
}
AbstractClassTestingTypeFilter filter = new AbstractClassTestingTypeFilter() {
@Override
protected boolean match(ClassMetadata metadata) {
String cleaned = metadata.getClassName().replaceAll("\$", “.”);
return clientClasses.contains(cleaned);
}
};
scanner.addIncludeFilter(
new AllTypeFilter(Arrays.asList(filter, annotationTypeFilter)));
}
for (String basePackage : basePackages) {
Set candidateComponents = scanner
.findCandidateComponents(basePackage);
//遍歷掃描出來的@FeignClient注解修飾的類
for (BeanDefinition candidateComponent : candidateComponents) {
if (candidateComponent instanceof AnnotatedBeanDefinition) {
// verify annotated class is an interface
//校驗@FeignClient注解修飾的類是否是interface
AnnotatedBeanDefinition beanDefinition = (AnnotatedBeanDefinition) candidateComponent;
AnnotationMetadata annotationMetadata = beanDefinition.getMetadata();
//斷言，@FeignClient注解修飾的類必須是interface
Assert.isTrue(annotationMetadata.isInterface(),
“@FeignClient can only be specified on an interface”);
}
}
//將feign client交由spring管理，聲明為spring的bean
private void registerFeignClient(BeanDefinitionRegistry registry,
AnnotationMetadata annotationMetadata, Map<String, Object> attributes) {
String className = annotationMetadata.getClassName();
//創建FeignClientFactoryBean，包含將feign client的注解屬性信息存入FeignClientFactoryBean中
BeanDefinitionBuilder definition = BeanDefinitionBuilder
.genericBeanDefinition(FeignClientFactoryBean.class);
//校驗feign client的配置，配置的fallback及fallbackFatory必須是實現類
validate(attributes);
//將@FeignClient注解配置的屬性放入FeignClientFactoryBean的BeanDefinitionBuilder中
definition.addPropertyValue(“url”, getUrl(attributes));
definition.addPropertyValue(“path”, getPath(attributes));
String name = getName(attributes);
definition.addPropertyValue(“name”, name);
definition.addPropertyValue(“type”, className);
definition.addPropertyValue(“decode404”, attributes.get(“decode404”));
definition.addPropertyValue(“fallback”, attributes.get(“fallback”));
definition.addPropertyValue(“fallbackFactory”, attributes.get(“fallbackFactory”));
definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
String alias = name + “FeignClient”;
AbstractBeanDefinition beanDefinition = definition.getBeanDefinition();
boolean primary = (Boolean)attributes.get(“primary”); // has a default, won’t be null
beanDefinition.setPrimary(primary);
String qualifier = getQualifier(attributes);
if (StringUtils.hasText(qualifier)) {
alias = qualifier;
}
BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className,
new String[] { alias });
//注冊bean到spring容器中
BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
}
在spring容器啟動時會調用FeignClientFactoryBean的getObject()方法（只有在其他bean注入feign client時才會調用），看下FeignClientFactoryBean的getObject()方法做了哪些處理。
public Object getObject() throws Exception {
//直接調用了getTarget()方法
return getTarget();
}
/**
-
@param the target type of the Feign client
-
@return a {@link Feign} client created with the specified data and the context information
*/
T getTarget() {
//這個FeignContext在FeignAutoConfiguration配置中已經聲明了，所以可以直接用applicationContext獲取bean
FeignContext context = applicationContext.getBean(FeignContext.class);
//配置feign 的decoder、encoder、retryer、contract、RequestInterceptor等
//這些有默認配置，在FeignAutoConfiguration及FeignClientsConfiguration中有默認配置
Feign.Builder builder = feign(context);if (!StringUtils.hasText(this.url)) {
//如果@FeignClient注解上指定了url，其實除非本地調試，一般不建議指定URL
String url;
if (!this.name.startsWith(“http”)) {
url = “http://” + this.name;
}
else {
url = this.name;
}
//處理URL，沒配置URL時，這里的URL形式為http://name+/path
url += cleanPath();
//使用負載均衡處理feign 請求
return (T) loadBalance(builder, context, new HardCodedTarget<>(this.type,
this.name, url));
}
//配置了FeignClient的具體URL
if (StringUtils.hasText(this.url) && !this.url.startsWith(“http”)) {
this.url = “http://” + this.url;
}
String url = this.url + cleanPath();
Client client = getOptional(context, Client.class);
if (client != null) {
if (client instanceof LoadBalancerFeignClient) {
// not load balancing because we have a url,
// but ribbon is on the classpath, so unwrap
client = ((LoadBalancerFeignClient)client).getDelegate();
}
builder.client(client);
}
Targeter targeter = get(context, Targeter.class);
return (T) targeter.target(this, builder, context, new HardCodedTarget<>(
this.type, this.name, url));
}
decoder：將http請求的response轉換成對象
encoder：將http請求的對象轉換成http request body
contract：校驗Feign Client上的注解及value值是否合法
retryer：定義http請求如果失敗了是否應該重試以及重試間隔、方式等等
RequestInterceptor：feign發起請求前的攔截器，可以全局定義basic auth、發起請求前自動添加header等等
從@FeignClient注解上是否指定URL，feign的處理分成了兩部分，如果未指定URL，則使用負載均衡去發送請求，指定URL，只會向指定的URL發送請求。
一般是不指定URL的，接下來先看下，不指定具體URL時，feign的處理。
protected T loadBalance(Feign.Builder builder, FeignContext context,
HardCodedTarget target) {
//默認client為LoadBalancerFeignClient，為啥？參見DefaultFeignLoadBalancedConfiguration
Client client = getOptional(context, Client.class);
if (client != null) {
builder.client(client);
//這個Targeter默認為DefaultTargeter，參見FeignAutoConfiguration
Targeter targeter = get(context, Targeter.class);
return targeter.target(this, builder, context, target);
}
throw new IllegalStateException(
“No Feign Client for loadBalancing defined. Did you forget to include spring-cloud-starter-netflix-ribbon?”);
}
Targeter默認為DefaultTargeter，client為LoadBalancerFeignClient。再看下DefaultTargeter.target()方法
public T target(FeignClientFactoryBean factory, Feign.Builder feign, FeignContext context,
Target.HardCodedTarget target) {
return feign.target(target);
}
Feign.target()方法。
public T target(Target target) {
return build().newInstance(target);
}
ReflectiveFeign.newInstance()方法。這里為什么是ReflectiveFeign？參考Feign.build()方法
public T newInstance(Target target) {
//這個apply方法就是ReflectiveFeign中的apply方法，返回了每個方法的調用包裝類SynchronousMethodHandler
Map<String, MethodHandler> nameToHandler = targetToHandlersByName.apply(target);
Map<Method, MethodHandler> methodToHandler = new LinkedHashMap<Method, MethodHandler>();
List defaultMethodHandlers = new LinkedList();
//這個target.type()返回的就是聲明@FeignClient注解所在的class
for (Method method : target.type().getMethods()) {
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)));
}
}
//返回了ReflectiveFeign.FeignInvocationHandler對象，這個對象的invoke方法其實就是調用了SynchronousMethodHandler.invoke方法
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;
}
public Map<String, MethodHandler> apply(Target key) {
//獲取類上的方法的元數據，如返回值類型，參數類型，注解數據等等
List 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);
}
//這個factory是SynchronousMethodHandler.Factory，create方法返回了一個SynchronousMethodHandler對象
result.put(md.configKey(),
factory.create(key, md, buildTemplate, options, decoder, errorDecoder));
}
return result;
}
簡單總結下啟動時Feign所做的處理：
獲取@EnableFeignClients注解配置的掃描包路徑，如果沒配置，默認為啟動類的包路徑。
獲得掃描包路徑下@FeignClient修飾的類
校驗@FeignClient修飾的類，包括類必須是interface，以及@FeignClient的fallback及fallbackFactory配置的必須是接口的實現類等
將@FeignClient修飾的類交由spring管理，聲明為bean，其他bean注入FeignClient時注入的其實是當前FeignClient的代理類，這個代理類包裝在Targeter內部，Targeter被注入到引用的bean中。
這樣做的好處是：在程序中使用Feign Client時就可以像其他spring 管理的bean一樣直接注入即可。
例如：
@Autowired
private CartFeignClient cartFeignClient;
@PostMapping("/toCart/{productId}")
public ResponseEntity addCart(@PathVariable(“productId”) Long productId) throws InterruptedException {
cartFeignClient.addCart(productId);
return ResponseEntity.ok(productId);
}
調用Feign Client時的feign的處理
剛分析了應用啟動及bean注入FeignClient時feign的處理，知道注入的其實是Targeter類，Targetr類包裝了FeignCLient的proxy，proxy內部綁定了methodHandler為SynchronousMethodHandler。接下來仔細分析下整個實際調用過程的處理。
前面提到feign實際處理方法調用的methodHandler是SynchronousMethodHandler。
實際上，首先調用的是ReflectiveFeign的靜態內部類FeignInvocationHandler，這個類實現了JDK的InvocationHandler接口，在調用代理類的方法時會被調用FeignInvocationHandler的invoke方法。
FeignInvocationHandler的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();
}
//除了equals、hashCode、toString方法外，其他方法都走dispatch.get(method).invoke(args)方法。
//點擊這個方法的實現類，就可以追到 SynchronousMethodHandler的invoke方法了。
return dispatch.get(method).invoke(args);
}
可以看到除了equals、hashCode、toString方法外，其他方法都走dispatch.get(method).invoke(args)方法。
點擊這個方法的實現類，就可以追到 SynchronousMethodHandler的invoke方法了。所以這里其實只是簡單起到轉發的作用。
SynchronousMethodHandler的invoke方法。
public Object invoke(Object[] argv) throws Throwable {
//根據調用參數創建一個RequestTemplate，用來具體處理http調用請求
RequestTemplate template = buildTemplateFromArgs.create(argv);
//克隆出一個一模一樣的Retryer，用來處理調用失敗后的重試
Retryer retryer = this.retryer.clone();
while (true) {
try {
//發送http request以及處理response等
return executeAndDecode(template);
} catch (RetryableException e) {
//處理重試次數、重試間隔等等
retryer.continueOrPropagate(e);
continue;
}
}
}
先來看下如何創建的RequestTemplate。
ReflectiveFeign的內部靜態類BuildTemplateByResolvingArgs的create方法。
public RequestTemplate create(Object[] argv) {
//獲取methodMetada的template，這個RequestTemplate是可變的，跟隨每次調用參數而變。
RequestTemplate mutable = new RequestTemplate(metadata.template());
if (metadata.urlIndex() != null) {
//處理@PathVariable在URL上插入的參數
int urlIndex = metadata.urlIndex();
checkArgument(argv[urlIndex] != null, “URI parameter %s was null”, urlIndex);
mutable.insert(0, String.valueOf(argv[urlIndex]));
}
//處理調用方法的param參數，追加到URL ？后面的參數
Map<String, Object> varBuilder = new LinkedHashMap<String, Object>();
for (Entry<Integer, Collection> 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);
}
}
}
//處理query參數以及body內容
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
//當 RequestTemplate處理完參數后，再處理@QueryMap注入的參數，以便優先于任意值。
Object value = argv[metadata.queryMapIndex()];
Map<String, Object> queryMap = toQueryMap(value);
template = addQueryMapQueryParameters(queryMap, template);
}
if (metadata.headerMapIndex() != null) {
//處理RequestTemplate的header內容
template = addHeaderMapHeaders((Map<String, Object>) argv[metadata.headerMapIndex()], template);
}
return template;
}
可以看到，第一步是根據調用時的參數等構造了RequestTemplate的param、body、header等內容。
再看executeAndDecode方法。
SynchronousMethodHandler的executeAndDecode方法。
Object executeAndDecode(RequestTemplate template) throws Throwable {
//構造Request，將RequestTemplate中的參數等放入Request中
Request request = targetRequest(template);
Response response;
try {
//這個client默認實現是Client接口中的Defalut，實現是通過HttpURLConnection發送請求
//另一種是LoadBalancerFeignClient，默認也是Client接口中的Defalut，可以通過配置指定為Apache的HTTPClient，也可以指定為OKhttp來發送請求，在每個具體實現中來通過ribbon實現負載均衡，負載到集群中不同的機器，這里不再發散
response = client.execute(request, options);
// ensure the request is set. TODO: remove in Feign 10
response.toBuilder().request(request).build();
} catch (IOException e) {
throw errorExecuting(request, e);
}
boolean shouldClose = true;
try {
//處理response的返回值
if (Response.class == metadata.returnType()) {
if (response.body() == null) {
return response;
}
// Ensure the response body is disconnected
byte[] bodyData = Util.toByteArray(response.body().asInputStream());
return response.toBuilder().body(bodyData).build();
}
//根據狀態碼處理下response
if (response.status() >= 200 && response.status() < 300) {
if (void.class == metadata.returnType()) {
return null;
} else {
Object result = decode(response);
shouldClose = closeAfterDecode;
return result;
}
} 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);
}
}
}
總結一下：
代理類先調用到FeignInvocationHandler的invoke方法，而這個invoke方法相當于直接調用了SynchronousMethodHandler的invoke方法。
SynchronousMethodHandler的invoke方法主要是構造了RequestTemplate以及出現異常重試的Retryer，最后根據構造的RequestTemplate發起了http請求以及decode。
構造RequestTemplate時，根據傳入的參數動態構建URL中的參數（@PathVarible）以及URL ？追加的參數，還有body等等，最后再處理@QueryMap注入的參數，以保證優先級最高。
發起http請求時，沒有負載均衡時，默認是通過JDK的HttpURLConnection發送請求，另一種就是LoadBalancerFeignClient各種實現類，如Apache的HTTPClient，以及OKhttp等，這些實現也是通過ribbon動態指定服務器IP地址，以達到負載均衡的作用。
總結
以上是生活随笔為你收集整理的SpringCloud之Feign源码分析的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： Properties 转YAML
- 下一篇： Java高级工程师学习路径