8. 负载均衡——OpenFeign

最新推荐文章于 2024-09-24 14:10:32 发布
最新推荐文章于 2024-09-24 14:10:32 发布
阅读量4.2k 收藏 4
点赞数
分类专栏： # springCloud H版本与Boot2.2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43318134/article/details/105310863
版权

1. 概述

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

        简单来说，Feign是一个声明式的Web服务客户端，让编写Web服务客户端变得非常容易，只需要创建一个接口并在接口上添加注解即可。

GitHub地址：https://github.com/spring-cloud/spring-cloud-openfeign

Feign旨在使编写java Http客户端变得更加容易。
前面在使用Ribbon+RestTemplate时，利用RestTemplate对http请求的封装处理，形成了一套模板化的调用方法。但是在实际开发中，由于对服务依赖的调用可能不止一处，往往一个接口会被多处调用，所以通常都会针对每个微服务自行封装一些客户端类来包装这些依赖服务的调用。所以Feign在此基础上做了进一步的封装，由它来帮我们定义和实现依赖服务接口的定义。
在Feign的实现下，我们只需创建一个接口并使用注解的方式来配置它（以前是dao接口上面标注Mapper注解，现在是一个微服务接口上标注一个Feign注解即可），即可完成对服务提供方的接口绑定，简化了使用Spring cloud Ribbon时，自动封装服务调用客户端的开发量。

Feign集成了Ribbon
利用Ribbon维护了Payment的服务列表信息，并且通过轮询实现了客户端的负载均衡，而与Ribbon不同的是，通过feign只需要定义服务绑定接口且以声明式的方法，优雅而简单的实现了服务调用。

Feign和OpenFeign的区别

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

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

2. Openfeign使用步骤

2.1 接口+注解

微服务调用接口+@FeignClient

2.2 实例说明

1）参考80工程，新建Module   cloud-consumer-feign-order80

2）pon.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>cloud2020</artifactId>
        <groupId>com.bjc.cloud</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>cloud-consumer-feign-order80</artifactId>
    <dependencies>
        <!-- openFeign -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
        <!-- 引入eureka客户端依赖 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <!-- 添加bootweb启动依赖与健康监控依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <!-- 热部署 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

        <!-- junit测试 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
        <dependency>
            <groupId>com.bjc.cloud</groupId>
            <artifactId>cloud-api-commons</artifactId>
            <version>${project.version}</version>
        </dependency>
    </dependencies>
</project>

3）application.yml文件

server:
  port: 80
eureka:
  client:
    register-with-eureka: false
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka

4）启动类

package com.bjc.cloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;

@SpringBootApplication
@EnableFeignClients
public class OrderFeignMain80 {
	public static void main(String[] args) {
		SpringApplication.run(OrderFeignMain80.class,args);
	}
}

5）业务类

5.1 业务逻辑接口+@FeignClient配置调用provider服务（新建PaymentfeignService接口并新增注解@FeignClient）

package com.bjc.cloud.service;

import com.bjc.cloud.entity.CommonResult;
import com.bjc.cloud.entity.Payment;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

/**
 * 该接口与8001生产者对应的Controller
 * */
@Component
@FeignClient(value = "CLOUD-PAYMENT-SERVICE")// 指定调用哪个微服务
public interface PaymentFeignService {
	@GetMapping("/payment/get/{id}")
	CommonResult<Payment>  getPaymentById(@PathVariable("id") Long id);
}

5.2 消费者Controller

package com.bjc.cloud.controller;

import com.bjc.cloud.entity.CommonResult;
import com.bjc.cloud.entity.Payment;
import com.bjc.cloud.service.PaymentFeignService;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

@RestController
public class OrderfeignController {
	@Resource
	private PaymentFeignService service;

	@GetMapping("/consumer/payment/get/{id}")
	public CommonResult<Payment> getPaymentbyId(@PathVariable("id") long id){
		return service.getPaymentById(id);
	}
}

2.3 测试

1）启动eureka

2）启动生产者

3）启动消费者（OpenFeign）

4）输入网址

刷新

再次刷新又是8001，说明OpenFeign默认采用的也是轮询算法。

3. OpenFeign的超时控制

OpenFeign默认等待1秒钟，超过后报错

3.1 情景模拟

1）在生产者的controller层模拟一个默认的超时的方法（集群都需要添加）

