1
<dependencies>
2
       <dependency>
3
            <groupId>org.springframework.cloud</groupId>
4
            <artifactId>spring-cloud-starter-openfeign</artifactId>
5
        </dependency>
6
    </dependencies>
7

8
<dependencyManagement>
9
        <dependencies>
10
            <dependency>
11
                <groupId>org.springframework.cloud</groupId>
12
                <artifactId>spring-cloud-dependencies</artifactId>
13
                <version>${spring-cloud.version}</version>
14
                <type>pom</type>
15
                <scope>import</scope>
16
            </dependency>
17
            <dependency>
18
                <groupId>com.alibaba.cloud</groupId>
19
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
20
                <version>${spring-cloud-ali.version}</version>
21
                <type>pom</type>
22
                <scope>import</scope>
23
            </dependency>
24
        </dependencies>
25
    </dependencyManagement>

开启feign#

如果不在项目扫码范围内，需要添加basePackages指定扫码包

1
@EnableFeignClients(basePackages = "com.zy.gulimall.common.feign")

开启hystrix#

1
feign:
2
  hystrix:
3
    enabled: true

Feign logging日志#

配置文件

1
logging:
2
  level:
3
    #com.eim.feign.ProFeig  为 feign包
4
    com.zy: debug

spring配置Log the headers, body, and metadata for both requests and responses.

1
    @Configuration
2
    public class FooConfiguration {
3
        @Bean
4
        Logger.Level feignLoggerLevel() {
5
            return Logger.Level.FULL;
6
        }
7
    }

超时时间#

如何配置好Hystrix和Ribbon的超时时间呢

其实是有套路的。因为Feign的请求：其实是Hystrix+Ribbon。Hystrix在最外层，然后再到Ribbon，最后里面的是http请求。所以说。Hystrix的熔断时间必须大于Ribbon的 ( ConnectTimeout + ReadTimeout )。而如果Ribbon开启了重试机制，还需要乘以对应的重试次数，保证在Ribbon里的请求还没结束时，Hystrix的熔断时间不会超时。

1
#开启熔断降级 hystrix
2
feign:
3
  hystrix:
4
    enabled: true
5
#openfeign超时时间由ribbon控制
6
ribbon:
7
  # 连接超时时间(ms)
8
  ConnectTimeout: 5000
9
  # 通信超时时间(ms)
10
  ReadTimeout: 5000
11
  # 是否对所有操作重试
12
  OkToRetryOnAllOperations: true
13
  # 同一服务不同实例的重试次数
14
  MaxAutoRetriesNextServer: 1
15
  # 同一实例的重试次数
16
  MaxAutoRetries: 1
17
#设置超时熔断时间（spring-cloud-starter-openfeign中的HystrixCommandProperties默认为1000毫秒）
18
hystrix:
19
  command:
20
    default:
21
      execution:
22
        isolation:
23
          thread:
24
            timeoutInMilliseconds: 10000

写feign接口#

name : 需要调用的服务名称

fallbackFactory：自定义服务降级工厂

decode404 ：Feign对于2XX和404 ，都不会走Fallback了。排除404，已经基本上够用了，如果想把409、400等status也加到例外中，可以重写一下Feign的errorDecoder。

configuration 自定义feign配置类

1
/**
2
 * <p>DESC: 会员feign</p>
3
 * <p>DATE: 2020-04-13 19:24</p>
4
 * <p>VERSION:2.0.0</p>
5
 * <p>@AUTHOR: ZhengYong</p>
6
 */
7
@FeignClient(name = "gulimall-member",fallbackFactory = MemberFeignFallbackFactory.class,decode404=true
8
        ,configuration = FeignConfiguration.class
9
)
10
public interface MemberFeign {
11

12
    @RequestMapping("member/growthchangehistory/list")
13
    R list(@RequestParam Map<String, Object> params);
14
}

fallbackFactory#

实现FallbackFactory，泛型填写自己的feign接口

重写create方法

BaseFallFactory接收Throwable（其实是异常），调用invoke方法（进行errorCode，message的赋值操作）

