springcloud-alibaba （04）GatewayFilter 自定义全局过滤器-认证和授权

GatewayFilter 自定义全局过滤器

内置的过滤器已经可以完成大部分的功能，但是对于企业开发的一些业务功能处理，还是需要我们自己编写过滤器来实现的，那么我们一起通过代码的形式自定义一个过滤器，去完成统一的权限校验。
开发中的鉴权逻辑：

• 当客户端第一次请求服务时，服务端对用户进行信息认证（登录）
• 认证通过，将用户信息进行加密形成token，返回给客户端，作为登录凭证
• 以后每次请求，客户端都携带认证的token
• 服务端对token进行解密，判断是否有效。

如上图，对于验证用户是否已经登录鉴权的过程可以在网关统一检验。
检验的标准就是请求中是否携带token凭证以及token的正确性。

01. token验证

1.1 导入依赖

在gateway中添加以下依赖

<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-loadbalancer</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- 使用redis工具类需要的依赖Log4j2 -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
</dependency>
<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-core</artifactId>
    <version>1.7.0</version>
</dependency>

1.2 配置类

server:
  port: 7003
spring:
  application:
    name: gateway-server
  cloud:
    nacos:
      discovery:
        server-addr: 192.168.157.129:8848
    gateway:
      discovery:
        locator:
          enabled: true # 让gateway可以发现nacos中的微服务
  redis:
    host: localhost
    port: 6379

1.3 添加注解

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

1.4 创建RedisTemplate Bean

@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory redisConnectionFactory){
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
        // key采用String的序列化方式
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        return redisTemplate;
    }
}

1.5 添加redis工具类

redis工具类（springboot）

1.6 编写过滤器

@Component
public class TokenFilter implements GlobalFilter, Ordered {

    @Autowired
    private RedisUtil redisUtils;


    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        //1、获取请求对象  ServerHttpRequest
        ServerHttpRequest request = exchange.getRequest();
        //2、获取请求的资源路径
        String path = request.getURI().getPath();

        //3、判断当前路径是否是不需要登录的资源路径—不需要则放过请求直接去执行目标接口
        //                                  —需要登录则如下判断token
        if(!"/user-server/user/login".equals(path) && !("/user-server/user/regist".equals(path))){
            //4、获取到请求头中的token
            List<String> tokens = request.getHeaders().get("token");
            String token = (tokens!=null&&tokens.size()>0)?tokens.get(0):null;
            //5、获取到请求头中的uid
            List<String> uids = request.getHeaders().get("uid");
            String uid = (uids!=null&&uids.size()>0)?uids.get(0):null;
            if(token!=null && uid!=null){
                //6、获取redis中的token
                String redis_token = String.valueOf(redisUtils.get("TOKEN_"+uid));
                //7、验证token是否有效
                if(redis_token==null|| "".equals(redis_token) || !redis_token.equals(token)){
                    //8、无效则返回错误相应
                    return onFailure(exchange.getResponse(),"token失效Q");
                }

            }else{
                //6、没有携带token返回错误相应
                return onFailure(exchange.getResponse(),"未登录，请先登录！");
            }
        }
        //去找执行目标方法
        return chain.filter(exchange);
    }

    @Override
    public int getOrder() {
        return 0;
    }

    public Mono<Void> onFailure(ServerHttpResponse response, String mes){
        JsonObject message = new JsonObject();
        message.addProperty("success", false);
        message.addProperty("code", 403);
        message.addProperty("data", mes);
        byte[] bits = message.toString().getBytes(StandardCharsets.UTF_8);
        DataBuffer buffer = response.bufferFactory().wrap(bits);
        //response.setStatusCode(HttpStatus.UNAUTHORIZED);
        //指定编码，否则在浏览器中会中文乱码
        response.getHeaders().add("Content-Type", "application/json;charset=UTF-8");
        return response.writeWith(Mono.just(buffer));
    }
}

上面这段代码是一个基于Spring Cloud Gateway的过滤器，主要用于验证请求是否携带有效的token和uid，如果没有或者token无效，则返回错误响应。大体思路如下：

