OpenFeign的介绍和使用（服务接口调用）_openfeign调用

目录

• • Feign概述:
  • • Feign是什么：
    • 如何包含使用 Feign：
    • Feign能干嘛：
    • Ribbon、Feign和OpenFeign的区别：
  • OpenFeign使用案例：
  • • 1.先准备测试用到的服务集群和Eureka集群：
    • 2.创建服务消费者模块：（空maven项目）：
    • 3.改pom:
    • 4.写yml：
    • 5.主启动类：com.fan.springcloud.OrderFeignMain80
    • 6.写service层：
    • 7. 写消费者controller：
    • 8.测试：http://localhost/consumer/payment/get/1
  • OpenFeign超时控制：
  • OpenFeign日志打印功能：

Feign概述:

使用案例可以参考：https://www.cnblogs.com/my-ordinary/p/12508997.html

Feign：假装，伪装的意思。

Feign是什么：

1. 声明式 REST 客户端：Feign

官网地址：https://spring.io/projects/spring-cloud-openfeign

官方参考文档：https://docs.spring.io/spring-cloud-openfeign/docs/current/reference/html/

Feign是一个声明式 Web 服务客户端。它使编写 Web Service客户端变得更容易。要使用 Feign 创建一个接口并对其进行注释。它具有可插入的注释支持，包括 Feign 注释和 JAX-RS 注释。Feign 还支持可插拔的编码器和解码器。Spring Cloud 对添加了对 Feign进行了封装，使其支持了Spring MVC 标准注解和支持使用HttpMessageConverters。Spring Cloud集成了Eureka, Spring Cloud CircuitBreaker，以及Spring Cloud LoadBalancer，在使用Feign时提供一个负载均衡的http客户端（即Feign可以与Eureka和Ribbon组合使用 以支持负载均衡）。

Spring Cloud OpenFeign 支持 Spring Cloud LoadBalancer 的阻塞模式可用的所有功能

如何包含使用 Feign：

注意：找到消费者微服务项目,进行编写和修改：

（1）配置pom.xml-
要将 Feign 包含在您的项目中，请使用带有 grouporg.springframework.cloud 和 artifact id的 starter spring-cloud-starter-openfeign。即：找到服务消费者项目，在pom中添加以下依赖

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

（2）然后在springboot主启动类加上注解@EnableFeignClients注解-
@EnableFeignClients申明该项目是Feign客户端，扫描对应的feign client。

@SpringBootApplication
@EnableFeignClients
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

}
1
2
3
4
5
6
7
8
9

（3）新增提供者API接口：feign简化了原先restTemplate+ribbon的远程调用,减少了代码量。达到远程调用微服务的一个service接口-
对应的接口：类似于mybatis的mapper接口

我们需要集中化管理API，就可以通过接口统一管理，需要新增商品服务的接口类ProductService，并添加@FeignClient(name=“springcloud-product-provider”)注解，其中name就是我们要访问的微服务的名称。比如getServiceInfo方法中@GetMapping(“product/provider/get/info”)和服务提供者8100的接口路径是一样的。

@Component
@FeignClient(name="springcloud-product-provider")//标注使用OpenFeign调用的springcloud-product-provider服务
public interface ProductService {

    /**
     * 查询
     *    以下方法名和参数都需要和服务提供者者保持一致，@GetMapping中的就是服务提供者对应的全路径
     * @return
     */
    @GetMapping("product/provider/get/info")
    public Result getServiceInfo();

    /**
     * 查询
     * @param id
     * @return
     */
    @GetMapping("product/provider/get/{id}")
    public Result selectById(@PathVariable("id") Long id);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

注意：vaule和name 其实是一个属性：-
鼠标点进去@FeignClient就发现他俩互相使用了别名：

(4)修改服务消费者Controller-
现在接口已经封装在了ProductService里面了，因此在消费者Controller，我们不用再通过微服务名加地址去访问了，修改后的Controller如下

@RestController
public class ProductConsumerController {

//RestTemplate 为旧的调用方式
@Resource
    RestTemplate restTemplate;