return new MemberFeign() 重写接口中的服务降级方法

1
@Slf4j
2
@Component
3
public class MemberFeignFallbackFactory implements FallbackFactory<MemberFeign> {
4

5
    @Override
6
    public MemberFeign create(Throwable throwable) {
7
        //解析错误
8
        BaseFallFactory invoke = new BaseFallFactory(throwable).invoke();
9
        final Integer errorCode = invoke.getErrorCode();
10
        final String message = invoke.getMessage();
11

12
        return new MemberFeign() {
13
            @Override
14
            public R list(Map<String, Object> params) {
15
                log.error("看见我了没有-------猪猪");
16
                return R.error(errorCode,message);
17
            }
18
        };
19
    }
20

21
}

BaseFallFactory#

接收Throwable异常信息，进行信息绑定

api业务异常，超时异常，feign失败异常

1
@Slf4j
2
public class BaseFallFactory {
3
    private Throwable throwable;
4
    private Integer errorCode;
5
    private String message;
6

7
    public BaseFallFactory(Throwable throwable) {
8
        this.throwable = throwable;
9
    }
10

11
    public Integer getErrorCode() {
12
        return errorCode;
13
    }
14

15
    public String getMessage() {
16
        return message;
17
    }
18

19
    public BaseFallFactory invoke() {
20
        //是否是api  异常
21
        if (throwable instanceof ApiException) {
22
            errorCode = ((ApiException) throwable).getCode();
23
            message = throwable.getMessage();
24
        }
25
        //是否是请求超时异常
26
        else if (throwable instanceof com.netflix.hystrix.exception.HystrixTimeoutException) {
27
            log.error("error={}", "feign调用超时，抛出RetryableException");
28
            errorCode = HttpStatus.REQUEST_TIMEOUT.value();
29
            message = "Read timed out";
30
        }
31
        else if (throwable instanceof com.netflix.client.ClientException) {
32
            log.error("error={}", "feign调用不可服务，抛出RetryableException");
33
            errorCode = HttpStatus.REQUEST_TIMEOUT.value();
34
            message = "not have available server";
35
        }
36
        //feign调用失败 异常
37
        else {
38
            log.error("error={}，错误信息={}", "feign调用失败，抛出FeignException", throwable.getMessage());
39
            errorCode = 400;
40
            message = throwable.getMessage();
41
        }
42
        return this;
43
    }
44
}

SpringCloud-feign客户端统一处理下游服务自定义异常#

经过尝试和查阅资料，Springcloud处理下游服务的异常是是通过默认的ErrorDecoder实现处理的，最终上游业务获取抛出的异常处理都是FeignException处理，到时上游业务统一异常处理造成困扰，下面解决方式为：

作用：异常解析器,需要实现ErrorDecoder。作用是,当feign服务调用其他服务出现异常,收到的异常数据流处理类.

调用流程 A 调用 B ,

B抛出异常，

全局异常处理，返回json,

熔断器触发，返回feignException

经过默认的ErrorDecoder

执行fallback降级中的方法

ExceptionErrorDecoder

1
/**
2
 * @author zy
3
 * @version 1.0
4
 * @Description  繼續往上抛出自定義異常
5
 * @date 2021/4/21 16:55
6
 */
7
@Slf4j
8
@Configuration
9
public class ExceptionErrorDecoder implements ErrorDecoder {
10

11
    @Override
12
    public Exception decode(String methodKey, Response response) {
13
        try {
14
            Response.Body body = response.body();
15
            if (body != null) {
16
                String str = Util.toString(body.asReader());
17
                log.info("string={}",str);
18
                ExceptionInfo exceptionInfo = JSON.parseObject(str,ExceptionInfo.class);
19
                if(exceptionInfo.getMsg() == null){
20
                    JSONObject jsonObject = JSON.parseObject(str);
21
                    Integer code = (Integer) jsonObject.get("status");
22
                    String msg  = (String) jsonObject.get("error");
23
                    return new EpException(code,msg);
24
                }
25
                return new EpException(exceptionInfo.getCode(),exceptionInfo.getMsg());
26
            }
27
        } catch (Exception e) {
28
            e.printStackTrace();
29
        }
30
        return FeignException.errorStatus(methodKey, response);
31
    }
32
}