1.获取请求对象ServerHttpRequest；

2.获取请求的资源路径；

3.判断当前路径是否是不需要登录的资源路径，如果需要，则通过；否则，继续进行验证流程；

4.获取到请求头中的token；

5.获取到请求头中的uid；

6.获取redis中的token；

7.验证token是否有效；

8.无效则返回错误相应。

如果你需要使用这段代码，需要添加相关的Spring Cloud Gateway和Redis依赖，以及配置相关的RedisUtil类。同时，您需要根据自己的业务逻辑修改一些代码细节。

1.7 redis添加数据

1.8 项目结构

1.9 测试过滤器

根据微服务的名称从Nacos服务注册中心中获取对应的服务实例

02. 鉴权

2.1 mysql 表

mysql数据库表

DROP TABLE IF EXISTS `res`;
CREATE TABLE `res`  (
  `id` int NOT NULL AUTO_INCREMENT,
  `res_name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 3 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;

INSERT INTO `res` VALUES (1, '/user-server/user/get1');
INSERT INTO `res` VALUES (2, '/user-server/user/get2');

DROP TABLE IF EXISTS `user`;
CREATE TABLE `user`  (
  `id` int NOT NULL AUTO_INCREMENT COMMENT '编号',
  `name` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '姓名',
  `age` int NULL DEFAULT NULL COMMENT '年龄',
  `deleted` int(1) UNSIGNED ZEROFILL NULL DEFAULT 0 COMMENT '0正常1删除',
  `updateTame` datetime NULL DEFAULT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 6 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci COMMENT = '用户表' ROW_FORMAT = Dynamic;

INSERT INTO `user` VALUES (1, 'bilal', 20, 0, '2023-04-13 15:07:47');
INSERT INTO `user` VALUES (2, 'name2', 23, 0, '2023-04-20 15:07:51');
INSERT INTO `user` VALUES (3, 'name3', 21, 0, '2023-04-01 15:08:02');

DROP TABLE IF EXISTS `user_res`;
CREATE TABLE `user_res`  (
  `id` int NOT NULL AUTO_INCREMENT,
  `u_id` int NULL DEFAULT NULL,
  `res_id` int NULL DEFAULT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 4 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;

INSERT INTO `user_res` VALUES (1, 1, 1);
INSERT INTO `user_res` VALUES (2, 1, 2);

这是一个建表和插入数据的 SQL 脚本，涉及了三个表：res，user，user_res。其中，res 表存储了资源的名称和 ID，user 表存储了用户的信息，user_res 表存储了用户和资源的关联关系。

sql语句:

SELECT res.res_name as resName FROM user
    JOIN user_res ON user.id=user_res.u_id
    JOIN res ON user_res.res_id=res.id
    WHERE user.id=1

这是一个基于给定的 user ID，查询该用户所拥有的所有资源名称的 SQL 语句。具体来说，它通过连接 user 表、user_res 表和 res 表三个表，筛选出该用户所拥有的资源 ID，然后再通过连接 res 表，获取每个资源 ID 对应的资源名称。最后通过 WHERE 条件语句限定了 user.id 的值为 1，也就是查询用户 ID 为 1 的用户所拥有的资源名称。

2.2 查看权限的接口

user-server 接口

@GetMapping("/selectResByUid")
public List<String> selectResByUid(@RequestParam("id") Integer id) {
    return userService.selectResByUid(id);
}

这段代码是一个基于用户 ID 查询该用户所拥有的所有资源名称的 API 接口。该接口接受一个参数 id 表示用户 ID，然后调用 userService 的 selectResByUid 方法来查询该用户所拥有的所有资源名称并返回结果。在这里假设 userService 是一个用于处理用户相关逻辑的服务类。

2.3 添加依赖

在网管中引入以下依赖：

<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-openfeign</artifactId>
    </dependency>
    <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-loadbalancer</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-gateway</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <!-- 使用redis工具类需要的依赖Log4j2 -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>
    <dependency>
        <groupId>io.micrometer</groupId>
        <artifactId>micrometer-core</artifactId>
        <version>1.7.0</version>
    </dependency>
</dependencies>

3.4 添加注解

@SpringBootApplication
@EnableDiscoveryClient
@EnableFeignClients("com.buba.feign")//开启Fegin
public class GatewayApplication {
    public static void main(String[] args) {
        SpringApplication.run(GatewayApplication.class, args);
        System.out.println("run");
    }
}

2.5 创建feign接口

@FeignClient(name = "user-server",path = "/user")//声明调用的提供者的name
public interface UserFeign {
    @GetMapping("/selectResByUid")
    List<String> selectResByUid(@RequestParam("id") Integer id);
}

这段代码定义了一个名为 UserFeign 的 Feign 客户端接口，用于调用名为 user-server 的服务提供者的 /user/selectResByUid 接口。其中 @FeignClient 注解声明了声明调用的服务提供者的名字为 user-server，路径为 /user。在接口中定义了一个 selectResByUid 方法，使用 @GetMapping 注解标明使用 GET 请求方式，并且传入一个 id 参数。该接口将在其他类中注入并调用。

2.6 编写过滤器

package com.buba.filter;

import com.alibaba.nacos.shaded.com.google.gson.JsonObject;
import com.buba.feign.UserFeign;
import com.buba.utils.RedisUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.context.annotation.Lazy;
import org.springframework.core.Ordered;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

@Component
public class TokenFilter2 implements GlobalFilter, Ordered {

    @Autowired
    private RedisUtil redisUtils;

    @Lazy
    @Autowired
    UserFeign userFeign;


    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        //1、获取请求对象  ServerHttpRequest
        ServerHttpRequest request = exchange.getRequest();
        //2、获取请求的资源路径
        String path = request.getURI().getPath();

        //5、获取到请求头中的uid
        List<String> uids = request.getHeaders().get("uid");
        String uid = (uids!=null&&uids.size()>0)?uids.get(0):null;

        //3、判断当前路径是否是不需要登录的资源路径—不需要则放过请求直接去执行目标接口
        //                                  —需要登录则如下判断token
        if(!"/user-server/user/login".equals(path) && !("/user-server/user/regist".equals(path))){
            //4、获取到请求头中的token
            List<String> tokens = request.getHeaders().get("token");
            String token = (tokens!=null&&tokens.size()>0)?tokens.get(0):null;

            if(token!=null && uid!=null){
                //6、获取redis中的token
                String redis_token = String.valueOf(redisUtils.get("TOKEN_"+uid));
                //7、验证token是否有效
                if(redis_token==null|| "".equals(redis_token) || !redis_token.equals(token)){
                    //8、无效则返回错误相应
                    return onFailure(exchange.getResponse(),"token失效Q");
                }
            }else{
                //6、没有携带token返回错误相应
                return onFailure(exchange.getResponse(),"未登录，请先登录！");
            }
        }
//以下为新增内容根据用户id查询该用户拥有的资源接//
        if(uid!=null && !"".equals(uid) ){
            Integer id = Integer.valueOf(uid);
            //在非阻塞上下文中使用阻塞调用可能会导致线程匮乏
//            List<String> res = userFeign.selectResByUid3(id);

            List<String> res = null;
            try {
                CompletableFuture<List<String>> future = CompletableFuture.supplyAsync(() -> userFeign.selectResByUid(id));
                res = future.get();
            } catch (InterruptedException | ExecutionException e) {
                throw new RuntimeException(e);
            }


            boolean b = res.contains(path);
            if(!b){
                return onFailure(exchange.getResponse(),"您没有该资源的访问权限！");
            }
        }
        //以上为新增内容
        //去找执行目标方法
        return chain.filter(exchange);
    }


    @Override
    public int getOrder() {
        return 0;
    }

    public Mono<Void> onFailure(ServerHttpResponse response, String mes){
        JsonObject message = new JsonObject();
        message.addProperty("success", false);
        message.addProperty("code", 403);
        message.addProperty("data", mes);
        byte[] bits = message.toString().getBytes(StandardCharsets.UTF_8);
        DataBuffer buffer = response.bufferFactory().wrap(bits);
        //response.setStatusCode(HttpStatus.UNAUTHORIZED);
        //指定编码，否则在浏览器中会中文乱码
        response.getHeaders().add("Content-Type", "application/json;charset=UTF-8");
        return response.writeWith(Mono.just(buffer));
    }
}

这段代码是一个网关过滤器，用于统一处理认证和授权。实现了 GlobalFilter 接口和 Ordered 接口，并将其声明为一个 Spring 组件。在 filter 方法中，先获取请求对象和请求路径。然后判断是否为需要登录的资源路径，如果需要登录，则会获取请求头中的 token 和 uid 参数，并根据 uid 查询该用户所拥有的资源名称，最后判断该用户是否有访问当前资源的权限。如果验证不通过，则会调用 onFailure 方法返回错误信息。否则将继续执行目标接口。

除了原有的登录和注册接口，该过滤器新增了一个过滤判断，即根据用户 ID 查询该用户所拥有的所有资源名称并判断用户是否有访问当前资源的权限。这一功能需要调用 UserFeign 中的 selectResByUid 方法，其中有一段使用了 CompletableFuture 利用异步进行远程调用，以免在非阻塞上下文中使用阻塞调用导致线程匮乏。如果用户没有访问权限，则会返回错误信息。

2.7 添加feign配置类

package com.buba.config;

import feign.Logger;
import feign.codec.Decoder;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.ObjectFactory;
import org.springframework.boot.autoconfigure.http.HttpMessageConverters;
import org.springframework.cloud.openfeign.support.ResponseEntityDecoder;
import org.springframework.cloud.openfeign.support.SpringDecoder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.MediaType;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;

import java.util.ArrayList;
import java.util.List;

@Configuration
public class FeignConfig {
    @Bean
    Logger.Level feignLevel() {
        //这里记录所有
        return Logger.Level.FULL;
    }

    @Bean
    public Decoder feignDecoder() {
        return new ResponseEntityDecoder(new SpringDecoder(feignHttpMessageConverter()));
    }

    public ObjectFactory<HttpMessageConverters> feignHttpMessageConverter() {
        final HttpMessageConverters httpMessageConverters = new HttpMessageConverters(new PhpMappingJackson2HttpMessageConverter());
        return new ObjectFactory<HttpMessageConverters>() {
            @Override
            public HttpMessageConverters getObject() throws BeansException {
                return httpMessageConverters;
            }
        };
    }

    public class PhpMappingJackson2HttpMessageConverter extends MappingJackson2HttpMessageConverter {
        PhpMappingJackson2HttpMessageConverter(){
            List<MediaType> mediaTypes = new ArrayList<>();
            mediaTypes.add(MediaType.valueOf(MediaType.TEXT_HTML_VALUE + ";charset=UTF-8"));
            setSupportedMediaTypes(mediaTypes);
        }
    }
}

这段代码是一个 Feign 配置类，用于配置 Feign 的日志级别和响应解码方式。其中，feignLevel 方法设置了日志级别为 FULL，表示记录所有级别的日志；feignDecoder 方法返回了一个 ResponseEntityDecoder 对象，包装了一个 SpringDecoder 对象和一个 feignHttpMessageConverter 对象，用于将 Feign 响应消息解码成对象。

FeignHttpMessageConverter 类继承了 MappingJackson2HttpMessageConverter 类，并重写了其构造方法。在 PhpMappingJackson2HttpMessageConverter 构造方法中，指定了支持的媒体类型为 text/html;charset=UTF-8，防止在接收到返回 text/html 格式的响应时出现中文乱码问题。

最后，这段代码把 PhpMappingJackson2HttpMessageConverter 封装成 ObjectFactory<HttpMessageConverters> 单例对象返回，以便 Feign 和 RestTemplate 可用。

2.8 测试