高考报名时间2022年11月1日还剩 天 距离2023年6月7日高考还有 天
栏目分类:
子分类:
返回
名师互学网用户登录
名师互学网
快速导航关闭
当前搜索
当前分类
前沿技术 软件开发 系统运维 产品运营 生活办公 面试经验 考试题库
子分类
人工智能 大数据 云计算 区块链 物联网 深度学习 机器学习 NLP 计算机视觉 语音识别 其他 大数据系统 数据可视化 数据挖掘与分析 其他 Docker/k8s 虚拟化 云平台 其他 基本原理 数字货币 智能合约 EOS应用 其他 通讯技术 嵌入式开发 单片机 物联网应用 HarmonyOS 其他 后端开发 Web开发 移动开发 游戏开发 Python Java 架构设计 C/C++/C# PHP .Net Go语言 R语言
实用工具
学习工具 小学数学练习 字帖生成 在线画板 函数绘制 拼音字母表 在线词典 黄历查询 亲戚关系计算 安全期计算 中国历史 Excel函数 模拟请求 json格式化 浏览器指纹
热门搜索
路由器设置 木托盘 宝塔面板 儿童python教程 心情低落 朋友圈 vim 双一流学科 专升本 我的学校 日记学校 西点培训学校 汽修学校 情书 化妆学校 塔沟武校 异形模板 西南大学排名 最精辟人生短句 6步教你追回被骗的钱 南昌大学排名 清朝十二帝 北京印刷学院排名 北方工业大学排名 北京航空航天大学排名 首都经济贸易大学排名 中国传媒大学排名 首都师范大学排名 中国地质大学(北京)排名 北京信息科技大学排名
名师互学网 > IT > 软件开发 > 后端开发 > Java

Spring Cloud进阶之路之OpenFeign源码解析

Java 更新时间： 发布时间： IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

Spring Cloud进阶之路之OpenFeign源码解析

1. OpenFeign 简介

Feign是一个声明式Web Service客户端。使用Feign能让编写Web Service客户端更加简单，它的使用方法是定义一个接口，然后在上面添加注解，同时也支持JAX-RS标准的注解。Feign也支持可拔插式的编码器和解码器。Spring Cloud对Feign进行了封装，使其支持了Spring MVC标准注解和HttpMessageConverters。Feign可以与Eureka和Ribbon组合使用以支持负载均衡。

Feign 灵感来源于 Retrofit , JAXRS-2.0 和 WebSocket，Feign 最初是为了降低统一绑定 Denominator 到 HTTP APIs 的复杂度，不管是否是 Restful。

Feign旨在使编写Java Http客户端变得更容易，在Feign的实现下，我们只需要创建一个接口并使用注解的方式来配置它，即可完成对服务提供方的接口绑定，简化了使用Spring Cloud时，自动封装服务调用客户端的开发量。

FeignOpenFeign
Feign是spring cloud组件中的一个轻量级Restful的HTTP服务客户端，Feign内置了Ribbon，用来做客户端负载均衡，去调用服务注册中心的服务。Feign的使用方式是：使用Feign的注解定义接口，调用这个接口，就可以调用服务注册中心的服务。OpenFeign是Spring Cloud在Feign的基础上支持了Spring MVC的注解，如@RequestMapping等等。OpenFeign的@FiegnClient可以解析SpringMVC的@RequestMapping注解下的接口，并通过动态代理的方式产生实现类，实现类中做负载均衡并调用其他服务

2. OpenFiegn的使用
  1. 在Spring Cloud应用中使用Feign组件，首先需要在依赖包中加入以下依赖：

  org.springframework.cloud
  spring-cloud-starter-openfeign
  1. 再定义一个可供调用的Feign组件示例如下：
@FeignClient(value = "servicename")
public interface IUserService {
	
    @RequestMapping(value = "getUserDetailInfo", method = RequestMethod.GET)
  ApiResult getUserDetailInfo(@RequestParam("username") String username);
}

上述代码中，每一个方法都代表通过 Feign 请求的一个接口， @RequestMapping 指定请求地址和请求方法。 @FeignClient 则用于指定调用的微服务，结合负载均衡框架在注册中心注册的服务列表中选择一个合适的服务地址。 目前对FeignClient的应用主要有2种方式：

  • 服务提供方定义好 Feign 组件，自己的 Controller 实现定义好的Feign组件接口，然后把Feign组件打包成SDK提供给调用方，这样的好处是便于后期服务提供方统一升级组件，比如更换调用路径和参数等；
  • 服务调用方自己封装 Feign 组件，这样的好处是调用方可以灵活的自定义Feign组件；