2）在80服务调用

2.1 接口

2.2 controller层

3）测试

3.1 直接调用8001的controller

3.2 调用80的

3.2 超时控制

        默认Feign客户端只等待一秒钟，但是服务端处理需要超过1秒钟，导致feign客户端不想等了，直接返回报错。为了避免这样的情况，有时候我们需要设置Feign客户端的超时控制

在yml中配置：

server:
  port: 80
eureka:
  client:
    register-with-eureka: false
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka
# 设置feign客户端超时时间（OpenFeign默认支持Ribbon）
ribbon:
  ReadTimeout: 10000           # 建立连接所用时间，适用于网络状况正常的情况下，两端连接所用的时间
  ConnectTimeout: 10000        # 建立连接后，从服务器读取到的可用资源所用的时间

设置完之后，等待80重新部署，完成，再次访问，如图：

4. OpenFeign日志打印功能

        Feign提供了日志打印功能，我们可以通过配置来调整日志级别，从而了解Feign中Http请求的细节。说白了就是对Feign接口的调用情况进行监控和输出

4.1 日志级别

NONE：默认的，不显示任何日志
BASIC：仅记录请求方法、URL、响应状态码及执行时间
HEADERS：除了BASIC中定义的信息之外，还有请求和响应的头信息
FULL：除了HEADERS中定义的信息之外，还有请求和响应的正文及元数据

4.2 配置Bean

package com.bjc.cloud.config;

import feign.Logger;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class FeignConfig {
	@Bean
	Logger.Level feignLogger(){
		return Logger.Level.FULL;
	}
}

4.3 yml文件开启日志的Feign客户端

server:
  port: 80
eureka:
  client:
    register-with-eureka: false
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka
# 设置feign客户端超时时间（OpenFeign默认支持Ribbon）
ribbon:
  ReadTimeout: 10000           # 建立连接所用时间，适用于网络状况正常的情况下，两端连接所用的时间
  ConnectTimeout: 10000        # 建立连接后，从服务器读取到的可用资源所用的时间

logging:
  level:
    com.bjc.cloud.service.PaymentFeignService: debug   # feign日志以什么级别监控哪个接口

4.4 查看日志

启动80微服务，调用服务，然后查看日志记录

5. 解决feign远程调用丢失请求头问题

feign在远程调用之前要构造请求，调用很多拦截器，如果没有拦截器，feign就使用它构造的请求，这个请求是没有请求头等信息的，因此，就导致了请求头丢失的问题出现。

 如图：

那么，我们可以自定义一个RequestInterceptor拦截器，在拦截器中将请求头信息写入这个新建的请求对象中。

package com.config;

import feign.RequestInterceptor;
import feign.RequestTemplate;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import java.util.Enumeration;

/**
 * @描述：feign配置
 * @创建时间: 2021/3/20
 */
@Configuration
public class FeignConfig {

    @Bean("requestInterceptor")
    public RequestInterceptor requestInterceptor(){
        return new RequestInterceptor() {
            @Override
            public void apply(RequestTemplate requestTemplate) {
                System.out.println("feign远程调用之前执行RequestInterceptor.apply");
                // 1. 使用RequestContextHolder拿到访问的请求对象
                ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
                HttpServletRequest request = requestAttributes.getRequest();
                // 2. 同步请求头数据
                // 注意：一般都是同步cookie  所以这里可以直接将cookie设置进去即可，不必要全部设置
                Enumeration<String> headerNames = request.getHeaderNames();
                if(null != headerNames && headerNames.hasMoreElements()){
                    while(headerNames.hasMoreElements()){
                        String headName = headerNames.nextElement();
                        requestTemplate.header(headName,request.getHeader(headName));
                    }
                }
            }
        };
    }

}

6. 解决feign异步调用丢失请求头问题

在上面的配置类中，执行到拦截器的时候，当是在异步任务中远程调用feign接口的时候，获取到的请求request就为null，使用request获取请求头的时候就会报空指针异常了。

原因：RequestContextHolder的底层原理是利用的ThreadLocal来共享上下文信息的，在不做异步请求之前，调用链如下图所示：

使用异步之后，结构就是如下图所示：

很明显的可以看出来问题，address与cart使用的是新开的线程，因此使用ThreadLocal自然是获取不到72号线程的数据的。

解决办法；

