Feign与Spring Cloud源码解析

Feign简介

在Feign的官方文档上，我们可以看到Feign最重要的一句话是：Feign makes writing java http clients easier。Feign主要的目也是为了简化我们编写远程访问的代码量。在使用 Feign 时，可以使用注解来修饰接口，这些注解中既包括了 Feign 自带的注解，也支持使用第三方的注解（通过注解转换来实现）。除此之外， Feign还支持插件式的编码器和解码器，使用者可以通过该特性，对请求和响应进行不同的封装与解析。Feign可以决定采用什么方式调用第三方接口OkHttpClient或者RibbonClient。而所有的这些特性都可以很容易的进行扩展，这也是Spring Cloud选择Feign的原因。官方文档：https://github.com/OpenFeign/feign

Feign简单实例

编写服务端的逻辑。可以通过Spring boot，提供任何一个接口供系统调用，如下便提供了一个简单的接口：

package com.ivan.provider.controller;

import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.ivan.provider.entity.User;

@RestController
public class UserController {

   @RequestMapping(value="/user/{id}")
   public User getUser(@PathVariable(value = "id") Integer id){
       User user = new User();
       user.setId(id);
       user.setName("ivan chen");
       user.setAge(18);
       return user;
   }
}

+在客户端需要引入feign相关的类，pom.xml代码如下：

   
       
           io.github.openfeign
           feign-core
           9.7.0
       
       
           io.github.openfeign
           feign-gson
           9.7.0

在客户端首先定义一个接口，我们的代码可以通过这个接口调用直接拿到我们想要的数据，代码如下：

package com.ivan.feign.client.service;

import com.ivan.feign.client.entity.User;

import feign.Param;
import feign.RequestLine;

public interface UserService {

   @RequestLine("GET /user/{id}")
   public User getUser(@Param("id") Integer id);
}

编写客户端的调用逻辑，我们可以在代码里直接通过UserService这个接口得到数据，省去了通过构造一系列的http client对象。代码如下：

package com.ivan.feign.client;

import com.ivan.feign.client.entity.User;
import com.ivan.feign.client.service.UserService;

import feign.Feign;
import feign.gson.GsonDecoder;

public class Client {

   public static void main(String[] args) {
       // 可以通过UserService进行方法的调用了。
       UserService userService = Feign.builder().decoder(new GsonDecoder()).target(UserService.class, "http://localhost:8000");
       //直接就能够得到User对象，这样代码逻辑上就更面向对象了
       User user = userService.getUser(2);
       System.out.println(user.getName());
   }

}

Feign的编解码器

通过上面的实例，可以看出通过Feign调用第三方接口会方便很多，除了不需要设置一系列的请求参数外，Feign还帮我们将请求返回的数据转成我们需要的业务对象，而这一切是通过解码器办到的。Feign还提供了编码器，他能够将我们需要发送的业务对象转成服务端能够接受的格式，比如json格式，xml格式。

Feign编码器实例

服务端增加一个服务接口，接收json格式的数据，代码如下：

package com.ivan.provider.controller;

import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import com.ivan.provider.entity.User;

@RestController
public class UserController {

    @RequestMapping(value = "/user/{id}")
    public User getUser(@PathVariable(value = "id") Integer id) {
        User user = new User();
        user.setId(id);
        user.setName("ivan chen");
        user.setAge(18);
        return user;
    }

    @RequestMapping(value = "/user/create", method = RequestMethod.POST, consumes = MediaType.APPLICATION_JSON_VALUE)
    public User createUserPerson(@RequestBody User user) {
        System.out.println(user.getName());
        user.setId(15);
        return user;
    }
}

客户端增加一个接口描述，这里面要用到Feign的 Headers注解，用于表明调用当前方法的时候，需要转成什么格式的数据，代码如下：

package com.ivan.feign.client.service;

import com.ivan.feign.client.entity.User;

import feign.Headers;
import feign.Param;
import feign.RequestLine;

public interface UserService {

    @RequestLine("GET /user/{id}")
    public User getUser(@Param("id") Integer id);
    
    @RequestLine("POST /user/create")
    @Headers("Content-Type: application/json")
    public User create(User user);
}

构造接口的实例对象的时候需要传入一个编码器对象，Feign对json格式提供了gson的编码器，我们可以利用这个编码器实现对象到json格式的转换。代码如下：

package com.ivan.feign.client;

import com.ivan.feign.client.entity.User;
import com.ivan.feign.client.service.UserService;

import feign.Feign;
import feign.gson.GsonDecoder;
import feign.gson.GsonEncoder;

public class Client {

    public static void main(String[] args) {
        /*        // 可以通过UserService进行方法的调用了。
        UserService userService = Feign.builder().decoder(new GsonDecoder()).target(UserService.class, "http://localhost:8000");
        //直接就能够得到User对象，这样代码逻辑上就更面向对象了
        User user = userService.getUser(2);
        System.out.println(user.getName());*/

        UserService userService = Feign.builder().encoder(new GsonEncoder()).decoder(new GsonDecoder()).target(UserService.class, "http://localhost:8000");
        User user = new User();
        user.setName("张山");
        user.setAge(88);
        
        user = userService.create(user);
        System.out.println(user.getId());

    }

}

Spring Cloud里应用Feign