注意：目前Feign调用对基本类型参数传值支持不是很好，所以参数最好封装成一个 DTO对象 进行传输。如果是JSON参数，最好再定义Feign组件时加上 @RequestBody 注解。

  1. 启用Feign组件是使用Feign的第一步，使用如下注解开启：
//启用Feign组件并配置扫描包路径
@EnableFeignClients(basePackages = {"com.xxx.service.api"})
  1. 接下来就是在需要调用接口的地方用Spring Bean一样调用其他服务了，示例如下：
@Autowired
private IUserService userservice;
3. OpenFeign源码解析 3.1. Feign Bean创建

Feign组件初始化是从 @EnableFeignClients 注解开始的，注解源码截图如下：

@EnableFeignClients 核心有2个方法， basePackages 与 defaultConfiguration ，前者用于定义扫描包路径，后者用于定义@FeignClient组件的配置类，在配置类中可以自己定义Feign请求的 Decoder 解码器、 Encoder 编码器、 Contract 组件扫描构造器。 在注解上有一个关键注解 @Import(FeignClientsRegistrar.class) ，导入了Feign组件的注册器，用于扫描Feign组件与初始化Feign组件的Bean定义信息，各阶段作用建下述源码注释。

class FeignClientsRegistrar implements ImportBeanDefinitionRegistrar, ResourceLoaderAware, EnvironmentAware {

	// patterned after Spring Integration IntegrationComponentScanRegistrar
	// and RibbonClientsConfigurationRegistgrar

	private ResourceLoader resourceLoader;

	private Environment environment;

	FeignClientsRegistrar() {
	}

	static void validateFallback(final Class clazz) {
		Assert.isTrue(!clazz.isInterface(), "Fallback class must implement the interface annotated by @FeignClient");
	}

	static void validateFallbackFactory(final Class clazz) {
		Assert.isTrue(!clazz.isInterface(), "Fallback factory must produce instances "
				+ "of fallback classes that implement the interface annotated by @FeignClient");
	}

	static String getName(String name) {
		if (!StringUtils.hasText(name)) {
			return "";
		}

		String host = null;
		try {
			String url;
			if (!name.startsWith("http://") && !name.startsWith("https://")) {
				url = "http://" + name;
			}
			else {
				url = name;
			}
			host = new URI(url).getHost();

		}
		catch (URISyntaxException e) {
		}
		Assert.state(host != null, "Service id not legal hostname (" + name + ")");
		return name;
	}

	static String getUrl(String url) {
		if (StringUtils.hasText(url) && !(url.startsWith("#{") && url.contains("}"))) {
			if (!url.contains("://")) {
				url = "http://" + url;
			}
			try {
				new URL(url);
			}
			catch (MalformedURLException e) {
				throw new IllegalArgumentException(url + " is malformed", e);
			}
		}
		return url;
	}

	static String getPath(String path) {
		if (StringUtils.hasText(path)) {
			path = path.trim();
			if (!path.startsWith("/")) {
				path = "/" + path;
			}
			if (path.endsWith("/")) {
				path = path.substring(0, path.length() - 1);
			}
		}
		return path;
	}

	@Override
	public void setResourceLoader(ResourceLoader resourceLoader) {
		this.resourceLoader = resourceLoader;
	}

