关于java:Feign远程调用

无关微服务中，服务与服务如何通信，我曾经给大家介绍了 Ribbon 近程调用的相干常识，不晓得大家有没有发现 Ribbon 的问题呢？

在 Ribbon 中，如果咱们想要发动一个调用，是这样的：

@Resource
private RestTemplate restTemplate

String result = restTemplate.getForObject("http://my-goods/goods/get", String.class);
Goods goods = JSONObject.parseObject(result, Goods.class);

这就像一个一般的 http 申请一样，须要对入参和出参进行手动解决。

打一眼看上去如同没什么问题，但认真一想就不对劲了：这个被调用的接口都是咱们本人写的，入参和出参都是确定的，甚至写被调用的接口的人都是同一个 … 有没有一种更好的形式，比方像调用本地办法一样间接调用它呢？

比方这样：

Goods goods = goodsServer.get();

这个术语叫：近程办法调用

明天的配角 Feign 就为咱们实现了这样的性能，上面有请~

官网是这样介绍的：Feign 是受 Retrofit、JAXRS-2.0 和 WebSocket 启发的 Java 到 HTTP 客户端 binder(我也不晓得这里怎么翻译)。

为什么说是 binder？在看 Feign 所实现的性能及出发点来说，Feign 自身并未实现 HTPP 客户端，而且在其余组件的客户端的下层进行了加强，咱们能够先来感受一下 Feign 所带给咱们的性能

java.net.URL
Apache HTTP
OK Http
Ribbon
Java 11 http2
….

Feign
JAX-RS
JAX-RS 2
SOAP
Spring 4
….

GSON
JAXB
Jackson
….

Hystrix
SLF4J
Mock

更多内容查看 github: https://github.com/OpenFeign/…

小伙伴能够本人轻易找个我的项目写，次要就是搞几个接口来调用

@RestController
@RequestMapping("/goods")
public class GoodsController {@GetMapping("/get-goods")
    public Goods getGoods(){return new Goods().setName("苹果")
                .setPrice(1.1)
                .setNumber(2);
    }

    @GetMapping("/list")
    public List<Goods> list(){ArrayList<Goods> goodsList = new ArrayList<>();
        Goods apple = new Goods().setName("苹果")
                .setPrice(1.1)
                .setNumber(2);
        goodsList.add(apple);
        Goods lemon = new Goods().setName("柠檬")
                .setPrice(5.1)
                .setNumber(3);
        goodsList.add(lemon);
        return goodsList;
    }

    @PostMapping("save")
    public void save(@RequestBody Goods goods){System.out.println(goods);
    }

    @DeleteMapping
    public void delete(String id){System.out.println(id);
    }
}

<dependencies>
  <dependency>
    <groupId>io.github.openfeign</groupId>
    <artifactId>feign-core</artifactId>
  </dependency>
  <!-- 用于编解码 -->
  <dependency>
    <groupId>io.github.openfeign</groupId>
    <artifactId>feign-jackson</artifactId>
  </dependency>
</dependencies>

public interface GoodsApi {@RequestLine("GET /goods/get-goods")
    Goods getGoods();

    @RequestLine("GET /goods/list")
    List<Goods> list();

    @RequestLine("POST /goods/save")
    @Headers("Content-Type: application/json")
    void save(Goods goods);

    @RequestLine("DELETE /goods?id={id}")
    @Headers("Content-Type: application/json")
    void delete(@Param("id") String id);
}

Feign 标准是什么置信小伙伴一看例子就懂了

public class FeignDemo {public static void main(String[] args) {
        // 构建 feign 接口
        GoodsApi goodsApi = Feign.builder()
                .encoder(new JacksonEncoder())
                .decoder(new JacksonDecoder())
                .target(GoodsApi.class, "http://localhost:8082");
        // 调用测试
        System.out.println(goodsApi.getGoods());
        System.out.println(goodsApi.list());
        goodsApi.save(new Goods().setName("banana"));
        goodsApi.delete("1");
    }
}

看到这里，不晓得大家有没有灵光一闪呢？

我要是把构建的代码写这样

@Bean
public GoodsApi goodsApi(){return Feign.builder()
                .encoder(new JacksonEncoder())
                .decoder(new JacksonDecoder())
                .target(GoodsApi.class, "http://localhost:8082");
}

而后应用时间接注入，woc，这不是爽翻天？

回顾 什么是 Feign章节，除了下面根本应用之外，feign 还反对 Spring 4 的标准，以及各种 http 客户端（如 okHttp)，重试超时，日志等，我给大家介绍一个比拟罕用的形式

减少依赖

<!-- spring4 标准 -->
<dependency>
  <groupId>io.github.openfeign</groupId>
  <artifactId>feign-spring4</artifactId>
  <version>10.10.1</version>
</dependency>
<!-- ribbon 客户端 -->
<dependency>
  <groupId>io.github.openfeign</groupId>
  <artifactId>feign-ribbon</artifactId>
</dependency>
<!-- okhttp 客户端 -->
<dependency>
  <groupId>io.github.openfeign</groupId>
  <artifactId>feign-okhttp</artifactId>
