04SpringCloud-Feign、Gateway

最新推荐文章于 2024-01-16 16:26:44 发布

ZuckD

最新推荐文章于 2024-01-16 16:26:44 发布

阅读量1k

点赞数 2

本文链接：https://blog.csdn.net/weixin_45817392/article/details/121344215

版权

1.http客户端Feign

1.1 基于Feign远程调用

RestTemplate方式调用存在的问题

先来看我们以前利用RestTemplate发起远程调用的代码:

存在下面的问题:

代码可读性差，编程体验不统一
参数复杂URL难以维护

Feign的介绍

Feign是一个声明式的http客户端，官方地址: https://github.com/OpenFeign/feign

其作用就是帮助我们优雅的实现http请求的发送，解决上面提到的问题。

什么叫声明式？之前学习事务就解除过，早期是手动开启事务，提交事务。后来有了Spring，Spring的声明式事务只需要你简单的配置文件里告诉Spring，我要对谁加事务，把规则定义好以后所有的事情都由Spring帮你做。

声明式HTTP客户端也是一样。你需要发HTTP请求，发起来麻烦，你把发请求所需要的信息声明出来，剩下的事情交给Feign帮你来做。

使用步骤：

1.引入依赖

orderservice / pom.xml

<!--feign客户端依赖-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

2.在order-service的启动类添加注解开启Feign功能：@EnableFeignClients

@EnableFeignClients
public class OrderApplication {
...
}

3.编写Feign客户端

package cn.itcast.order.clients;

import cn.itcast.order.pojo.User;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

@FeignClient("userservice")
public interface UserClient {

    @GetMapping("/user/{id}")
    User findById(@PathVariable("id") Long Id);
}

4.修改OrderService

这是之前的代码

//注入RestTemplate
    @Autowired
    private RestTemplate restTemplate;

    public Order queryOrderById(Long orderId) {
        // 1.查询订单
        Order order = orderMapper.findById(orderId);
        // 2.利用RestTemplate发起Http请求，查询用户
        // 2.1 url路径
        String url = "http://userservice/user/"+order.getUserId();
        // 2.2 发送http请求，实现远程调用
        User user = restTemplate.getForObject(url, User.class);
        // 3.封装User到Order
        order.setUser(user);
        // 4.返回
        return order;
    }

利用Feign的代码

@Autowired
private UserClient userClient;

public Order queryOrderById(Long orderId) {
    // 1.查询订单
    Order order = orderMapper.findById(orderId);
    // 2. 用Feign来远程调用
    User user = userClient.findById(order.getUserId());
    // 3.封装User到Order
    order.setUser(user);
    // 4.返回
    return order;
}

启动Order-service ，发送请求。

发现8081和8082都被访问到了，说明我们不仅仅实现了远程调用。Feign也提供了的负载均衡。Feign内部集成了负载均衡（也就是集成了ribbon，自动实现了负载均衡）。

1.2 自定义配置

1.2.1 修改日志级别

feign:
  client:
    config:
      default:
        loggerLevel: FULL # 日志级别

default 表示是全局配置，如果写服务名称，是针对某个微服务

#Feign
feign:
  client:
    config:
      userservice:
        loggerLevel: FULL # 日志级别

修改日志的方式二：

java代码方式

package cn.itcast.order.config;

import feign.Logger;
import org.springframework.context.annotation.Bean;

/**
 * 配置Feign日志FeignClientConfiguration
 * @author:whd
 * @createTime: 2021/11/15
 */
public class FeignClientConfiguration {
    @Bean
    public Logger.Level feignLogLevel(){
        return Logger.Level.BASIC;
    }
}

修改启动类

1.全局配置@EnableFeignClients配置在启动类上

@EnableFeignClients(defaultConfiguration = FeignClientConfiguration.class)
public class OrderApplication {
    ...
}

2.局部配置@FeignClient配置在Feign客户端上

@FeignClient(value = "userservice",configuration = FeignClientConfiguration.class)
public interface UserClient {

    @GetMapping("/user/{id}")
    User findById(@PathVariable("id") Long Id);
}

1.3 性能优化

推荐使用第二种、第三种

因此优化Feign的性能主要包括:
①使用连接池代替默认的URLConnection
②日志级别，最好用basic或none

1.打开order-service/pom.xml