	@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) {

		LinkedHashSet candidateComponents = new LinkedHashSet<>();
		Map attrs = metadata.getAnnotationAttributes(EnableFeignClients.class.getName());
		final Class[] clients = attrs == null ? null : (Class[]) attrs.get("clients");
		if (clients == null || clients.length == 0) {
			ClassPathScanningCandidateComponentProvider scanner = getScanner();
			scanner.setResourceLoader(this.resourceLoader);
			scanner.addIncludeFilter(new AnnotationTypeFilter(FeignClient.class));
			Set basePackages = getBasePackages(metadata);
			for (String basePackage : basePackages) {
				candidateComponents.addAll(scanner.findCandidateComponents(basePackage));
			}
		}
		else {
			for (Class clazz : clients) {
				candidateComponents.add(new AnnotatedGenericBeanDefinition(clazz));
			}
		}

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

	private void registerFeignClient(BeanDefinitionRegistry registry, AnnotationMetadata annotationMetadata,
			Map attributes) {
		String className = annotationMetadata.getClassName();
		Class clazz = ClassUtils.resolveClassName(className, null);
		ConfigurableBeanFactory beanFactory = registry instanceof ConfigurableBeanFactory
				? (ConfigurableBeanFactory) registry : null;
		String contextId = getContextId(beanFactory, attributes);
		String name = getName(attributes);
		FeignClientFactoryBean factoryBean = new FeignClientFactoryBean();
		factoryBean.setBeanFactory(beanFactory);
		factoryBean.setName(name);
		factoryBean.setContextId(contextId);
		factoryBean.setType(clazz);
		factoryBean.setRefreshableClient(isClientRefreshEnabled());
		BeanDefinitionBuilder definition = BeanDefinitionBuilder.genericBeanDefinition(clazz, () -> {
			factoryBean.setUrl(getUrl(beanFactory, attributes));
			factoryBean.setPath(getPath(beanFactory, attributes));
			factoryBean.setDecode404(Boolean.parseBoolean(String.valueOf(attributes.get("decode404"))));
			Object fallback = attributes.get("fallback");
			if (fallback != null) {
				factoryBean.setFallback(fallback instanceof Class ? (Class) fallback
						: ClassUtils.resolveClassName(fallback.toString(), null));
			}
			Object fallbackFactory = attributes.get("fallbackFactory");
			if (fallbackFactory != null) {
				factoryBean.setFallbackFactory(fallbackFactory instanceof Class ? (Class) fallbackFactory
						: ClassUtils.resolveClassName(fallbackFactory.toString(), null));
			}
			return factoryBean.getObject();
		});
		definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
		definition.setLazyInit(true);
		validate(attributes);

		AbstractBeanDefinition beanDefinition = definition.getBeanDefinition();
		beanDefinition.setAttribute(FactoryBean.OBJECT_TYPE_ATTRIBUTE, className);
		beanDefinition.setAttribute("feignClientsRegistrarFactoryBean", factoryBean);

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

		beanDefinition.setPrimary(primary);

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

		BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className, qualifiers);
		BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);

		registerOptionsBeanDefinition(registry, contextId);
	}
}

核心代码实际可以只关注以下 registerFeignClient 方法片段，定义好了创建Feign组件Bean的FactoryBean：

private void registerFeignClient(BeanDefinitionRegistry registry, AnnotationMetadata annotationMetadata,
			Map attributes) {
		String className = annotationMetadata.getClassName();
		Class clazz = ClassUtils.resolveClassName(className, null);
		ConfigurableBeanFactory beanFactory = registry instanceof ConfigurableBeanFactory
				? (ConfigurableBeanFactory) registry : null;
		String contextId = getContextId(beanFactory, attributes);
		String name = getName(attributes);
		FeignClientFactoryBean factoryBean = new FeignClientFactoryBean();
		factoryBean.setBeanFactory(beanFactory);
		factoryBean.setName(name);
		factoryBean.setContextId(contextId);
		factoryBean.setType(clazz);
		factoryBean.setRefreshableClient(isClientRefreshEnabled());
		BeanDefinitionBuilder definition = BeanDefinitionBuilder.genericBeanDefinition(clazz, () -> {
			factoryBean.setUrl(getUrl(beanFactory, attributes));
			factoryBean.setPath(getPath(beanFactory, attributes));
			factoryBean.setDecode404(Boolean.parseBoolean(String.valueOf(attributes.get("decode404"))));
			Object fallback = attributes.get("fallback");
			if (fallback != null) {
				factoryBean.setFallback(fallback instanceof Class ? (Class) fallback
						: ClassUtils.resolveClassName(fallback.toString(), null));
			}
			Object fallbackFactory = attributes.get("fallbackFactory");
			if (fallbackFactory != null) {
				factoryBean.setFallbackFactory(fallbackFactory instanceof Class ? (Class) fallbackFactory
						: ClassUtils.resolveClassName(fallbackFactory.toString(), null));
			}
			return factoryBean.getObject();
		});
		definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
		definition.setLazyInit(true);
		validate(attributes);

		AbstractBeanDefinition beanDefinition = definition.getBeanDefinition();
		beanDefinition.setAttribute(FactoryBean.OBJECT_TYPE_ATTRIBUTE, className);
		beanDefinition.setAttribute("feignClientsRegistrarFactoryBean", factoryBean);

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

		beanDefinition.setPrimary(primary);

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

		BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className, qualifiers);
		BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);

		registerOptionsBeanDefinition(registry, contextId);
	}

