簡化本地Feign調用的方法

在平常的工作中，OpenFeign作為微服務間的調用組件使用的非常普遍，接口配合注解的調用方式突出一個簡便，讓我們能無需關注內部細節(jié)就能實現服務間的接口調用。

但是工作中用久了，發(fā)現Feign也有些使用起來麻煩的地方，下面先來看一個問題，再看看我們在工作中是如何解決，以達到簡化Feign使用的目的。

先看問題

在一個項目開發(fā)的過程中，我們通常會區(qū)分開發(fā)環(huán)境、測試環(huán)境和生產環(huán)境，如果有的項目要求更高的話，可能還會有個預生產環(huán)境。

開發(fā)環(huán)境作為和前端開發(fā)聯調的環(huán)境，一般使用起來都比較隨意，而我們在進行本地開發(fā)的時候，有時候也會將本地啟動的微服務注冊到注冊中心nacos上，方便進行調試。

這樣，注冊中心的一個微服務可能就會擁有多個服務實例，就像下面這樣：

眼尖的小伙伴肯定發(fā)現了，這兩個實例的ip地址有一點不同。

線上環(huán)境現在一般使用容器化部署，通常都是由流水線工具打成鏡像然后扔到docker中運行，因此我們去看一下服務在docker容器內的ip：

可以看到，這就是注冊到nacos上的服務地址之一，而列表中192開頭的另一個ip，則是我們本地啟動的服務的局域網地址?？匆幌孪旅孢@張圖，就能對整個流程一目了然了。

總結一下：

兩個service都是通過宿主機的ip和port，把自己的信息注冊到nacos上

線上環(huán)境的service注冊時使用docker內部ip地址

本地的service注冊時使用本地局域網地址

那么這時候問題就來了，當我本地再啟動一個serviceB，通過FeignClient來調用serviceA中的接口時，因為Feign本身的負載均衡，就可能把請求負載均衡到兩個不同的serviceA實例。

如果這個調用請求被負載均衡到本地serviceA的話，那么沒什么問題，兩個服務都在同一個192.168網段內，可以正常訪問。但是如果負載均衡請求到運行在docker內的serviceA的話，那么問題來了，因為網絡不通，所以會請求失?。?/p>

說白了，就是本地的192.168和docker內的虛擬網段172.17屬于純二層的兩個不同網段，不能互訪，所以無法直接調用。

那么，如果想在調試時把請求穩(wěn)定打到本地服務的話，有一個辦法，就是指定在FeignClient中添加url參數，指定調用的地址：

@FeignClient(value="serviceA",url="http://127.0.0.1:8088/")
publicinterfaceClientA{
@GetMapping("/test/get")
Stringget();
}

但是這么一來也會帶來點問題：

代碼上線時需要再把注解中的url刪掉，還要再次修改代碼，如果忘了的話會引起線上問題

如果測試的FeignClient很多的話，每個都需要配置url，修改起來很麻煩

那么，有什么辦法進行改進呢？為了解決這個問題，我們還是得從Feign的原理說起。

Feign原理

簡單來說，就是項目中加的@EnableFeignClients這個注解，實現時有一行很重要的代碼：

@Import(FeignClientsRegistrar.class)

這個類實現了ImportBeanDefinitionRegistrar接口，在這個接口的registerBeanDefinitions方法中，可以手動創(chuàng)建BeanDefinition并注冊，之后spring會根據BeanDefinition實例化生成bean，并放入容器中。

Feign就是通過這種方式，掃描添加了@FeignClient注解的接口，然后一步步生成代理對象，具體流程可以看一下下面這張圖：

后續(xù)在請求時，通過代理對象的FeignInvocationHandler進行攔截，并根據對應方法進行處理器的分發(fā)，完成后續(xù)的http請求操作。

ImportBeanDefinitionRegistrar

上面提到的ImportBeanDefinitionRegistrar，在整個創(chuàng)建FeignClient的代理過程中非常重要， 所以我們先寫一個簡單的例子看一下它的用法。先定義一個實體類：

@Data
@AllArgsConstructor
publicclassUser{
Longid;
Stringname;
}

通過BeanDefinitionBuilder，向這個實體類的構造方法中傳入具體值，最后生成一個BeanDefinition：