    @Resource //注入接口，可进行调用，类似于service中注入xxxMapper
    ProductService productService;

    //public static String url = "http://localhost:8100/";
    public static String url = "http://springcloud-product-provider/";

    /**
     * 查询
     * @return
     */
    @GetMapping("product/consumer/get/info")
    public Result getServiceInfo(){
        return productService.getServiceInfo();
        /*return new Result(200, "查询成功",
                restTemplate.getForObject(url+"product/provider/get/info", Result.class));*/
    }

    /**
     * 查询
     * @param id
     * @return
     */
    @GetMapping("product/consumer/get/{id}")
    public Result selectById(@PathVariable("id") Long id){
        return productService.selectById(id);
        //原先的调用方式需要拼接地址
       /* return new Result(200, "查询成功",
                restTemplate.getForObject(url+"product/provider/get/"+id, Result.class));*/
    }

}
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
38

​

（5）测试-
现在我们已经配置好了消费端通过OpenFeign调用远程接口，接下来就是重启消费端服务8200，重启后，浏览器访问消费者API

Feign能干嘛：

在Spring Cloud中使用OpenFeign，可以做到使用HTTP请求访问远程服务，就像调用本地方法一样的，开发者完全感知不到这是在调用远程方法，更感知不到在访问HTTP请求。-

Ribbon、Feign和OpenFeign的区别：

Ribbon

• Ribbon 是 Netflix开源的基于HTTP和TCP等协议负载均衡组件
• Ribbon 可以用来做客户端负载均衡，调用注册中心的服务
• Ribbon的使用需要代码里手动调用目标服务，请参考官方示例：https://github.com/Netflix/ribbon

Feign

• Feign是Spring Cloud组件中的一个轻量级RESTful的HTTP服务客户端
• Feign内置了Ribbon，用来做客户端负载均衡，去调用服务注册中心的服务。
• Feign的使用方式是：使用Feign的注解定义接口，调用这个接口，就可以调用服务注册中心的服务
• Feign支持的注解和用法请参考官方文档：https://github.com/OpenFeign/feign
• Feign本身不支持Spring MVC的注解，它有一套自己的注解

OpenFeign

• OpenFeign是Spring Cloud 在Feign的基础上支持了Spring MVC的注解，如@RequesMapping等等。
• OpenFeign的@FeignClient可以解析SpringMVC的@RequestMapping注解下的接口，并通过动态代理的方式产生实现类，实现类中做负载均衡并调用其他服务。
• Feign可以把Rest的请求进行隐藏，伪装成类似SpringMVC的Controller一样。你不用再自己拼接url，拼接参数等等操作，一切都交给Feign去做。

OpenFeign使用案例：

这里注册中心我们使用Eureka:

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

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

消费端使用Feign-
-

2.创建服务消费者模块：（空maven项目）：

服务消费者模块名称：cloud-consumer-feign-order80-

3.改pom:

 <dependencies>
        <!--注册中心放到第一个，eureka 服务,用于注册中心-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <!--客户端使用openfeign-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
        <!--web下的两个配套-->
        <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>
            <version>2.2.2.RELEASE</version>
        </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>
    </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

​

4.写yml：

server:
  port: 80

eureka:
  client:
    register-with-eureka: false #false表示不向注册中心注册自己。
    service-url: 
      defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka
1
2
3
4
5
6
7
8

5.主启动类：com.fan.springcloud.OrderFeignMain80

package com.fan.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来代替。

-
在sprigcloud包下创建 service.PaymentFeignService 接口：（和我们原先的service接口类似，但是这里不用写实现类）：

package com.fan.springcloud.service;

import com.fan.springcloud.entity.CommonResult;
import com.fan.springcloud.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;

@Component//标记成一个spring组件
@FeignClient(name = "CLOUD-PAYMENT-SERVICE") //那么name或者value的值为：服务提供方 的服务名称
//标注使用OpenFeign调用的springcloud-product-provider服务
public interface PaymentFeignService {
   //以下方法名和参数都需要和服务提供者者保持一致，@GetMapping中的就是服务提供者对应的全路径
    @GetMapping(value = "/payment/get/{id}")
    public CommonResult<Payment> getPaymentById(
            @PathVariable("id") Long id
    );
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

​

接口中的方法其实就是要调用服务的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

​

那么在openfeign的service接口中的@GetMapping的值就是/a/b。而不是直接和方法上@GetMapping相同的/b。-
如果写成/b会报feign.FeignException$NotFound: status 404 reading PaymentFeignService#getPay错误找不到相关方法。

其他需要的类：我们写一个实体类和结果类CommonResult：-
-

@FeignClient注解属性

@FeignClient(value="run-product",fallback = ProductClientServiceFallBack.class)
//@FeignClient(name="runClient",url="localhost:8001")
public interface ProductClientService {}
1
2
3

vaule和name 其实是一个属性：-
鼠标点进去@FeignClient就发现他俩互相使用了别名：

关于调用目前有两种：

1、接口提供方在注册中心。

如果服务提供方已经注册到注册中心了，那么name或者value的值为：服务提供方的服务名称。必须为所有客户端指定一个name或者value-
@FeignClient(value=“run-product”,fallback = ProductClientServiceFallBack.class)

2、单独的一个http接口，接口提供方没有注册到注册中心。-
@FeignClient(name=“runClient11111”,url=“localhost:8001”)-
此处name的值为:调用客户端的名称。

以上两种方式都能正常调用。name可以为注册中心的实例名称，加上url属性时，name的值就与注册中心实例名称无关。至于url属性和name属性的关系,如果同时指定name和url属性,则以url属性为准,name属性指定的值便当做客户端的名称

补充知识点：

1、调用时间设置。 A服务调用B的接口。 B的接口如果处理时间长，导致连接超时。这时候要设置超时时间。默认是1秒。

#设置feign客户端超时时间(OpenFeign默认支持ribbon)-
#ribbon:-
#指的是建立连接所用的时间，适用于网络状况正常的情况下,两端连接所用的时间

#ReadTimeout: 5000

#指的是建立连接后从服务器读取到可用资源所用的时间

#ConnectTimeout: 5000

2、接口日志处理

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

---

---

@FeignClient用于创建声明是API接口，该接口是RESTful风格的。Feign被设计成插拔式的，可注入其他组件和Feign一起使用。最典型的是如果Ribbon可用，Feign会和Ribbon相结合进行负载均衡。

在代码中，value()和name()一样，是被调用的服务的ServiceId。url()直接填写硬编码URL地址。decode404（）即404是被解码，还是抛异常。configuration（）指明FeignClient的配置类，默认的配置类为FeignClientsConfiguration类，在缺省情况下，这个类注入了默认的Decoder、Encoder和Constant等配置的bean。fallback()为配置熔断器的处理类。-

---

---

7. 写消费者controller：

服务消费者OrderFeignController :注入带有FeignClient注解的接口，并远程调用接口中的方法-
在controller中调用service接口方法：

package com.fan.springcloud.controller;

import com.fan.springcloud.entity.CommonResult;
import com.fan.springcloud.entity.Payment;
import com.fan.springcloud.service.PaymentFeignService;
import lombok.extern.slf4j.Slf4j;
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
@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
11
12
13
14
15
16
17
18
19
20
21
22
23

​

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

8.测试：http://localhost/consumer/payment/get/1

测试：http://localhost/consumer/payment/get/1-

总结：-

OpenFeign超时控制：

-
-
-
-
-

OpenFeign日志打印功能：

-
-
-
-

测试：-
-
后台查看日志：-