创建一个 FeignClientFactoryBean 对象， BeanDefinitionBuilder.genericBeanDefinition 设置Url，Path，decode404，以及降级fallback等属性，返回 BeanDefinitionBuilder 的对象,可以看到， BeanDefinitionBuilder 的构造返回的是 FeignClientFactoryBean 的 getObject() 方法。

接下来可以查看Feign代理Bean实例是如何创建的的，参见 FeignClientFactoryBean 源码：

public class FeignClientFactoryBean
		implements FactoryBean, InitializingBean, ApplicationContextAware, BeanFactoryAware {

	

	private static Log LOG = LogFactory.getLog(FeignClientFactoryBean.class);

	private Class type;

	private String name;

	private String url;

	private String contextId;

	private String path;

	private boolean decode404;

	private boolean inheritParentContext = true;

	private ApplicationContext applicationContext;

	private BeanFactory beanFactory;

	private Class fallback = void.class;

	private Class fallbackFactory = void.class;

	private int readTimeoutMillis = new Request.Options().readTimeoutMillis();

	private int connectTimeoutMillis = new Request.Options().connectTimeoutMillis();

	private boolean followRedirects = new Request.Options().isFollowRedirects();

	private boolean refreshableClient = false;

	private final List additionalCustomizers = new ArrayList<>();

	@Override
	public void afterPropertiesSet() {
		Assert.hasText(contextId, "Context id must be set");
		Assert.hasText(name, "Name must be set");
	}

	protected Feign.Builder feign(FeignContext context) {
		FeignLoggerFactory loggerFactory = get(context, FeignLoggerFactory.class);
		Logger logger = loggerFactory.create(type);

		// @formatter:off
		//FeignContext继承自BeanFactoty，所以可以用于获取Bean
		//1、builder使用的Encoder、Decoder、Contract都来自FeignClientsConfiguration自动配置类中定义
		Feign.Builder builder = get(context, Feign.Builder.class)
				// required values
				.logger(logger)
				.encoder(get(context, Encoder.class))
				.decoder(get(context, Decoder.class))
				.contract(get(context, Contract.class));
		// @formatter:on

		configureFeign(context, builder);

		return builder;
	}

	private void applyBuildCustomizers(FeignContext context, Feign.Builder builder) {
		Map customizerMap = context.getInstances(contextId,
				FeignBuilderCustomizer.class);

		if (customizerMap != null) {
			customizerMap.values().stream().sorted(AnnotationAwareOrderComparator.INSTANCE)
					.forEach(feignBuilderCustomizer -> feignBuilderCustomizer.customize(builder));
		}
		additionalCustomizers.forEach(customizer -> customizer.customize(builder));
	}

	protected void configureFeign(FeignContext context, Feign.Builder builder) {
		FeignClientProperties properties = beanFactory != null ? beanFactory.getBean(FeignClientProperties.class)
				: applicationContext.getBean(FeignClientProperties.class);

		FeignClientConfigurer feignClientConfigurer = getOptional(context, FeignClientConfigurer.class);
		setInheritParentContext(feignClientConfigurer.inheritParentConfiguration());

		if (properties != null && inheritParentContext) {
			if (properties.isDefaultToProperties()) {
				configureUsingConfiguration(context, builder);
				configureUsingProperties(properties.getConfig().get(properties.getDefaultConfig()), builder);
				configureUsingProperties(properties.getConfig().get(contextId), builder);
			}
			else {
				configureUsingProperties(properties.getConfig().get(properties.getDefaultConfig()), builder);
				configureUsingProperties(properties.getConfig().get(contextId), builder);
				configureUsingConfiguration(context, builder);
			}
		}
		else {
			configureUsingConfiguration(context, builder);
		}
	}

	protected void configureUsingConfiguration(FeignContext context, Feign.Builder builder) {
	    // feign的日志级别
		Logger.Level level = getInheritedAwareOptional(context, Logger.Level.class);
		if (level != null) {
			builder.logLevel(level);
		}
		// feign的重试机制
		Retryer retryer = getInheritedAwareOptional(context, Retryer.class);
		if (retryer != null) {
			builder.retryer(retryer);
		}
		// feign的异常解码
		ErrorDecoder errorDecoder = getInheritedAwareOptional(context, ErrorDecoder.class);
		if (errorDecoder != null) {
			builder.errorDecoder(errorDecoder);
		}
		else {
			FeignErrorDecoderFactory errorDecoderFactory = getOptional(context, FeignErrorDecoderFactory.class);
			if (errorDecoderFactory != null) {
				ErrorDecoder factoryErrorDecoder = errorDecoderFactory.create(type);
				builder.errorDecoder(factoryErrorDecoder);
			}
		}
		Request.Options options = getInheritedAwareOptional(context, Request.Options.class);
		if (options == null) {
			options = getOptionsByName(context, contextId);
		}

		// feign的读取超时设置以及连接超时
		if (options != null) {
			builder.options(options);
			readTimeoutMillis = options.readTimeoutMillis();
			connectTimeoutMillis = options.connectTimeoutMillis();
			followRedirects = options.isFollowRedirects();
		}

		//2、装入Feign请求的拦截器
		Map requestInterceptors = getInheritedAwareInstances(context,
				RequestInterceptor.class);
		if (requestInterceptors != null) {
			List interceptors = new ArrayList<>(requestInterceptors.values());
			AnnotationAwareOrderComparator.sort(interceptors);
			builder.requestInterceptors(interceptors);
		}
		QueryMapEncoder queryMapEncoder = getInheritedAwareOptional(context, QueryMapEncoder.class);
		if (queryMapEncoder != null) {
			builder.queryMapEncoder(queryMapEncoder);
		}
		if (decode404) {
			builder.decode404();
		}
		ExceptionPropagationPolicy exceptionPropagationPolicy = getInheritedAwareOptional(context,
				ExceptionPropagationPolicy.class);
		if (exceptionPropagationPolicy != null) {
			builder.exceptionPropagationPolicy(exceptionPropagationPolicy);
		}

		Map capabilities = getInheritedAwareInstances(context, Capability.class);
		if (capabilities != null) {
			capabilities.values().stream().sorted(AnnotationAwareOrderComparator.INSTANCE)
					.forEach(builder::addCapability);
		}
	}


	private void addDefaultQueryParams(FeignClientProperties.FeignClientConfiguration config, Feign.Builder builder) {
		Map> defaultQueryParameters = config.getDefaultQueryParameters();
		if (Objects.nonNull(defaultQueryParameters)) {
			builder.requestInterceptor(requestTemplate -> {
				Map> queries = requestTemplate.queries();
				defaultQueryParameters.keySet().forEach(key -> {
					if (!queries.containsKey(key)) {
						requestTemplate.query(key, defaultQueryParameters.get(key));
					}
				});
			});
		}
	}

	private void addDefaultRequestHeaders(FeignClientProperties.FeignClientConfiguration config,
			Feign.Builder builder) {
		Map> defaultRequestHeaders = config.getDefaultRequestHeaders();
		if (Objects.nonNull(defaultRequestHeaders)) {
			builder.requestInterceptor(requestTemplate -> {
				Map> headers = requestTemplate.headers();
				defaultRequestHeaders.keySet().forEach(key -> {
					if (!headers.containsKey(key)) {
						requestTemplate.header(key, defaultRequestHeaders.get(key));
					}
				});
			});
		}
	}

	private  T getOrInstantiate(Class tClass) {
		try {
			return beanFactory != null ? beanFactory.getBean(tClass) : applicationContext.getBean(tClass);
		}
		catch (NoSuchBeanDefinitionException e) {
			return BeanUtils.instantiateClass(tClass);
		}
	}

	protected  T get(FeignContext context, Class type) {
		T instance = context.getInstance(contextId, type);
		if (instance == null) {
			throw new IllegalStateException("No bean found of type " + type + " for " + contextId);
		}
		return instance;
	}

	protected  T getOptional(FeignContext context, Class type) {
		return context.getInstance(contextId, type);
	}

	protected  T getInheritedAwareOptional(FeignContext context, Class type) {
		if (inheritParentContext) {
			return getOptional(context, type);
		}
		else {
			return context.getInstanceWithoutAncestors(contextId, type);
		}
	}

	protected  Map getInheritedAwareInstances(FeignContext context, Class type) {
		if (inheritParentContext) {
			return context.getInstances(contextId, type);
		}
		else {
			return context.getInstancesWithoutAncestors(contextId, type);
		}
	}

	protected  T loadBalance(Feign.Builder builder, FeignContext context, HardCodedTarget target) {
		Client client = getOptional(context, Client.class);
		if (client != null) {
			builder.client(client);
			applyBuildCustomizers(context, builder);
			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-loadbalancer?");
	}

	
	protected Request.Options getOptionsByName(FeignContext context, String contextId) {
		if (refreshableClient) {
			return context.getInstance(contextId, Request.Options.class.getCanonicalName() + "-" + contextId,
					Request.Options.class);
		}
		return null;
	}

	@Override
	public Object getObject() {
		return getTarget();
	}

	
	 T getTarget() {
		FeignContext context = beanFactory != null ? beanFactory.getBean(FeignContext.class)
				: applicationContext.getBean(FeignContext.class);
		//从Spring Context中获取到Feign的Builder
		Feign.Builder builder = feign(context);
		//如果@FeignClient注解没有配置URL属性
		if (!StringUtils.hasText(url)) {

			if (LOG.isInfoEnabled()) {
				LOG.info("For '" + name + "' URL not provided. Will try picking an instance via load-balancing.");
			}
			if (!name.startsWith("http")) {
				url = "http://" + name;
			}
			else {
				url = name;
			}
			url += cleanPath();
			return (T) loadBalance(builder, context, new HardCodedTarget<>(type, name, url));
		}
		//处理@FeignClient URL属性(主机名)存在的情况
		if (StringUtils.hasText(url) && !url.startsWith("http")) {
			url = "http://" + url;
		}
		String url = this.url + cleanPath();
		//获取到调用客户端：Spring封装了基于Ribbon的客户端（LoadBalancerFeignClient）
		//1、Feign自己封装的Request（基于java.net原生），2、OkHttpClient（新一代/HTTP2），3、ApacheHttpClient（常规）等
		Client client = getOptional(context, Client.class);
		if (client != null) {
		    // 判断client是否是负载均衡客户端，如果是，则走注册中心选取服务
			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();
			}
			if (client instanceof RetryableFeignBlockingLoadBalancerClient) {
				// not load balancing because we have a url,
				// but Spring Cloud LoadBalancer is on the classpath, so unwrap
				client = ((RetryableFeignBlockingLoadBalancerClient) client).getDelegate();
			}
			//设置调用客户端
			builder.client(client);
		}

		applyBuildCustomizers(context, builder);
		//DefaultTargeter或者FeignCircuitBreakerTargeter，其中FeignCircuitBreakerTargeter带熔断和降级功能
		//主要用户在Builder中配置调用失败回调方法
		Targeter targeter = get(context, Targeter.class);
		//Bean创建实际目标封装，最终生成InvocationHandler
		return (T) targeter.target(this, builder, context, new HardCodedTarget<>(type, name, url));
	}

	private String cleanPath() {
		if (path == null) {
			return "";
		}
		String path = this.path.trim();
		if (StringUtils.hasLength(path)) {
			if (!path.startsWith("/")) {
				path = "/" + path;
			}
			if (path.endsWith("/")) {
				path = path.substring(0, path.length() - 1);
			}
		}
		return path;
	}

	@Override
	public Class getObjectType() {
		return type;
	}

	@Override
	public boolean isSingleton() {
		return true;
	}

	public Class getType() {
		return type;
	}

	public void setType(Class type) {
		this.type = type;
	}

} 

