物联网架构成长之路(56)-SpringCloudGateway+JWT实现网关鉴权

0. 前言
　　结合前面两篇博客，前面博客实现了Gateway网关的路由功能。此时，如果每个微服务都需要一套帐号认证体系就没有必要了。可以在网关处进行权限认证。然后转发请求到后端服务。这样后面的微服务就可以直接调用，而不需要每个都单独一套鉴权体系。参考了Oauth2和JWT，发现基于微服务，使用JWT会更方便一些，所以准备集成JWT作为微服务架构的认证方式。
　　【https://www.cnblogs.com/wunaozai/p/12512753.html】　　物联网架构成长之路(54)-基于Nacos+Gateway实现动态路由
　　【https://www.cnblogs.com/wunaozai/p/12512850.html】　　物联网架构成长之路(55)-Gateway+Sentinel实现限流、熔断

 

1. Gateway增加一个过滤器
　　在上一篇博客中实现的Gateway，增加一个AuthFilter过滤器。目的就是对所有的请求进行认证。
　　代码可以参考官方的几个标准过滤器

　　AuthFilter.java

package com.wunaozai.demo.gateway.config.filter;

import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.List;
import java.util.Map;

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.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.annotation.Order;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.http.HttpCookie;
import org.springframework.http.HttpStatus;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.util.MultiValueMap;
import org.springframework.util.StringUtils;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.server.ServerWebExchange;

import com.wunaozai.demo.gateway.config.JsonResponseUtils;
import reactor.core.publisher.Mono;

@Configuration
public class AuthFilter {

    private static final String JWT_TOKEN = "jwt-token";
    
    @Autowired
    private RestTemplate restTemplate;
    
    @Bean
    @Order
    public GlobalFilter authJWT() {
        GlobalFilter auth = new GlobalFilter() {
            @Override
            public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
                System.out.println("filter auth....");
                ServerHttpRequest request = exchange.getRequest();
                ServerHttpResponse response = exchange.getResponse();
                //判断是否需要过滤
                String path = request.getURI().getPath();
                List<String> pages = Arrays.asList("/auth/v1/login", 
                        "/auth/v1/refresh", "/auth/v1/check");
                for(int i=0; i<pages.size(); i++) {
                    if(pages.get(i).equals(path)) {
                        //直接通过，传输到下一级
                        return chain.filter(exchange); 
                    }
                }
                
                //判断是否存在JWT
                String jwt = "";
                List<String> headers = request.getHeaders().get(JWT_TOKEN);
                if(headers != null && headers.size() > 0) {
                    jwt = headers.get(0);
                }
                if(StringUtils.isEmpty(jwt)) {
                    MultiValueMap<String, HttpCookie> cookies = request.getCookies();
                    if(cookies != null && cookies.size() > 0) {
                        List<HttpCookie> cookie = cookies.get(JWT_TOKEN);
                        if(cookie != null && cookie.size() > 0) {
                            HttpCookie ck = cookie.get(0);
                            jwt = ck.getValue();
                        }
                    }
                }
                if(StringUtils.isEmpty(jwt)) {
                    //返回未授权错误
                    return error(response, JsonResponseUtils.AUTH_UNLOGIN_ERROR);
                }

                //通过远程调用判断JWT是否合法
                String json = "";
                try {
                    Map<?, ?> ret = restTemplate.getForObject("http://jieli-story-auth/auth/v1/info?jwt=" + jwt, Map.class);
                    String code = ret.get("code").toString();
                    if(!"0".equals(code)) {
                        //返回认证错误
                        return error(response, JsonResponseUtils.AUTH_EXP_ERROR);
                    }
                    json = ret.get("data").toString();
                } catch (Exception e) {
                    e.printStackTrace();
                    return error(response, JsonResponseUtils.AUTH_EXP_ERROR);
                }
                //将登录信息保存到下一级
                ServerHttpRequest newRequest = request.mutate().header("auth", json).build();
                ServerWebExchange newExchange = 
                        exchange.mutate().request(newRequest).build();
                return chain.filter(newExchange);
            }
        };
        return auth;
    }

    private Mono<Void> error(ServerHttpResponse response, String json) {
        //返回错误
        response.getHeaders().add("Content-Type", "application/json;charset=UTF-8");
        response.setStatusCode(HttpStatus.UNAUTHORIZED);
        DataBuffer buffer = response.bufferFactory().wrap(json.getBytes(StandardCharsets.UTF_8));
        return response.writeWith(Mono.just(buffer));
    }
}

　　BeanConfig.java

package com.wunaozai.demo.gateway.config.filter;

import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestTemplate;

@Component
public class BeanConfig {
    
