FeignClient源码简单分析

示例的FeignClient代码HelloClient.java

@FeignClient(name = "helloClient", url = "localhost:8080")
public interface HelloClient {

    @RequestMapping(method = RequestMethod.GET, value = "/hello/helloworld")
    String getNames();

    @RequestMapping(method = RequestMethod.GET, value = "/hello/helloworld2")
    String getNames2(@SpringQueryMap FeignClientParams params);
}

整个过程大致分为两个步骤：①将FeignClient接口对应beanDefinition注入IoC容器；②调用FeignClient接口时基于JDK的AOP实现HTTP请求。

注入IoC容器

依次调用AbstractApplicationContext#refresh()、invokeBeanFactoryPostProcessors(beanFactory)、FeignClientsRegistrar#registerBeanDefinitions()、registerDefaultConfiguration()、registerFeignClients()，代码如下：

@Override
public void registerBeanDefinitions(AnnotationMetadata metadata,
        BeanDefinitionRegistry registry) {
    registerDefaultConfiguration(metadata, registry);
    registerFeignClients(metadata, registry);
}

在registerDefaultConfiguration()检查是否使用了EnableFeignClients.class注解。

private void registerDefaultConfiguration(AnnotationMetadata metadata,
			BeanDefinitionRegistry registry) {
    Map<String, Object> defaultAttrs = metadata
            .getAnnotationAttributes(EnableFeignClients.class.getName(), true);
	//如果使用了改注解，就开启包扫描
    if (defaultAttrs != null && defaultAttrs.containsKey("defaultConfiguration")) {
        String name;
        if (metadata.hasEnclosingClass()) {
            name = "default." + metadata.getEnclosingClassName();
        }
        else {
            name = "default." + metadata.getClassName();
        }
        registerClientConfiguration(registry, name,
                defaultAttrs.get("defaultConfiguration"));
    }
}

在registerFeignClients()中，完成IoC注入

public void registerFeignClients(AnnotationMetadata metadata,
			BeanDefinitionRegistry registry) {
    ClassPathScanningCandidateComponentProvider scanner = getScanner();
    scanner.setResourceLoader(this.resourceLoader);

    Set<String> basePackages;

    Map<String, Object> attrs = metadata
            .getAnnotationAttributes(EnableFeignClients.class.getName());
    AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(
            FeignClient.class);
    final Class<?>[] clients = attrs == null ? null
            : (Class<?>[]) attrs.get("clients");
    if (clients == null || clients.length == 0) {
        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)));
    }
 	
 	//根据FeignClient所在的package进行扫描注入IoC
    for (String basePackage : basePackages) {
        Set<BeanDefinition> candidateComponents = scanner
                .findCandidateComponents(basePackage);
        for (BeanDefinition candidateComponent : candidateComponents) {
            if (candidateComponent instanceof AnnotatedBeanDefinition) {
                // verify annotated class is an interface
                AnnotatedBeanDefinition beanDefinition = (AnnotatedBeanDefinition) candidateComponent;
                AnnotationMetadata annotationMetadata = beanDefinition.getMetadata();
                Assert.isTrue(annotationMetadata.isInterface(),
                        "@FeignClient can only be specified on an interface");
				//获取该FeignClient的注解属性，如"url"、"contextId"等
                Map<String, Object> attributes = annotationMetadata
                        .getAnnotationAttributes(
                                FeignClient.class.getCanonicalName());
				//从"contextId"、"value"、"name"、"serviceId"获取FeignClient的name，后面的值会覆盖前面的值
                String name = getClientName(attributes);
                //注册configuration至IoC
                registerClientConfiguration(registry, name,
                        attributes.get("configuration"));
				//注册FeignClient至IoC
                registerFeignClient(registry, annotationMetadata, attributes);
            }
        }
    }
}

private void registerFeignClient(BeanDefinitionRegistry registry,
			AnnotationMetadata annotationMetadata, Map<String, Object> attributes) {
    String className = annotationMetadata.getClassName();
    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);

    String alias = contextId + "FeignClient";
    AbstractBeanDefinition beanDefinition = definition.getBeanDefinition();
    beanDefinition.setAttribute(FactoryBean.OBJECT_TYPE_ATTRIBUTE, className);

    // has a default, won't be null
    boolean primary = (Boolean) attributes.get("primary");

    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);
}

基于JDK的AOP的拦截

大致分为以下两步：

1. 代理对象注入IoC
   通过ReflectiveFeign#newInstance()创建代理对象，并将其注入IoC容器（在AbstractApplicationContext#refresh()的finishBeanFactoryInitialization(beanFactory)处调用）
2. 调用AOP过程
   通过ReflectiveFeign#invoke()方法实现，它实现了InvocationHandler接口，代码如下：

@Override
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();
    }	
	//Map<Method, MethodHandler> dispatch保存了FeignClient所有的方法
    return dispatch.get(method).invoke(args);
}

调用链如下