在上述源码中，最核心的是 getObject 方法，方法中定义好了如何去初始化一个FeignClient组件，在代理Bean中织入了哪些方法，具体可以参见代码中文注释。 我们先暂时略过上述工厂Bean创建代理对象时，使用到Feign的其他组件，如：Encoder、Decoder、Contract等，后面再详细阐述。 当调用target方法时，会触发实际会触发FeignBuiler组件的newInstance源码如下：
 

class DefaultTargeter implements Targeter {

	@Override
	public  T target(FeignClientFactoryBean factory, Feign.Builder feign, FeignContext context,
			Target.HardCodedTarget target) {
		return feign.target(target);
	}

}
 

Feign.Builder.target 会触发 Feign.Builer 组件的 newInstance
 

 

Feign.Builer 组件的 newInstance 源码如下：
 

@Override
public  T newInstance(Target target) {
  	//核心方法，解析定义的@FeignClient组件中的方法和请求路径
    Map nameToHandler = targetToHandlersByName.apply(target);
    Map methodToHandler = new LinkedHashMap();
    List defaultMethodHandlers = new LinkedList();

    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)));
      }
    }
    //调用工厂Bean，创建执行Handler
    MethodHandler是feign的一个接口，这个接口的invoke方法，是动态代理调用者InvocationHandler的invoke()方法最终调用的方法。
    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;
  }

