Spring Cloud OpenFeign底层实现原理

已于 2024-04-17 11:26:40 修改
阅读量911 收藏 29
点赞数 16
分类专栏： SpringCloud OpenFeign 文章标签： spring cloud
于 2024-04-16 22:31:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/y_eatmeat/article/details/137843287
版权

Spring Cloud OpenFeign底层实现原理

先说一下写这篇文章的一个原因，就是我被面试官吊打了，我只知道OpenFeign底层采用了RestTemplate进行调用，采用了动态代理，但是具体怎么实现的我就母鸡了。为了防止同样的地方摔倒，我决定我现在这里爬起来。

一 、简介

OpenFeign是Spring Cloud 在Feign的基础上支持了Spring MVC的注解，如@RequesMapping等等。
OpenFeign的@FeignClient可以解析SpringMVC的@RequestMapping注解下的接口，并通过动态代理的方式产生实现类，实现类中做负载均衡并调用其他服务。

二、OpenFeign的使用

1. 引入依赖

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
  <groupId>com.alibaba.cloud</groupId>
  <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

2. 启动类添加@EnableFeignClients注解

@EnableDiscoveryClient
@SpringBootApplication
@EnableFeignClients(basePackages = {"xx.xx"})
@ComponentScan(basePackages = {"xx.xx"})
public class TagApplication {
    public static void main(String[] args) {
        SpringApplication application = new SpringApplication(TagApplication.class);
    }
}

3. 编写业务类

@FeignClient(name = "user-service")
public interface BaseFeignApi {
    @GetMapping("/list")
    List<User> getList();
}

三、OpenFeign实现原理

1.@EnableFeignClients(basePackages = {"xx.xx"})注解

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(FeignClientsRegistrar.class)
public @interface EnableFeignClients {

	String[] value() default {};

	String[] basePackages() default {};

	Class<?>[] basePackageClasses() default {};

	Class<?>[] defaultConfiguration() default {};

	Class<?>[] clients() default {};
}

2.FeignClientsRegistrar类

2.1 FeignClientsRegistrar类
class FeignClientsRegistrar
		implements ImportBeanDefinitionRegistrar, ResourceLoaderAware, EnvironmentAware {
    ....
}
2.2ImportBeanDefinitionRegistrar()函数
public interface ImportBeanDefinitionRegistrar {
    default void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry, BeanNameGenerator importBeanNameGenerator) {
        this.registerBeanDefinitions(importingClassMetadata, registry);
    }

    default void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
    }
}

FeignClientsRegistrar本质是一个ImportBeanDefinitionRegistrar,并且持有环境变量和资源加载器的能力,FeignClientsRegistrar重写了registerBeanDefinitions方法,该方法在容器上下文刷新(启动时调用refresh)时被调用,调用时机此处不展开分析,我们看一下.

2.3FeignClientsRegistrar#registerBeanDefinitions()函数
@Override
public void registerBeanDefinitions(AnnotationMetadata metadata,
        BeanDefinitionRegistry registry) {
    // 处理@EnableFeignClients注解上的属性配置，将配置注册到容器仲
    registerDefaultConfiguration(metadata, registry);
    // 核心方法：注册@FeignClient对应的接口，奖@FeignClient注册到容器中
    registerFeignClients(metadata, registry);
}
2.4FeignClientsRegistrar#registerFeignClients()函数
	public void registerFeignClients(AnnotationMetadata metadata,
			BeanDefinitionRegistry registry) {

        // 创建Spring内置的扫描器
		ClassPathScanningCandidateComponentProvider scanner = getScanner();
		scanner.setResourceLoader(this.resourceLoader);

		Set<String> basePackages;

		Map<String, Object> attrs = metadata
				.getAnnotationAttributes(EnableFeignClients.class.getName());
		AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(
				FeignClient.class);
        // 获取 EnableFeignClients 注解中的 clients 属性值
		final Class<?>[] clients = attrs == null ? null
				: (Class<?>[]) attrs.get("clients");
		if (clients == null || clients.length == 0) {
            // 添加过滤器：过滤器所有被 @FeignClient 标记接口
			scanner.addIncludeFilter(annotationTypeFilter);
			basePackages = getBasePackages(metadata);
		}
		else {
			final Set<String> 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)));
		}
		// 处理@FeignClient类，解析
		for (String basePackage : basePackages) {
			Set<BeanDefinition> 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<String, Object> attributes = annotationMetadata
							.getAnnotationAttributes(
									FeignClient.class.getCanonicalName());

					String name = getClientName(attributes);
					registerClientConfiguration(registry, name,
							attributes.get("configuration"));
					// 重点方法，注入FeignClient对象
					registerFeignClient(registry, annotationMetadata, attributes);
				}
			}
		}
	}

