SpringCloud-OpenFeign学习-1

最新推荐文章于 2023-05-14 21:13:05 发布
最新推荐文章于 2023-05-14 21:13:05 发布
阅读量293 收藏 1
点赞数
分类专栏： 框架整理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40356878/article/details/117416274
版权

Feign接口注入容器时机

一、Springcloud-openfeign使用

示例：整合springboot项目的使用：版本对应关系

  1. 阿里官方对应版本：SpringBoot-SpringCloud-SpringCloudAlibaba各版本对应关系
  2. Spring官方：SpringBoot-SpringCloud版本对应关系，需格式化json串
  3. SpringCloud官方：点击对应的Reference文档，文档内有版本描述
  4. 版本对应不上，可能会出现兼容性问题，建议版本保持对应。
  1. 引入依赖
        <spring.boot.version>2.4.5</spring.boot.version>
        <spring.cloud.version>2020.0.2</spring.cloud.version>

		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-openfeign</artifactId>
		</dependency>
  1. 开启feign客户端注解
    项目代码结构
/**
 * 服务提供方启动类
 */
@EnableFeignClients
@SpringBootApplication
public class OauthServerApplication {

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

}

/**
 * feign客户端，能力提供者
 */
@RestController
@RequestMapping("/test")
public class TestFeignController {

    @GetMapping("/get")
    public String getTest(){
        return "ok";
    }
}

# 服务提供者应用配置
server:
  port: 8082
spring:
  application:
    name: test-application

/**
 * @Description：消费端启动类
 * @ClassName：ResourceApplication
 */
@EnableFeignClients
@SpringBootApplication
public class ResourceApplication {
    public static void main(String[] args) {
        SpringApplication.run(ResourceApplication.class,args);
    }
}

@FeignClient(name = "oauthServiceFeign", path = "/test", url = "http://localhost:8082")
public interface OauthServiceFeign {

    @GetMapping("/get")
    String getTest();
}

# 服务消费端应用配置
server:
  port: 8081
spring:
  application:
    name: resource-application
  1. 测试用例
/**
 * 消费端测试类，调用服务端远程服务
 */
@SpringBootTest
@RunWith(SpringRunner.class)
class OauthServiceFeignTest {

    @Autowired
    OauthServiceFeign oauthServiceFeign;

    @Test
    void getTest() {
        String test = oauthServiceFeign.getTest();
        System.out.println("调用远程feign接口，返回结果: " + test);
    }
}
  1. 返回结果
2021-05-31 17:25:23.877  INFO 9252 --- [           main] c.t.r.feign.OauthServiceFeignTest        : Started OauthServiceFeignTest in 2.016 seconds (JVM running for 3.004)
调用远程feign接口，返回结果: ok
2021-05-31 17:25:24.274  INFO 9252 --- [extShutdownHook] o.s.s.concurrent.ThreadPoolTaskExecutor  : Shutting down ExecutorService 'applicationTaskExecutor'
Disconnected from the target VM, address: '127.0.0.1:63339', transport: 'socket'

Process finished with exit code 0

二、Open-Feign使用步骤解析

1. 引入spring-cloud-starter-openfeign

该pom引入：spring-cloud-openfeign-core，springboot启动过程中会加载spring.factories文件，并初始化该配置文件的配置类，从而达到自动装配。
springboot自动装配

# spring.factories 内容
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.cloud.openfeign.ribbon.FeignRibbonClientAutoConfiguration,\
org.springframework.cloud.openfeign.hateoas.FeignHalAutoConfiguration,\
org.springframework.cloud.openfeign.FeignAutoConfiguration,\
org.springframework.cloud.openfeign.encoding.FeignAcceptGzipEncodingAutoConfiguration,\
org.springframework.cloud.openfeign.encoding.FeignContentGzipEncodingAutoConfiguration,\
org.springframework.cloud.openfeign.loadbalancer.FeignLoadBalancerAutoConfiguration

1.简单分析spring.factories做了哪些事情

  • FeignHalAutoConfiguration

@Configuration(proxyBeanMethods = false)
@ConditionalOnWebApplication
@ConditionalOnClass(RepresentationModel.class) // 指定RepresentationModel类存在类路径时，初始化该配置类   （该示例不存在该类，故该配置类在启动时未初始化） 
@AutoConfigureAfter({ JacksonAutoConfiguration.class, HttpMessageConvertersAutoConfiguration.class,
		RepositoryRestMvcAutoConfiguration.class })
