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高级工程师学习路径