第一部分是为了找到@Feignclient标识的接口类，第二部分就是对找出的接口类进行处理了处理，主要关注registerClientConfiguration和registerFeignClient函数。

其中registerClientConfiguration是为了处理@FeignClient#configuration属性的，在这个函数会往spirng容器中添加#{serviceName}.FeignClientSpecification作为名字的FeignClientSpecification类对象，例如user-center.FeignClientSpecification。

而registerFeignClient函数则是处理接口类的主要方法了。我们在之前考虑到，我们在接口上填写了@FeignClient注解，在之后程序中我们可以直接引用这个接口对象来调用接口上的函数，理论分析一波：接口如果没有实现类，是不能直接在spring中直接进行注入并调用相应的方法的，一定需要我们去实现这个接口，那么我们可以想到，OpenFeign中一定做了这样的操作。

接下来我们看一下registerFeignClient函数

2.5registerFeignClient()函数
	private void registerFeignClient(BeanDefinitionRegistry registry,
			AnnotationMetadata annotationMetadata, Map<String, Object> attributes) {
		String className = annotationMetadata.getClassName();
        // 创建一个 BeanDefinitionBuilder 对象，用于构建并注入 FeignClientFactoryBean
		BeanDefinitionBuilder definition = BeanDefinitionBuilder
				.genericBeanDefinition(FeignClientFactoryBean.class);
        // 参数校验
		validate(attributes);
        // 设置BeanDefinition参数
		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);
	}

3. 接口代理对象的构建

3.1FeignClientFactoryBean类

OpenFeign 接口代理对象的构建，主要是通过 Spring 的扩展接口 FactoryBean<T> 来实现的。在上面的代码中，通过解析 FeignClient 对象，构建成一个 FeignClientFactoryBean 对象，Spring 在注入对应接口是，会调用 FeignClientFactoryBean 对象中的 getObject() 方法，返回注入对应的代理对象。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

class FeignClientFactoryBean
		implements FactoryBean<Object>, InitializingBean, ApplicationContextAware {
    
    @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 = this.applicationContext.getBean(FeignContext.class);
		Feign.Builder builder = feign(context);
		// 判断当前 FeignClient 注解中的url是否为空，如果不为空，直接通过url的调用
		if (!StringUtils.hasText(this.url)) {
			if (!this.name.startsWith("http")) {
				this.url = "http://" + this.name;
			}
			else {
				this.url = this.name;
			}
			this.url += cleanPath();
            // 返回目标对象
			return (T) loadBalance(builder, context,
					new HardCodedTarget<>(this.type, this.name, this.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();
			}
			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();
			}
			builder.client(client);
		}
		Targeter targeter = get(context, Targeter.class);
        // 返回目标对象
		return (T) targeter.target(this, builder, context,
				new HardCodedTarget<>(this.type, this.name, url));
	}
}
3.2 Targeter#target()函数

HystrixTargeter类实现了Targeter。

class HystrixTargeter implements Targeter {