根据原理图，很容易想到的一个解决办法是在新的线程中，将旧是请求对象设置到新线程中，代码如图：

 

武汉小喽啰
关注
专栏目录
【SpringCloudNetflix-OpenFeign客户端负载均衡】
qq_44856967的博客
07-22 667
接着上章【SpringCloudNetflix-Ribbon客户端负载均衡】，继续学习OpenFeign客户端负载均衡Feign是一个声明式的http客户端，使用Feign可以实现声明式REST调用，它的目的就是让Web Service调用更加简单。Feign整合了Ribbon和SpringMvc注解，这让Feign的客户端接口看起来就像一个Controller。Feign提供了HTTP请求的模板，通过编写简单的接口和插入注解，就可以定义好HTTP请求的参数、格式、地址等信息。
Spring Cloud——OpenFeign
努力找工作呀
04-16 390
一.简介 Java项目中接口调用： HttpClient: Apache Jakarta Common下的子项目，用来提供高效的、最新的、功能丰富的支持 Http 协议的客户端编程工具包，并且它支持 HTTP 协议最新版本和建议。 Okhttp：一个处理网络请求的开源项目，是安卓端最火的轻量级框架，由 Square 公司贡献，用于替代 HttpUrlConnection 和 Apache HttpClient。OkHttp 拥有简洁的 API、高效的性能，并支持多种协议（HTTP/2 和 SPDY）。
OpenFeign 与负载均衡
qq806925608的博客
07-01 1249
在启动类上添加@EnableFeignClients 注解。
微服务篇：OpenFeign
最新发布
2301_81054483的博客
09-24 1991
OpenFeign是一个轻量级的HTTP客户端开发工具，它是Netflix开源的项目之一，用于简化HTTP请求的调用和处理。OpenFeign的设计目标是使API调用更加简单和优雅。它提供了一组注解和接口，通过声明方式定义HTTP请求，然后自动生成实现代码。这样开发人员只需要编写接口定义和相关的注解，就可以实现对远程服务的调用。OpenFeign支持多种HTTP请求方式，包括GET、POST、PUT、DELETE等。它还支持请求参数的传递、请求头的设置、请求体的序列化等功能。
OpenFeign实现负载均衡
Leon_Jinhai_Sun的博客
07-28 2587
OpenFeign实现负载均衡
07-负载均衡之OpenFeign
普通人一枚
05-08 755
1. ribbon的问题 使用ribbon时，我们发现 Robbin确实可以做到负载均衡，也可以修改负载均衡算法 很灵活。 但是使用Ribbon时我们发现，我们还需要拼接URL路径，这很显然不是很优雅，我们开发是面向接口面向对象开发，而不是面向URL拼接开发，OpenFeign 就是在Ribbon的基础上，通过接口+注解的方式 实现负载均衡的 2. feign的过时说明 3. openFeign的使用步骤 3.1. 消费者端添加依赖 <dependency> .
SpringCloud 中openfeign负载均衡
牛肉胡辣汤
08-23 2666
当OpenFeign与Ribbon负载均衡器结合使用时，它会根据Ribbon的负载均衡策略选择一个服务实例进行调用。Ribbon负载均衡器会通过维护一张服务实例列表，并根据一定的策略将请求分发到不同的实例上，以实现负载均衡的效果。这样，OpenFeign会根据服务名称来查找注册中心中的服务实例，并根据Ribbon的负载均衡策略选择一个实例进行调用。这样，当调用MyService类中的getResource方法时，OpenFeign会根据服务名称和Ribbon负载均衡策略选择一个可用的服务实例进行调用。
springcloud实战：服务间通信——OpenFeign
m0_63437643的博客
02-10 565
Spring Cloud OpenFeign Spring Cloud OpenFeign是一个声明式的 HTTP客户端，它简化了HTTP客户端的开发，使编写Web服务的客户端变得更容易。使用Spring Cloud OpenFeign，只需要创建一个接口并注解，就能很容易地调用各服务提供的HTTP接口。Spring Cloud OpenFeign基于OpenFeign实现，它除了提供声明式的 HTTP客户端外，还整合了Spring Cloud Hystrix，能够轻松实现熔断器模型。 Spri
SpringCloud(六)——OpenFeign服务接口调用
筱筱攻程师的博客
01-27 221
文章目录一、概述1.OpenFeign是什么？2.能干嘛？3.Feign和OpenFeign两者区别二、OpenFeign使用步骤三、OpenFeign超时控制1.OpenFeign超时控制是什么？四、OpenFeign日志打印功能 一、概述 1.OpenFeign是什么？ Feign是一个声明式的web服务客户端，让编写web服务客户端变得非常容易，只需创建一个接口并在接口上添加注解即可 官网：https://github.com/spring-cloud/spring-cloud-openfeign
Spring Could系列（三）Rest风格访问——OpenFeign
qq_45646289的博客
03-29 796
Spring Could OpenFeign 一、OpenFeign的概述 OpenFeign是Spring Could基于Feign发明的。OpenFeign是一个声明式的Rest风格的网络访问客户端，它具有可插入式注释支持，包括feign注释和 JAX-RS 注释。 OpenFeign还支持可插入式编码器和解码器。春云增加了对Spring MVC 注释的支持，以及默认在Spring Web 中使用相同内容的支持。春云集成了eureka、Spring Could断路器以及Spring Could负载平衡器
SpringCloud（三）——OpenFeign、Ribbon、Hystrix原理分析及实例演示
不要总是等明天再开始
08-09 1255
这里写目录标题一级目录二级目录三级目录1. Ribbon负载均衡Ribbon 负载均衡原理分析负载均衡使用小结2. RESTful SpringCloud OpenFeign 声明式RESTful客户端OpenFeign原理小结3. Hystrix 熔断器熔断器的意义Hystrix 原理断路器服务降级和隔离4. 综合实例演示小结 一级目录 二级目录 三级目录 1. Ribbon负载均衡 当系统访问量剧增时，通常会通过增加服务器数量横向扩展，多个服务器需要均衡，避免某台服务器承担过多的访问请求，而某些服务器处
11-OpenFeign-实现负载均衡策略
宣晨光
02-14 2772
默认开启负载均衡策略，并使用default RoundRobinLoadBalancer策略。2021.0.1版本使用 spring-cloud-loadbalancer。无需yaml文件配置，openfeignclient配置。
3.OpenFeign与负载均衡
ljz66254的博客
08-03 1116
声明式 REST 客户端:Feign 通过使用 JAX-RS(JavaApieXtensionsofRESTful webServivces)或 SpringMVc 注解的修饰方式，生成接口的动态实现。Feign，假装、伪装。openFeign 可以将提供者提供的 Restful服务伪装为接口进行消费,消费者只需使用“feign 接口 + 注解”的方式即可直接调用提供者提供的 Restful 服务而无需再使用 RestTemplate。
OpenFeign负载均衡配置
weixin_43903629的博客
08-16 7026
OpenFeign负载均衡
OpenFeign服务调用与负载均衡
Apollo
06-18 1172
OpenFeign服务调用与负载均衡
SpringCloud--OpenFeign与负载均衡
qq_44962906的博客
01-28 6543
OpenFeign与负载均衡
openfeign负载均衡
qq_21277357的博客
11-29 689
我们点进去看到,他的负载均衡方式就是采用的rabbion。可以看到在控制台有这一段日志。#打印feign调用日志。在配置文件添加这些配置。#开启debug日志。
OpenFeign(负载均衡)
qq_44667523的博客
09-27 489
​ OpenFeign是Spring Cloud家族中的成员之一,是一种声明式\模块化的HTTP客户端.最核心的作用是为 HTTP 形式的 Rest [API](https://so.csdn.net/so/search?default: #default指定对所有的微服务有效，可以指定具体的微服务名。default: #default指定对所有的微服务有效，可以指定具体的微服务名。## 访问 url http://localhost:8085/test。#微服务调用超时配置。
浅谈springcloud入门（三）-负载均衡OpenFeign
HCutopia的博客
07-22 1275
提到OpenFeign，就不得不提到另一个HTTP服务客户端，Feign。Feign是Spring Cloud组件中的一个轻量级RESTful的HTTP服务客户端，Feign内置了Ribbon，用来做客户端负载均衡，去调用服务注册中心的服务。Feign的使用方式是：使用Feign的注解定义接口，调用这个接口，就可以调用服务注册中心的服务。但是Feign是在2019就已经不再更新了，通过maven网站就可以看出来，随之取代的是OpenFeign，从名字上就可以知道，他是Feign的升级版。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值