publicclassMyBeanDefinitionRegistrar
implementsImportBeanDefinitionRegistrar{
@Override
publicvoidregisterBeanDefinitions(AnnotationMetadataimportingClassMetadata,
BeanDefinitionRegistryregistry){
BeanDefinitionBuilderbuilder
=BeanDefinitionBuilder.genericBeanDefinition(User.class);
builder.addConstructorArgValue(1L);
builder.addConstructorArgValue("Hydra");

AbstractBeanDefinitionbeanDefinition=builder.getBeanDefinition();
registry.registerBeanDefinition(User.class.getSimpleName(),beanDefinition);
}
}

registerBeanDefinitions方法的具體調用時間是在之后的ConfigurationClassPostProcessor執(zhí)行postProcessBeanDefinitionRegistry方法時，而registerBeanDefinition方法則會將BeanDefinition放進一個map中，后續(xù)根據它實例化bean。

在配置類上通過@Import將其引入：

@Configuration
@Import(MyBeanDefinitionRegistrar.class)
publicclassMyConfiguration{
}

注入這個User測試：

@Service
@RequiredArgsConstructor
publicclassUserService{
privatefinalUseruser;

publicvoidgetUser(){
System.out.println(user.toString());
}
}

結果打印，說明我們通過自定義BeanDefinition的方式成功手動創(chuàng)建了一個bean并放入了spring容器中：

User(id=1,name=Hydra)

好了，準備工作鋪墊到這結束，下面開始正式的改造工作。

改造

到這里先總結一下，我們糾結的點就是本地環(huán)境需要FeignClient中配置url，但線上環(huán)境不需要，并且我們又不想來回修改代碼。

除了像源碼中那樣生成動態(tài)代理以及攔截方法，官方文檔中還給我們提供了一個手動創(chuàng)建FeignClient的方法。

簡單來說，就是我們可以像下面這樣，通過Feign的Builder API來手動創(chuàng)建一個Feign客戶端。

簡單看一下，這個過程中還需要配置Client、Encoder、Decoder、Contract、RequestInterceptor等內容。

Client：實際http請求的發(fā)起者，如果不涉及負載均衡可以使用簡單的Client.Default，用到負載均衡則可以使用LoadBalancerFeignClient，前面也說了，LoadBalancerFeignClient中的delegate其實使用的也是Client.Default

Encoder和Decoder：Feign的編解碼器，在spring項目中使用對應的SpringEncoder和ResponseEntityDecoder，這個過程中我們借用GsonHttpMessageConverter作為消息轉換器來解析json

RequestInterceptor：Feign的攔截器，一般業(yè)務用途比較多，比如添加修改header信息等，這里用不到可以不配

Contract：字面意思是合約，它的作用是將我們傳入的接口進行解析驗證，看注解的使用是否符合規(guī)范，然后將關于http的元數據抽取成結果并返回。如果我們使用RequestMapping、PostMapping、GetMapping之類注解的話，那么對應使用的是SpringMvcContract

其實這里剛需的就只有Contract這一個，其他都是可選的配置項。我們寫一個配置類，把這些需要的東西都注入進去：

@Slf4j
@Configuration(proxyBeanMethods=false)
@EnableConfigurationProperties({LocalFeignProperties.class})
@Import({LocalFeignClientRegistrar.class})
@ConditionalOnProperty(value="feign.local.enable",havingValue="true")
publicclassFeignAutoConfiguration{
static{
log.info("feignlocalroutestarted");
}

@Bean
@Primary
publicContractcontract(){
returnnewSpringMvcContract();
}

@Bean(name="defaultClient")
publicClientdefaultClient(){
returnnewClient.Default(null,null);
}

@Bean(name="ribbonClient")
publicClientribbonClient(CachingSpringLoadBalancerFactorycachingFactory,
SpringClientFactoryclientFactory){
returnnewLoadBalancerFeignClient(defaultClient(),cachingFactory,
clientFactory);
}

@Bean
publicDecoderdecoder(){
HttpMessageConverterhttpMessageConverter=newGsonHttpMessageConverter();
ObjectFactorymessageConverters=()->newHttpMessageConverters(httpMessageConverter);
SpringDecoderspringDecoder=newSpringDecoder(messageConverters);
returnnewResponseEntityDecoder(springDecoder);
}

@Bean
publicEncoderencoder(){
HttpMessageConverterhttpMessageConverter=newGsonHttpMessageConverter();
ObjectFactorymessageConverters=()->newHttpMessageConverters(httpMessageConverter);
returnnewSpringEncoder(messageConverters);
}
}

在這個配置類上，還有三行注解，我們一點點解釋。