	@Override
	public <T> T target(FeignClientFactoryBean factory, Feign.Builder feign,
			FeignContext context, Target.HardCodedTarget<T> target) {
		if (!(feign instanceof feign.hystrix.HystrixFeign.Builder)) {
			return feign.target(target);
		}
		feign.hystrix.HystrixFeign.Builder builder = (feign.hystrix.HystrixFeign.Builder) feign;
		String name = StringUtils.isEmpty(factory.getContextId()) ? factory.getName()
				: factory.getContextId();
		SetterFactory setterFactory = getOptional(name, context, SetterFactory.class);
		if (setterFactory != null) {
			builder.setterFactory(setterFactory);
		}
		Class<?> fallback = factory.getFallback();
		if (fallback != void.class) {
			return targetWithFallback(name, context, target, builder, fallback);
		}
		Class<?> fallbackFactory = factory.getFallbackFactory();
		if (fallbackFactory != void.class) {
			return targetWithFallbackFactory(name, context, target, builder,
					fallbackFactory);
		}
		// 返回目标对象
		return feign.target(target);
	}
}
3.3 Feign对象

feign.target(target)函数

public abstract class Feign {
    
	public <T> T target(Target<T> target) {
		// 创建代理对象
        return this.build().newInstance(target);
    }
    
    public abstract <T> T newInstance(Target<T> target);

	/**
	 * 构建 Feign对象
	 */
    public Feign build() {
        Client client = (Client)Capability.enrich(this.client, this.capabilities);
        Retryer retryer = (Retryer)Capability.enrich(this.retryer, this.capabilities);
        List<RequestInterceptor> requestInterceptors = (List)this.requestInterceptors.stream().map((ri) -> {
            return (RequestInterceptor)Capability.enrich(ri, this.capabilities);
        }).collect(Collectors.toList());
        Logger logger = (Logger)Capability.enrich(this.logger, this.capabilities);
        Contract contract = (Contract)Capability.enrich(this.contract, this.capabilities);
        Options options = (Options)Capability.enrich(this.options, this.capabilities);
        Encoder encoder = (Encoder)Capability.enrich(this.encoder, this.capabilities);
        Decoder decoder = (Decoder)Capability.enrich(this.decoder, this.capabilities);
        // 创建代理对象的 InvocationHandler 工厂实例
        InvocationHandlerFactory invocationHandlerFactory = (InvocationHandlerFactory)Capability.enrich(this.invocationHandlerFactory, this.capabilities);
        QueryMapEncoder queryMapEncoder = (QueryMapEncoder)Capability.enrich(this.queryMapEncoder, this.capabilities);
        Factory synchronousMethodHandlerFactory = new Factory(client, retryer, requestInterceptors, logger, this.logLevel, this.decode404, this.closeAfterDecode, this.propagationPolicy, this.forceDecoding);
        ParseHandlersByName handlersByName = new ParseHandlersByName(contract, options, encoder, decoder, queryMapEncoder, this.errorDecoder, synchronousMethodHandlerFactory);
        return new ReflectiveFeign(handlersByName, invocationHandlerFactory, queryMapEncoder);
    }
}

点击进入newInstance()函数

3.4ReflectiveFeign 对象

ReflectiveFeign继承了Feign

public class ReflectiveFeign extends Feign {
/**
 * 创建代理对象
 */
  @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>();
	// 解析模板：将方法解析，封装为MethodHandler
    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;
  }
}

看到这里就比较清晰了,把接口中的方法和默认实现放到Map<Method, MethodHandler>中然后使用InvocationHandlerFactory.Default()创建InvocationHandler,然后使用jdk动态代理生成接口的代理并返回,这里主要看一下Feign的InvocationHandler实现:

  static class FeignInvocationHandler implements InvocationHandler {

    private final Target target;
    private final Map<Method, MethodHandler> dispatch;

    FeignInvocationHandler(Target target, Map<Method, MethodHandler> dispatch) {
      this.target = checkNotNull(target, "target");
      this.dispatch = checkNotNull(dispatch, "dispatch for %s", target);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
      if ("equals".equals(method.getName())) {
        try {
          Object otherHandler =
              args.length > 0 && args[0] != null ? Proxy.getInvocationHandler(args[0]) : null;
          return equals(otherHandler);
        } catch (IllegalArgumentException e) {
          return false;
        }
      } else if ("hashCode".equals(method.getName())) {
        return hashCode();
      } else if ("toString".equals(method.getName())) {
        return toString();
      }

      return dispatch.get(method).invoke(args);
    }
   }