@AutoConfigureBefore(HypermediaAutoConfiguration.class)
public class FeignHalAutoConfiguration {

	@Bean
	@ConditionalOnMissingBean
	public TypeConstrainedMappingJackson2HttpMessageConverter halJacksonHttpMessageConverter(
			ObjectProvider<ObjectMapper> objectMapper, ObjectProvider<HalConfiguration> halConfiguration,
			ObjectProvider<MessageResolver> messageResolver, ObjectProvider<CurieProvider> curieProvider,
			ObjectProvider<LinkRelationProvider> linkRelationProvider) {

		ObjectMapper mapper = objectMapper.getIfAvailable(ObjectMapper::new).copy();
		mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);

		HalConfiguration configuration = halConfiguration.getIfAvailable(HalConfiguration::new);

		CurieProvider curieProviderInstance = curieProvider
				.getIfAvailable(() -> new DefaultCurieProvider(Collections.emptyMap()));

		Jackson2HalModule.HalHandlerInstantiator halHandlerInstantiator = new Jackson2HalModule.HalHandlerInstantiator(
				linkRelationProvider.getIfAvailable(), curieProviderInstance, messageResolver.getIfAvailable(),
				configuration);

		mapper.setHandlerInstantiator(halHandlerInstantiator);

		if (!Jackson2HalModule.isAlreadyRegisteredIn(mapper)) {
			Jackson2HalModule halModule = new Jackson2HalModule();
			mapper.registerModule(halModule);
		}

		TypeConstrainedMappingJackson2HttpMessageConverter converter = new TypeConstrainedMappingJackson2HttpMessageConverter(
				RepresentationModel.class);
		converter.setSupportedMediaTypes(Arrays.asList(HAL_JSON));
		converter.setObjectMapper(mapper);
		return converter;
	}

}
  • FeignAutoConfiguration
@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(Feign.class)
@EnableConfigurationProperties({ FeignClientProperties.class, FeignHttpClientProperties.class,
		FeignEncoderProperties.class })
@Import(DefaultGzipDecoderConfiguration.class) // 引入了该配置类，并初始化该配置类：主要配置默认 Gzip 解码器，具体作用这里不做说明
public class FeignAutoConfiguration {

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

	@Autowired(required = false) // 从容器中注入FeignClientSpecification实例 创建时机下面说明
	private List<FeignClientSpecification> configurations = new ArrayList<>();

	@Bean	// 作用不做说明
	public HasFeatures feignFeature() {
		return HasFeatures.namedFeature("Feign", Feign.class);
	}

	@Bean	// 初始化feign上下文
	public FeignContext feignContext() {
		FeignContext context = new FeignContext();
		// 
		context.setConfigurations(this.configurations);
		return context;
	}

	@Configuration(proxyBeanMethods = false)
	@ConditionalOnClass({ Module.class, Page.class, Sort.class }) // 该示例不存在该类，故该配置类在启动时未初始化
	@ConditionalOnProperty(value = "feign.autoconfiguration.jackson.enabled", havingValue = "true")
	protected static class FeignJacksonConfiguration {

		@Bean
		@ConditionalOnMissingBean(PageJacksonModule.class)
		public PageJacksonModule pageJacksonModule() {
			return new PageJacksonModule();
		}

		@Bean
		@ConditionalOnMissingBean(SortJacksonModule.class)
		public SortJacksonModule sortModule() {
			return new SortJacksonModule();
		}

	}

	@Configuration(proxyBeanMethods = false)
	@Conditional(FeignCircuitBreakerDisabledConditions.class)
	protected static class DefaultFeignTargeterConfiguration {

		@Bean
		@ConditionalOnMissingBean // feign代理类
		public Targeter feignTargeter() {
			return new DefaultTargeter();
		}

	}

	@Configuration(proxyBeanMethods = false)
	@ConditionalOnClass(CircuitBreaker.class)
	@ConditionalOnProperty(value = "feign.circuitbreaker.enabled", havingValue = "true")
	protected static class CircuitBreakerPresentFeignTargeterConfiguration {

		@Bean
		@ConditionalOnMissingBean(CircuitBreakerFactory.class)
		public Targeter defaultFeignTargeter() {
			return new DefaultTargeter();
		}