    /**
     * 消费者
     * @return
     */
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

　　JsonResponseUtils.java

package com.wunaozai.demo.gateway.config;

/**
 * 常量返回
 * @author wunaozai
 * @Date 2020-03-18
 */
public class JsonResponseUtils {
    
    public static final String BLOCK_FLOW_ERROR = "{\"code\": -1, \"data\": null, \"msg\": \"系统限流\"}";
    public static final String AUTH_UNLOGIN_ERROR = "{\"code\": -1, \"data\": null, \"msg\": \"未授权\"}";
    public static final String AUTH_EXP_ERROR = "{\"code\": -1, \"data\": null, \"msg\": \"授权过期\"}";
    public static final String AUTH_PARAM_ERROR = "{\"code\": -1, \"data\": null, \"msg\": \"参数异常\"}";
    
}

 

2. Auth授权服务
　　这里使用JWT作为微服务间的鉴权协议
　　pom.xml

        <!-- JWT -->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.1</version>
        </dependency>

　　AuthController.java（这里面包含了部分数据库操作代码，如果测试，删除即可）

package com.wunaozai.demo.auth.controller;

import java.util.HashMap;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.api.R;

import io.jsonwebtoken.Claims;
import com.wunaozai.demo.auth.common.utils.SecretUtils;
import com.wunaozai.demo.auth.common.utils.jwt.JWTToken;
import com.wunaozai.demo.auth.common.utils.jwt.JWTUtils;
import com.wunaozai.demo.auth.model.entity.AuthUserModel;
import com.wunaozai.demo.auth.service.IAuthUserService;

@RestController
@RequestMapping(value="/auth/v1")
public class AuthController {

    @Autowired
    private IAuthUserService authuserService;
    
    @RequestMapping(value="/login")
    public R<Object> login(String username, String password, String type){
        AuthUserModel user = getUser(username);
        if(user == null) {
            return R.failed("帐号密码错误");
        }
        if(user.getStatus() == false) {
            return R.failed("当前账号被禁用");
        }
        if (checkPwd(user, password) == false) {
            return R.failed("帐号密码错误");
        }
        Map<String, String> map = new HashMap<>();
        map.put("userId", user.getUserId().toString());
        map.put("username", user.getUsername());
        String body = JSONObject.toJSONString(map);
        JWTToken token = JWTUtils.getJWT(body, "admin");
        return R.ok(token);
    }
    @RequestMapping(value="/check")
    public R<Object> check(String jwt){
        boolean flag = JWTUtils.checkJWT(jwt);
        return R.ok(flag);
    }
    @RequestMapping(value="/refresh")
    public R<Object> refresh(String jwt){
        boolean flag = JWTUtils.checkJWT(jwt);
        if(flag == false) {
            return R.ok("Token已过期");
        }
        JWTToken token = JWTUtils.refreshJWT(jwt);
        return R.ok(token);
    }
    @RequestMapping(value="/info")
    public R<Object> info(String jwt){
        boolean flag = JWTUtils.checkJWT(jwt);
        if(flag == false) {
            return R.ok("Token已过期");
        }
        Claims claims = JWTUtils.infoJWT(jwt);
        return R.ok(claims);
    }
    
    /**
     * 匹配密码
     * @param user
     * @param password
     * @return
     */
    private boolean checkPwd(AuthUserModel user, String password) {
        if(user == null) {
            return false;
        }
        return SecretUtils.matchBcryptPassword(password, user.getPassword());
    }
    /**
     * 获取用户模型
     * @param username
     * @return
     */
    private AuthUserModel getUser(String username) {
       QueryWrapper<AuthUserModel> query = new QueryWrapper<>();
       query.eq("username", username);
       return authuserService.getOne(query);
    }
}

　　JWTToken.java

package com.wunaozai.demo.auth.common.utils.jwt;

import lombok.Builder;
import lombok.Getter;
import lombok.Setter;

@Getter
@Setter
@Builder
public class JWTToken {
    private String access_token;
    private String token_type;
    private Long expires_in;
}

　　JWTUtils.java

package com.wunaozai.demo.auth.common.utils.jwt;

import java.util.Base64;
import java.util.Date;
import java.util.UUID;

import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.JwtBuilder;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;

/**
 * JWT 工具类
 * @author wunaozai
 * @Date 2020-03-18
 */
public class JWTUtils {

