文章目录
- 1.自动配置FeignAutoConfiguration
- 2.生成 Feign Client
- 2.1 从Feign Client子容器获取组件
- 2.2 Feign Client子容器的创建
- 2.3 构建Feign Client实例
1.自动配置FeignAutoConfiguration
spring-cloud-starter-openfeign 包含了 spring-cloud-openfeign-core
FeignAutoConfiguration:
- FeignClientSpecification: FeignClient的配置类。
- FeignContext: Spring容器中所有的FeignClient规范类实例都放入了FeignContext。其中存在两个map。
2.生成 Feign Client
FeignClientFactoryBean: 就是Spring的FactoryBean。
2.1 从Feign Client子容器获取组件
FeignClientFactoryBean.getObject():
//FeignClientFactoryBean.java
public Object getObject() throws Exception {return getTarget();
}
//FeignClientFactoryBean.java
<T> T getTarget() {//根据spring容器,获取FeignContext,Feign的上下文,也是FeignClient的工厂类FeignContext context = this.applicationContext.getBean(FeignContext.class);//根据FeignContext,获取一个Feign的构建器Feign.Builder builder = feign(context);...return (T) targeter.target(this, builder, context,new HardCodedTarget<>(this.type, this.name, url));
}
- 根据spring容器, 获取FeignContext, 是FeignClient的工厂类。
- 根据FeignContext, 获取Feign的构造器。
feign: 从Feign Client子容器获取组件。
//FeignClientFactoryBean.java
protected Feign.Builder feign(FeignContext context) {//get方法:从FeignContext中获取对应类型的实例,底层会从当前FeignClient对应的子容器中获取//这里获取Feign的日志工厂FeignLoggerFactory loggerFactory = get(context, FeignLoggerFactory.class);Logger logger = loggerFactory.create(this.type);// @formatter:off//这里获取Feign的构建器//构建器的意义我们不需要关注复杂的构建流程,只需要给构建器传递一些需要的组件即可//这里主要往构建器放入一些FeignClient依赖的一些组件Feign.Builder builder = get(context, Feign.Builder.class)// required values.logger(logger).encoder(get(context, Encoder.class)).decoder(get(context, Decoder.class)).contract(get(context, Contract.class));// @formatter:on//获取FeignClientProperties进行一些属性的配置configureFeign(context, builder);return builder;
}//看其中一个get方法:
//FeignClientFactoryBean.java
protected <T> T get(FeignContext context, Class<T> type) {//注意,当前类是FeignClientFactoryBean//所以这个this.contextId实际上是当前FeignClient的服务id、微服务名称T instance = context.getInstance(this.contextId, type);if (instance == null) {throw new IllegalStateException("No bean found of type " + type + " for " + this.contextId);}return instance;
}
//NamedContextFactory.java,就是FeignContext.java
public <T> T getInstance(String name, Class<T> type) {//根据name先获取对应的子容器//name就是微服务名称,FeignClient的名称AnnotationConfigApplicationContext context = getContext(name);//根据类型从当前子容器,和子容器所有的祖先容器中查找bean的名称,判断是否存在if (BeanFactoryUtils.beanNamesForTypeIncludingAncestors(context,type).length > 0) {//存在就返回对应类型的实例return context.getBean(type);}return null;
}
2.2 Feign Client子容器的创建
获取子容器, 如果获取不到的话则创建子容器。
getContext -> createContext:
//NamedContextFactory.java
//FeignContext.java继承自NamedContextFactory.java
protected AnnotationConfigApplicationContext getContext(String name) {if (!this.contexts.containsKey(name)) {synchronized (this.contexts) {//双重检查锁,线程安全问题if (!this.contexts.containsKey(name)) {//子容器还不存在则进行创建this.contexts.put(name, createContext(name));}}}return this.contexts.get(name);
}//创建子容器
//NamedContextFactory.java
protected AnnotationConfigApplicationContext createContext(String name) {AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();//这里configurations存的就是各个feign client的规范类if (this.configurations.containsKey(name)) {//获取规范类中的配置类for (Class<?> configuration : this.configurations.get(name).getConfiguration()) {//将对应服务名称的配置类注册到该容器context.register(configuration);}}for (Map.Entry<String, C> entry : this.configurations.entrySet()) {//default开头的是全局的规范类,存的是@EnableFeignClients的defaultConfiguration属性配置的配置类if (entry.getKey().startsWith("default.")) {for (Class<?> configuration : entry.getValue().getConfiguration()) {//将全局的配置类注册到该容器context.register(configuration);}}}//注册占位符配置解析器,可以解析bean定义属性值和{@code @Value}注解中的占位符。//注册默认配置类,defaultConfigType就是FeignClientsConfiguration.classcontext.register(PropertyPlaceholderAutoConfiguration.class,this.defaultConfigType);//添加具有最高优先级的给定属性源对象。context.getEnvironment().getPropertySources().addFirst(new MapPropertySource(this.propertySourceName,Collections.<String, Object>singletonMap(this.propertyName, name)));if (this.parent != null) {// 关键!为当前容器设置父容器context.setParent(this.parent);context.setClassLoader(this.parent.getClassLoader());}context.setDisplayName(generateDisplayName(name));//刷新容器context.refresh();return context;
}
采用DCL锁来控制单例。
2.3 构建Feign Client实例
FeignClientFactoryBean.getObject():
//FeignClientFactoryBean.java
public Object getObject() throws Exception {return getTarget();
}//FeignClientFactoryBean.java
<T> T getTarget() {//根据spring容器,获取FeignContext,Feign的上下文,也是FeignClient的工厂类FeignContext context = this.applicationContext.getBean(FeignContext.class);//根据FeignContext,获取一个Feign的构建器//底层就是从当前feignClient名称对应的子容器中获取一些// 创建FeignClient所依赖的组件实例Feign.Builder builder = feign(context);//判断是否指定url属性,没有指定了就会负载均衡的方式进行远程调用if (!StringUtils.hasText(this.url)) {//为服务名补全协议if (!this.name.startsWith("http")) {this.url = "http://" + this.name;}else {this.url = this.name;}//拼接前缀,就是path属性,cleanPath会先格式化一下this.url += cleanPath();//没有指定url,使用具有负载均衡的远程调用客户端 构建feignClientreturn (T) loadBalance(builder, context,new HardCodedTarget<>(this.type, this.name, this.url));}//指定了url,则是直连方式if (StringUtils.hasText(this.url) && !this.url.startsWith("http")) {//补全协议this.url = "http://" + this.url;}//拼接前缀,就是path属性,cleanPath会先格式化一下String url = this.url + cleanPath();//getOptional:也是从context中对应的feignClient名称的子容器中获取Client类型的实例//这个Client就是发起远程调用的客户端Client client = getOptional(context, Client.class);if (client != null) {//判断client是否是具有负载均衡的功能client,如果是的话取消包装//确保直连if (client instanceof LoadBalancerFeignClient) {// ribbon的负载均衡客户端// not load balancing because we have a url,// but ribbon is on the classpath, so unwrap// 没有负载平衡,因为我们有一个URL,但是ribbon在类路径中,所以请取消包装client = ((LoadBalancerFeignClient) client).getDelegate();}if (client instanceof FeignBlockingLoadBalancerClient) {// openFeign的负载均衡客户端// not load balancing because we have a url,// but Spring Cloud LoadBalancer is on the classpath, so unwrap// 因为我们有一个URL,所以没有负载均衡// 但是Spring Cloud LoadBalancer在类路径上,因此请取消包装client = ((FeignBlockingLoadBalancerClient) 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));
}
没有指定url,使用具有负载均衡的远程调用客户端 构建feignClient。
//HystrixTargeter.java
public <T> T target(FeignClientFactoryBean factory, Feign.Builder feign,FeignContext context, Target.HardCodedTarget<T> target) {if (!(feign instanceof feign.hystrix.HystrixFeign.Builder)) {//没有开启熔断功能话就不是熔断的Builder走这return feign.target(target);}//如果开启了熔断,就会处理一些服务降级的配置:feign.hystrix.HystrixFeign.Builder builder = (feign.hystrix.HystrixFeign.Builder) feign;String name = StringUtils.isEmpty(factory.getContextId()) ? factory.getName(): factory.getContextId();SetterFactory setterFactory = getOptional(name, context, SetterFactory.class);if (setterFactory != null) {builder.setterFactory(setterFactory);}Class<?> fallback = factory.getFallback();if (fallback != void.class) {return targetWithFallback(name, context, target, builder, fallback);}Class<?> fallbackFactory = factory.getFallbackFactory();if (fallbackFactory != void.class) {return targetWithFallbackFactory(name, context, target, builder,fallbackFactory);}//也是调feign.targetreturn feign.target(target);
}
- 没有开启熔断功能话就不是熔断的Builder。
- 如果开启了熔断,就会处理一些服务降级的配置。
//Feign.java
public <T> T target(Target<T> target) {return build().newInstance(target);
}
ReflectiveFeign.newInstance():
//ReflectiveFeign.java
public <T> T newInstance(Target<T> target) {//targetToHandlersByName.apply:生成方法处理器//返回值nameToHandler:// key:当前feignClient的方法名// value:方法处理器Map<String, MethodHandler> nameToHandler = targetToHandlersByName.apply(target);//methodToHandler:key是方法对象,value是方法处理器Map<Method, MethodHandler> methodToHandler = new LinkedHashMap<Method, MethodHandler>();//默认方法处理器列表List<DefaultMethodHandler> defaultMethodHandlers = new LinkedList<DefaultMethodHandler>();//遍历当前feignClient的接口的所有的方法for (Method method : target.type().getMethods()) {if (method.getDeclaringClass() == Object.class) {//Object的方法不处理continue;} else if (Util.isDefault(method)) {//是否是接口中的默认方法//默认方法创建一个默认方法处理器DefaultMethodHandler handler = new DefaultMethodHandler(method);//添加到默认方法处理器集合defaultMethodHandlers.add(handler);//保存方法和处理器映射关系methodToHandler.put(method, handler);} else {//不是默认方法,就是抽象方法//从nameToHandler获取已经生成好的对应的方法处理器methodToHandler.put(method, nameToHandler.get(Feign.configKey(target.type(), method)));}}//jdk动态代理,创建InvocationHandler,再创建代理对象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;
}
通过jdk动态代理, 创建InvocationHandler, 再创建代理对象。