<!--引入HttpClient依赖-->
<dependency>
    <groupId>io.github.openfeign</groupId>
    <artifactId>feign-httpclient</artifactId>
</dependency>

2.order-service/application.yml

feign:
  httpclient:
    enabled: true #支持httpClient的开关
    max-connections: 200 #最大连接数
    max-connections-per-route: 50 #单个路径的最大连接数

优化就搞定了，接下来总结以下。

Feign的优化:

日志级别尽量用basic
使用HttpClient或OKHttp代替URLConnection
①引入feign-httpClient依赖
②配置文件开启httpClient功能,设置连接池参数

1.4 最佳实践分析

1.4.1 方案一

UserClient接口里声明的方法和UserController里的方法实际上除了函数名其他必须是一样的，那么可以考虑将他们抽取成一个父接口，让他们一个基础一个实现就行。不过官方是不推荐这种方式的。

It is generally not advisable to share an interface between a server and a client. It introduces tight coupling, and also actually doesn’t work with Spring MVC in its current form (method parameter mapping is not inherited).
在服务器和客户端之间共享接口通常是不可取的。它引入了紧密耦合，以及实际上，SpringMVC的当前形式并不适用(方法参数映射不是继承的)。

方式二：

既然你order服务，pay服务都要调用我user服务，那我user服务可以独立出一个模块，用于书写公共的UserClient,User类，配置类等。你用，只需要引入依赖然后调用即可。

但仍然存在弊端，你只需要UserClient但却引入了大量的东西。是不是有点浪费。

所以企业开发没有最佳的方案，根据你的需求去选择不同的方案

Feign的最佳实践:
①让controller和FeignClient继承同一接口
②将FeignClient、POjO、Feign的默认配置都定义到一个项目中供所有消费者使用

1.5 实现最佳实践

抽取FeignClient

实现最佳实践方式二的步骤如下:

首先创建一个module,命名为feign-api, 然后引入feign的starter依赖
将order-service中编写的UserClient、User、DefaultFeignConfiguration都复制到feign-api项目中
在order-service中引入feign-api的依赖
修改order-service中的所有与上述三个组件有关的import部分，改成导入feign-api中的包
重启测试

1.创module引依赖

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

2.移动

将order-service下的clients和config都移到feign-api模块下。

同时将order-service下的pojo的User复制过来

然后feign的api就准备好了

然后将Order-service的clients和config都删掉

然后在Order-service的applicaiton.yml进行引入统一feign的api

<!--引入自己写的feign-api-->
<dependency>
    <groupId>cn.itcast.demo</groupId>
    <artifactId>feign-api</artifactId>
    <version>1.0</version>
</dependency>

修改Order、OrderService、启动类OrderApplication里找不到包的User和UserClient

这里启动会报错，原因是找不到UserClient

3.一个问题

当定义的FeignClient不在SpringBootApplication的扫描包范围时,这些FeignClient无法使用。有两种方式解决:

方式- -:指定FeignClient所在包
@EnableFeignClients(basePackages = "cn.itcast.feign.clients")
方式二:指定FeignClient字节码
@EnabLeFeignCLients(clients = {UserClient.class})

推荐第二种方式，用哪个就指定哪个

运行，发送请求，没问题。

2.Gateway网关

2.1 网关作用介绍

网关功能

身份认证和权限校验
服务路由、负载均衡
请求限流

对整个微服务的保护

SpringCloud中网关实现

gateway
zuul

Zuul是基于Servlet的实现，属于阻塞式编程。而SpringCloudGateway则是基于Spring5中提供的WebFlux。属于响应式编程的实现，具备更好的性能。

所以基本都会使用gateway作为网关

2.2快速入门

搭建网关服务的步骤：

1.创建

创建新module（gateway)，引入SpringCloudGateway的依赖和nacos的服务发现依赖: .

<!--nacos服务发现依赖-->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

<!--网关依赖-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>

2.搭建

搭建网关，创建Springboot服务

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

3.配置

编写网关的application.yml

server:
  port: 10010
