feign和openFeign区别和openFeign教程

一、Feign与OpenFeign的区别

• 1）Feign是Spring Cloud组件中一个轻量级RESTful的HTTP服务客户端，Feign内置了Ribbon，用来做客户端负载均衡，去调用服务注册中心的服务。Feign的使用方式是：使用Feign的注解定义接口，调用接口，就可以调用服务注册中心的服务。

Feign的依赖

1 
2     org.springframework.cloud
3     spring-cloud-starter-feign
4 

• 2）OpenFeign是Spring Cloud在Feign的基础上支持了SpringMVC的注解，如@RequestMapping等等。OpenFeign的@FeignClient可以解析SpringMVC的@RequestMapping注解下的接口，并通过动态代理的方式产生实现类，实现类中.

OpenFeign的依赖

1 
2     org.springframework.cloud
3     spring-cloud-starter-openfeign
4 　　

说明：
springcloud F 及F版本以上 springboot 2.0 以上基本上使用openfeign，openfeign 如果从框架结构上看就是2019年feign停更后出现版本，也可以说大多数新项目都用openfeign ，2018年以前的项目在使用feign

二、openFeign教程

Spring-Cloud-OpenFeign使用教程 - 知乎

Spring Cloud OpenFeign使用教程

Spring Cloud OpenFeign Demo

之前项目中需要在Spring Cloud中使用OpenFeign的情况，Spring Cloud的版本是目前最新的Greenwich.SR2版本，对应的Spring boot是2.1.7.RELEASE。

在网上找了很多资料，大多言之不详，并且版本也比较低，不适合我的最新版本Spring Cloud的需求。 所以决定还是自己写个教程。

本教程要解决如下几个问题：

1. 怎么配置OpenFeignServer
2. 怎么配置OpenFeignClient
3. 多个参数传递问题
4. FeignClient的日志问题
5. 多个FeignClient使用同一个name的问题

怎么配置OpenFeignServer

我们知道OpenFeign是用在Spring Cloud中的声明式的web service client。

OpenFeignServer就是一个普通的Rest服务，不同的是我们需要将他注册到eureka server上面，方便后面的OpenFeignClient调用。

启动类如下：

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

我们定义了两个Rest服务:

OrderController:

@Slf4j
@RestController
@RequestMapping(path = "/order")
public class OrderController {

    /**
     * PostMapping with @RequestBody
     * @param user
     */
    @PostMapping("doOrder")
    public void doOrder(@RequestBody User user){
        log.info("do order !!!!");
    }
}

UserController:

@RestController
@RequestMapping(path = "/user")
public class UserController {

    /**
     * GetMapping example with @RequestParam
     * @param userId
     * @return userName
     */
    @GetMapping("getUserName")
    public String getUserName(@RequestParam("userId") String userId){
        if("100".equals(userId)) {
            return "张学友";
        }else{
            return "刘德华";
        }
    }

    /**
     * GetMapping example with @RequestParam and @SpringQueryMap
     * @param userId
     * @param user
     * @return userAge
     */
    @GetMapping("getUserAge")
    public String getUserAge(@RequestParam("userId") String userId, @SpringQueryMap User user){
        if("100".equals(userId)) {
            return "20";
        }else{
            return "18";
        }
    }
}

我们将其注册到eureka上面，名字为openfeign-server

spring:
  application:
    name: openfeign-server

怎么配置OpenFeignClient

OpenFeignClient的pom依赖如下：

    org.springframework.cloud
    spring-cloud-starter-openfeign

配置OpenFeignClient只需要使用@FeignClient来注解一个interface即可，如下所示：

@FeignClient(value = "openfeign-server")
@RequestMapping(path = "/user")
public interface UserClient {

    @GetMapping("getUserName")
    public String getUserName(@RequestParam("userId") String userId);

    @GetMapping("getUserAge")
    public String getUserAge(@RequestParam("userId") String userId, @SpringQueryMap User user);
}

其中@FeignClient中的value是要调用的服务的注册名，即OpenFeignServer在eureka的注册名。

FeignClient的 Request路径，方式和参数要和被调用的Rest服务保持一致。

