• 登录以及权限系统，用户认证信息存储设计思维

    一，登录

    1. 首先在system模块提供一个统一的接口，入参为一个用户名，出参是该用户的所有信息，包括用户名，密码，以及该用户在每个公司所有的角色，以及权限信息，可将反参缓存入NOSQL数据库中
    2. 在登录模块中先去缓存中获取看该用户的用户信息是否有缓存，有的话，直接返回，没有的话远程调用上述1的接口获取吗，然后通过返回的信息和登录接口的信息进行对比校验，如果都正确，通过jwt工具返回token

    二，用户权限校验，用户认证信息存储

    （1）通过全局拦截器，及网关设计

    1. 首先网关会拦截所有的请求，然后我们可以在网关模块定义一个放行白名单，比如一些登录接口，引用swagger页面的接口进行放行
    2. 拦截下来的接口，我们去获取它的请求头看是否有token，没有的话，直接返回未授权
    3. 有的话继续下边的操作，解析token，通过解析出来的用户信息，通过用户名从system获取该用户的所有信息
    4. 然后先校验token中解析出来的密码与system查询出来的密码是否一致
    5. 如果一致，再进行下一步鉴权，通过system查询出来的用户信息，查询该用户在所有公司所有的权限信息，然后和当前请求的权限信息进行对比，如果发现当前请求url与查询出来的所有的url都不匹配，则返回未授权，若匹配，则将登录认证信息，比如用户名，密码，公司信息，若有多语种，还可添加语言等加入请求头中

    代码如下：包括如何定义过滤器，以及上述操作

    定义过滤器：

    1. package sca.pro.gateway.common.auth;
    2.  
    3. import org.springframework.beans.factory.annotation.Autowired;
    4. import org.springframework.cloud.gateway.filter.GatewayFilter;
    5. import org.springframework.cloud.gateway.filter.factory.AbstractGatewayFilterFactory;
    6. import org.springframework.stereotype.Component;
    7.  
    8. /**
    9.  * @author shq
    10.  * @description 自定义token认证过滤器工厂
    11.  * @createDate 2022-5-25
    12.  * @updateUser
    13.  * @updateDate
    14.  * @updateRemark
    15.  */
    16. @Component
    17. public class AuthGatewayFilterFactory extends AbstractGatewayFilterFactory {
    18.  
    19.     @Autowired
    20.     private AuthGatewayFilter authGatewayFilter;
    21.  
    22.     @Override
    23.     public GatewayFilter apply(Object config) {
    24.         return authGatewayFilter;
    25.     }
    26. }
      27.  

      1. package sca.pro.gateway.common.auth;
      2.  
      3. import cn.hutool.json.JSONUtil;
      4. import com.fasterxml.jackson.databind.ObjectMapper;
      5. import org.springframework.beans.factory.annotation.Autowired;
      6. import org.springframework.boot.context.properties.EnableConfigurationProperties;
      7. import org.springframework.cloud.gateway.filter.GatewayFilter;
      8. import org.springframework.cloud.gateway.filter.GatewayFilterChain;
      9. import org.springframework.core.Ordered;
      10. import org.springframework.core.io.buffer.DataBuffer;
      11. import org.springframework.data.redis.core.StringRedisTemplate;
      12. import org.springframework.data.redis.core.ValueOperations;
      13. import org.springframework.http.HttpStatus;
      14. import org.springframework.http.server.reactive.ServerHttpRequest;
      15. import org.springframework.http.server.reactive.ServerHttpResponse;
      16. import org.springframework.stereotype.Component;
      17. import org.springframework.util.AntPathMatcher;
      18. import org.springframework.util.CollectionUtils;
      19. import org.springframework.util.MultiValueMap;
      20. import org.springframework.web.server.ServerWebExchange;
      21. import reactor.core.publisher.Flux;
      22. import reactor.core.publisher.Mono;
      23. import sca.pro.common.contants.Contants;
      24. import sca.pro.common.redis.authInfo.AuthInfo;
      25. import sca.pro.common.redis.authInfo.CompanyInfo;
      26. import sca.pro.common.response.HttpCode;
      27. import sca.pro.common.response.HttpResult;
      28. import sca.pro.common.utils.PasswordUtils;
      29. import sca.pro.common.utils.SystemUtils;
      30. import sca.pro.gateway.feign.SystemFeignService;
      31.  
      32. import javax.annotation.PostConstruct;
      33. import javax.annotation.Resource;
      34. import java.io.File;
      35. import java.security.PrivateKey;
      36. import java.security.PublicKey;
      37. import java.util.*;
      38. import java.util.stream.Collectors;
      39.  
      40. /**
      41.  * @author shq
      42.  * @description 身份认证过滤器
      43.  * @createDate 2022-5-25
      44.  * @updateUser
      45.  * @updateDate
      46.  * @updateRemark
      47.  */
      48. @Component
      49. @EnableConfigurationProperties(JwtProperties.class)
      50. public class AuthGatewayFilter implements GatewayFilter, Ordered {
      51.     @Resource
      52.     private JwtProperties jwtProperties;
      53.  
      54.     @Autowired
      55.     private StringRedisTemplate stringRedisTemplate;
      56.     @Autowired
      57.     private SystemFeignService systemFeignService;
      58.  
      59.     // spring的路径匹配器
      60.     private final static AntPathMatcher antPathMatcher = new AntPathMatcher();
      61.  
      62.     private static PublicKey publicKey;
      63.     private static PrivateKey privateKey;
      64.  
      65.     /**
      66.      * 初始化公私钥
      67.      *
      68.      * @throws Exception
      69.      */
      70.     @PostConstruct
      71.     public void init() throws Exception {
      72.         boolean flag = false;
      73.         String path = SystemUtils.getApplicationPath() + Contants.JWT_RSAKEY_PATH;
      74.         String pubPath = path + "/rsa.pub";
      75.         String priPath = path + "/rsa.pri";
      76.         File file = new File(path);
      77.         if (!file.exists()) {
      78.             file.mkdirs();
      79.         } else {
      80.             File pubFile = new File(pubPath);
      81.             File priFile = new File(priPath);
      82.             if (!pubFile.exists() || !priFile.exists()) {
      83.                 pubFile.delete();
      84.                 priFile.delete();
      85.             } else {
      86.                 flag = true;
      87.             }
      88.         }
      89.         if (!flag) {
      90.             RsaUtils.generateKey(pubPath, priPath, Contants.JWT_SECRET);
      91.         }
      92.         if (publicKey == null) {
      93.             publicKey = RsaUtils.getPublicKey(pubPath);
      94.             privateKey = RsaUtils.getPrivateKey(priPath);
      95.         }
      96.     }
      97.  
      98.     /**
      99.      * 排序规则
      100.      *
      101.      * @return
      102.      */
      103.     @Override
      104.     public int getOrder() {
      105.         return -100;
      106.     }
      107.  
      108.     /**
      109.      * jwt全局过滤器
      110.      *
      111.      * @param exchange
      112.      * @param chain
      113.      * @return
      114.      */
      115.     @Override
      116.     public Mono filter(ServerWebExchange exchange, GatewayFilterChain chain) {
      117.         // 获取request和response
      118.         ServerHttpRequest request = exchange.getRequest();
      119.         ServerHttpResponse response = exchange.getResponse();
      120.  
      121.         // 获取请求的url
      122.         String url = exchange.getRequest().getURI().getPath();
      123.  
      124.         // 检查url放行
      125.         for (String skip : jwtProperties.getSkipAuthUrls()) {
      126.             if (antPathMatcher.match(skip, url)) {
      127.                 return chain.filter(exchange);
      128.             }
      129.         }
      130.  
      131.         // 检查header中jwt是否存在
      132.         MultiValueMap headers = request.getHeaders();
      133.         if (CollectionUtils.isEmpty(headers) || !headers.containsKey(Contants.JWT_HEADER_KEY)) {
      134.             return unAuthorized(exchange);
      135.         }
      136.  
      137.         // 解析jwt
      138.         String username = null;
      139.         Map mapInfo = null;
      140.         try {
      141.             mapInfo = JwtUtils.getInfoFromToken(headers.getFirst(Contants.JWT_HEADER_KEY), publicKey);
      142.             if (mapInfo == null || mapInfo.get("username") == null) {
      143.                 return unAuthorized(exchange);
      144.             }
      145.             username = mapInfo.get("username").toString();
      146.             if (username.equals("")) {
      147.                 return unAuthorized(exchange);
      148.             }
      149.         } catch (Exception e) {
      150.             return unAuthorized(exchange);
      151.         }
      152.  
      153.         // 获取权限信息
      154.         AuthInfo authInfo = null;
      155.         String rKey = String.format(Contants.RKEY_SYSTEM_AUTHINFO, username);
      156.         ValueOperations ops = stringRedisTemplate.opsForValue();
      157.         String rValue = ops.get(rKey);
      158.         if (rValue == null) {
      159.             HttpResult result = systemFeignService.getAuthInfo(username);
      160.             if (result.getCode() != HttpCode.SUCCESS || result.getData() == null) {
      161.                 return unAuthorized(exchange);
      162.             } else {
      163.                 authInfo = JSONUtil.toBean(result.getData().toString(), AuthInfo.class);
      164.             }
      165.         } else {
      166.             authInfo = JSONUtil.toBean(rValue, AuthInfo.class);
      167.         }
      168.         if (authInfo.getUserInfo() == null) {
      169.             return unAuthorized(exchange);
      170.         }
      171.  
      172.         // 密码校验
      173.         if (!PasswordUtils.matchPassword(
      174.                 mapInfo.get("password").toString(),
      175.                 authInfo.getUserInfo().getPassword(),
      176.                 authInfo.getUserInfo().getSalt())) {
      177.             return passwordError(exchange);
      178.         }
      179.         //判断账号是否可用
      180.         if (authInfo.getUserInfo().getUserStatus()==0){
      181.             return userNoUse(exchange);
      182.         }
      183.         String companyName = (String)mapInfo.get("companyName");
      184.         List list = authInfo.getList();
      185.         //获取用户在当前公司的所有菜单权限
      186.         List collect = list.stream().filter(g -> g.getCompanyName().equals(companyName)).flatMap((a) -> a.getRoles().stream().flatMap(b -> b.getAuthorities().stream()).distinct()).distinct().collect(Collectors.toList());
      187.         // 权限校验
      188.         if (!username.equals("system")){
      189.             if (collect.contains(url)) {
      190.                 return hasNoPermission(exchange);
      191.             }
      192.         }
      193.  
      194.         // 将认证信息放入header
      195.         ServerHttpRequest host = exchange.getRequest().mutate().header(Contants.JWT_MAP_KEY, JSONUtil.toJsonStr(mapInfo)).build();
      196.         ServerWebExchange build = exchange.mutate().request(host).build();
      197.  
      198.         return chain.filter(build);
      199.     }
      200.  
      201.     private static Mono unAuthorized(ServerWebExchange exchange) {
      202.         ServerHttpResponse response = exchange.getResponse();
      203.         response.setStatusCode(HttpStatus.OK);
      204.         response.getHeaders().add("Content-Type", "application/json; charset=utf-8");
      205.         HttpResult result = new HttpResult().builder().code(HttpCode.UNAUTHORIZED).build();
      206.         return Mono.defer(() -> {
      207.             byte[] bytes;
      208.             try {
      209.                 bytes = new ObjectMapper().writeValueAsBytes(result);
      210.             } catch (Exception e) {
      211.                 throw new RuntimeException();
      212.             }
      213.             DataBuffer buffer = response.bufferFactory().wrap(bytes);
      214.             return response.writeWith(Flux.just(buffer));
      215.         });
      216.     }
      217.  
      218.     private static Mono passwordError(ServerWebExchange exchange) {
      219.         ServerHttpResponse response = exchange.getResponse();
      220.         response.setStatusCode(HttpStatus.OK);
      221.         response.getHeaders().add("Content-Type", "application/json; charset=utf-8");
      222.         HttpResult result = new HttpResult().builder().code(HttpCode.PASSWORDERROR).message("密码错误").build();
      223.         return Mono.defer(() -> {
      224.             byte[] bytes;
      225.             try {
      226.                 bytes = new ObjectMapper().writeValueAsBytes(result);
      227.             } catch (Exception e) {
      228.                 throw new RuntimeException();
      229.             }
      230.             DataBuffer buffer = response.bufferFactory().wrap(bytes);
      231.             return response.writeWith(Flux.just(buffer));
      232.         });
      233.     }
      234.     private static Mono userNoUse(ServerWebExchange exchange) {
      235.         ServerHttpResponse response = exchange.getResponse();
      236.         response.setStatusCode(HttpStatus.OK);
      237.         response.getHeaders().add("Content-Type", "application/json; charset=utf-8");
      238.         HttpResult result = new HttpResult().builder().code(HttpCode.USERNOUSE).message("账号不可用,请联系管理员").build();
      239.         return Mono.defer(() -> {
      240.             byte[] bytes;
      241.             try {
      242.                 bytes = new ObjectMapper().writeValueAsBytes(result);
      243.             } catch (Exception e) {
      244.                 throw new RuntimeException();
      245.             }
      246.             DataBuffer buffer = response.bufferFactory().wrap(bytes);
      247.             return response.writeWith(Flux.just(buffer));
      248.         });
      249.     }
      250.  
      251.  
      252.     private static Mono hasNoPermission(ServerWebExchange exchange) {
      253.         ServerHttpResponse response = exchange.getResponse();
      254.         response.setStatusCode(HttpStatus.OK);
      255.         response.getHeaders().add("Content-Type", "application/json; charset=utf-8");
      256.         HttpResult result = new HttpResult().builder().code(HttpCode.FORBIDDEN).build();
      257.         return Mono.defer(() -> {
      258.             byte[] bytes;
      259.             try {
      260.                 bytes = new ObjectMapper().writeValueAsBytes(result);
      261.             } catch (Exception e) {
      262.                 throw new RuntimeException();
      263.             }
      264.             DataBuffer buffer = response.bufferFactory().wrap(bytes);
      265.             return response.writeWith(Flux.just(buffer));
      266.         });
      267.     }
      268. }
       

      6.定义全局拦截器，再自定义一个注解，进行拦截判断，如果加了该注解，则说明该接口需要用到认证信息，则将认证信息从请求头中取出存入threadlocal中，涉及到两个类，一个是拦截器，一个是存储类，如下
       

      1. package sca.pro.system.common.request;
      2.  
      3. import cn.hutool.json.JSONUtil;
      4. import org.springframework.web.method.HandlerMethod;
      5. import org.springframework.web.servlet.ModelAndView;
      6. import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
      7. import sca.pro.common.contants.Contants;
      8. import sca.pro.common.jwt.MapInfo;
      9. import sca.pro.common.response.HttpCode;
      10. import sca.pro.common.response.HttpResult;
      11.  
      12. import javax.servlet.http.HttpServletRequest;
      13. import javax.servlet.http.HttpServletResponse;
      14. import java.io.IOException;
      15. import java.io.PrintWriter;
      16. import java.lang.reflect.Method;
      17.  
      18. /**
      19.  * @author shq
      20.  * @description Request拦截器
      21.  * @createDate 2022-5-27
      22.  * @updateUser
      23.  * @updateDate
      24.  * @updateRemark
      25.  */
      26. public class RequestContextInterceptor extends HandlerInterceptorAdapter {
      27.     @Override
      28.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
      29.         if (!(handler instanceof HandlerMethod)) {
      30.             return true;
      31.         }
      32.         Method method = ((HandlerMethod) handler).getMethod();
      33.         if (!method.isAnnotationPresent(AuthInfoRequired.class)) {
      34.             return true;
      35.         }
      36.         AuthInfoRequired annotation = method.getAnnotation(AuthInfoRequired.class);
      37.         if (!annotation.required()) {
      38.             return true;
      39.         }
      40.         if (initHeaderContext(request)) {
      41.             return super.preHandle(request, response, handler);
      42.         } else {
      43.             returnJson(response, JSONUtil.toJsonStr(new HttpResult().builder()
      44.                     .code(HttpCode.UNAUTHORIZED).build()));
      45.             return false;
      46.         }
      47.     }
      48.  
      49.     private boolean initHeaderContext(HttpServletRequest request) {
      50.         String mapInfoStr = request.getHeader(Contants.JWT_MAP_KEY);
      51.         if (mapInfoStr != null) {
      52.             try {
      53.                 MapInfo mapInfo = JSONUtil.toBean(mapInfoStr, MapInfo.class);
      54.                 new RequestContext.RequestContextBuild()
      55.                         .mapInfo(mapInfo)
      56.                         .bulid();
      57.                 if (mapInfo.getUsername() == null) {
      58.                     return false;
      59.                 }
      60.                 return true;
      61.             } catch (Exception e) {
      62.                 return false;
      63.             }
      64.         } else {
      65.             return false;
      66.         }
      67.     }
      68.  
      69.     private void returnJson(HttpServletResponse response, String json) throws Exception {
      70.         PrintWriter writer = null;
      71.         response.setCharacterEncoding("UTF-8");
      72.         response.setContentType("text/html; charset=utf-8");
      73.         try {
      74.             writer = response.getWriter();
      75.             writer.print(json);
      76.         } catch (IOException e) {
      77.         } finally {
      78.             if (writer != null)
      79.                 writer.close();
      80.         }
      81.     }
      82.  
      83.     @Override
      84.     public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
      85.         RequestContext.clean();
      86.         super.postHandle(request, response, handler, modelAndView);
      87.     }
      88. }
       

      1. package sca.pro.system.common.request;
      2.  
      3. import sca.pro.common.jwt.MapInfo;
      4.  
      5. /**
      6.  * @author shq
      7.  * @description 请求上下文声明
      8.  * @createDate 2022-5-27
      9.  * @updateUser
      10.  * @updateDate
      11.  * @updateRemark
      12.  */
      13. public class RequestContext {
      14.     private static final ThreadLocal REQUEST_HEADER_CONTEXT_THREAD_LOCAL = new ThreadLocal<>();
      15.  
      16.     private MapInfo mapInfo;
      17.  
      18.     public String getUsername() {
      19.         if (mapInfo != null) {
      20.             return mapInfo.getUsername();
      21.         }
      22.         return null;
      23.     }
      24.     public String getCompanyName() {
      25.         if (mapInfo != null) {
      26.             return mapInfo.getCompanyName();
      27.         }
      28.         return null;
      29.     }
      30.     public String getlanguageName() {
      31.         if (mapInfo != null) {
      32.             return mapInfo.getLanguageName();
      33.         }
      34.         return null;
      35.     }
      36.  
      37.     public static RequestContext getInstance() {
      38.         return REQUEST_HEADER_CONTEXT_THREAD_LOCAL.get();
      39.     }
      40.  
      41.     public void setContext(RequestContext context) {
      42.         REQUEST_HEADER_CONTEXT_THREAD_LOCAL.set(context);
      43.     }
      44.  
      45.     public static void clean() {
      46.         REQUEST_HEADER_CONTEXT_THREAD_LOCAL.remove();
      47.     }
      48.  
      49.     private RequestContext(RequestContextBuild requestHeaderContextBuild) {
      50.         this.mapInfo = requestHeaderContextBuild.mapInfo;
      51.         setContext(this);
      52.     }
      53.  
      54.     public static class RequestContextBuild {
      55.         private MapInfo mapInfo;
      56.  
      57.         public RequestContextBuild mapInfo(MapInfo mapInfo) {
      58.             this.mapInfo = mapInfo;
      59.             return this;
      60.         }
      61.  
      62.         public RequestContext bulid() {
      63.             return new RequestContext(this);
      64.         }
      65.     }
      66. }
       

      7.在需要使用认证信息的地方只需要加上这个AuthInfoRequired注解，即可通过RequestContext.getinstance().get对应的认证信息即可获取，到此第一种方法结束
       

       

      (2)为了保证网关的业务纯净，我们一般不在网管进行鉴权，而且上述的方法也稍微有些繁琐，我们可以自定义一个注解，通过aop环绕进行统一拦截，这次设计需要在nacos中定义一个独立的白名单文件，然后还是一样先对拦截的请求进行 白名单放行，然后获取token进行解析，获取对应的用户信息进行判读密码，权限校验，与上边相同，直接上代码‘
       

      1. package sca.pro.core.authentication.handler;
      2.  
      3. import cn.hutool.core.convert.Convert;
      4. import cn.hutool.json.JSONUtil;
      5. import lombok.extern.log4j.Log4j2;
      6. import org.apache.commons.lang3.StringUtils;
      7. import org.aspectj.lang.ProceedingJoinPoint;
      8. import org.aspectj.lang.Signature;
      9. import org.aspectj.lang.annotation.Around;
      10. import org.aspectj.lang.annotation.Aspect;
      11. import org.aspectj.lang.annotation.Pointcut;
      12. import org.aspectj.lang.reflect.MethodSignature;
      13. import org.springframework.beans.factory.annotation.Autowired;
      14. import org.springframework.beans.factory.annotation.Value;
      15. import org.springframework.boot.context.properties.EnableConfigurationProperties;
      16. import org.springframework.core.annotation.Order;
      17. import org.springframework.data.redis.core.StringRedisTemplate;
      18. import org.springframework.data.redis.core.ValueOperations;
      19. import org.springframework.stereotype.Component;
      20. import org.springframework.util.AntPathMatcher;
      21. import org.springframework.web.context.request.RequestContextHolder;
      22. import org.springframework.web.context.request.ServletRequestAttributes;
      23. import sca.pro.common.contants.Contants;
      24. import sca.pro.common.exception.BusinessException;
      25. import sca.pro.common.jwt.MapInfo;
      26. import sca.pro.common.redis.authInfo.AuthInfo;
      27. import sca.pro.common.redis.authInfo.CompanyInfo;
      28. import sca.pro.common.response.HttpCode;
      29. import sca.pro.common.response.HttpResult;
      30. import sca.pro.common.threadlocal.ThreadLocalUtils;
      31. import sca.pro.common.utils.PasswordUtils;
      32. import sca.pro.common.utils.SystemUtils;
      33. import sca.pro.core.authentication.annotation.HasPermission;
      34. import sca.pro.core.authentication.util.JwtProperties;
      35. import sca.pro.core.authentication.util.JwtUtils;
      36. import sca.pro.core.authentication.util.RsaUtils;
      37. import sca.pro.core.feign.SystemCheckFeignService;
      38.  
      39. import javax.annotation.PostConstruct;
      40. import javax.annotation.Resource;
      41. import javax.servlet.http.HttpServletRequest;
      42. import java.io.File;
      43. import java.io.UnsupportedEncodingException;
      44. import java.security.PrivateKey;
      45. import java.security.PublicKey;
      46. import java.util.*;
      47. import java.util.stream.Collectors;
      48.  
      49. @Log4j2
      50. @Aspect
      51. // 数字越小，执行顺序越高，@Transactional的顺序为Integer.MAX_VALUE
      52. @Order(-1)
      53. @Component
      54. @EnableConfigurationProperties(JwtProperties.class)
      55. public class AuthenticationHandler {
      56.     // spring的路径匹配器
      57.     private final static AntPathMatcher antPathMatcher = new AntPathMatcher();
      58.  
      59.     private static PublicKey publicKey;
      60.     private static PrivateKey privateKey;
      61.     @Resource
      62.     private JwtProperties jwtProperties;
      63.  
      64.     @Autowired
      65.     private StringRedisTemplate stringRedisTemplate;
      66.     @Autowired
      67.     private SystemCheckFeignService systemFeignService;
      68.     @Value("${spring.application.name}")
      69.     private String springApplicationName;
      70.  
      71.     /**
      72.      * 切入点
      73.      * 1. execution 表达式主体
      74.      * 2. * 任意类型返回值
      75.      * 3. com.company.web.controller 切入包
      76.      * 4. .. 当前包及子包
      77.      * 5. * 所有类
      78.      * 6. .*(..) 所有方法与任何参数
      79.      */
      80.     @Pointcut("execution(* sca.pro.*.controller..*.*(..)))")
      81.     public void cut() {
      82.     }
      84.     /**
      85.      * 本执行在事务外层，在GlobalExceptionHandler内层
      86.      *
      87.      * @param joinPoint
      88.      * @throws Throwable
      89.      */
      90.     @Around("cut()")
      91.     public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
      93.         long startTime = System.currentTimeMillis();
      95.         ServletRequestAttributes sra = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
      96.         HttpServletRequest request = sra.getRequest();
      97.         Signature signature = joinPoint.getSignature();
      98.         MethodSignature methodSignature = (MethodSignature) signature;
      100.         log.info("Request begin");
      101.         log.info("ModuleName: {}", springApplicationName);
      102.         log.info("RequestMethod: {}", request.getMethod());
      103.         log.info("RequestURI: {}", request.getRequestURI());
      104.         log.info("RemoteAddr: {}", request.getRemoteAddr());
      105.         log.info("MethodName: {}", methodSignature.getDeclaringTypeName() + "." + methodSignature.getName());
      107.         // todo 入参待处理
      108.         // Object[] args = joinPoint.getArgs();
      110.         // 用户身份认证
      111.         // 网关强制过滤掉了GlobalContants.HEADER_LOGIN_INFO_BASE64_KEY，在内部进行构建
      112.         boolean isLoginInfoRequired = methodSignature.getMethod().isAnnotationPresent(HasPermission.class);
      113.         try {
      114.             if (isLoginInfoRequired) {
      115.                 String loginInfoStr = sra.getRequest().getHeader(Contants.HEADER_LOGIN_INFO_BASE64_KEY);
      116.                 if (loginInfoStr != null) {
      117.                     // 将请求头信息加入本地变量，用于跨服务调用 将请求头信息进行解析，用于业务处理
      118.                     ThreadLocalUtils.set(Contants.HEADER_LOGIN_INFO_BASE64_KEY, loginInfoStr);
      119.                     MapInfo mapInfo=JSONUtil.toBean(JSONUtil.parseObj(loginInfoStr), MapInfo.class);
      120.                     ThreadLocalUtils.set(Contants.LOCAL_LOGIN_INFO_OBJECT_KEY, mapInfo);
      121.                 } else {
      122.                     // 获取request和response
      124.                     // 获取请求的url
      125.                     String url =request.getRequestURI() ;
      127.                     // 检查url白名单放行
      128.                     for (String skip : jwtProperties.getSkipAuthUrls()) {
      129.                         if (antPathMatcher.match(skip, url)) {
      130.                             Object object = joinPoint.proceed(joinPoint.getArgs());
      131.                             // todo 出参待处理
      132.                             return object;
      133.                         }
      134.                     }
      135.                     Map mapInfo = null;
      136.                     AuthInfo authInfo = null;
      137.                     // 检查header中jwt是否存在
      138.                     String header = request.getHeader(Contants.JWT_HEADER_KEY);
      139.                     if (StringUtils.isEmpty(header)) {
      140.                         throw new BusinessException(HttpCode.UNAUTHORIZED, "未授权");
      141.                     }
      142.                     // 解析jwt
      143.                     String username = null;
      144.                     try {
      145.                         mapInfo = JwtUtils.getInfoFromToken(URLDecoderString(header), publicKey);
      146.                         if (mapInfo == null || mapInfo.get("username") == null) {
      147.                             throw new BusinessException(HttpCode.UNAUTHORIZED, "未授权");
      148.                         }
      149.                         username = mapInfo.get("username").toString();
      150.                         if (username.equals("")) {
      151.                             throw new BusinessException(HttpCode.UNAUTHORIZED, "未授权");
      152.                         }
      153.                         //判断token是否是最新的
      154.                         String token = systemFeignService.getToken(username);
      155.                         if (token!=null){
      156.                             if (!token.equals(header)){
      157.                                 throw new BusinessException(7777, "账号已在别处登录");
      158.                             }
      159.                         }
      160.                     } catch (Exception e) {
      161.                         throw new BusinessException(HttpCode.UNAUTHORIZED, "未授权");
      162.                     }
      164.                     // 获取权限信息
      165.                     String rKey = String.format(Contants.RKEY_SYSTEM_AUTHINFO, username);
      166.                     rKey = StringUtils.join(rKey, ":", username);
      167.                     ValueOperations ops = stringRedisTemplate.opsForValue();
      168.                     String rValue = ops.get(rKey);
      169.                     if (rValue == null) {
      170.                         HttpResult result = systemFeignService.getAuthInfo(username, mapInfo.get("companyName").toString());
      171.                         if (result.getCode() != HttpCode.SUCCESS || result.getData() == null) {
      172.                             throw new BusinessException(HttpCode.UNAUTHORIZED, "未授权");
      173.                         } else {
      174.                             authInfo = JSONUtil.toBean(result.getData().toString(), AuthInfo.class);
      175.                         }
      176.                     } else {
      177.                         authInfo = JSONUtil.toBean(rValue, AuthInfo.class);
      178.                     }
      179.                     if (authInfo.getUserInfo() == null) {
      180.                         throw new BusinessException(HttpCode.UNAUTHORIZED, "未授权");
      182.                     }
      184.                     // 密码校验
      185.                     if (!PasswordUtils.matchPassword(
      186.                             mapInfo.get("password").toString(),
      187.                             authInfo.getUserInfo().getPassword(),
      188.                             authInfo.getUserInfo().getSalt())) {
      189.                         throw new BusinessException(HttpCode.PASSWORDERROR, "密码错误");
      190.                     }
      191.                     //判断账号是否可用
      192.                     if (authInfo.getUserInfo().getUserStatus() == 0) {
      193.                         throw new BusinessException(HttpCode.USERNOUSE, "账号不可用请联系管理员");
      194.                     }
      196.                     String companyName = (String) mapInfo.get("companyName");
      197.                     List list = authInfo.getList();
      198.                     //获取用户在当前公司的所有菜单权限
      199.                     List collect = list.stream().filter(g -> g.getCompanyName().equals(companyName)).flatMap((a) -> a.getRoles().stream().flatMap(b -> b.getAuthorities().stream()).distinct()).distinct().collect(Collectors.toList());
      200.                     // 权限校验
      201.                     if (!username.equals("system")) {
      202.                         if (collect.contains(url)) {
      203.                             throw new BusinessException(HttpCode.FORBIDDEN, "无权限");
      204.                         }
      205.                     }
      206.                     // 将请求头信息加入本地变量，用于跨服务调用 将请求头信息进行解析，用于业务处理
      207.                     ThreadLocalUtils.set(Contants.HEADER_LOGIN_INFO_BASE64_KEY,JSONUtil.toJsonStr( Convert.convert(MapInfo.class,mapInfo)));
      208.                     MapInfo loginInfo =Convert.convert(MapInfo.class,mapInfo);
      209.                     ThreadLocalUtils.set(Contants.LOCAL_LOGIN_INFO_OBJECT_KEY, loginInfo);
      210.                 }
      211.             }
      212.             Object object = joinPoint.proceed(joinPoint.getArgs());
      213.             // todo 出参待处理
      214.             return object;
      215.         } catch (Throwable e) {
      216.             throw e;
      217.         } finally {
      218.             log.info("Cost time: {}ms", System.currentTimeMillis() - startTime);
      219.             ThreadLocalUtils.clear();
      220.         }
      221.     }
      223.     public static String URLDecoderString(String str) {
      224.         String result = "";
      225.         if (null == str) {
      226.             return "";
      227.         }
      228.         try {
      229.             result = java.net.URLDecoder.decode(str, "UTF-8");
      230.         } catch (UnsupportedEncodingException e) {
      231.             e.printStackTrace();
      232.         }
      233.         return result;
      234.     }
      237.     /**
      238.      * 初始化公私钥
      239.      *
      240.      * @throws Exception
      241.      */
      242.     @PostConstruct
      243.     public void init() throws Exception {
      244.         boolean flag = false;
      245.         String path = SystemUtils.getApplicationPath() + Contants.JWT_RSAKEY_PATH;
      246.         String pubPath = path + "/rsa.pub";
      247.         String priPath = path + "/rsa.pri";
      248.         File file = new File(path);
      249.         if (!file.exists()) {
      250.             file.mkdirs();
      251.         } else {
      252.             File pubFile = new File(pubPath);
      253.             File priFile = new File(priPath);
      254.             if (!pubFile.exists() || !priFile.exists()) {
      255.                 pubFile.delete();
      256.                 priFile.delete();
      257.             } else {
      258.                 flag = true;
      259.             }
      260.         }
      261.         if (!flag) {
      262.             RsaUtils.generateKey(pubPath, priPath, Contants.JWT_SECRET);
      263.         }
      264.         if (publicKey == null) {
      265.             publicKey = RsaUtils.getPublicKey(pubPath);
      266.             privateKey = RsaUtils.getPrivateKey(priPath);
      267.         }
      268.     }
      269. }
       

      
                
                    
                

                
    27. 

                    相关阅读:
      
                    
C++编程常见错误及处理                            
      
编辑“事件处理”中设置鼠标指针样式                            
      
基于SpERT的中文关系抽取                            
      
DS5上ARM编译器样例工程改为GCC编译                            
      
C语言第三十一弹---自定义类型：结构体(下)                            
      
校园论坛（Java）—— 数据报表模块                            
      
HTML 之 块级元素、行内元素和行内块元素之间的嵌套规则                            
      
软件测试面试题：请试着比较一下黑盒测试、白盒测试、单元测试、集成测试、系统测试、验收测试的区别与联系？                            
      
「实用场景教程」如何用日程控件DHTMLX Scheduler制作酒店预订日历？（二）                            
      
git命令 本地                            
      
                          
                
      28. 
                
    28. 
                    原文地址：https://blog.csdn.net/weixin_59244784/article/details/127106362
                
      29.