SpringBoot：拦截

小咪咪 2024-03-22 11:44 16阅读 0赞

### 拦截 ###

##### 依赖 #####

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

##### 配置类 #####

import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.servlet.HandlerInterceptor;
    import org.springframework.web.servlet.config.annotation.*;
    
    @Configuration
    public class InterceptorConfig implements WebMvcConfigurer {
        
    
        @Bean
        public HandlerInterceptor MyInterceptor() {
        
            return new WebHandlerInterceptor();
        }
    
        @Override
        public void addInterceptors(InterceptorRegistry registry) {
        
            InterceptorRegistration interceptor = registry.addInterceptor(MyInterceptor());
            // 拦截所有、排除
            interceptor.addPathPatterns("/**")
                    .excludePathPatterns("/login","/login");
        }
    
        /**
         * 跨域支持配置
         * @param registry
         */
        @Override
        public void addCorsMappings(CorsRegistry registry) {
        
            registry.addMapping("/**").allowCredentials(true).allowedOrigins("*").allowedMethods("GET", "PUT", "DELETE", "POST", "OPTIONS").maxAge(3600);
        }
    }

##### 拦截器 #####

import org.apache.commons.lang.StringUtils;
    import org.springframework.web.servlet.HandlerInterceptor;
    
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    @Slf4j
    @Component
    public class WebHandlerInterceptor implements HandlerInterceptor {
        
    
        //handler执行之前
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        
    
            //获取jwt
            String tokenInfo = request.getHeader("Authorization");
    
            if (StringUtils.isNotEmpty(tokenInfo)){
        
    
                try{
        
    
                    //解析令牌
                    Map<String, Object> tokenMap = JWTUtil.decode(tokenInfo);
                    //String shopId = (String) tokenMap.get("shopId");
    
                    //将令牌Map放入自定义的上下文对象中
                    TenantContext.addAttachments(tokenMap);
    
                }catch (Exception e){
        
                    log.error("解析令牌失败");
                    e.printStackTrace();
                }
            }
            return true;
        }
    }

##### 生成JWT令牌 #####

//生成令牌
    Map<String,Object> tokenMap = new HashMap<>();
    tokenMap.put("shopId",shopId);
    tokenMap.put("storeId",staff.getStoreId());
    tokenMap.put("loginUserId",staff.getStaffId());
    tokenMap.put("loginUserName",loginName);
    tokenMap.put("userType",SystemCode.USER_TYPE_STAFF);
    
    String tokenInfo = "";
    try {
        
        tokenInfo = JWTUtil.createJWTByObj(tokenMap,secret);
    } catch (IOException e) {
        
        result.setStatus(ResultCode.error);
        result.setDesc("加密失败");
        return result;
    }

##### 工具类 #####

import com.alibaba.fastjson.JSON;
    import io.jsonwebtoken.*;
    import org.apache.commons.codec.binary.Base64;
    
    import javax.crypto.SecretKey;
    import javax.crypto.spec.SecretKeySpec;
    import java.io.IOException;
    import java.time.LocalDateTime;
    import java.time.ZoneId;
    import java.time.ZonedDateTime;
    
    
    public class JWTUtil{
        
        /**
         * 签发JWT
         * @param tokenMap
         * @param secret
         * @return
         * @throws IOException
         */
        public static String createJWTByObj(Map<String, Object> tokenMap, String secret) throws IOException {
        
            SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;
    
            SecretKey secretKey = generalKey(secret);
    
            ZoneId zoneId = ZoneId.systemDefault();
            ZonedDateTime zdt = LocalDateTime.now().plusDays(3).atZone(zoneId);
    
            //添加构成JWT的参数
            JwtBuilder builder = Jwts.builder().setHeaderParam("typ", "JWT")
                    .setId("restkeeper") //签发应用Id
                    .setIssuedAt(Date.from(zdt.toInstant())) //签发时间
                    .setHeaderParam("alg", "HS256")  //加密算法
                    .addClaims(tokenMap)
                    .setExpiration(Date.from(zdt.toInstant()))  //设置过期时间
                    .signWith(signatureAlgorithm, secretKey);  //用密钥签名
    
    
            //生成JWT
            return builder.compact();
        }
    
        /**
         * 验证jwt
         */
        public static VerifyResult verifyJwt(String token, String secret) {
        
            //签名秘钥，和生成的签名的秘钥一模一样
            SecretKey key = generalKey(secret);
            try {
        
    
                ZoneId zoneId = ZoneId.systemDefault();
                ZonedDateTime zdt = LocalDateTime.now().atZone(zoneId);
                Jwt jwt = Jwts.parser()
                        .setSigningKey(key)
                        .parse(token);
    
    
                Date date = ((Claims) jwt.getBody()).getExpiration();
                if (date == null) {
        
                    return new VerifyResult(false, 5002);
                }
                LocalDateTime expires = LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
                if (expires.isBefore(LocalDateTime.now())) {
        
                    return new VerifyResult(false, 5001);
                }
    
                return new VerifyResult(true, 200);
            } catch (Exception e) {
        
                e.printStackTrace();
    
                return new VerifyResult(false, 5002);
            }//设置需要解析的jwt
        }
    
        public static Map<String,Object> decode(String token) throws IOException {
        
            String bodyData = token.split("\\.")[1];
    
            String bodyStr = new String(Base64.decodeBase64(bodyData),"UTF-8");
            return JSON.parseObject(bodyStr,Map.class);
        }
    
        /**
         * 生成key
         *
         * @param jwtSecret
         * @return
         */
        private static SecretKey generalKey(String jwtSecret) {
        
            String stringKey = jwtSecret;
            byte[] encodedKey = Base64.decodeBase64(stringKey);
            SecretKey key = new SecretKeySpec(encodedKey, 0, encodedKey.length, "AES");
    
            return key;
        }
    
        @Data
        public static class VerifyResult{
        
            private boolean isValidate;
            /**
             * 5001:token过期;5002:无效token;5003:token校验异常
             */
            private int code;
    
            private Map<String,Object> tokenMap;
    
            public VerifyResult(boolean isValidate, int code) {
        
                this.isValidate = isValidate;
                this.code = code;
                System.out.println("1111");
            }
        }
    }

##### ThreadLocal #####

在这里插入代码片import java.util.LinkedHashMap;
    
    public class TenantContext {
        
    
        static ThreadLocal<Map<String,Object>> threadLocal = new ThreadLocal<Map<String, Object>>(){
        
            @Override
            protected Map<String, Object> initialValue() {
        
                return new LinkedHashMap<String, Object>();
            }
        };
    
        public static void addAttachment(String key, Object value){
        
            threadLocal.get().put(key,value);
        }
        public static void addAttachments(Map<String, Object> map){
        
            threadLocal.get().putAll(map);
        }
    
        public static String getShopId(){
        
            return String.valueOf(threadLocal.get().get("shopId"));
        }
    
        public static Map<String, Object> getAttachments(){
        
            return threadLocal.get();
        }
    
        public static String getStoreId(){
        
            return String.valueOf(threadLocal.get().get("storeId"));
        }
    
        public static String getUserType(){
        
            return String.valueOf(threadLocal.get().get("userType"));
        }
    
        public static  void clear(){
        
            threadLocal.remove();
        }
    
        public static String getLoginUserId(){
        
            Map<String, Object> stringObjectMap = threadLocal.get();
            return String.valueOf(threadLocal.get().get("loginUserId"));
        }
    
        public static String getLoginUserName(){
        
            return String.valueOf(threadLocal.get().get("loginUserName"));
        }
    }