</dependency>
<!-- 日志 -->
<dependency>
  <groupId>io.github.openfeign</groupId>
  <artifactId>feign-slf4j</artifactId>
</dependency>
<dependency>
  <groupId>ch.qos.logback</groupId>
  <artifactId>logback-classic</artifactId>
</dependency>

编写接口

public interface Spring4GoodsApi {@GetMapping("/goods/get-goods")
    Goods getGoods();

    @GetMapping("/goods/list")
    List<Goods> list();

    @PostMapping(value = "/goods/save", consumes = MediaType.APPLICATION_JSON_VALUE)
    void save(Goods goods);

    @DeleteMapping("/goods")
    void delete(@RequestParam(value = "id") String id);
}

测试

public class Spring4FeignDemo {public static void main(String[] args) {Spring4GoodsApi goodsApi = Feign.builder()
                // 应用 spring4 标准
                .contract(new SpringContract())
                // 应用 jackson 编解码
                .encoder(new JacksonEncoder())
                .decoder(new JacksonDecoder())
                // okhttp 客户端
                .client(new OkHttpClient())
                // 申请失败重试，默认最大 5 次
                .retryer(new Retryer.Default())
                // 申请超时配置
                .options(new Request.Options(10, TimeUnit.SECONDS, 60, TimeUnit.SECONDS, true))
                // 日志配置，将在申请前后打印日志
                .logger(new Slf4jLogger())
                // 日志等级配置，BASIC: 只打印申请门路和响应状态码根本信息
                .logLevel(Logger.Level.BASIC)
                .target(Spring4GoodsApi.class, "http://localhost:8082");
        System.out.println(goodsApi.getGoods());
        System.out.println(goodsApi.list());
        goodsApi.save(new Goods().setName("banana"));
        goodsApi.delete("1");
    }
}

是个 http 客户端就会有拦截器机制，用于在申请前对立做一些操作：比方增加申请头

feign 的拦截器应用形式如下：

public class AuthFeignInterceptor implements RequestInterceptor {
    @Override
    public void apply(RequestTemplate template) {System.out.println("进入拦截器");
           HttpServletRequest request =
                ((ServletRequestAttributes) Objects.requireNonNull(RequestContextHolder.getRequestAttributes())).getRequest();
        template.header("token", request.getHeader("token"));
    }
}

实现 RequestInterceptor 即可

在 build 时退出

Feign.builder()
  .requestInterceptor(new AuthFeignInterceptor())
  .target(Spring4GoodsApi.class, "http://localhost:8082");

以上就是 Feign 的罕用形式了，学会之后，整合到 Spring Cloud 也是手到擒来。

官网文档：https://docs.spring.io/spring…

该整合样例为订单服务调用商品服务

间接三板斧走起

在 order-server 中引入依赖

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

在 Application 类中加上注解EnableFeignClients

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

任何一个配置类都能够，然而举荐在启动类上加，因为注解默认扫描该注解类门路下的所有包，而后启动类又是在最顶端的，所以这样就能够扫描到所有的包了。

当然，你也能够间接扫描某个包，毕竟个别 feign 接口都放在一起

见配置章节

三板斧完结，开始编写样例

@FeignClient(name = "my-goods", path = "/goods", contextId = "goods")
public interface GoodsApi {@GetMapping("/get-goods")
    Goods getGoods();

    /**
     * get 形式传加入上需 @SpringQueryMap 注解
     */
    @GetMapping("/goods")
    Goods getGoods(@SpringQueryMap Goods goods);

    @GetMapping("/list")
    List<Goods> list();

    @PostMapping(value = "/save")
    void save(Goods goods);

    @DeleteMapping
    void delete(String id);
}

FeignClient:

name: 调用的服务名称

path: 门路前缀，该类下的所有接口都会继承该门路

contextId: 用于辨别不同的 feign 接口，因为一般来说一个服务不止一个 feign 接口，比方还有个 GoodsDetailApi(商品详情), 然而他们的 name 属性是雷同的，都是商品服务，所有须要一个 contextId 来辨别不同的业务场景

其余的与罕用形式雷同

@RestController
@RequestMapping("/order")
public class OrderController {
    @Resource
    private GoodsApi goodsApi;

    @GetMapping("/get-goods")
    public Goods getGoods(){return goodsApi.getGoods();
    }
}

在罕用形式中，咱们构建一个 feign 接口的各种属性，是通过硬编码实现的，整合到 spring 之后，能够通过配置的形式实现了，更加的灵便。

feign:
  client:
    config:
      # 全局配置, 配置类外面的属性名叫 defaultConfig, 值却是 default, 留神不要搞错
      default:
        loggerLevel: FULL
      # 独自服务配置 对应的是 contextId 优先级更高
      goods:
        loggerLevel: BASIC

全局配置这里特地坑，不看源码基本不晓得怎么配，小伙伴肯定要留神

feign 默认应用的 HttpURLConnection 作为客户端，小伙伴也能够替换成其余的客户端