首先是引入的配置類LocalFeignProperties，里面有三個屬性，分別是是否開啟本地路由的開關、掃描FeignClient接口的包名，以及我們要做的本地路由映射關系，addressMapping中存的是服務名和對應的url地址：

@Data
@Component
@ConfigurationProperties(prefix="feign.local")
publicclassLocalFeignProperties{
//是否開啟本地路由
privateStringenable;

//掃描FeignClient的包名
privateStringbasePackage;

//路由地址映射
privateMapaddressMapping;
}

下面這行注解則表示只有當配置文件中feign.local.enable這個屬性為true時，才使當前配置文件生效：

@ConditionalOnProperty(value="feign.local.enable",havingValue="true")

最后，就是我們重中之重的LocalFeignClientRegistrar了，我們還是按照官方通過ImportBeanDefinitionRegistrar接口構建BeanDefinition然后注冊的思路來實現。

并且，FeignClientsRegistrar的源碼中已經實現好了很多基礎的功能，比如掃掃描包、獲取FeignClient的name、contextId、url等等，所以需要改動的地方非常少，可以放心的大抄特超它的代碼。

先創(chuàng)建LocalFeignClientRegistrar，并注入需要用到的ResourceLoader、BeanFactory、Environment。

@Slf4j
publicclassLocalFeignClientRegistrarimplements
ImportBeanDefinitionRegistrar,ResourceLoaderAware,
EnvironmentAware,BeanFactoryAware{

privateResourceLoaderresourceLoader;
privateBeanFactorybeanFactory;
privateEnvironmentenvironment;

@Override
publicvoidsetResourceLoader(ResourceLoaderresourceLoader){
this.resourceLoader=resourceLoader;
}

@Override
publicvoidsetBeanFactory(BeanFactorybeanFactory)throwsBeansException{
this.beanFactory=beanFactory;
}

@Override
publicvoidsetEnvironment(Environmentenvironment){
this.environment=environment;
}

//先省略具體功能代碼...
}

然后看一下創(chuàng)建BeanDefinition前的工作，這一部分主要完成了包的掃描和檢測@FeignClient注解是否被添加在接口上的測試。下面這段代碼基本上是照搬源碼，除了改動一下掃描包的路徑，使用我們自己在配置文件中配置的包名。

@Override
publicvoidregisterBeanDefinitions(AnnotationMetadataimportingClassMetadata,BeanDefinitionRegistryregistry){
ClassPathScanningCandidateComponentProviderscanner=ComponentScanner.getScanner(environment);
scanner.setResourceLoader(resourceLoader);
AnnotationTypeFilterannotationTypeFilter=newAnnotationTypeFilter(FeignClient.class);
scanner.addIncludeFilter(annotationTypeFilter);

StringbasePackage=environment.getProperty("feign.local.basePackage");
log.info("begintoscan{}",basePackage);

SetcandidateComponents=scanner.findCandidateComponents(basePackage);

for(BeanDefinitioncandidateComponent:candidateComponents){
if(candidateComponentinstanceofAnnotatedBeanDefinition){
log.info(candidateComponent.getBeanClassName());

//verifyannotatedclassisaninterface
AnnotatedBeanDefinitionbeanDefinition=(AnnotatedBeanDefinition)candidateComponent;
AnnotationMetadataannotationMetadata=beanDefinition.getMetadata();
Assert.isTrue(annotationMetadata.isInterface(),
"@FeignClientcanonlybespecifiedonaninterface");

Mapattributes=annotationMetadata
.getAnnotationAttributes(FeignClient.class.getCanonicalName());

Stringname=FeignCommonUtil.getClientName(attributes);
registerFeignClient(registry,annotationMetadata,attributes);
}
}
}

接下來創(chuàng)建BeanDefinition并注冊，Feign的源碼中是使用的FeignClientFactoryBean創(chuàng)建代理對象，這里我們就不需要了，直接替換成使用Feign.builder創(chuàng)建。

