Fifle拦截器

我会带着你远行 2021-09-25 12:56 194阅读 0赞

package com.lenovo.szq.bigdata.filter;
    
    import com.alibaba.fastjson.JSON;
    import com.lenovo.szq.bigdata.auth.entity.SessionUser;
    import com.lenovo.szq.bigdata.auth.util.AuthCacheUtils;
    import com.lenovo.szq.bigdata.auth.util.CommonConstant;
    import com.lenovo.szq.bigdata.auth.util.JwtUtil;
    import com.lenovo.szq.bigdata.util.RedisUtil;
    import com.lenovo.szq.bigdata.util.ResponseResult;
    import org.apache.commons.lang.StringUtils;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    
    import javax.servlet.*;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    import java.nio.charset.StandardCharsets;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    public class SsoFilter implements Filter {
    
        public static final String USER_ATTRIBUTE_KEY = "USER_ACCOUNT";
    
        private static final Logger COMMON_LOG = LoggerFactory.getLogger(SsoFilter.class);
    
        protected static List<Pattern> patterns = new ArrayList<Pattern>();
        protected static List<String> path = new ArrayList<>();
    
        @Autowired
        private RedisUtil redisUtil;
    
        @Autowired
        private LoginFilterComponent loginFilterComponent;
    
        @Override
        public void init(FilterConfig filterConfig) throws ServletException {
            //需要排除的资源
            patterns.add(Pattern.compile(".*(.js|.css|.png|.ico|.html|.svg|.jpg|.json|.ttf)$"));
            path.add("login");
            path.add("/");
            path.add("help/action/info");
            path.add("conf/finebi/dashboard");
            path.add("auth/checkToken");
            path.add("data/getMaketAnalysisDP");
            path.add("data/getMaketAnalysisSubDP");
            path.add("iov/query/jump");
            path.add("warning/runHighWarningCalc");
            path.add("warning/runNormalWarningCalc");
            path.add("datahub/xcec");
    //        path.add("sale/check");
    //        path.add("sale/card");
    //        path.add("sale/hotMap");
    //        path.add("sale/top");
    //        path.add("sale/trend");
    //        path.add("car/series");
    //        path.add("car/type");
        }
    
        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
    
            HttpServletRequest request = (HttpServletRequest) servletRequest;
            HttpServletResponse response = (HttpServletResponse) servletResponse;
            String url = getCheckPath(request);
            //排除不需要验证的资源
            if (isInclude(url) || path.contains(url)) {
                filterChain.doFilter(servletRequest, servletResponse);
                return;
            }
    
            String token = request.getHeader("X-Access-Token");
            if (StringUtils.isEmpty(token)) {
                token = request.getParameter("xat");
                if (StringUtils.isEmpty(token)) {
                    token = request.getParameter("token");
                    if (StringUtils.isEmpty(token)) {
                        COMMON_LOG.info("=======[auth]======没有token，校验失败，返回401");
                        response.setContentType("application/json; charset=utf-8");
                        loginFilterComponent.addLoginPageURLHeader(response);
    					 returnResponse(response, 401, "用户过期，请重新登录", null);
                        return;
                    }
                }
            }
    
            String cacheTokenKey = CommonConstant.PREFIX_USER_TOKEN + token;
            String cacheToken = redisUtil.getString(cacheTokenKey);
            if (StringUtils.isEmpty(cacheToken)) {
                COMMON_LOG.info("=======[auth]======没有token，校验失败，返回401");
                loginFilterComponent.addLoginPageURLHeader(response);
                 returnResponse(response, 401, "用户过期，请重新登录", null);
                return;
            }
    
            // 从JWT解析出登录用户信息
            SessionUser sessionUser = JwtUtil.parseFromToken(token);
            if (sessionUser == null) {
                COMMON_LOG.info("=======[auth]======token解析失败，返回401");
                loginFilterComponent.addLoginPageURLHeader(response);
                 returnResponse(response, 401, "用户过期，请重新登录", null);
                return;
            }
    
            servletRequest.setAttribute(USER_ATTRIBUTE_KEY, sessionUser.getAccount());
    
            //刷新时间
            redisUtil.expire(cacheTokenKey, JwtUtil.EXPIRE_TIME / 1000);
    
            // 校验token有效性
    //        if (!JwtUtil.verify(token, userName)) {
            // JWT过期
    //            COMMON_LOG.info("=======[auth]======JWT过期，校验失败，返回401");
    //            returnResponse(response, 401, "用户过期，请重新登录", null);
    //            return;
    //            cacheToken = JwtUtil.sign(userName);
    //            cacheTokenKey = "PREFIX_USER_TOKEN " + cacheToken;
    //
    //            // 把新的返回给前端
    //            response.setHeader("X-Access-Token", cacheToken);
    //        }
    
    
    //        hack code
    //        SessionUser sessionUser = hackLogin();
    
            COMMON_LOG.info("user[{}] access uri[{}]", sessionUser.getAccount(), url);
            try {
                AuthCacheUtils.cacheSessionUser(sessionUser);
                filterChain.doFilter(servletRequest, servletResponse);
            } finally {
                AuthCacheUtils.clearThreadCache();
            }
        }
    
        @Override
        public void destroy() {
        }
    
        private void returnResponse(HttpServletResponse response, int code, String desc, Object data) throws IOException {
            ResponseResult resultObj = new ResponseResult(code, data, desc);
            String resultJson = JSON.toJSONString(resultObj);
            response.setContentType("application/json;charset=utf-8");
            response.getOutputStream().write(resultJson.getBytes(StandardCharsets.UTF_8));
        }
    
        private SessionUser hackLogin() {
            SessionUser sessionUser = new SessionUser();
            sessionUser.setAccount("admin");
            sessionUser.setToken("123");
            return sessionUser;
        }
    
        /**
         * 是否需要过滤
         *
         * @param url
         * @return
         */
        private boolean isInclude(String url) {
            for (Pattern pattern : patterns) {
                Matcher matcher = pattern.matcher(url);
                if (matcher.matches()) {
                    return true;
                }
            }
            return false;
        }
    
        public String getCheckPath(HttpServletRequest request) {
            String url = request.getRequestURI().substring(request.getContextPath().length());
            if (url.startsWith("/") && url.length() > 1) {
                url = url.substring(1);
            }
            return url;
        }
    }