四、服务调用

正如我们前边所说,通过@Autowired或者@Resource注入的时候,注入的是被封装之后的代理类实现,
jdk动态代理持有的是ReflectiveFeign.FeignInvocationHandler类型的InvocationHandler,那么具体调用的时候,会调用FeignInvocationHandler#invoke()方法

4.1 FeignInvocationHandler对象
static class FeignInvocationHandler implements InvocationHandler { 
    private final Target target;
    private final Map<Method, MethodHandler> dispatch;

    FeignInvocationHandler(Target target, Map<Method, MethodHandler> dispatch) {
      this.target = checkNotNull(target, "target");
      this.dispatch = checkNotNull(dispatch, "dispatch for %s", target);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
      if ("equals".equals(method.getName())) {
        try {
          Object otherHandler =
              args.length > 0 && args[0] != null ? Proxy.getInvocationHandler(args[0]) : null;
          return equals(otherHandler);
        } catch (IllegalArgumentException e) {
          return false;
        }
      } else if ("hashCode".equals(method.getName())) {
        return hashCode();
      } else if ("toString".equals(method.getName())) {
        return toString();
      }
	  // 执行方法
      return dispatch.get(method).invoke(args);
    }
   }

前几个判断分支都是调用了Object的基本方法,最后dispatch.get(method).invoke(args)才是接口的业务方法调用,dispatch的类型是Map<Method, MethodHandler>,是接口中方法与MethodHandler的映射关系,而MethodHandler又被SynchronousMethodHandler.Factory封装成SynchronousMethodHandler(实现了MethodHandler):

4.2 SynchronousMethodHandler类

SynchronousMethodHandler类实现了MethodHandler。那么dispatch.get(method).invoke(args)最终调用的就是SynchronousMethodHandler#invoke()方法:

final class SynchronousMethodHandler implements MethodHandler {
      @Override
  public Object invoke(Object[] argv) throws Throwable {
    // 构建请求的一个模版
    RequestTemplate template = buildTemplateFromArgs.create(argv);
    Options options = findOptions(argv);
    Retryer retryer = this.retryer.clone();
    while (true) {
      try {
        // 可以看到调用的时候默认是带有重试能力,默认是5次,具体调用交给executeAndDecode来实现:
        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;
      }
    }
  }
}

可以看到调用的时候默认是带有重试能力,默认是5次,具体调用交给executeAndDecode来实现:

Object executeAndDecode(RequestTemplate template, Options options) throws Throwable {
    Request request = targetRequest(template);

    if (logLevel != Logger.Level.NONE) {
      logger.logRequest(metadata.configKey(), logLevel, request);
    }

    Response response;
    long start = System.nanoTime();
    try {
       // 通过 Client执行，进行远程调用
      response = client.execute(request, options);
    } catch (IOException e) {
      if (logLevel != Logger.Level.NONE) {
        logger.logIOException(metadata.configKey(), logLevel, e, elapsedTime(start));
      }
      throw errorExecuting(request, e);
    }
    long elapsedTime = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start);

    boolean shouldClose = true;
    try {
      if (logLevel != Logger.Level.NONE) {
        response =
            logger.logAndRebufferResponse(metadata.configKey(), logLevel, response, elapsedTime);
      }
      if (Response.class == metadata.returnType()) {
        if (response.body() == null) {
          return response;
        }
        if (response.body().length() == null ||
            response.body().length() > MAX_RESPONSE_BUFFER_SIZE) {
          shouldClose = false;
          return response;
        }
        // Ensure the response body is disconnected
        byte[] bodyData = Util.toByteArray(response.body().asInputStream());
        return response.toBuilder().body(bodyData).build();
      }
      if (response.status() >= 200 && response.status() < 300) {
        if (void.class == metadata.returnType()) {
          return null;
        } else {
          Object result = decode(response);
          shouldClose = closeAfterDecode;
          return result;
        }
      } else if (decode404 && response.status() == 404 && void.class != metadata.returnType()) {
        Object result = decode(response);
        shouldClose = closeAfterDecode;
        return result;
      } else {
        throw errorDecoder.decode(metadata.configKey(), response);
      }
    } catch (IOException e) {
      if (logLevel != Logger.Level.NONE) {
        logger.logIOException(metadata.configKey(), logLevel, e, elapsedTime);
      }
      throw errorReading(request, response, e);
    } finally {
      if (shouldClose) {
        ensureClosed(response.body());
      }
    }
  }