		@Bean
		@ConditionalOnMissingBean
		@ConditionalOnBean(CircuitBreakerFactory.class)
		public Targeter circuitBreakerFeignTargeter(CircuitBreakerFactory circuitBreakerFactory) {
			return new FeignCircuitBreakerTargeter(circuitBreakerFactory);
		}

	}

	// the following configuration is for alternate feign clients if
	// SC loadbalancer is not on the class path.
	// see corresponding configurations in FeignLoadBalancerAutoConfiguration
	// for load-balanced clients.
	@Configuration(proxyBeanMethods = false)
	@ConditionalOnClass(ApacheHttpClient.class) // 该示例不存在该类，故该配置类在启动时未初始化
	@ConditionalOnMissingBean(CloseableHttpClient.class)
	@ConditionalOnProperty(value = "feign.httpclient.enabled", matchIfMissing = true)
	@Conditional(HttpClient5DisabledConditions.class)
	protected static class HttpClientFeignConfiguration {

		private final Timer connectionManagerTimer = new Timer(
				"FeignApacheHttpClientConfiguration.connectionManagerTimer", true);

		@Autowired(required = false)
		private RegistryBuilder registryBuilder;

		private CloseableHttpClient httpClient;

		@Bean
		@ConditionalOnMissingBean(HttpClientConnectionManager.class)
		public HttpClientConnectionManager connectionManager(
				ApacheHttpClientConnectionManagerFactory connectionManagerFactory,
				FeignHttpClientProperties httpClientProperties) {
			final HttpClientConnectionManager connectionManager = connectionManagerFactory.newConnectionManager(
					httpClientProperties.isDisableSslValidation(), httpClientProperties.getMaxConnections(),
					httpClientProperties.getMaxConnectionsPerRoute(), httpClientProperties.getTimeToLive(),
					httpClientProperties.getTimeToLiveUnit(), this.registryBuilder);
			this.connectionManagerTimer.schedule(new TimerTask() {
				@Override
				public void run() {
					connectionManager.closeExpiredConnections();
				}
			}, 30000, httpClientProperties.getConnectionTimerRepeat());
			return connectionManager;
		}

		@Bean
		public CloseableHttpClient httpClient(ApacheHttpClientFactory httpClientFactory,
				HttpClientConnectionManager httpClientConnectionManager,
				FeignHttpClientProperties httpClientProperties) {
			RequestConfig defaultRequestConfig = RequestConfig.custom()
					.setConnectTimeout(httpClientProperties.getConnectionTimeout())
					.setRedirectsEnabled(httpClientProperties.isFollowRedirects()).build();
			this.httpClient = httpClientFactory.createBuilder().setConnectionManager(httpClientConnectionManager)
					.setDefaultRequestConfig(defaultRequestConfig).build();
			return this.httpClient;
		}

		@Bean
		@ConditionalOnMissingBean(Client.class)
		public Client feignClient(HttpClient httpClient) {
			return new ApacheHttpClient(httpClient);
		}

		@PreDestroy
		public void destroy() {
			this.connectionManagerTimer.cancel();
			if (this.httpClient != null) {
				try {
					this.httpClient.close();
				}
				catch (IOException e) {
					if (LOG.isErrorEnabled()) {
						LOG.error("Could not correctly close httpClient.");
					}
				}
			}
		}

	}

	@Configuration(proxyBeanMethods = false)
	@ConditionalOnClass(OkHttpClient.class) // 该示例不存在该类，故该配置类在启动时未初始化
	@ConditionalOnMissingBean(okhttp3.OkHttpClient.class)
	@ConditionalOnProperty("feign.okhttp.enabled")
	protected static class OkHttpFeignConfiguration {

		private okhttp3.OkHttpClient okHttpClient;

		@Bean
		@ConditionalOnMissingBean(ConnectionPool.class)
		public ConnectionPool httpClientConnectionPool(FeignHttpClientProperties httpClientProperties,
				OkHttpClientConnectionPoolFactory connectionPoolFactory) {
			Integer maxTotalConnections = httpClientProperties.getMaxConnections();
			Long timeToLive = httpClientProperties.getTimeToLive();
			TimeUnit ttlUnit = httpClientProperties.getTimeToLiveUnit();
			return connectionPoolFactory.create(maxTotalConnections, timeToLive, ttlUnit);
		}

