spring boot — 拦截器

1. 配置拦截器

package com.gl.crpt.common.Interceptor;

import com.auth0.jwt.interfaces.Claim;
import com.gl.crpt.system.entity.User;
import com.gl.crpt.system.service.UserService;
import com.gl.crpt.system.util.BadRequestException;
import com.gl.crpt.system.util.TokenUtil;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.util.Map;


@Component
public class LoginInterceptor implements HandlerInterceptor{

    private final String tokenHeader;//定义token
    private final UserService userService;

    public LoginInterceptor(@Value("${jwt.header}") String tokenHeader, UserService userService) {
        this.tokenHeader = tokenHeader;
        this.userService = userService;
    }


    /**
     * 拦截（Controller方法调用之前）
     *
     * @param request  request
     * @param response response
     * @param o        o
     * @return 通过与否
     * @throws Exception 异常处理
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object o) throws Exception {


        HttpSession session = request.getSession();//获取session

     

        //获取token
        final String requestHeader = request.getHeader(this.tokenHeader);


        String username = null;
        String authToken = null;
        if (requestHeader != null && requestHeader.startsWith("Bearer ")) {
            //获取token中Bearer的值
            authToken = requestHeader.substring(7);
            try {
                //从token中获取username
                Map<String, Claim> stringClaimMap = TokenUtil.verifyToken(authToken);
                System.out.println(stringClaimMap);
                username = stringClaimMap.get("token").asString();

                User users = (User) userService.findByName(username);
                session.setAttribute("user",users);//将用户信息存入seesion中
                //request.setAttribute("user",users);
//                username = jwtTokenUtil.getUsernameFromToken(authToken);

                return true;
            } catch (Exception e) {

                //log.error(e.getMessage());
                throw new BadRequestException("token已经失效");
            }
        }
        System.out.println("没有token");
        throw new BadRequestException("token不存在，请些登录账号");
    }

    // 此方法为处理请求之后调用（调用过controller方法之后，跳转视图之前）
    @Override
    public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o,
                           ModelAndView modelAndView) throws Exception {

    }

    // 此方法为整个请求结束之后进行调用
    @Override
    public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse,
                                Object o, Exception e) throws Exception {

    }





}

2.配置拦截器生效

package com.gl.crpt.common.Interceptor;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;


/**
 * 配置拦截器
 */
@Configuration
public class MyHandlerInterceptorConfig implements WebMvcConfigurer {

    @Autowired
    private LoginInterceptor loginInterceptor;


    // 这个方法用来注册拦截器，我们自己写好的拦截器需要通过这里添加注册才能生效
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // addPathPatterns("/**") 表示拦截所有的请求，
        // excludePathPatterns("/login", "/register") 表示除了登陆与注册之外，因为登陆注册不需要登陆也可以访问
        registry.addInterceptor(loginInterceptor)
                //.excludePathPatterns("**/api/login")
                .excludePathPatterns("/loginsss")//测试
                .excludePathPatterns("/error")
                .excludePathPatterns("/swagger-ui.html")//api接口文档
                .excludePathPatterns("/swagger-resources/**")//api接口文档
                .excludePathPatterns("/webjars/**")//api接口文档
                .excludePathPatterns("/*/api-docs")//api接口文档
                .excludePathPatterns("/*/yzm")//图片验证码
                .excludePathPatterns("/*/img")//图片验证码
                .excludePathPatterns("/*/addusr")//注册
                .excludePathPatterns("/*/email")//邮箱
                .excludePathPatterns("/*/all")//获取所有企业
                .excludePathPatterns("/*/allaoe")//获取所有aoe等级
                .addPathPatterns("/**")//拦截所有
        ;
    }



}

3.创建和获取token

package com.gl.crpt.system.util;

import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTVerifier;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.interfaces.Claim;
import com.auth0.jwt.interfaces.DecodedJWT;

import java.io.UnsupportedEncodingException;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

public class TokenUtil {



    /**
     * 公共密钥
     */
    public static final String SECRET = "michong";


    /**
     * 创建token
     * @return
     * @throws UnsupportedEncodingException
     */
    public static String createToken(String tokens) throws UnsupportedEncodingException {

        //签发时间
        Date date = new Date();

        //过期时间- 1分钟过期
        Calendar nowTime = Calendar.getInstance();
        nowTime.add(Calendar.MINUTE,600);
        Date expiresDate = nowTime.getTime();

        Map<String,Object> map = new HashMap<>();
        map.put("alg","HS256");
        map.put("typ","JWT");
        String token = JWT.create()
                .withClaim("token", tokens)
                //设置过期时间
                .withExpiresAt(expiresDate)
                //设置签发时间
                .withIssuedAt(date)
                .sign(Algorithm.HMAC256(SECRET));

        return token;
    }


    /**
     * 解密
     * @param token
     * @return
     * @throws UnsupportedEncodingException
     */
    public static Map<String, Claim> verifyToken(String token) throws UnsupportedEncodingException {

        JWTVerifier verifier = JWT.require(Algorithm.HMAC256(SECRET))
                .build();

        DecodedJWT jwt = null;

        try{

            //解密
            jwt = verifier.verify(token);

        }catch (Exception e){
            throw new RuntimeException("token已经失效");
        }

        return jwt.getClaims();

    }



}