privatevoidregisterFeignClient(BeanDefinitionRegistryregistry,
AnnotationMetadataannotationMetadata,Mapattributes){
StringclassName=annotationMetadata.getClassName();
Classclazz=ClassUtils.resolveClassName(className,null);
ConfigurableBeanFactorybeanFactory=registryinstanceofConfigurableBeanFactory
?(ConfigurableBeanFactory)registry:null;
StringcontextId=FeignCommonUtil.getContextId(beanFactory,attributes,environment);
Stringname=FeignCommonUtil.getName(attributes,environment);

BeanDefinitionBuilderdefinition=BeanDefinitionBuilder
.genericBeanDefinition(clazz,()->{
Contractcontract=beanFactory.getBean(Contract.class);
ClientdefaultClient=(Client)beanFactory.getBean("defaultClient");
ClientribbonClient=(Client)beanFactory.getBean("ribbonClient");
Encoderencoder=beanFactory.getBean(Encoder.class);
Decoderdecoder=beanFactory.getBean(Decoder.class);

LocalFeignPropertiesproperties=beanFactory.getBean(LocalFeignProperties.class);
MapaddressMapping=properties.getAddressMapping();

Feign.Builderbuilder=Feign.builder()
.encoder(encoder)
.decoder(decoder)
.contract(contract);

StringserviceUrl=addressMapping.get(name);
StringoriginUrl=FeignCommonUtil.getUrl(beanFactory,attributes,environment);

Objecttarget;
if(StringUtils.hasText(serviceUrl)){
target=builder.client(defaultClient)
.target(clazz,serviceUrl);
}elseif(StringUtils.hasText(originUrl)){
target=builder.client(defaultClient)
.target(clazz,originUrl);
}else{
target=builder.client(ribbonClient)
.target(clazz,"http://"+name);
}

returntarget;
});

definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
definition.setLazyInit(true);
FeignCommonUtil.validate(attributes);

AbstractBeanDefinitionbeanDefinition=definition.getBeanDefinition();
beanDefinition.setAttribute(FactoryBean.OBJECT_TYPE_ATTRIBUTE,className);

//hasadefault,won'tbenull
booleanprimary=(Boolean)attributes.get("primary");
beanDefinition.setPrimary(primary);

String[]qualifiers=FeignCommonUtil.getQualifiers(attributes);
if(ObjectUtils.isEmpty(qualifiers)){
qualifiers=newString[]{contextId+"FeignClient"};
}

BeanDefinitionHolderholder=newBeanDefinitionHolder(beanDefinition,className,
qualifiers);
BeanDefinitionReaderUtils.registerBeanDefinition(holder,registry);
}

在這個過程中主要做了這么幾件事：

通過beanFactory拿到了我們在前面創(chuàng)建的Client、Encoder、Decoder、Contract，用來構建Feign.Builder

通過注入配置類，通過addressMapping拿到配置文件中服務對應的調用url

通過target方法替換要請求的url，如果配置文件中存在則優(yōu)先使用配置文件中url，否則使用@FeignClient注解中配置的url，如果都沒有則使用服務名通過LoadBalancerFeignClient訪問

在resources/META-INF目錄下創(chuàng)建spring.factories文件，通過spi注冊我們的自動配置類：

org.springframework.boot.autoconfigure.EnableAutoConfiguration=
com.feign.local.config.FeignAutoConfiguration

最后，本地打包即可：

mvncleaninstall

測試

引入我們在上面打好的包，由于包中已經包含了spring-cloud-starter-openfeign，所以就不需要再額外引feign的包了：

com.cn.hydra
feign-local-enhancer
1.0-SNAPSHOT

在配置文件中添加配置信息，啟用組件：

feign:
local:
enable:true
basePackage:com.service
addressMapping:
hydra-service:http://127.0.0.1:8088
trunks-service:http://127.0.0.1:8099

創(chuàng)建一個FeignClient接口，注解的url中我們可以隨便寫一個地址，可以用來測試之后是否會被配置文件中的服務地址覆蓋：

@FeignClient(value="hydra-service",
contextId="hydra-serviceA",
url="http://127.0.0.1:8099/")
publicinterfaceClientA{
@GetMapping("/test/get")
Stringget();

@GetMapping("/test/user")
UsergetUser();
}

啟動服務，過程中可以看見了執(zhí)行掃描包的操作：

在替換url過程中添加一個斷點，可以看到即使在注解中配置了url，也會優(yōu)先被配置文件中的服務url覆蓋：

使用接口進行測試，可以看到使用上面的代理對象進行了訪問并成功返回了結果：

如果項目需要發(fā)布正式環(huán)境，只需要將配置feign.local.enable改為false或刪掉，并在項目中添加Feign原始的@EnableFeignClients即可。

總結

本文提供了一個在本地開發(fā)過程中簡化Feign調用的思路，相比之前需要麻煩的修改FeignClient中的url而言，能夠節(jié)省不少的無效勞動，并且通過這個過程，也可以幫助大家了解我們平常使用的這些組件是怎么與spring結合在一起的，熟悉spring的擴展點。

審核編輯：劉清