//请求方法和路径解析器
  static final class ParseHandlersByName {

    private final Contract contract;
    private final Options options;
    private final Encoder encoder;
    private final Decoder decoder;
    private final ErrorDecoder errorDecoder;
    private final QueryMapEncoder queryMapEncoder;
    private final SynchronousMethodHandler.Factory factory;

    ParseHandlersByName(
        Contract contract,
        Options options,
        Encoder encoder,
        Decoder decoder,
        QueryMapEncoder queryMapEncoder,
        ErrorDecoder errorDecoder,
        SynchronousMethodHandler.Factory factory) {
      this.contract = contract;
      this.options = options;
      this.factory = factory;
      this.errorDecoder = errorDecoder;
      this.queryMapEncoder = queryMapEncoder;
      this.encoder = checkNotNull(encoder, "encoder");
      this.decoder = checkNotNull(decoder, "decoder");
    }

    public Map apply(Target target) {
      //核心方法：解析@FeignClient组件，Feign自带的则解析自己的注解格式，Spring提供了解析MVC注解的SpringMvcContract
      List metadata = contract.parseAndValidateMetadata(target.type());
      Map result = new LinkedHashMap();
      for (MethodMetadata md : metadata) {
        BuildTemplateByResolvingArgs buildTemplate;
        if (!md.formParams().isEmpty() && md.template().bodyTemplate() == null) {
          buildTemplate =
              new BuildFormEncodedTemplateFromArgs(md, encoder, queryMapEncoder, target);
        } else if (md.bodyIndex() != null || md.alwaysEncodeBody()) {
          buildTemplate = new BuildEncodedTemplateFromArgs(md, encoder, queryMapEncoder, target);
        } else {
          buildTemplate = new BuildTemplateByResolvingArgs(md, queryMapEncoder, target);
        }
        if (md.isIgnored()) {
          result.put(md.configKey(), args -> {
            throw new IllegalStateException(md.configKey() + " is not a method handled by feign");
          });
        } else {
          result.put(md.configKey(),
              factory.create(target, md, buildTemplate, options, decoder, errorDecoder));
        }
      }
      return result;
    }
  }
 