    private static final String JWT_KEY = "test";
    /**
     * 生成JWT
     * @param body
     * @param role
     * @return
     */
    public static JWTToken getJWT(String body, String role) {
        Long expires_in = 1000 * 60 * 60 * 24L; //一天
        long time = System.currentTimeMillis();
        time = time + expires_in;
        JwtBuilder builder = Jwts.builder()
                .setId(UUID.randomUUID().toString()) //设置唯一ID
                .setSubject(body) //设置内容，这里用JSON包含帐号信息
                .setIssuedAt(new Date()) //签发时间
                .setExpiration(new Date(time)) //过期时间
                .claim("roles", role) //设置角色
                .signWith(SignatureAlgorithm.HS256, generalKey()) //设置签名 使用HS256算法，并设置密钥
                ;
        String code = builder.compact();
        JWTToken token = JWTToken.builder()
                                        .access_token(code)
                                        .expires_in(expires_in / 1000)
                                        .token_type("JWT")
                                        .build();
        return token;
    }
    /**
     * 解析JWT
     * @param jwt
     * @return
     */
    public static Claims parseJWT(String jwt) {
        Claims body = Jwts.parser().setSigningKey(generalKey()).parseClaimsJws(jwt).getBody();
        return body;
    }
    /**
     * 刷新JWT
     * @param jwt
     * @return
     */
    public static JWTToken refreshJWT(String jwt) {
        Claims claims = parseJWT(jwt);
        String body = claims.getSubject();
        String role = claims.get("roles").toString();
        return getJWT(body, role);
    }
    /**
     * 获取JWT信息
     * @param jwt
     * @return
     */
    public static Claims infoJWT(String jwt) {
        Claims claims = parseJWT(jwt);
        return claims;
    }
    /**
     * 验证JWT
     * @param jwt
     * @return
     */
    public static boolean checkJWT(String jwt) {
        try {
            Claims body = Jwts.parser().setSigningKey(generalKey()).parseClaimsJws(jwt).getBody();
            if(body != null) {
                return true;
            }
        } catch (Exception e) {
            return false;
        }
        return false;
    }

    /**
     * 生成加密后的秘钥 secretKey
     * @return
     */
    public static SecretKey generalKey() {
        byte[] encodedKey = Base64.getDecoder().decode(JWT_KEY);
        SecretKey key = new SecretKeySpec(encodedKey, 0, encodedKey.length, "AES");
        return key;
    }
}

 

3. Res资源服务
　　测试是否转发到后端服务
　　IndexController.java

package com.wunaozai.demo.res.controller.web;

import java.util.HashMap;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.baomidou.mybatisplus.extension.api.R;

@RestController
@RequestMapping(value="/res/v1/")
public class IndexController {

    @Autowired
    private HttpServletRequest request;
    
    @RequestMapping(value="/login")
    public R<Map<String, Object>> login(){
        Map<String, Object> data = new HashMap<String, Object>();
        data.put("", "");
        return R.ok(data);
    }
    
    @RequestMapping(value="/test")
    public R<Object> test(String msg, @RequestBody String body){
        System.out.println(msg);
        System.out.println(body);
        System.out.println(request.getHeader("auth"));
        return R.ok("ok");
    }
}

 

4. 系统架构图
　　整体的架构流程图，就是一个请求经过Nginx，进行前后端分离。后端请求转发到Gateway，Gateway通过Nacos上配置的route（路由转发规则，限流Sentinel规则）。判断是否携带JWT-Token信息，请求访问Auth授权服务，查询是否正确的JWT-Token合法用户。如果是合法用户，将对应的请求转发到后端各个微服务中，以本例子，将/res/v1 开头转发到StoryRes服务，将/aiml/v1 开头的请求转发到StoryAIML服务。
　　架构流程图

　　各个微服务

　　各个微服务注册到Nacos上

　　本项目所有Nacos上的配置信息

 

5. 测试过程
　　通过PostMan进行模拟测试
5.1 请求/auth/v1/login
　　注意保存返回的access_token，以后每次请求都需要设置到Header上

 

5.2 请求/auth/v1/info
　　注意将jwt-token设置到Header上，这里就是返回用户信息。一般是给后端服务查询用的。不会暴露给用户。可以看到AuthFilter.java 这个类就是调用这个微服务，实现验证当前用户是否合法。同时将这个返回保存到Header上，并将登录信息保存到下一级。这样后面的微服务可以通过判断Header里面的这个登录信息userId。作为外键。

 

5.3 请求/res/v1/test
　　注意将jwt-token设置到Header上，这里模拟测试，通过QueryParam方式传参数和Body传参数。后端都是可以正常接收并打印

　　后续就会出基于vue-element-admin的前端开发框架，结合到本项目。实现前后端分离。【期待】

 

参考资料：
　　https://blog.csdn.net/tianyaleixiaowu/article/details/83375246
　　https://www.cnblogs.com/fdzang/p/11812348.html

本文地址：https://www.cnblogs.com/wunaozai/p/12522485.html
本系列目录： https://www.cnblogs.com/wunaozai/p/8067577.html
个人主页：https://www.wunaozai.com/