这样我们就可以像下面一样来调用OpenFeignClient了：

@Slf4j
@RestController
public class UserController {

    @Autowired
    private UserClient userClient;

    @GetMapping("getUserName2")
    public void getUserName(){
        log.info(userClient.getUserName("100"));
    }
}

查看FeignClient注解代码如下：

public @interface FeignClient {
    @AliasFor("name")
    String value() default "";

    String contextId() default "";

    @AliasFor("value")
    String name() default "";

    String qualifier() default "";

    String url() default "";

    boolean decode404() default false;

    Class[] configuration() default {};

    Class fallback() default void.class;

    Class fallbackFactory() default void.class;

    String path() default "";

    boolean primary() default true;
}

下面就对各个属性进行分析：

value、name
value和name的作用一样，如果没有配置url那么配置的值将作为服务名称，用于服务发现。反之只是一个名称。value和name必须配一个

contextId
我们不想将所有的调用接口都定义在一个类中，有一种解决方案就是为每个Client手动指定不同的contextId，这样就不会冲突了。

url
url用于配置指定服务的地址，相当于直接请求这个服务，不经过Ribbon的服务选择。像调试等场景可以使用。

decode404
当调用请求发生404错误时，decode404的值为true，那么会执行decoder解码，否则抛出异常。

configuration
configuration是配置Feign配置类，在配置类中可以自定义Feign的Encoder、Decoder、LogLevel、Contract等。

fallback
定义容错的处理类，也就是回退逻辑，fallback的类必须实现Feign Client的接口，无法知道熔断的异常信息。（不推荐）

fallbackFactory
也是容错的处理，可以知道熔断的异常信息。（推荐）

path
path定义当前FeignClient访问接口时的统一前缀，比如接口地址是/user/get, 如果你定义了前缀是user, 那么具体方法上的路径就只需要写/get 即可。

primary
primary对应的是@Primary注解，默认为true，官方这样设置也是有原因的。当我们的Feign实现了fallback后，也就意味着Feign Client有多个相同的Bean在Spring容器中，当我们在使用@Autowired进行注入的时候，不知道注入哪个，所以我们需要设置一个优先级高的，@Primary注解就是干这件事情的。

qualifier
qualifier对应的是@Qualifier注解，使用场景跟上面的primary关系很淡，一般场景直接@Autowired直接注入就可以了。
 

第三方调用，在项目使用openFeign：（入参可以是json对象/实体/json字符串，返回值类型对应起来即可）

package com.oceansite.system.api;


import com.alibaba.fastjson.JSONObject;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;

/**
 * @ClassName: RemoteNavigationService
 * @Description: 
 * @Author: 
 * @Date: 2022/3/29 9:36
 **/
@FeignClient(contextId = "remoteNavigationService",url = "https://xcx.apsatcom.com/OSN/api/prod",name = "navigation")  
//上面远程调用的url是写死的，可以通过增加uri入参，实现动态url，见文末
public interface RemoteNavigationService {
    /**
     *@Description: 小站列表接口
     *@Author: yangfengfan
     *@Param: [jsonObject]
     *@Return: com.oceansite.system.api.domain.Result
     *@Date: 2022/3/29 10:53
     **/
    @PostMapping(value = "/terminal/group/v1",headers = {"accept-encoding=gzip","content-type=application/json; charset=UTF-8","accept=application/json"})
    public JSONObject getTerminalGroupPage2(@RequestBody JSONObject navigationData);
    /**
     *@Description: 小站实时信息查询接口
     *@Author: yangfengfan
     *@Param: [jsonObject]
     *@Return: com.oceansite.system.api.domain.Result
     *@Date: 2022/3/29 10:53
     **/
    @PostMapping(value = "/terminal/status/v1",headers = {"accept-encoding=gzip","content-type=application/json; charset=UTF-8","accept=application/json"})
    public JSONObject getListTerminalByParm(@RequestBody JSONObject navigationData);

    /**
     *@Description: 小站数据发送接收链路接口
     *@Author: yangfengfan
     *@Param: [jsonObject]
     *@Return: com.oceansite.system.api.domain.Result
     *@Date: 2022/3/29 10:53
     **/
    @PostMapping(value = "/nms/ucp/v1",headers = {"accept-encoding=gzip","content-type=application/json; charset=UTF-8","accept=application/json"})
    public JSONObject qeryNmsUcpInfo(@RequestBody JSONObject navigationData);
}