解析@FeignClient注解，生成MethodHandler,具体的解析类是 ParseHandlerByName 。这个类是 ReflectiveFeign 的内部类。
 

ParseHandlerByName.apply 解析@FeignClient组件.
 

Feign自带的则解析自己的注解格式，Spring提供了解析MVC注解的SpringMvcContract
 

List metadata = contract.parseAndValidateMetadata(target.type());
 

newInstance 拿到注解元数据以后，循环处理注解元数据，创建每个方法对应的 MethodHandler ，这个 MethodHandler 最终会被代理对象调用。最终 MethodHandler 都会保存到下面这个集合中，然后返回。
 

MethodHandler 是feign的一个接口，这个接口的 invoke 方法，是动态代理调用者 InvocationHandler的invoke() 方法最终调用的方法。
 

Map nameToHandler = targetToHandlersByName.apply(target);
    Map methodToHandler = new LinkedHashMap();
    List defaultMethodHandlers = new LinkedList();

    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 的 invoke() 方法最终回调 MethodHandler 的 invoke() 来发送http请求。这就是Feign动态代理的具体实现。
 

// 创建动态代理调用者 
InvocationHandler handler = factory.create(target, methodToHandler); 
// 反射生成feign接口代理 
T proxy = (T) Proxy.newProxyInstance(target.type().getClassLoader(),
        new Class[] {target.type()}, handler);
 

InvocationHandler.invoke() 的具体实现在 FeignInvocationHandler.invoke() ， FeignInvocationHandler 也是 ReflectiveFeign 的一个内部类。里面有很多细节处理这里不再赘述，我们直接进入核心那一行代码，以免影响思路，我们是理Feign的实现原理的！不要在意这些细节！
 

// InvocationHandler 的 invoke() 方法最终回调 MethodHandler 的 invoke() 来发送http请求
 

ReflectiveFeign类的invoke()方法，第100行，代码的后半段，如下：
 

 

(MethodHandler)this.dispatch.get(method). invoke(args);
 

this.dispatch：这是一个map，就是保存所有的MethodHandler的集合。参考创建InvocationHandler的位置：ReflectiveFeign类的newInstance()方法的第64行。
 

this.dispatch.get(method)：这里的method就是我们开发者写的feign接口中定义的方法的方法名！这段代码的意思就是从MethodHandler集合中拿到我们需要调用的那个方法。
 

this.dispatch.get(method).invoke(args)：这里的invoke就是调用的MethodHandler.invoke()，动态代理回调代理类，就这样完成了，oh my god，多么伟大的创举！
 