		@Bean
		public okhttp3.OkHttpClient client(OkHttpClientFactory httpClientFactory, ConnectionPool connectionPool,
				FeignHttpClientProperties httpClientProperties) {
			Boolean followRedirects = httpClientProperties.isFollowRedirects();
			Integer connectTimeout = httpClientProperties.getConnectionTimeout();
			Boolean disableSslValidation = httpClientProperties.isDisableSslValidation();
			this.okHttpClient = httpClientFactory.createBuilder(disableSslValidation)
					.connectTimeout(connectTimeout, TimeUnit.MILLISECONDS).followRedirects(followRedirects)
					.connectionPool(connectionPool).build();
			return this.okHttpClient;
		}

		@PreDestroy
		public void destroy() {
			if (this.okHttpClient != null) {
				this.okHttpClient.dispatcher().executorService().shutdown();
				this.okHttpClient.connectionPool().evictAll();
			}
		}

		@Bean
		@ConditionalOnMissingBean(Client.class)
		public Client feignClient(okhttp3.OkHttpClient client) {
			return new OkHttpClient(client);
		}

	}

	@Configuration(proxyBeanMethods = false)
	@ConditionalOnClass(ApacheHttp5Client.class) // 该示例不存在该类，故该配置类在启动时未初始化
	@ConditionalOnMissingBean(org.apache.hc.client5.http.impl.classic.CloseableHttpClient.class)
	@ConditionalOnProperty(value = "feign.httpclient.hc5.enabled", havingValue = "true")
	@Import(org.springframework.cloud.openfeign.clientconfig.HttpClient5FeignConfiguration.class)
	protected static class HttpClient5FeignConfiguration {

		@Bean
		@ConditionalOnMissingBean(Client.class)
		public Client feignClient(org.apache.hc.client5.http.impl.classic.CloseableHttpClient httpClient5) {
			return new ApacheHttp5Client(httpClient5);
		}

	}

	@Configuration(proxyBeanMethods = false)
	@ConditionalOnClass(OAuth2ClientContext.class) // 该示例不存在该类，故该配置类在启动时未初始化
	@ConditionalOnProperty("feign.oauth2.enabled")
	protected static class Oauth2FeignConfiguration {

		@Bean
		@ConditionalOnMissingBean(OAuth2FeignRequestInterceptor.class)
		@ConditionalOnBean({ OAuth2ClientContext.class, OAuth2ProtectedResourceDetails.class })
		public RequestInterceptor oauth2FeignRequestInterceptor(OAuth2ClientContext oAuth2ClientContext,
				OAuth2ProtectedResourceDetails resource) {
			return new OAuth2FeignRequestInterceptor(oAuth2ClientContext, resource);
		}

	}

}
  • FeignAcceptGzipEncodingAutoConfiguration
@Configuration(proxyBeanMethods = false)
@EnableConfigurationProperties(FeignClientEncodingProperties.class)
@ConditionalOnClass(Feign.class)
@ConditionalOnBean(Client.class)
@ConditionalOnProperty(value = "feign.compression.response.enabled", matchIfMissing = false) // 该示例不存在该配置项，故该配置类在启动时未初始化
// The OK HTTP client uses "transparent" compression.
// If the accept-encoding header is present it disable transparent compression
@ConditionalOnMissingBean(type = "okhttp3.OkHttpClient")
@AutoConfigureAfter(FeignAutoConfiguration.class)
public class FeignAcceptGzipEncodingAutoConfiguration {

	@Bean
	public FeignAcceptGzipEncodingInterceptor feignAcceptGzipEncodingInterceptor(
			FeignClientEncodingProperties properties) {
		return new FeignAcceptGzipEncodingInterceptor(properties);
	}

}
  • FeignContentGzipEncodingAutoConfiguration
@Configuration(proxyBeanMethods = false)
@EnableConfigurationProperties(FeignClientEncodingProperties.class)
@ConditionalOnClass(Feign.class)
// The OK HTTP client uses "transparent" compression.
// If the content-encoding header is present it disable transparent compression
@ConditionalOnMissingBean(type = "okhttp3.OkHttpClient")
@ConditionalOnProperty("feign.compression.request.enabled") // 该示例不存在该配置项，故该配置类在启动时未初始化
@AutoConfigureAfter(FeignAutoConfiguration.class)
public class FeignContentGzipEncodingAutoConfiguration {

	@Bean
	public FeignContentGzipEncodingInterceptor feignContentGzipEncodingInterceptor(
			FeignClientEncodingProperties properties) {
		return new FeignContentGzipEncodingInterceptor(properties);
	}

}
  • FeignLoadBalancerAutoConfiguration
