Feign封装请求基本原理（启动和注入）
通过一个例子看基于Feign的http请求原理。对Feign的操作主要分为：项目启动时处理、IOC容器注入时处理；实际的调用处理。目录：
1、例子；
2、项目启动时：Feign引入；
3、Bean的注入：@Autowired等；
4、接口方法的调用；
1. 例子
例子是一个用Maven管理的Spring Boot项目。
在pom.xml添加feign依赖
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-openfeign</artifactId>
<version>2.2.2.RELEASE</version>
</dependency>
这里只引用一个依赖，它会自动依赖其他Feign相关项。
FeignClient调用接口，添加@FeignClient注解
package com.mingo.exp.feign.remote;
import com.mingo.exp.feign.TestFeignRequestInterceptor;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
/**
* test 1
*
* @author Doflamingo
*/
@FeignClient(name = "test1", url = "http://hq.sinajs.cn", configuration = TestFeignRequestInterceptor.class)
public interface FeignTest1Service {
/**
* 获取<>hq.sinajs.cn</>网站数据
*
* @param list
* @return
*/
@GetMapping("/")
String getStockInfo(@RequestParam("list") String list);
}
这里还添加了一个Feign请求拦截器
package com.mingo.exp.feign;
import feign.RequestInterceptor;
import feign.RequestTemplate;
import org.springframework.context.annotation.Configuration;
/**
* Feign请求拦截
*
* @author Doflamingo
*/
@Configuration
public class TestFeignRequestInterceptor implements RequestInterceptor {
/**
* @param requestTemplate 请求模板
*/
@Override
public void apply(RequestTemplate requestTemplate) {
// 这里我未操作requestTemplate 只打印一行文本
System.out.println("Feign请求拦截...");
}
}
测试类
package com.mingo.exp.feign;
import com.mingo.exp.feign.remote.FeignTest1Service;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
@SpringBootTest
@RunWith(SpringRunner.class)
public class FeignRequestTest {
@Autowired
private FeignTest1Service feignTest1Service;
@Test
public void Test_1() {
String result = feignTest1Service.getStockInfo("sz000063");
System.out.println(result);
}
}
在启动类上要添加@EnableFeignClients注解
package com.mingo.exp;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;
/**
* @author Doflamingo
*/
@SpringBootApplication
@EnableFeignClients
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
}
运行结果
Feign请求拦截...
var hq_str_sz000063="中兴通讯,39.710,39.540,38.910,39.740,38.880,38.900,38.910,55869686,2183069899.570,516348,38.900,129234,38.890,575200,38.880,52700,38.870,66800,38.860,37900,38.910,127819,38.920,49100,38.930,24811,38.940,82444,38.950,2020-07-30,15:00:03,00";
2. 项目启动时：Feign引入
对Feign的处理主要通过两个注解：@EnableFeignClients 和 @FeignClient。配置类加上@EnableFeignClients注解，在项目启动时Spring IOC容器注册Feign相关Bean。最终目的就是生成@FeignClient注解接口的代理类对象。
先看@EnableFeignClients，如下图
这里通过@Import(FeignClientsRegistrar.class)对Feign进行相关初始化，实现了ImportBeanDefinitionRegistrar接口，在项目启动时Spring会调用registerBeanDefinitions(AnnotationMetadata metadata,BeanDefinitionRegistry registry)方法。
项目启动时
FeignClientsRegistrar类相关代码如下
// ImportBeanDefinitionRegistrar接口方法，项目启动时会执行该方法
// 这里的AnnotationMetadata存放启动类（com.mingo.exp.DemoApplication）相关元数据信息
@Override
public void registerBeanDefinitions(AnnotationMetadata metadata,
BeanDefinitionRegistry registry) {
// Feign Client缺省配置
registerDefaultConfiguration(metadata, registry);
// 处理@FeignClient注解接口
registerFeignClients(metadata, registry);
}
// 默认的Feign配置类
private void registerDefaultConfiguration(AnnotationMetadata metadata,
BeanDefinitionRegistry registry) {
// 获取@EnableFeignClients注解的属性
Map<String, Object> defaultAttrs = metadata
.getAnnotationAttributes(EnableFeignClients.class.getName(), true);
if (defaultAttrs != null && defaultAttrs.containsKey("defaultConfiguration")) {
// default.com.mingo.exp.DemoApplication.FeignClientSpecification
String name;
if (metadata.hasEnclosingClass()) {
name = "default." + metadata.getEnclosingClassName();
}
else {
name = "default." + metadata.getClassName();
}
// Class<?>[] defaultConfiguration() default {};
registerClientConfiguration(registry, name,
defaultAttrs.get("defaultConfiguration"));
}
}
// 处理@FeignClient注解接口
public void registerFeignClients(AnnotationMetadata metadata,
BeanDefinitionRegistry registry) {
// 这里用于搜索被@FeignClient注解的接口
ClassPathScanningCandidateComponentProvider scanner = getScanner();
scanner.setResourceLoader(this.resourceLoader);
Set<String> basePackages;
Map<String, Object> attrs = metadata
.getAnnotationAttributes(EnableFeignClients.class.getName());
// @FeignClient注解的标记
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属性没值时才在basePackages中扫描被@FeignClient注解的接口
scanner.addIncludeFilter(annotationTypeFilter);
basePackages = getBasePackages(metadata);
}
else {
final Set<String> clientClasses = new HashSet<>();
basePackages = new HashSet<>();
for (Class<?> clazz : clients) {
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) {
// 找到被@FeignClient注解的类
Set<BeanDefinition> candidateComponents = scanner
.findCandidateComponents(basePackage);
for (BeanDefinition candidateComponent : candidateComponents) {
if (candidateComponent instanceof AnnotatedBeanDefinition) {
AnnotatedBeanDefinition beanDefinition = (AnnotatedBeanDefinition) candidateComponent;
// 本例是com.mingo.exp.feign.remote.FeignTest1Service接口元数据信息
AnnotationMetadata annotationMetadata = beanDefinition.getMetadata();
// 只能在接口上注解
Assert.isTrue(annotationMetadata.isInterface(),
"@FeignClient can only be specified on an interface");
Map<String, Object> attributes = annotationMetadata
.getAnnotationAttributes(
FeignClient.class.getCanonicalName());
// 这里面会判断name或value是否存在
String name = getClientName(attributes);
// 本例是注册com.mingo.exp.feign.TestFeignRequestInterceptor
registerClientConfiguration(registry, name,
attributes.get("configuration"));
registerFeignClient(registry, annotationMetadata, attributes);
}
}
}
}
// 这里为每一个合法@FeignClient注解的接口生成一个FeignClientFactoryBean对象，注册到IOC容器
private void registerFeignClient(BeanDefinitionRegistry registry,
AnnotationMetadata annotationMetadata, Map<String, Object> attributes) {
String className = annotationMetadata.getClassName();
// FeignClientFactoryBean实现了FactoryBean接口，用于装饰和实例化Feign的客服端
// 其getObject()可得到动态代理的客户端对象
BeanDefinitionBuilder definition = BeanDefinitionBuilder
.genericBeanDefinition(FeignClientFactoryBean.class);
validate(attributes);
definition.addPropertyValue("url", getUrl(attributes));
definition.addPropertyValue("path", getPath(attributes));
String name = getName(attributes);
definition.addPropertyValue("name", name);
String contextId = getContextId(attributes);
definition.addPropertyValue("contextId", contextId);
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);
// 本例是test1FeignClient
String alias = contextId + "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 });
// 注册
BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
}
// 用于注册Feign相关的ClientConfiguration，如拦截器等
private void registerClientConfiguration(BeanDefinitionRegistry registry, Object name,
Object configuration) {
BeanDefinitionBuilder builder = BeanDefinitionBuilder
.genericBeanDefinition(FeignClientSpecification.class);
// FeignClientSpecification(String name, Class<?>[] configuration)的构造器
builder.addConstructorArgValue(name);
builder.addConstructorArgValue(configuration);
// 注册bean
registry.registerBeanDefinition(
name + "." + FeignClientSpecification.class.getSimpleName(),
builder.getBeanDefinition());
}
__ FeignClientFactoryBean类实现了FactoryBean接口，用于装饰和实例化Feign的客服端。 FactoryBean为IOC容器生成Bean更加灵活。FactoryBean#getObject()方法得到的bean即是用@Autowired等真正注入的Feign客服端代理对象。__
3. Bean的注入：@Autowired等
也就是执行处理这行代码时
FeignClientFactoryBean怎样生成代理对象
// 在使用@Autowired等注入bean时，容器会调用getObject()生成业务真实的bean
// FactoryBean#getObject()实现
@Override
public Object getObject() throws Exception {
return getTarget();
}
/**
* @param <T> the target type of the Feign client
* @return a {@link Feign} client created with the specified data and the context
* information
*/
<T> T getTarget() {
// 进行默认或设置的FeignClientsConfiguration的encoder、decoder、retryer等进行处理
FeignContext context = this.applicationContext.getBean(FeignContext.class);
Feign.Builder builder = feign(context);
// 本例url = http://hq.sinajs.cn 所以不走这一步
// 即是单纯的http请求，不需要配合Spring Cloud
if (!StringUtils.hasText(this.url)) {
if (!this.name.startsWith("http")) {
this.url = "http://" + this.name;
}
else {
this.url = this.name;
}
this.url += cleanPath();
return (T) loadBalance(builder, context,
new HardCodedTarget<>(this.type, this.name, this.url));
}
if (StringUtils.hasText(this.url) && !this.url.startsWith("http")) {
this.url = "http://" + this.url;
}
// 可是设置@FeignClient的path属性，会在这里接在url后面
String url = this.url + cleanPath();
// 本例是null
Client client = getOptional(context, Client.class);
// 单纯的http请求，不需要配合Spring Cloud
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();
}
if (client instanceof FeignBlockingLoadBalancerClient) {
// not load balancing because we have a url,
// but Spring Cloud LoadBalancer is on the classpath, so unwrap
client = ((FeignBlockingLoadBalancerClient) client).getDelegate();
}
builder.client(client);
}
// HystrixTargeter
Targeter targeter = get(context, Targeter.class);
// 生成代理对象bean。HardCodedTarget对象用于存type、url等信息
return (T) targeter.target(this, builder, context,
new HardCodedTarget<>(this.type, this.name, url));
}
上述代码的进入HystrixTargeter.target(...)
进入Feign.Builder.target()
进入ReflectiveFeign.newInstance()
// ReflectiveFeign构造器
ReflectiveFeign(ParseHandlersByName targetToHandlersByName, InvocationHandlerFactory factory,
QueryMapEncoder queryMapEncoder) {
this.targetToHandlersByName = targetToHandlersByName;
this.factory = factory;
this.queryMapEncoder = queryMapEncoder;
}
// 生成代理对象
@SuppressWarnings("unchecked")
@Override
public <T> T newInstance(Target<T> target) {
// targetToHandlersByName.apply(target) 会对@FeignClient注解接口方法生成对应的SynchronousMethodHandler
Map<String, MethodHandler> nameToHandler = targetToHandlersByName.apply(target);
// 这里面存的就是每一个远程调用方法的实际处理 SynchronousMethodHandler
Map<Method, MethodHandler> methodToHandler = new LinkedHashMap<Method, MethodHandler>();
List<DefaultMethodHandler> defaultMethodHandlers = new LinkedList<DefaultMethodHandler>();
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 {
// Methed对象为key
methodToHandler.put(method, nameToHandler.get(Feign.configKey(target.type(), method)));
}
}
// 生成对@FeignClient注解接口方法的代理处理
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);
}
// 生成的代理对象即是IOC容器注入的bean
return proxy;
}
// 类FeignInvocationHandler
static class FeignInvocationHandler implements InvocationHandler {
private final Target target;
private final Map<Method, MethodHandler> dispatch;
// InvocationHandler handler = factory.create(target, methodToHandler);这行代码触发
// dispatch的key即是方法名，MethodHandler即是实际的代理处理（SynchronousMethodHandler）
FeignInvocationHandler(Target target, Map<Method, MethodHandler> dispatch) {
this.target = checkNotNull(target, "target");
this.dispatch = checkNotNull(dispatch, "dispatch for %s", target);
}
// 代理处理@FeignClient接口的方法
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 继承Object的方法处理
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();
}
// 找到对应的SynchronousMethodHandler 并调用
return dispatch.get(method).invoke(args);
}
// 省略了其他代码
}
@FeignClient注解接口方法生成对应的SynchronousMethodHandler
生成的代理对象
4. 接口方法的调用
下一篇文章在细谈。
原创
Doflamingo
https://www.cnblogs.com/doflamingo
