【微服务】- SpringCloud整合OpenFeign及OpenFeign简单使用_spring feign 和 openfeign

简介

位置：https://cloud.spring.io/spring-cloud-openfeign/2.2.x/reference/html/

Feign是一个声明式WebService客户端。 使用Feign能让编写Web Service客户端更加简单。

它的使用方法是定义一个服务接口然后在上面添加注解。Feign也支 持可拔插式的编码器和解码器。Spring Cloud对Feign进行了封装使其支持了Spring MVC标准注解和HttpMessageConverters。Feign可以与Eureka和Ribbon组合使用以支持负载均衡。

概述

feign是一个声明式web服务客户端，让编写web客户服务端变得非常简单。只需要创建一个接口并在接口添加注解即可。

Feign的作用

Feign旨在使编写Java Http客户端变得更容易。

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

Feign集成了Ribbon

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

Feign和OpenFeign的区别

SpringCloud集成OpenFeign

1.先准备测试用到的服务集群和Eureka集群

Eureka是服务注册中心就不多说。8081和8082服务是两个功能相同的项目，是一个服务集群，因为OpenFeign代替了Ribbon + RestTemplate的工作，故说明OpenFeign带有Ribbon的依赖可以实现负载均衡。服务集群的功能很简单，就是从数据库中根据id进行查询。

2.新建OpenFeign项目（空maven项目）

cloud-consumer-feign-order80

3.添加依赖

<dependencies>
    <dependency>
        <groupId>wf.springcloud</groupId>
        <artifactId>cloud-api-commons</artifactId>
        <version>1.0-SNAPSHOT</version>
        <scope>compile</scope>
    </dependency>
    <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.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <!--   引入eureka客户端     -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
    <!--  open feign      -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-openfeign</artifactId>
    </dependency>
</dependencies>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

4.添加配置文件（application.yml）

server:
  port: 80

eureka:
  client:
    register-with-eureka: false   #是否将自己注册到注册中心,集群必须设置为true配合ribbon
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka, http://eureka7002.com:7002/eureka
1
2
3
4
5
6
7
8

5.写主启动类

package wf.springcloud
@SpringBootApplication
@EnableFeignClients
public class OrderFeignMain80 {
    public static void main(String[] args) {
        SpringApplication.run(OrderFeignMain80.class,args);
    }
}
1
2
3
4
5
6
7
8

注意@EnableFeignClients注解不能少，这表明在该服务中使用了OpenFeign。

6.写service层

上面说过OpenFeign代替了Ribbon + RestTemplate的工作，即它还要承担RestTemplate，而在OpenFeign中的代替方案就是建一个，接口并使用注解的方式来配置它。类似于SpringBoot项目中Dao层的工作。从其他地方查询数据。不过此处项目小故用service来代替。

package wf.springcloud.service;
@FeignClient(value = "CLOUD-PAYMENT-SERVICE")
@Component
public interface PaymentFeignService {
    @GetMapping(value = "/payment/get/{id}")
    public CommonResult<Payment> getPaymentById(@PathVariable("id") Long id);
}
1
2
3
4
5
6
7

接口中的方法其实就是要调用服务的controller层的类接口的形式。下面是服务层的controller