@ConditionalOnClass(Feign.class)
@ConditionalOnBean({ LoadBalancerClient.class, LoadBalancerClientFactory.class })// 该示例不存在该Bean，故该配置类在启动时未初始化
@AutoConfigureBefore(FeignAutoConfiguration.class)
@AutoConfigureAfter({ BlockingLoadBalancerClientAutoConfiguration.class, LoadBalancerAutoConfiguration.class })
@EnableConfigurationProperties(FeignHttpClientProperties.class)
@Configuration(proxyBeanMethods = false)
// Order is important here, last should be the default, first should be optional
// see
// https://github.com/spring-cloud/spring-cloud-netflix/issues/2086#issuecomment-316281653
@Import({ HttpClientFeignLoadBalancerConfiguration.class, OkHttpFeignLoadBalancerConfiguration.class,
		HttpClient5FeignLoadBalancerConfiguration.class, DefaultFeignLoadBalancerConfiguration.class })
public class FeignLoadBalancerAutoConfiguration {

}

2. 开启Feign注解：@EnableFeignClients

1. @EnableFeignClients 作用

1. @EnableFeignClients 参数
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(FeignClientsRegistrar.class) // 重要：初始化FeignClientsRegistrar实例
public @interface EnableFeignClients {

	// basePackages()属性的别名。 允许更简洁的注释声明
	String[] value() default {};
	
	// 用于扫描带注释组件的基本包
	String[] basePackages() default {};

	// 用于指定要扫描带注释组件的包。 将扫描指定的每个类的包
	Class<?>[] basePackageClasses() default {};

	// 客户端默认配置
	Class<?>[] defaultConfiguration() default {};

	// 用@FeignClient 注释的类列表。 如果不为空，则禁用类路径扫描
	Class<?>[] clients() default {};

}
2. FeignClientsRegistrar作用
class FeignClientsRegistrar implements 
ImportBeanDefinitionRegistrar,  // 动态创建自定义Bean到Spring中: 即 @FeignClient 注解的bean的解析
ResourceLoaderAware, 
EnvironmentAware {
......

	// 解析入口， 即FeignClient Bean 注入容器时机
	@Override
	public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
		// 解析 @EnableFeignClients 注解
		registerDefaultConfiguration(metadata, registry);
		// 解析@FeignClient注解（重点）
		registerFeignClients(metadata, registry);
	}

	public void registerFeignClients(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {

		LinkedHashSet<BeanDefinition> candidateComponents = new LinkedHashSet<>();
		Map<String, Object> attrs = metadata.getAnnotationAttributes(EnableFeignClients.class.getName());
		final Class<?>[] clients = attrs == null ? null : (Class<?>[]) attrs.get("clients");

		// @EnableFeignClients没有指定clients 时，会通过扫描class创建feignclient bean
		if (clients == null || clients.length == 0) {
			// 扫描器
			ClassPathScanningCandidateComponentProvider scanner = getScanner();
			// 类加载器
			scanner.setResourceLoader(this.resourceLoader);
			// 过滤类型：指定过滤出注解类型为FeignClient的 bean 的定义
			scanner.addIncludeFilter(new AnnotationTypeFilter(FeignClient.class));
			// 拿到解析包路径：默认是@EnableFeignClients 注解所在类下的包
			Set<String> basePackages = getBasePackages(metadata);
			for (String basePackage : basePackages) {
				candidateComponents.addAll(scanner.findCandidateComponents(basePackage));
			}
		}
		else {
			for (Class<?> clazz : clients) {
				candidateComponents.add(new AnnotatedGenericBeanDefinition(clazz));
			}
		}
		
		// 拿到所有FeignClient注解的bean的定义，进行进一步处理
		for (BeanDefinition candidateComponent : candidateComponents) {
		
			if (candidateComponent instanceof AnnotatedBeanDefinition) {
				// 校验@FeignClient只能注解在接口上
				AnnotatedBeanDefinition beanDefinition = (AnnotatedBeanDefinition) candidateComponent;
				AnnotationMetadata annotationMetadata = beanDefinition.getMetadata();
				Assert.isTrue(annotationMetadata.isInterface(), "@FeignClient can only be specified on an interface");

				// 拿到 @FeignClient注解的所有属性值
				Map<String, Object> attributes = annotationMetadata
						.getAnnotationAttributes(FeignClient.class.getCanonicalName());

				String name = getClientName(attributes);
				// 注入@FeignClient 中指定的 configuration，注入的beanname 为 name + FeignClientSpecification
				registerClientConfiguration(registry, name, attributes.get("configuration"));
				
				// 注入 @FeignClient bean定义（重点）
				registerFeignClient(registry, annotationMetadata, attributes);
			}
		}
	}

	private void registerFeignClient(BeanDefinitionRegistry registry, AnnotationMetadata annotationMetadata,
			Map<String, Object> 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);
		
		// 构造FeignClient bean工厂，所有的FeignClient bean在这里生成
		FeignClientFactoryBean factoryBean = new FeignClientFactoryBean();
		factoryBean.setBeanFactory(beanFactory);
		factoryBean.setName(name);
		factoryBean.setContextId(contextId);
		factoryBean.setType(clazz);

		// 指定FeignClient 生成的步骤，即feign接口对象初始化到容器的定义，指定了FactoryBean，在自动注入时genericBeanDefinition()方法传入的方法，进而调用FactoryBean中的getObject方法，获取代理对象注入到容器中（简单看一下这个方法）
		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);
		// 这里是容器初始化时，feign接口具体添加到容器的内容
		BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
	}

}

	// 指定FeignClient 生成的步骤
	public static <T> BeanDefinitionBuilder genericBeanDefinition(Class<T> beanClass, Supplier<T> instanceSupplier) {
		BeanDefinitionBuilder builder = new BeanDefinitionBuilder(new GenericBeanDefinition());
		builder.beanDefinition.setBeanClass(beanClass);
		// 注意这里指定生成bean的方式，在获取时通过该方法拿到代理对象
		builder.beanDefinition.setInstanceSupplier(instanceSupplier);
		return builder;
	}