多个参数传递问题

一般我们会使用@GetMapping和@PostMapping两种方式来调用Rest服务。

而接收的参数则会使用@RequestParam和@RequestBody来获取。

首先我们讲一下@RequestBody，@RequestBody只能用在Post请求，并且一个Post请求只能有一个@RequestBody。 @RequestBody的参数可以包括复杂类型。

然后我们讲一下@RequestParam，@RequestParam可以用在Post和Get请求中，但是要注意：@RequestParam 的参数只能是基本类型或者Enum，或者List和Map（List和Map里面也只能是基本类型）。所以@RequestParam可以和@RequestBody一起使用。

如果我们是Get请求，但是又有复合类型怎么办？ 比如我们想传递一个User对象。User对象里面只有普通的两个String属性。 这里我们可以使用@SpringQueryMap：

    @GetMapping("getUserAge")
    public String getUserAge(@RequestParam("userId") String userId, @SpringQueryMap User user);

注意：@SpringQueryMap后面的参数只能是普通的POJO，不能是复合类型，否则解析不了。如果必须使用复合类型，那么使用@RequestBody吧。

FeignClient的日志问题

OpenFeign的Logger.Level有4种级别：

• NONE 没有日志
• BASIC 请求方法，请求URL，返回Code和执行时间
• HEADERS 请求和返回的头部基本信息
• FULL 请求和返回的头部，内容，元数据

要想使用这些级别，必须将OpenFeignClient的logger设置成debug级别：

#日志配置
logging:
  level:
    com:
      flydean: debug

同时我们在代码中配置OpenFeign的日志级别：

@Configuration
public class CustFeignLogConfig {
    @Bean
    Logger.Level feignLoggerLevel() {
        return Logger.Level.FULL;
    }
}

这样我们在日志里面就可以看到DEBUG的所有HTTP请求信息。

多个FeignClient使用同一个name的问题

其实这里我们的Server定义了两个Rest服务，User和Order。

上面我们讲到了可以这样定义UserClient：

@FeignClient(value = "openfeign-server")
@RequestMapping(path = "/user")
public interface UserClient {
    ...
}

如果我们同样的这样定义OrderClient：

@FeignClient(value = "openfeign-server")
@RequestMapping(path = "/order")
public interface OrderClient {
    ...
}

运行时候就会报错。 原因是两个FeignClient使用了同一个value！

那怎么解决这个问题呢？

/**
 * 因为@FeignClient的value不能重复，所以需要在这里以自定义的方式来创建
 * @author wayne
 * @version FeignClientController,  2019/9/5 7:07 下午
 */
@Data
@Component
@Import(FeignClientsConfiguration.class)
public class FeignClientController {

    private OrderClient orderClient;
    private UserClient userClient;

    public FeignClientController(Decoder decoder, Encoder encoder, Client client, Contract contract) {
        this.orderClient = Feign.builder().client(client)
                .encoder(encoder)
                .decoder(decoder)
                .contract(contract)
                //默认是Logger.NoOpLogger
                .logger(new Slf4jLogger(OrderClient.class))
                //默认是Logger.Level.NONE
                .logLevel(Logger.Level.FULL)
                .target(OrderClient.class, "http://openfeign-server");

        this.userClient = Feign.builder().client(client)
                .encoder(encoder)
                .decoder(decoder)
                .contract(contract)
                //默认是Logger.NoOpLogger
                .logger(new Slf4jLogger(UserClient.class))
                //默认是Logger.Level.NONE
                .logLevel(Logger.Level.FULL)
                .target(UserClient.class, "http://openfeign-server");
    }
}

方法就是手动创建FeignClient, 上面的例子中，我们手动创建了OrderClient和UserClient两个FeignClient。

注意下面的代码片段，手动创建的FeignClient默认是没有logger和logLevel的。所以上面我们配置好的log信息对手动创建的FeignClient是无效的。 下面展示了如何手动添加：