首先需要在pom.xml文件里加上相关的依赖，pom.xml里的代码如下：

    
        
            
                org.springframework.cloud
                spring-cloud-dependencies
                Edgware.SR4
                pom
                import
            
        
    

    
        
            org.springframework.cloud
            spring-cloud-starter-eureka
        
        
            org.springframework.cloud
            spring-cloud-starter-feign

spring-cloud-starter-feign 这个 JAR包包含了Ribbon相关的依赖，也就是说在实际开发中，只要集成了Feign，自动就集成了Ribbon。有相应的负载能力了。

定义消费端要用到的接口，这里用到的注解变成了Spring MVC提供的注解了，说明Spring Cloud在集成Feign的时候做了相应的注解转换。FeignClient里需要写上这个类是调用那个服务端的名称。

package com.ivan.client.feign.service;

import org.springframework.cloud.netflix.feign.FeignClient;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

import com.ivan.client.feign.entity.User;

@FeignClient("provider")
public interface UserService {

    @RequestMapping(method = RequestMethod.GET, value = "/user/{id}")
    public User getUser(@PathVariable("id") Integer id);

    @RequestMapping(method = RequestMethod.POST, value = "/user/create", consumes = MediaType.APPLICATION_JSON_VALUE)
    public User create(User user);

}

在启动类上加上EnableFeignClients注解。

package com.ivan.client.feign;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.netflix.feign.EnableFeignClients;

@SpringBootApplication
@EnableEurekaClient
@EnableFeignClients
public class App {

    public static void main(String[] args) {
        SpringApplication.run(App.class, args);
    }
}

编写服务消费端，在服务消费端，可以直接通过Autowired注解注入刚刚定义的接口。这样的代码有更易维护，代码逻辑与配置分离等优点。代码如下：

package com.ivan.client.feign.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import com.ivan.client.feign.entity.User;
import com.ivan.client.feign.service.UserService;

@RestController
public class ConsumerUserController {

    @Autowired
    private UserService userService;

    @RequestMapping(value = "/consumer/user/{id}")
    public User getUser(@PathVariable(value = "id") Integer id) {
        return userService.getUser(id);
    }

    @RequestMapping(value = "/consumer/user/create", method = RequestMethod.GET)
    public User createUserPerson() {
        User user = new User();
        user.setName("张山");
        user.setAge(18);
        user = userService.create(user);
        System.out.println(user.getId());
        return user;
    }
}

运行上面代码发现客户端已经自动实现了Ribbon的负载能力。

Spring Cloud都为我们加载了那些Feign相关的对象

在代码里应用上Feign，能够让我们的代码具有更好的维护性，那Spring Cloud是如何做到的呢?从上面的代码上看我们至少可以得到如下猜测：

通过FeignClient注解，我们得到的UserService对象一定是通过FeignBuilder构造出来的对象，这样才可能具备访问第三方接口的能力。
我们在接口方法里用到的注解都是Spring MVC的注解，Spring Cloud一定提供了某种转换器将Spring MVC的注解转成Feign内部的注解。
Spring Cloud应该提供了某些编解码器来对请求需要发送的对象与得到的对象进行编解码。

EnableFeignClients里的秘密

在启动类上，我们加上了EnableFeignClients这个注解，那这个注解到底为我们做了那些工作呢，打开这个类的源码，我们可以看到如下代码：

image.png

看到FeignClientRegistrar类，你应该可以猜测到这个类的功能应该就是将FeignClient注解的类注册到Spring IOC容器里。带着这样的猜测来看看FeignClientRegistrar类的注要代码。关键代码我都有加上相应的注释：

package org.springframework.cloud.netflix.feign;


/**
 * @author Spencer Gibb
 * @author Jakub Narloch
 * @author Venil Noronha
 */
class FeignClientsRegistrar implements ImportBeanDefinitionRegistrar,
        ResourceLoaderAware, BeanClassLoaderAware, EnvironmentAware {

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

    private void registerDefaultConfiguration(AnnotationMetadata metadata,
            BeanDefinitionRegistry registry) {
        Map 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"));
        }
    }

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

        Set basePackages;

        Map attrs = metadata
                .getAnnotationAttributes(EnableFeignClients.class.getName());
//这里定义了注解的过滤器，只有FeignClient注解才会被筛出来
        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 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) {
            Set 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");

                    Map attributes = annotationMetadata
                            .getAnnotationAttributes(
                                    FeignClient.class.getCanonicalName());

                    String name = getClientName(attributes);
                    registerClientConfiguration(registry, name,
                            attributes.get("configuration"));

                    registerFeignClient(registry, annotationMetadata, attributes);
                }
            }
        }
    }

/**
 * 
  这个方法很重要噢，里面将@FeignClient注解定义的类转成BeanDefinition对象，这样Spring IOC容器就有办法帮我们生成具体的FeignClient注解里定义的实例了。注意这里的BeanDefinition对象的实例是FeignClientFactoryBean对象，从这个对象中我们知道他一定提供了getObject方法，而这个方法里一定是调用了Feign Builder。
 */
    private void registerFeignClient(BeanDefinitionRegistry registry,
            AnnotationMetadata annotationMetadata, Map 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);
        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 });
        BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
    }

}

FeignClientFactoryBean 这个类里有个关键的方法。feign方法会查找容器里定义的Encoder，Decoder与Contract类。