总结

本篇仅大致描述feign作用及注入流程，后续学习代理对象生成及feign方法的调用原理。
TaoTaoNing
关注
专栏目录
java.lang.ClassNotFoundException: org.springframework.hateoas.mvc.TypeConstrainedMappingJackson2Http
程序哥聊面试
07-22 56
先记录下来，等找到原因了在更新。
Spring Cloud与微服务学习总结（11）——spring cloud-openFeign 声明式远程调用总结
科技D人生
10-13 415
一、概述 1.1、是什么 Feign是一个声明式的Web服务客户端，让编写Web服务客户端变得非常容易，只需创建一个接口并在接口上申明注解 Github:https://github.com/spring-cloud/spring-cloud-openfeign 1.2、作用 Feign旨在使编写Java Http客户端变的更容易；Feign集成了Ribbon，利用Ribbon维护了Payment的服务列表，并且通过轮询实现了客户端的负载均衡。而与Ribbon不同的是，通过Feign只需要定义服务绑
最适合新手入门的SpringCloud教程 7—OpenFeign「F版本」
Java杂记
04-05 1375
SpringCloud版本：Finchley.SR2 SpringBoot版本：2.0.3.RELEASE 源码地址：https://gitee.com/bingqilinpeishenme/Java-Tutorials 前言 Tips：OpenFeign的使用类似于Dao接口的开发 上一篇使用了RestTemplate的服务调用，但是有一些问题：通过RestTemplate发送请求时候...
Spring Cloud入门-OpenFeign服务消费者(Hoxton版本)
m0_66640396的博客
04-25 1067
[](()在启动类上添加@EnableFeignClients注解来启用Feign的客户端功能 @EnableFeignClients @EnableDiscoveryClient @SpringBootApplication public class FeignServiceApplication { public static void main(String[] args) { SpringApplication.run(FeignServiceApplication.class, args); }
SpringCloud之OpenFeign组件
qq_42682745的博客
06-13 250
SpringCloud之OpenFeign组件(要先做服务注册哦) 1. OpenFeign简介 OpenFeign是一个声明式的伪http客户端，他集成了ribbon组件能够实现负载均衡，并且支持spring mvc注解。 2. 如何使用它？ 使用它是通过接口的方式，一个服务调用关系就要写一个接口，接口中定义要调用的方法。 a.引入OpenFeign依赖 <dependency> <groupId>org.springframework.cloud&l
[SpringCloud踩坑笔记]-关于EnableFeignClients的basePackages
embbls的博客
07-05 2万+
如果使用了springcloud的openFeign,在application上需要添加@EnableFeignClients注解.却没有明确指明basePackages的路劲. 则spring ioc不会自动为外部引入的其他服务jar包里, 标注了@FeignClient注解的interface自动生成bean对象. 正确的做法应该是明确指定basePackages的值,比如像这样: ...
深入浅出Spring Cloud整合OpenFeign
CERTAINTY的博客
12-28 1463
深入浅出Spring Cloud整合OpenFeign
Spring Cloud OpenFeign示例代码
10-28
Spring Cloud OpenFeign是Spring Cloud生态中的一个组件，主要用于简化微服务之间的调用，它提供了声明式的Web服务客户端实现。OpenFeign使得开发者能够通过简单的注解定义接口，即可实现远程服务的调用，如同调用...
GuLi商城-SpringCloud-OpenFeign-日志、超时配置参考
兴趣是最好的老师
03-17 570
GuLi商城-SpringCloud-OpenFeign-日志、超时配置参考
【springcloud 微服务】springcloud openfeign使用详解
congge_study的博客
05-14 6659
springcloud openfeign使用详解
spring-cloud-starter-openfeign里面自带负载均衡
最新发布
07-28
- *1* *2* *3* [SpringCloud学习——服务调用与负载均衡（Ribbon、OpenFeign）](https://blog.csdn.net/KIMTOU/article/details/125358337)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra...
SpringCloud中集成OpenFeign实现服务调用
BADAO_LIUMANG_QIZHI的博客
05-17 1228
场景 SpringCloud中集成Eureka实现服务注册(单机Eureka构建)： SpringCloud中集成Eureka实现服务注册(单机Eureka构建)_霸道流氓气质的博客-CSDN博客 SpringCloud中集成Eureka实现集群部署服务注册与服务提供者： SpringCloud中集成Eureka实现集群部署服务注册与服务提供者_霸道流氓气质的博客-CSDN博客 SpringCloud中集成Eureka时通过Discovery实现服务发现： SpringCloud中集成Eurek
Feign源码之@EnableFeignClients
Ethan_199402的博客
12-27 2079
注解属性 先看一下@EnableFeignClients有5个属性 @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE) @Documented @Import(FeignClientsRegistrar.class) public @interface EnableFeignClients { /** * Alias for the {@link #basePackages()} attribute. Allows for mo
OpenFeign介绍和使用注意
魂-淡
03-28 6655
FeignClient注解的使用介绍 value，name value 和 name 的作用一样，如果没有配置url那么配置的值将作为服务名称，用于服务发现。反之只是一个名称。 serviceId serviceId已经废弃了，直接使用name即可。 contextId 比如我们有个user服务，但user服务中有很多个接口，我们不想将所有的调用接口都定义在一个类中，比如： Client 1 @FeignClient(name = "optimization-user") public interface
SpringCloud:EnableFeignClients注解用法
进击的小白
11-08 3627
了解Feign客户端使用@EnableFeignClients加载各种微服务接口的方式，解决无法启动加载微服务FeignClient接口的问题。
【springcloud系列】springcloud整合openfeign
Think_and_work的博客
10-18 830
集成openfeign 1、引入依赖，记得版本一致【可以优先引入dependencyManagement】，然后引入openfeign和loadbalancer <dependencyManagement> <dependencies> <dependency> <groupId>org.springframework.cloud</groupId>
SpringBoot2.1.7引入spring-cloud-starter-openfeign依赖问题
Kevin_Gu6的博客
08-14 2万+
最近在学习SpringCloud，需要用到Feign，在引入Feign依赖的时候遇到的问题： 网上很多人说SpringBoot2.X版本后，引入Feign依赖是： <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-...
Spring Cloud OpenFeign教程,一个注解搞定,最详细使用教程
weixin_44839328的博客
12-28 1404
以Spring Cloud微服务项目为例，两个子项目：gulimall_coupon、gulimall_product 1、引入open-feign <-使用spring阿里巴巴版本控制,所以没写版本号-> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-c.
Spring Cloud OpenFeign详解
热门推荐
成长的足迹
08-02 11万+
作为Spring Cloud的子项目之一，Spring Cloud OpenFeign以将OpenFeign集成到Spring Boot应用中的方式，为微服务架构下服务之间的调用提供了解决方案。首先，利用了OpenFeign的声明式方式定义Web服务客户端；其次还更进一步，通过集成Ribbon或Eureka实现负载均衡的HTTP客户端。 Spring Cloud OpenFeign的最新版本是2...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值