//默认是Logger.NoOpLogger
                .logger(new Slf4jLogger(OrderClient.class))
                //默认是Logger.Level.NONE
                .logLevel(Logger.Level.FULL)

超时控制介绍

默认Feign客户端只等待一秒钟,但是服务霭处理需要超过1秒，导致Feign客户端不想等待了,直接返回报错。为了避免这样的情况,有时候我们需要设置Feign客户端的超时控制。
解决方法：ym|文件中开启配置，application.yml

# 设置feign客户端超时时间（OpenFeign默认支持Ribbon）
ribbon:
  # 指的是建立连接后从服务器读取到可用资源所用时间
  ReadTimeout: 5000
  # 指的是建立连接所用的时间，适用于网络状况正常的情况下，两端连接所用的时间
  ConnectTimeout: 5000

没配置上面的yml文件时，如果我们调用如下的方法会报错

 @GetMapping("/feign/timeout")
    public String paymentFeignTimeout() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return serverPort;
    }

 配置了，就会出现以下结果

如何运行

本项目的模块都是以spring boot构建的，直接在编译器中运行Main方法即可启动。

1. 启动openfeign-registry-server

openfeign-registry-server会启动eureka server,供后面的OpenFeignServer和OpenFeignClient注册。

1. 启动openfeign-server

2. 启动openfeign-client

3. 测试openFeignClient

get请求url： http://localhost:8000/getUserName1

查看日志，看看输出吧。

本项目代码地址 ：spring-cloud-openfeign-demo

更多教程请参考 flydean的博客

三、OpenFeign配置文件详解

Feign 配置文件详解_丶自定义-CSDN博客_feign 配置文件

可以在应用程序中指定 application.properties / application.properties 文件，或作为命令行开关。本附录提供了通用Spring Cloud OpenFeign属性的列表，以及对使用它们的底层类的引用。

配置项	默认值	描述
feign.client.config
feign.client.default-config	default
feign.client.default-to-properties	true
feign.compression.request.enabled	false	配置请求GZIP压缩。
feign.compression.request.mime-types	[text/xml, application/xml, application/json]	配置压缩支持的MIME TYPE
feign.compression.request.min-request-size	2048	配置压缩数据大小的下限
feign.compression.response.enabled	false	配置响应GZIP压缩。
feign.compression.response.useGzipDecoder	false	启用默认的gzip解码器。
feign.httpclient.connection-timeout	2000	连接超时时间(单位：秒)
feign.httpclient.connection-timer-repeat	3000
feign.httpclient.disable-ssl-validation	false
feign.httpclient.enabled	true	开启(true)/关闭(false) Apache HTTP请求方式
feign.httpclient.follow-redirects	true
feign.httpclient.max-connections	200	线程池最大连接数（全局）
feign.httpclient.max-connections-per-route	50	线程池最大连接数（单个HOST）
feign.httpclient.time-to-live	900	线程存活时间(单位：秒)
feign.httpclient.time-to-live-unit
feign.hystrix.enabled	false	开启(true)/关闭(false)Hystrix功能
feign.okhttp.enabled	false	开启(true)/关闭(false) OK HTTP请求方式

Feign提供了两大类配置属性来配置上述三种HTTP客户端，feign.client.*和feign.httpclient.*，前者支持按实例进行配置（注解-1），后者全局共享一套配置，包含线程池配置，但只影响HttpClient和OkHttp，不影响HttpURLConnection，具体关系见下表。

注解-1：所谓按实例进行配置，就是指每个FeignClient实例都可以通过feign.client..*来单独进行配置，注意首字母小写。而feign.client.default.*表示默认配置。

HTTP客户端	连接超时时间	请求超时时间	线程存活时间	线程池最大连接数（全局）	线程池最大连接数（单个HOST）
HttpURLConnection	feign.client.[default|].connect-timeout 默认值：10秒	feign.client.[default|].read-timeout 默认值：60秒	N/A	N/A	N/A
HttpClient	feign.httpclient.connection-timeout 默认值：2秒	默认值： -1（RequestConfig.Builder.socketTimeout）	feign.httpclient.time-to-live 默认值：900秒	feign.httpclient.max-connections 默认值：200	feign.httpclient.max-connections-per-route 默认值：50
OkHttp	feign.httpclient.connection-timeout 默认值：2秒	feign.client.[default|].read-timeout 默认值：10秒	feign.httpclient.time-to-live 默认值：900秒	feign.httpclient.max-connections 默认值：200	N/A