MethodHandler.invoke() 的具体实现： SynchronousMethodHandler.invoke()
 

 

到了这里，就是发送请求的逻辑了。发送请求前，首先要创建请求模板，然后调用请求拦截器RequestInterceptor进行请求处理。
 

@Override
    public Object invoke(Object[] argv) throws Throwable {
        // 创建RequestTemplate
        RequestTemplate template = buildTemplateFromArgs.create(argv);
        Options options = findOptions(argv);
        // 创建feign重试器，进行失败重试
        Retryer retryer = this.retryer.clone();
        while (true) {
            try {
                // 发送请求
                return executeAndDecode(template, options);
            } 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;
            }
        }
    }
 

RequestTemplate模板需要经过一系列拦截器的处理。我们可以自定义请求拦截器，我们自定义的拦截器，也会在此时进行调用，所有实现了RequestTemplate接口的类，都会在这里被调用。比如我们可以自定义拦截器把全局事务id放在请求头里。
 

到此源码解析完毕
 
3.2 配置与优化 

  1.  
    超时时间配置
     
    在自动装配属性 FeignClientProperties.FeignClientConfiguration 类中
     
    使用yaml
     


feign: 
  client:
    config:
      default:
        connectTimeout: 500
        readTimeout: 15000
 

  1. 请求重试


Feign的重试是通过配置Retryer来实现，在 FeignClientsConfiguration 自动配置类中，配置了一个默认的 Retryer.NEVER_RETRY ，表示用不重试。不重试和重试超过限制次数都是抛出异常来停止重试。可以通过自定义 Retryer 来覆盖默认的配置
 

  1. 编码/消息头处理


对具体调用请求可以通过3种方式来进行编解码处理：
 

  • 定义 RequestInterceptor ，在请求前处理编码与附加消息头;
  • 自定义 Encoder ，在编码阶段处理请求头;
  • 在 @FeignClient 组件接口 @RequestMapping 的 headers 属性中附带消息头信息；


  1. 其他事项


  • 在定义Feign组件时， @RequestMapping 注解只加在方法上，不要放在类上，Spring MVC自带的Dispacher请求映射会扫描所有带 @RequestMapping 类，容易导致一些不必要的问题；

4 Feign 总结 

Feign架构图
 

 

  • 基于JDK动态代理生成代理类。
  • 根据接口类的注解声明规则，解析出底层MethodHandler
  • 基于RequestBean动态生成request。
  • Encoder将bean包装成请求。
  • 拦截器负责对请求和返回进行装饰处理。
  • 日志记录。
  • 基于重试器发送http请求，支持不同的http框架，默认使用的是HttpUrlConnection。







转载请注明：文章转载自 www.mshxw.com















Java相关栏目本月热门文章












热门相关搜索






路由器设置
木托盘
宝塔面板
儿童python教程
心情低落
朋友圈
vim
双一流学科
专升本
我的学校
日记学校
西点培训学校
汽修学校
情书
化妆学校
塔沟武校
异形模板
西南大学排名
最精辟人生短句
6步教你追回被骗的钱
南昌大学排名
清朝十二帝
北京印刷学院排名
北方工业大学排名
北京航空航天大学排名
首都经济贸易大学排名
中国传媒大学排名
首都师范大学排名
中国地质大学(北京)排名
北京信息科技大学排名
中央民族大学排名
北京舞蹈学院排名
北京电影学院排名
中国戏曲学院排名
河北政法职业学院排名
河北经贸大学排名
天津中德应用技术大学排名
天津医学高等专科学校排名
天津美术学院排名
天津音乐学院排名
天津工业大学排名
北京工业大学耿丹学院排名
北京警察学院排名
天津科技大学排名
北京邮电大学(宏福校区)排名
北京网络职业学院排名
北京大学医学部排名
河北科技大学排名
河北地质大学排名
河北体育学院排名















学习工具


代数计算器


三角函数


解析几何


立体几何






知识解答


教育知识


百科知识


生活知识


常识知识






写作必备


作文大全


作文素材


句子大全



实用范文






关于我们


关于我们


联系我们


网站地图






 交流群

名师互学网交流群




名师互学网客服

名师互学网客服












名师互学网 版权所有 (c)2021-2022      ICP备案号：晋ICP备2021003244-6号
 








我们一直用心在做

关于我们
文章归档
网站地图
联系我们

版权所有 (c)2021-2022 MSHXW.COM


ICP备案号：晋ICP备2021003244-6号