大佬教程收集整理的这篇文章主要介绍了Feign使用分析，大佬教程大佬觉得挺不错的，现在分享给大家，也给大家做个参考。
在实现的效果上来说Feign = RestTemplate+Ribbon+HyStrix
Feign实现RestTemplate+Ribbon效果，只需要以下几步
在springcloud项目调用方的pom文件中加入openFeign的配置
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
在启动类中加入@EnableFeignClients
同时使用接口声明的方式来实现接口调用
@FeignClient(name = "zhao-service-resume")
public interface ResumeFeignClient {
@GetMapping("/resume/openstate/{userID}")
public Integer findDefaultResumeState(@PathVariable Long userId) ;
}
这个接口的声明与被调用方的实现完全一样，我们需要在声明时@FeignClient(name = "zhao-service-resume")声明被调用的服务，即可按照默认的方式进行调用
使用单元测试测试即可测试到负载均衡的效果,访问两次，分别访问到8081和8082端口的服务
@RunWith(SpringRunner.class)
@SpringBootTest(classes = DeliverApplication8091.class)
public class FeignTest {
@Autowired
ResumeFeignClient feignClient;
@Test
public void feignTest(){
Integer port = feignClient.findDefaultResumeState(2195321L);
System.out.println("测试的结果"+port);
}
}
那么如何在配置类中配置负载均衡呢？格式如下,同时我们还配置了请求的超时时间，在没有配置hyStrix的情况下，会出现超时的情况，
zhao-service-resume:
ribbon: #请求连接超时时间
ConnectTimeout: 2000
#请求处理超时时间
ReadTimeout: 5000
#对所有操作都进⾏重试
OkToRetryOnAllOperations: true
####根据如上配置，当访问到故障请求的时候，它会再尝试访问⼀次当前实例（次数由MaxAutoRetries配置），
####如果不⾏，就换⼀个实例进⾏访问，如果还不⾏，再换⼀次实例访问（更换次数由MaxAutoRetriesNextServer配置），
####如果依然不⾏，返回失败信息。
MaxAutoRetries: 0 #对当前选中实例重试次数，不包括第⼀次调⽤
MaxAutoRetriesNextServer: 0 #切换实例的重试次数
NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RoundRobinRule #负载策略调整
超时的报错feign.RetryableException: Read timed out execuTing GET http://zhao-service-resume/resume/openstate/2195321
即是没有配置重试的这几个参数也是同样的效果
首先是先开启熔断器
feign:
hyStrix:
enabled: true
接着增加超时处理逻辑的相关配置
hyStrix:
command:
default:
execution:
isolation:
thread:
timeoutInMilliseconds: 15000
但是即使我在被调用方只线程休眠了十秒，程序依然被熔断了。查阅资料表明，HyStrix将采用feign和hyStrix超时时间中较小的那个进行超时判定
增加降级兜底方法
@Component
public class FeignClientfallBACk implements ResumeFeignClient {
@Override
public Integer findDefaultResumeState(Long userId) {
return -1;
}
}
在调用方增加降级配置
@FeignClient(name = "zhao-service-resume",fallBACk = FeignClientfallBACk.class)
public interface ResumeFeignClient {
@GetMapping("/resume/openstate/{userID}")
public Integer findDefaultResumeState(@PathVariable Long userId) ;
}
同时可以在@FeignClient中增加path属性，将方法上的公共路径提取到类中
配置属性如下
feign:
compression:
request:
enabled: true
min-request-size: 2048
mime-types: text/html,application/xml,application/json # 设置压缩的数据类型
response:
enabled: true
以上配置包含的两个属性，min-request-size: 2048表示开启压缩的最小值为2048字节，mime-types为支持压缩的数据类型，当前的这几种类型未默认值
首先在yml中设置具体的类的日志响应级别
logging:
level:
# Feign⽇志只会对⽇志级别为debug的做出响应
com.lagou.edu.controller.service.ResumeserviceFeignClient:
debug
然后就是针对feign的log的配置
import feign.Logger;
import org.springframework.context.Annotation.bean;
import org.springframework.context.Annotation.Configuration;
@Configuration
public class FeignConfig {
@Bean
Logger.Level feignLevel(){
return Logger.Level.FULL;
}
}
需要注意的是，此处引入的是feign.Logger,此处表示的含义是feign将会打印请求的所有信息如下
还是依据前文，依照启动类注解和spring.factories中配置的自动配置类来进行分析，首先我们看@EnableFeignClients注解中的FeignClientsRegistrar的具体内容,实现的依然是Spring中的注入beanDefinition的内容
@Override
public void registerBeanDefinitions(AnnotationMetadata metadata,
BeanDefinitionRegistry registry) {
registerDefaultConfiguration(metadata, registry);
registerFeignClients(metadata, registry);
}
registerDefaultConfiguration注入默认配置我们基本可以确定就是加入一些默认配置，而registerFeignClients就是最终实现逻辑的地方。而最终实现逻辑的地方是在该方法下的
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();
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);
}
而这个类都依赖于 BeanDefinitionBuilder definition = BeanDefinitionBuilder.genericBeanDefinition(FeignClientFactoryBean.class);几乎可以确定注入的时候就是FeignClientFactoryBean这个工厂Bean在起作用，那么我们在进入里面看一看,工厂Bean最重要的就是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() {
FeignContext context = applicationContext.getBean(FeignContext.class);
Feign.builder builder = feign(context);
if (!StringUtils.hasText(thiS.Url)) {
if (!this.name.startsWith("http")) {
url = "http://" + this.name;
}
else {
url = this.name;
}
url += cleanPath();
return (T) loadBalance(builder, context, new HardCodedTarget<>(this.type,
this.name, url));
}
if (StringUtils.hasText(thiS.Url) && !thiS.Url.startsWith("http")) {
thiS.Url = "http://" + thiS.Url;
}
String url = thiS.Url + cleanPath();
Client client = getOptional(context, Client.class);
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();
}
builder.client(client);
}
Targeter targeter = get(context, Targeter.class);
return (T) targeter.target(this, builder, context, new HardCodedTarget<>(
this.type, this.name, url));
}
在上述代码中，基本上就是构造客户端并调用的过程，那么最关键的就是实现了Ribbon功能的负载均衡的loadBalance操作中内容
protected <T> T loadBalance(Feign.builder builder, FeignContext context,
HardCodedTarget<T> target) {
Client client = getOptional(context, Client.class);
if (client != null) {
builder.client(client);
Targeter targeter = get(context, Targeter.class);
return targeter.target(this, builder, context, target);
}
throw new IllegalStateException(
"No Feign Client for loadBalancing defined. Did you forget to include spring-cloud-starter-netflix-ribbon?");
}
而 targeter.target这段最后都会执行到feign类中的这个方法中
public <T> T target(Target<T> target) {
return build().newInstance(target);
}
关注到newInstance方法发现最终实现时在ReflectiveFeign类中
@Override
public <T> T newInstance(Target<T> target) {
Map<String, MethodHandler> nameToHandler = targetToHandlersByName.apply(target);
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 {
methodToHandler.put(method, nameToHandler.get(Feign.configKey(target.type(), method)));
}
}
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;
}
上述可见，最终生成的类实际上一个代理类完成了最终的调用，而在代理对象就完成了最后的负载均衡等处理,生成代理对象使用的死FeignInvocationHandler的invoke方法
static final class Default implements InvocationHandlerFactory {
@Override
public InvocationHandler create(Target target, Map<Method, MethodHandler> dispatch) {
return new ReflectiveFeign.FeignInvocationHandler(target, dispatch);
}
}
最后执行了相关的编解码操作
@Override
public Object invoke(Object[] argv) throws Throwable {
requestTemplate template = buildTemplateFromArgs.create(argv);
Retryer retryer = this.retryer.clone();
while (true) {
try {
return executeAndDecode(templatE);
} catch (RetryableException E) {
try {
retryer.conTinueOrPropagate(E);
} catch (RetryableException th) {
Throwable cause = th.getCause();
if (propagationPolicy == UNWRAP && cause != null) {
throw cause;
} else {
throw th;
}
}
if (logLevel != Logger.Level.NONE) {
logger.logRetry(metadata.configKey(), logLevel);
}
conTinue;
}
}
}
而执行并解码的操作executeAndDecode中最重要的就是client.execute方法，点进去之后发现，居然最终调用的就是LoadBalancerFeignClient.execute方法
最终在该方法中实现了远程调用和负载均衡
以上是大佬教程为你收集整理的Feign使用分析全部内容，希望文章能够帮你解决Feign使用分析所遇到的程序开发问题。
如果觉得大佬教程网站内容还不错，欢迎将大佬教程推荐给程序员好友。
本图文内容来源于网友网络收集整理提供，作为学习参考使用，版权属于原作者。
如您有任何意见或建议可联系处理。小编QQ：384754419，请注明来意。