核心是client.execute(),我们选择性看一下Default默认的实现:

@Override
public Response execute(Request request, Options options) throws IOException {
  HttpURLConnection connection = convertAndSend(request, options);
  return convertResponse(connection, request);
}

很明显,最终服务调用会委托给HttpURLConnection来执行,然后组装结果和状态码返回调用,到这里openfeign的服务调用就分析完了,为了帮助理解和有更直观的概念,我们看一下服务调用时序图:

在这里插入图片描述
图是我在网上找了一张，是OkHttpClient的，原理都是一样的，大家凑活看一下。

注意：

我们知道OpenFeign的底层默认会交给HttpURLConnection处理，HttpURLConnection是不支持连接池的。所以这里我们可以配置为HttpClient 或OkHttpClient等进行一个优化。具体配置如下：

feign:
  client:
    config:
      default:
      # 日志级别，这里是我本地开发环境设置为FULL，生产环境不建议设置为FULL，可以设置为HEAD
        loggerLevel: FULL
  # 使用httpclient   
  httpclient:
    enabled: true
    max-connections: 200
    max-connections-per-route: 50
 # OpenFeign第一次加载慢是因为底层采用了懒加载的方式，我们这里采用了饥饿加载的方式
 ribbon:
  eager-load:
    enabled: true
    clients: easyexcelService

五、总结

  1. 通过 @EnableFeignCleints 触发 Spring 应用程序对 classpath 中 @FeignClient 修饰类的扫描
  2. 解析到 @FeignClient 修饰类后， Feign 框架通过扩展 Spring Bean Deifinition 的注册逻辑， 最终注册一个 FeignClientFacotoryBean 进入 Spring 容器
  3. Spring 容器在初始化其他用到 @FeignClient 接口的类时， 获得的是 FeignClientFacotryBean 产生的一个代理对象 Proxy.
  4. 基于 java 原生的动态代理机制， 针对 Proxy 的调用， 都会被统一转发给 Feign 框架所定义的一个 InvocationHandler ， 由该 Handler 完成后续的 HTTP 转换， 发送， 接收， 翻译HTTP响应的工作

感觉这块的逻辑还是有点难度的，我debug源码三四次才搞懂OpenFeign底层是如何创建代理对象，如何实现调用的。想要了解OpenFeign底层原理的同学可以自己手动debug一下源码看一看具体的执行流程。

纸上得来终觉浅，绝知此事要躬行。

参考：

  • https://blog.csdn.net/weixin_41821642/article/details/129874394?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522171325961116800188518011%2522%252C%2522scm%2522%253A%252220140713.130102334…%2522%257D&request_id=171325961116800188518011&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2allbaidu_landing_v2~default-5-129874394-null-null.142v100pc_search_result_base4&utm_term=openfeign%E5%BA%95%E5%B1%82%E8%B0%83%E7%94%A8%E5%8E%9F%E7%90%86&spm=1018.2226.3001.4187

  • https://blog.csdn.net/bz120413/article/details/122215774?ops_request_misc=&request_id=&biz_id=102&utm_term=openfeign%E5%BA%95%E5%B1%82%E8%B0%83%E7%94%A8%E5%8E%9F%E7%90%86&utm_medium=distribute.pc_search_result.none-task-blog-2allsobaiduweb~default-3-122215774.142v100pc_search_result_base4&spm=1018.2226.3001.4187