前言：所有的客户端都为 Client 接口的实现类，想要晓得是否替换胜利只需在对应的实现类中打个断点

引入依赖

<dependency>
  <groupId>org.apache.httpcomponents</groupId>
  <artifactId>httpclient</artifactId>
</dependency>
<dependency>
  <groupId>io.github.openfeign</groupId>
  <artifactId>feign-httpclient</artifactId>
  <version>10.10.1</version>
</dependency>

这样就能够了，不必批改任何配置，这是因为当服务中蕴含 ApacheHttpClient 的 class 时，httpClient 的 feign 主动配置类就会失效，并且比默认的 HttpURLConnection 主动配置类优先级更高。此时服务就将注入 HttpClient 作为客户端。

源码如下：

@Import 导入的程序是 HttpClient, OkHttp, Default(HttpURLConnection)

该配置类的失效条件就是存在 ApacheHttpClient 类，而 feign.httpclient.enabled 配置默认不配也是失效。

引入依赖

<dependency>
  <groupId>io.github.openfeign</groupId>
  <artifactId>feign-okhttp</artifactId>
</dependency>

因为咱们在上一步引入了 httpclient 依赖，而 httpclient 的优先级比 okhttp 高，并且是默认失效，所以想要 okhttp 失效有两种形式：

删除掉 httpclient 的依赖
显示敞开 httpclient

这里我应用第二种形式

feign:
  # 将 httpclient 敞开
  httpclient:
    enabled: false
  # 将 okhttp 开启
  okhttp:
    enabled: true

有时当申请数据过大时，进行压缩数据能够无效的进步申请性能，feign 也提供这样的配置形式

留神：压缩只在非 okhttp 客户端时失效

feign:
  httpclient:
    enabled: true
  # 配置压缩
  compression:
    request:
      enabled: true
      # 压缩的类型，默认就是这些
      mime-types: text/xml, application/xml, application/json
      # 压缩的字节最小阈值，超过该大小才进行压缩，默认 1024
      min-request-size: 10

这里我应用 httpclient，不写也能够，我只是为了让大家晓得我没用 okhttp

互联网利用无奈解决的问题之一：网络分区。当被服务提供者呈现这种状况，始终无奈响应状况，咱们也不可能让服务消费者始终傻傻的等着，所以咱们能够给服务配置一个超时工夫，超过肯定的工夫被调用的服务未响应，就把申请掐断。

feign 的配置：

feign:
  client:
    config:
      # 全局配置
      default:
        # 连贯超时工夫 单位毫秒  默认 10 秒
        connectTimeout: 1000
        # 申请超时工夫 单位毫秒  默认 60 秒
        readTimeout: 5000

互联网利用无奈解决的问题之二：网络抖动。当经验这种状况时，咱们只能让服务进行重试。

feign 配置：

feign:
  client:
    config:
      # 全局配置
      default:
        # 重试 默认重试 5 次
        retryer: feign.Retryer.Default

拦截器与罕用形式雷同，实现 RequestInterceptor 接口即可

@Component
public class AuthFeignInterceptor implements RequestInterceptor {
    @Override
    public void apply(RequestTemplate template) {System.out.println("进入拦截器");
           HttpServletRequest request =
                ((ServletRequestAttributes) Objects.requireNonNull(RequestContextHolder.getRequestAttributes())).getRequest();
        template.header("token", request.getHeader("token"));
    }
}

加上 @Component 注解放到 spring 容器中，服务启动时会主动退出到 feign 的拦截器链

也能够应用配置的形式

feign:
  client:
    config:
      # 全局配置
      default:
        requestInterceptors:
          - com.my.micro.service.order.interceptor.AuthFeignInterceptor

本篇具体介绍了一种近程办法调用形式：Feign，当初，带大家来简略的回顾一下。

什么是 Feign？

一种近程办法调用客户端，整合了 ribbon,httpclient, okhttp, 反对各种各样的标准，如 Spring4

Feign 的根本应用形式？

编辑接口，加上 Feign 反对的标准注解，应用 Feign.Builder 构建出代理类，发动调用。

如何整合 SpringCloud？

引入依赖，加上 @EnableFeignClients 注解，依据需要减少配置

本篇内容根本涵盖了 Feign 的罕用形式，心愿大家有所播种，咱们下期再见~

gittee: https://gitee.com/lzj960515/m…

集体博客空间：https://zijiancode.cn/archive…

看完之后想必有所播种吧~ 想要理解更多精彩内容，欢送关注公众号：程序员阿鉴，阿鉴在公众号欢送你的到来~

关于java:Feign远程调用

Ribbon 的问题

什么是 Feign

客户端

标准

编解码

其余

根本应用

1. 在商品服务中编写 crud

2. 建设一个 demo，引入依赖

3. 编写 feign 标准的接口

4. 测试

灵光一闪

比拟罕用的应用形式

拦截器

整合 Spring Cloud

1. 退出依赖

2. 减少注解

3. 编写配置

4. 编写样例

5. 测试

配置

日志

客户端

应用 httpclient

应用 OkHttp

GZIP 压缩

容错重试

拦截器

小结