spring:
  application:
    name: gateway

  cloud:
    nacos:
      server-addr: localhost:8848 #nacos地址
    gateway:
      routes:
        - id: user-service #路由表示，必须唯一
          uri: lb://userservice #路由的目标地址
          predicates: #路由断言，判断请求是否符合规则
            - Path=/user/** #路径断言，判断是否是以/user开头
        - id: order-service
          uri: lb://orderservice
          predicates:
            - Path=/order/**

4.启动

启动网关，访问http://localhost:10010/order/101，成功，order和user服务都能访问到！

步骤：

5.总结

总结：

网关搭建步骤：

1.网关搭建步骤:

创建项目，引入nacos服务发现和gateway依赖

配置application.yml,包括服务基本信息、nacos地址、路由

2.路由配置包括:

路由id: 路由的唯一标示
路由目标(uri) : 路由的目标地址，http代表固定地址, lb代表根据服务名负载均衡
路由断言(predicates) : 路由断言，判断请求是否符合要求，符合则转发到路由目的地
路由过滤器(filters) :对请求或响应做处理

2.3 路由断言工厂

我们在配置文件中写的断言规则只是字符串，这些字符串会被Predicate Factory读取并处理,转变为路由判断的条件

例如Path=/user/**是按照路径匹配，这个规则是org.springframework.cloud.gateway.handler.predicate.PathRoutePredicateFactory类来处理的

像这样的断言工厂在SpringCloudGateway还有十几个

更多配置请参考官网

spring官网-Route Predicate Factories

修改进行如下配置后，测试After的使用，这里是2031年以后，明显不符合

gateway:
  routes:
    - id: user-service #路由表示，必须唯一
      uri: lb://userservice #路由的目标地址
      predicates: #路由断言，判断请求是否符合规则
        - Path=/user/** #路径断言，判断是否是以/user开头
    - id: order-service
      uri: lb://orderservice
      predicates:
        - Path=/order/**
        - After=2031-01-20T17:42:47.789-07:00[Asia/Shanghai]

测试完毕。路由不符合规则。

这11种无需记住，根据需求，照着官网例子抄即可。

PredicateFactory 的作用是什么？

读取用户配置的断言规则，然后把它解析成对应的判断条件，将来用户请求进来了做判断。

2.4 路由的过滤器配置

GatewayFilter是网关中提供的一种过滤器，可以对进入网关的请求和微服务返回的响应做处理

Spring提供的过滤器工厂GatewayFilterFactory

Spring提供了31种不同的路由过滤器工厂。

Spring官网-路由过滤器工厂30多个

1.配置

网关配置(让访问user路径的请求，请求头都加上这个字符串)

filters:
	- AddRequestHeader=Truth,wowowowowoo!!!!

server:
  port: 10010
spring:
  application:
    name: gateway

  cloud:
    nacos:
      server-addr: localhost:8848 #nacos地址
    gateway:
      routes:
        - id: user-service #路由表示，必须唯一
          uri: lb://userservice #路由的目标地址
          predicates: #路由断言，判断请求是否符合规则
            - Path=/user/** #路径断言，判断是否是以/user开头
          filters:
            - AddRequestHeader=Truth,wowowowowoo!!!!
        - id: order-service
          uri: lb://orderservice
          predicates:
            - Path=/order/**
            - After=2031-01-20T17:42:47.789-07:00[Asia/Shanghai]

2.请求修改

修改userController，以便能够观察到请求头的变化。其中@RequestHeader用于接收请求头信息，其中required = false表示你可以有请求头，也可以没有。

/**
 * 路径： /user/110
 *
 * @param id 用户id
 * @return 用户
 */
@GetMapping("/{id}")
public User queryById(@PathVariable("id") Long id,
                      @RequestHeader(value = "Truth",required = false)String truth) {
    System.out.print("*********\nTruth:"+truth+"\n************");

    return userService.queryById(id);
}

3.默认过滤器

如果我想给所有的服务都加上这个请求头应该如何加？

default-filters配置

  cloud:
    nacos:
      server-addr: localhost:8848 #nacos地址
    gateway:
     ...
      default-filters:
        - AddRequestHeader=Truth,wowowowowoo!!!!

重启网关，访问请求，观察，成功！

总结：

过滤器的作用是什么?
①对路由的请求或响应做加工处理，比如添加请求头
②配置在路由下的过滤器只对当前路由的请求生效

defaultFilters的作用是什么?
①对所有路由都生效的过滤器

2.5 全局过滤器

全局过滤器GlobalFilter