从上表可以看到，Feign提供了两个连接超时配置，HttpURLConnection使用feign.client.[default|].connect-timeout，而HttpClient和OkHttp则使用feign.httpclient.connection-timeout，这一点要尤其注意。

参考地址：

【Spring Cloud】详解Feign常用配置

 Spring Cloud OpenFeign

动态URL问题：

//url必须写一个默认的,是什么不重要，执行时会被替换

 @FeignClient(contextId = "remoteDataFlowService",url = "http://58.254.146.130:8989/OSN/api/test1",name = "DataFlow")
public interface RemoteDataFlowService {
    /**
     *@Description: 余额查询接口
     *@Author: yangfengfan
     *@Param: [jsonObject]
     *@Return: com.oceansite.system.api.domain.Result
     *@Date: 2022/3/29 10:53
     **/
    @PostMapping(value = "/payment/detail/v1",headers = {"accept-encoding=gzip","content-type=application/json; charset=UTF-8","accept=application/json"})
    JSONObject getBalanceInquiry(@RequestParam(value = "uri")URI uri, @RequestBody String DataFlowData);

    
-------------------------------------------------------------------------------


   @Value("${asiapacific6d.dataflow.url}")
    String url;


    @PostMapping("/payment/detail/v1")
    public JSONObject getBalanceInquiry(@RequestBody DataFlowData dataFlowData) throws URISyntaxException {
        JSONObject json = (JSONObject) JSONObject.toJSON(dataFlowData);
        System.out.println(json.toJSONString());
        return remoteDataFlowService.getBalanceInquiry(new URI(url),json.toJSONString());
    }

在入参中加入URI参数，就可以支持url可配置，调试多个环境的时候有用。

openfeign 实现动态Url - lshan - 博客园

OpenFeign中动态URl_wangdaoyin2010的博客-CSDN博客_openfeign 动态url

遇到的问题：nested exception is java.lang.IllegalStateException: RequestParam.value() was empty on parameter 0

@FeignClient注解下的类似@RequestParam注解等一定要有value属性

注意：

@FeignClient中的configuration使用拦截器，可以给微服务间的调用，增加参数或鉴权使用

@FeignClient(name = "weixinService", url = "https://api.weixin.qq.com",
        configuration = WeiXinInterceptor.class)
public interface WeiXinService {

下方的拦截器如果类上加@Configuration，那么全局生效，如果不加，则@FeignClient指定生效。

package com.byd.msp.gateway.fegin.wexin;

import feign.Client;
import feign.RequestInterceptor;
import feign.RequestTemplate;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;

/**
 * 微信接口统一鉴权
 */
@Component
public class WeiXinInterceptor implements RequestInterceptor {
    /**
     * 小程序 appId
     */
    @Value("${wechat.app_id:xxxxx}")
    private String appId;

    /**
     * 小程序 appSecret
     */
    @Value("${wechat.app_secret:xxxxxx}")
    private String secret;

    @Override
    public void apply(RequestTemplate requestTemplate) {
        requestTemplate.query("appid", appId);
        requestTemplate.query("secret", secret);
        requestTemplate.query("grant_type", "authorization_code");
    }

    @Bean
    public Client generateClient() {
        try {
            SSLContext ctx = SSLContext.getInstance("SSL");
            X509TrustManager tm = new X509TrustManager() {
                @Override
                public void checkClientTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
                }

                @Override
                public void checkServerTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
                }

                @Override
                public X509Certificate[] getAcceptedIssuers() {
                    return new X509Certificate[0];
                }
            };
            ctx.init(null, new TrustManager[]{tm}, new SecureRandom());
            return new Client.Default(ctx.getSocketFactory(), (hostname, session) -> true);
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException(e);
        } catch (KeyManagementException e) {
            throw new RuntimeException(e);
        }
    }
}