@RestController
@Slf4j
public class PaymentController {
    @Resource
    private PaymentService paymentService;
    @Value("${server.port}")
    private String serverport;
    @GetMapping(value = "/payment/get/{id}")
    public CommonResult<Payment> getPaymentById(@PathVariable("id") Long id){
        Payment result = paymentService.getPaymentById(id);
        log.info("查询结果:" + result);
        if (result != null){
            return new CommonResult<Payment>(200,"查询成功！ port:" + serverport,result);
        }else {
            return new CommonResult<Payment>(444,"查询失败！",null);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

此处就表明了OpenFeign中的一个特性支持SpringMVC的注解。
要注意的是服务层@GetMapping(value = “/payment/get/{id}”)是controller中url的全拼，此处没在PaymentController类上没加类似@RequestMapping(value = “/xx”)。故conroller中的@GetMapping(value = “/payment/get/{id}”)与service中的相同。

如果在类中加相关mapping如

@RestController
@Slf4j
@RequestMapping(value = "/a")
public class OrderFeignController {
    @Resource
    private PaymentFeignService paymentFeignService;
    @GetMapping(value = "/b")
    public CommonResult<Payment> getPaymentById(@PathVariable("id") Long id){
        return paymentFeignService.getPaymentById(id);
    }
}
1
2
3
4
5
6
7
8
9
10
11

那么在service中的@GetMapping的值就是/a/b。而不是直接和方法上@GetMapping相同的/b。
如果写成/b回报

feign.FeignException$NotFound: status 404 reading PaymentFeignService#getPay
1

错误找不到相关方法。

7.写controller

@RestController
@Slf4j
public class OrderFeignController {
    @Resource
    private PaymentFeignService paymentFeignService;
    @GetMapping(value = "/consumer/payment/get/{id}")
    public CommonResult<Payment> getPaymentById(@PathVariable("id") Long id){
        return paymentFeignService.getPaymentById(id);
    }
}
1
2
3
4
5
6
7
8
9
10

就像普通项目中调用service就可完成需要的功能。

8.测试结果

访问http://localhost/consumer/payment/get/5

可以看到负载均衡起作用了。

9.总结

OpenFeign的超时控制

OpenFeign默认调用的服务超时时间为1s，如果超过会报错

下面是演示：

1.在8081和8082中添加一个超时的方法

@GetMapping(value = "/payment/feign/timeout")
public String paymentFeignTimeout(){
    try {
        Thread.sleep(3000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return serverport;
}
1
2
3
4
5
6
7
8
9

2.在Feign的服务中添加相关方法

在service的接口中添加

@GetMapping(value = "/payment/feign/timeout")
public String paymentFeignTimeout();
1
2

在controller中添加

@GetMapping(value = "/consumer/payment/feign/timeout")
public String paymentFeignTimeout(){
    return paymentFeignService.paymentFeignTimeout();
}
1
2
3
4

此时启动项目服务，访问http://localhost/consumer/payment/feign/timeout会出现

This application has no explicit mapping for /error, so you are seeing this as a fallback.
Fri Apr 10 22:52:28 CST 2020
There was an unexpected error (type=Internal Server Error, status=500).
Read timed out executing GET http://CLOUD-PAYMENT-SERVICE/payment/feign/timeout
feign.RetryableException: Read timed out executing GET http://CLOUD-PAYMENT-SERVICE/payment/feign/timeout
	at feign.FeignException.errorExecuting(FeignException.java:213)
	at feign.SynchronousMethodHandler.executeAndDecode(SynchronousMethodHandler.java:115)
...
1
2
3
4
5
6
7
8

超时错误。想要对Feign的超时进行控制只需要在yml文件添加相关配置即可

对feign的超时控制

在application.yml添加

server:
  port: 80

eureka:
  client:
    register-with-eureka: false   #是否将自己注册到注册中心,集群必须设置为true配合ribbon
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka, http://eureka7002.com:7002/eureka
#设置feign客户端超时时间(openFeign默认支持ribbon)
ribbon:
  #指的是建立连接所用的时间，适用于网络状况iE常的情况下两端连接所用的时间
  ReadTimeout: 5000
  #指的是建立连接后从服务器读取到可用资源所用的时间
  ConnectTimeout: 5000
1
2
3
4
5
6
7
8
9
10
11
12
13
14

启动项目会发现，超时错误消失。程序可以正常访问。

OpenFeign的日志打印功能

是什么

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

2.OpenFeign的日志级别

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

3.如何启用日志打印功能

1.添加配置类

import feign.Logger;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
 * @Description TODO
 * @Author gyhdx
 * @Date 2020/4/10 23:05
 */
@Configuration
public class FeignConfig {
    @Bean
    Logger.Level feignLoggerLevel(){
        return Logger.Level.FULL;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

注意此处的Logger要使用feign中的。
2.在yml文件中添加相关配置

logging:
  level:
    # feign日志以什么级别监控哪个接口
    wf.springcloud.service.PaymentFeignService: debug
1
2
3
4

注意添加成功后都是蓝颜色的除了debug

3.访问PaymentFeignService接口中存在的方法

配置成功