全局过滤器的作用也是处理一切进入网关的请求和微服务响应，与GatewayFilter的作用一样。

区别在于GatewayFilter通过配置定义，处理逻辑是固定的。而GlobalFilter的逻辑需要自己写代码实现。

定义方式是实现GlobalFilter接口。

案例

2.5.1 定义过滤器的优先级

方式一：注解设置

@Order(0)用于定义该类，它的优先级，值越小，优先级越高。（包含负数）

方式二：实现Ordered接口，重新getOrder方法，返回优先级

//@Order(-1)
@Component
public class AuthorizeFilter implements GlobalFilter , Ordered {

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
       ....
    }

    @Override
    public int getOrder() {
        return -1;
    }
}

访问

访问地址	结果
http://localhost:10010/user/1	401
http://localhost:10010/user/1?authorization=admin	访问成功

自定义过滤器，实现了简单的登录逻辑。【过滤器一定要有顺序！！！！】

1.全局过滤器的作用是什么?
对所有路由都生效的过滤器，并且可以自定义处理逻辑
2.实现全局过滤器的步骤?
①实现G{obalFilter接口
②添加@Order注解或实现Ordered接口
③编写处理逻辑

2.6 过滤器链执行顺序

请求进入网关会碰到三类过滤器:当前路由的过滤器、DefaultFilter、 GlobalFilter

请求路由后，会将当前路由过滤器和DefaultFilter. GlobalFilter, 合并到一个过滤器链(集合) 中，排序后依次执行每个过滤器。

路由过滤器和Default过滤器是同一类，都叫GatewayFilter

GatewayFilterAdapter，适配器类里实现了GatewayFilter接口

内部接收private final GLobaLFilterI delegate;

【所以它等于是把GlobalFilter做了一个适配变成了GatewayFilter去用。】

所以可以认为网关中所有过滤器都是GatewayFilter

每一个过滤器都必须指定一个int类型的order值， order值越小，优先级越高，执行顺序越靠前。

GlobalFilter通过实现Ordered接口，或者添加@Order注解来指定order值，由我们自己指定

路由过滤器和defaultFilter的order由Spring指定，默认是按照声明顺序从1递增。

当过滤器的order值一样时，会按照defaultFilter > 路由过滤器 > GlobalFilter的顺序执行。

分析来自源码：

org. springframework. cloud. gateway . route . RouteDefinitionRouteLocator#getFilters()方法是先加载defaultFilters,然后再加载某个route的filters,然后合并。

org. springframework. cloud. gateway . handLer . FilteringWebHandLer#handLe()方法会加载全局过滤器，与前面的过滤器合并后根据order排序,组织过滤器链

总结：

路由过滤器、defaultFilter、全局过滤器的执行顺序?
①order值越小，优先级越高
②当order值一样时，顺序是defaultFilter最先，然后是局部的路由过滤器，最后是全局过滤器

2.7 网关的cors跨域配置

2.7.1 跨域问题处理

跨域:域名不一致就是跨域，主要包括:

域名不同: www.taobao.com 和www.taobao.org和www.jd.com和miaosha.jd.com

域名相同，端口不同: localhost:8080和localhost:8081

跨域问题: 浏览器禁止请求的发起者与服务端发生跨域ajax请求，请求被浏览器拦截的问题

解决方案：CORS

网关已经帮我们做好了CORS底层的逻辑，我们只需要配置即可

2.7.2 测试

打开课前资料

用VSCODE启动一个本地服务器去访问

报了这个问题

我这里是用http://localhost:5500访问的，你修改成自己对应打开的IP与端口即可

spring:
  cloud:
    gateway:
      globalcors: # 全局的跨域处理
        add-to-simple-url-handler-mapping: true # 解决options请求被拦截问题
        corsConfigurations:
          '[/**]':
            allowedOrigins: # 允许哪些网站的跨域请求
              - "http://localhost:5500"
              - "http://www.leyou.com"
            allowedMethods: # 允许的跨域ajax的请求方式
              - "GET"
              - "POST"
              - "DELETE"
              - "PUT"
              - "OPTIONS"
            allowedHeaders: "*" # 允许在请求中携带的头信息
            allowCredentials: true # 是否允许携带cookie
            maxAge: 360000 # 这次跨域检测的有效期