ExceptionInfo

1
@Data
2
public class ExceptionInfo{
3

4
   private int code;
5

6
   private String msg;
7

8
   private Object data;
9

10
}

同一个客户端client，配置多个feign#

1、开启bean重复定义

1
spring.main.allow-bean-definition-overriding=true

2、添加 qualifier 属性

新增一个@FeignClient(value = “parking”），添加 qualifier（限定）

1
@FeignClient(value = "parking",qualifier = "space")

3、导入时指定 qualifier

1
    @Qualifier("space")
2
    @Autowired
3
    private ParkingSpaceFeign spaceFeign;

Feign跨服务调用导出（下载）接口#

Feign调用#

Feign调用导出接口的方法的出参不是和提供端的方法出入参一样就可以了，一般我们的导出接口都是无返回，直接将内容输出到response中，所以我们调用导出接口的feignt方法需要使用feign提供的Response来接收响应，如下

Feign接口方法#

注意：response为feign的
1
import feign.Response

1
    /**
2
     * @Author ths
3
     * @Description 导出公司管理数据
4
     * @Date 14:10 2021/4/26
5
     * @Param [commPageDto]
6
     * @return void
7
     **/
8
    @ApiOperation("导出公司管理数据")
9
    @PostMapping( "/epParkManagementCompany/export")
10
    Response export(@RequestBody EpParkManagementCompanyPageRequest commPageDto)

生产者controller方法：#

注意：feign接口上没有HttpServletResponse，生产者有HttpServletResponse

1
    /**
2
     * @Author ths
3
     * @Description 导出公司管理数据
4
     * @Date 14:35 2021/4/27
5
     * @Param [response, commPageDto]
6
     * @return void
7
     **/
8
    @ApiOperation("导出公司管理数据")
9
    @PostMapping( "/export")
10
    public void export(@RequestBody EpParkManagementCompanyPageRequest commPageDto,HttpServletResponse response) {
11
        epParkManagementCompanyService.export(commPageDto,response);
12
    }

消费调用者#

注意：重组response

1
    @ApiOperation("导出公司管理数据")
2
    @PostMapping("/export")
3
    public void export(@RequestBody EpParkManagementCompanyPageRequest commPageDto, HttpServletResponse servletResponse) {
4
        //调用
5
        Response response = parkingFeign.export(commPageDto);
6
        //重组response
7
        Response.Body body = response.body();
8
        for (Object key : response.headers().keySet()) {
9
            List<String> kList = (List) response.headers().get(key);
10
            for (String val : kList) {
11
                servletResponse.setHeader(key.toString(), val);
12
            }
13
        }
14
        try (InputStream inputStream = body.asInputStream();
15
             OutputStream outputStream = servletResponse.getOutputStream()) {
16
                byte[] b = new byte[inputStream.available()];
17
                inputStream.read(b);
18
                outputStream.write(b);
19
                outputStream.flush();
20
        } catch (IOException e) {
21
            log.error("导出Excel失败", e);
22
        }
23
    }

流程 Feign调用其他服务的导出服务，主要流程是通过Feign的Response来接收提供端导出接口的响应，然后通过resp.body()获取响应体，将响应体通过asInputStream方法转为InputStream 输入流，最主要的过程就是将输入流的内容写入到Feign客户端的response输出流中即可

如果这篇文章对你有帮助，欢迎分享给更多人！

SpringCloud OpenFeign：声明式服务调用

https://onecodemaker.cn/posts/springcloud-02-openfeign/

作者

糖糖IT

发布于

2026-03-05

许可协议

CC BY-NC-SA 4.0

部分信息可能已经过时

SpringCloud Gateway：新一代微服务网关

SpringCloud Eureka：服务注册与发现详解