YAnalytics
关注
  • 16
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Spring Cloud - Openfeign 实现原理分析
qq_61863348的博客
03-26 671
OpenFeign 是一个声明式 RESTful 网络请求客户端。OpenFeign 会根据带有注解的函数信息构建出网络请求的模板，在发送网络请求之前，OpenFeign 会将函数的参数值设置到这些请求模板中。虽然 OpenFeign 只能支持基于文本的网络请求，但是它可以极大简化网络请求的实现，方便编程人员快速构建自己的网络请求应用。
SpringCloud之OpenFegin基本介绍及原理分析
HRebel的博客
12-15 1137
本文主要内容： 简单了解原生Feign、Spring Cloud Open Fegin是什么 一、Spring Cloud Open Fegin介绍 1.1、Feign基础介绍 Feign：是申明式Web服务客户端，基于JAX-RS（javaRest规范）实现的 申明式：通过接口声明、Annotation驱动 Web服务：HTTP通讯协议 客户端：用户服务调用存根 Feign可以将一个Service声明为可以被HTTP方式调用，底层基于面向接口的动态代理方式生成实现类，将请求调用委托到动态代理实现
OpenFeign 基本介绍和原理了解
热门推荐
weixin_40364776的博客
01-15 1万+
OpenFeign的使用展示和原理解读
OpenFeign的实现原理（附Feign和OpenFeign的区别）
weixin_42585386的博客
11-09 3857
OpenFeign的实现原理（附Feign和OpenFeign的区别）
【Spring Cloud 进阶】OpenFeign 底层原理解析
VLyb
02-29 2175
Feign 的原理
Openfeign的实现原理
gr5201314的博客
01-11 4950
OpenFeign 是 Spring Cloud 家族的一个成员， 它最核心的作用是为 HTTP 形式的 Rest API 提供了非常简洁高效的 RPC 调用方式。 如果说 Spring Cloud 其他成员解决的是系统级别的可用性，扩展性问题， 那么 OpenFeign 解决的则是与开发人员利益最为紧密的开发效率问题。 完成 Feign 调用前所进行的操作： 添加依赖 <spring-cloud.version>Hoxton.SR9</spring-cloud.ve
Spring Cloud OpenFeign 使用示例
08-10
Spring Cloud OpenFeign 示例代码工程。该工程基于官方示例（https://github.com/spring-cloud-samples/feign-eureka），额外添加了注册中心模块feign-eureka-central（eureka is running on http://localhost:8761...
微服务 Springcloud OpenFeign
06-02
资源用springcloud搭的一个微服务框架，涉及OpenFeign知识点，适合初学者理解微服务，大神绕过。
SpringCloud底层原理
01-27
一、业务场景介绍二、SpringCloud核心组件：Eureka三、SpringCloud核心组件：Feign四、SpringCloud核心组件：Ribbon五、SpringCloud核心组件：Hystrix六、SpringCloud核心组件：Zuul七、总结毫无疑问，SpringCloud是...
springcloud同时整合dubbo与openfeign
05-20
案例代码为springcloud-libaba整合dubbo同时也整合了openfeign，消费方可以通过两种方式调用服务提供方的接口，代码下载后简单修改下数据库链接可以直接运行起来，如果运行时有任何问题可以私信我；
openfeign底层原理
最新发布
大连赵哥的博客
04-14 339
openfeign底层原理
Spring Cloud Netflix-OpenFeign基本使用及其原理
雨后是冰雹
01-10 976
OpenFeign一、OpenFeign基本使用1.1 OpenFeign接口定义1.2 OpenFeign接口注入二、OpenFeign底层原理2.1 FeignClient 注解的扫描与解析2.2 接口代理对象的构建2.3 远程通信的实现 OpenFeign 目标是减少 HTTP API的复杂性，希望能将 HTTP 调用做到像RPC一样易用。OpenFeign的基本原理是将需要调用的接口通过 Spring 中的扩展接口 ImportBeanDefinitionRegistrar 注入成一个 Proxy
OpenFeign调用服务的核心原理解析
曳凡的博客
03-19 6676
引言 OpenFeign在分布式服务中运用非常广泛，他和RPC所要达到的效果一致，就是为了简化远程服务调用的操作，通过使用OpenFeign可以使得调用远程服务就像调用本地服务一样方便。 但是其和RPC在实现上还是不太一样，不一样的地方主要还是调用的方式，OpenFeign是内部实现了rest服务调用，从而一个本地服务调用远程服务的接口时，主要还是通过rest服务调用的方式，那么对于服务端的要求就是其服务需要将这个接口通过rest暴露出来，不然OpenFeign将无法工作；而RPC则不需要服务端将该接口以r
OpenFeign 实现原理
u012925692的博客
01-08 1639
OpenFeign 简介 OpenFeign 是一个声明式 RESTful 网络请求客户端。OpenFeign 会根据带有注解的函数信息构建出网络请求的模板，在发送网络请求之前，OpenFeign 会将函数的参数值设置到这些请求模板中。虽然 OpenFeign 只能支持基于文本的网络请求，但是它可以极大简化网络请求的实现，方便编程人员快速构建自己的网络请求应用。 核心组件与概念 在阅读源码时，可以沿着两条线路进行，一是被@FeignClient注解修饰的接口类如何创建，也就是其 Bean 实例是如何被
一文看懂Openfeign服务调用原理
叔牙的专栏
12-29 1181
OpenFeign是Spring Cloud 在Feign的基础上支持了Spring MVC的注解，如@RequesMapping等等。 OpenFeign的@FeignClient可以解析SpringMVC的@RequestMapping注解下的接口，并通过动态代理的方式产生实现类，实现类中做负载均衡并调用其他服务。
OpenFeign(2)---＞OpenFeign 的原理分析
qq_34978129的博客
12-14 936
1、由于分析源码比较枯燥，因为我将openFeign的整体原理通过流程图的信息展示： 整体的流程如上图所示，核心思想就是通过代理来进行拦截，然后使用Contract解析接口方法，生产对应的请求然后进行http通讯。 2、openFeign默认继承了R进行负载均衡，spring-cloud-starter-openfeign 的jar包中，默认就是依赖了ribbon 相关的包。 ...
SpringCloud全系列（一）： OpenFeign原理解析
大步流星的博客
11-25 1万+
1、背景 之前未曾想过会有全面拥抱Spring Cloud的一天，这是我来腾讯后写的第一篇博客，也是第一篇关于Spring Cloud体系的博客，废话少说，我们进入主题。 我们知道HTTP的重要性，也知道开发Web服务端还是很爽的，Spring MVC 或 Spring WebFlux 一套拳打完直接收工即可，但作为Web服务的调用方（这里主要指服务端调用服务端），由于需要熟悉各种（OkHttp、HttpClient）组件的使用，而且还要显示的序列化和反序列化，很多样板代码，写起来很痛苦，瞬间不香了，还
openfeign底层调用原理
09-01
OpenFeign 是一个基于注解的声明式 REST 客户端，它简化了使用 Spring Cloud 中的服务间调用。底层调用原理如下： 1. 定义接口：首先，我们需要定义一个接口，使用 `@FeignClient` 注解标记接口，并指定要调用的服务名称。 2. 创建代理对象：在应用程序启动时，OpenFeign 会扫描带有 `@FeignClient` 注解的接口，并创建代理对象。代理对象实现了该接口，并通过 Feign 运行时生成的字节码处理请求。 3. 发起请求：当我们在应用程序中调用 Feign 接口的方法时，实际上是调用了代理对象的方法。代理对象会将方法的参数和注解信息转化为 HTTP 请求，然后通过底层的 HTTP 客户端发送请求到指定的服务。 4. 处理请求：服务端接收到请求后，根据请求路径、HTTP 方法等信息，找到对应的处理器进行处理，并生成响应。 5. 返回结果：当服务端处理完请求后，会将处理结果返回给代理对象。代理对象将响应转换为预期的数据类型，并返回给调用方。 总体来说，OpenFeign 封装了底层的 HTTP 客户端，使得我们可以使用类似于本地方法调用的方式来进行服务间的调用。这样，我们可以更加方便地实现微服务架构中的服务间通信。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值