标签：拦截器 return 前后 springframework token error 使用 import response

jwt拦截器

添加jjwt的依赖

<!--token依赖  jjwt-->
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.7.0</version>
</dependency>

token的配置

jwt:
  config:
    key: dfbz #token密钥
    exp: 6000 #过期时间
    prefix: dfbz_ #密钥前缀

创建token

package com.example.demo.utils;


import io.jsonwebtoken.Claims;
import io.jsonwebtoken.JwtBuilder;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import lombok.Data;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.core.env.Environment;

import java.util.Date;

//yml配置文件
@ConfigurationProperties("jwt.config")
@Data
public class CreateJWTUtil {

    @Autowired
    private Environment env;


    private String key;
private long exp;
private String prefix;
    /**
     * 签发jwt
     * @param id
     * @param username
     * @param role
     * @return
     */
    public String createJwt(Integer id,String username,String role){
        long nowMillis = System.currentTimeMillis();
        String exp = env.getProperty("jwt.config.exp");
        int a = Integer.valueOf(exp);
        Date now =new Date(nowMillis);
        JwtBuilder builder= Jwts.builder()
                .setId(String.valueOf(id))
                //设置密钥
                .signWith(SignatureAlgorithm.HS256,key)
                //用户名
                .setSubject(username)
                //角色权限
                .claim("role",role)
                //token创建时间
                .setIssuedAt(now)
                //设置token过期时间
                .setExpiration(new Date(nowMillis+a));

        return builder.compact();
    }

    /**
     * 解析token
     * @param token
     * @return
     */
    public Claims parseJwt(String token){
        Claims claims = Jwts.parser()
                //当初签发时的秘钥
                .setSigningKey(key)
                //token字符串
                .parseClaimsJws(token)
                .getBody();
        return claims;
    }
}

拦截器的设置

package com.example.demo.Interceptor;

import com.alibaba.fastjson.JSON;
import com.example.demo.utils.CreateJWTUtil;
import io.jsonwebtoken.Claims;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.env.Environment;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.PrintWriter;
import java.util.HashMap;

@Component
public class JwtInterceptor extends HandlerInterceptorAdapter {
    @Autowired
    private CreateJWTUtil jwtUtil;
    @Autowired
    private Environment env;

    /**
     * 拦截器验证token
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String auth = request.getHeader("auth");
        //配置文件的数据
        String prefix = env.getProperty("jwt.config.prefix");
        //auth.startsWith(prefix)以什么开头
        if (!StringUtils.isEmpty(auth)&& auth.startsWith(prefix)){
            //截取token
            String token = auth.substring(prefix.length());
            //解析token
            Claims claims = jwtUtil.parseJwt(token);


            if (null != claims && !StringUtils.isEmpty(claims.get("sub"))){
                return true;
            }
        }
        response.setCharacterEncoding("utf8");
        response.setContentType("application/json;charset=UTF-8");
        HashMap<String, Object> ma = new HashMap<>();
        ma.put("code",response.SC_UNAUTHORIZED);
        ma.put("msg","请重新登录");
        PrintWriter writer = response.getWriter();
        writer.println(JSON.toJSONString(ma));//转换成JSON格式返回
        return false;
    }
}

选择需要验证token的接口

package com.example.demo.config;

import com.example.demo.Interceptor.JwtInterceptor;
import org.springframework.context.annotation.Bean;
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 TokenConfig implements WebMvcConfigurer {

    @Bean
    public JwtInterceptor myHandlerInterceptor() {
        return new JwtInterceptor();
    }

    @Override
    public void addInterceptors(InterceptorRegistry registry){
        registry.addInterceptor(myHandlerInterceptor())
        		//选择全部接口
                .addPathPatterns("/**")
                //登录接口除外
                .excludePathPatterns("/cutFood/login");
    }
}

登录生成token

Login getObjLogin = loginService.login(userName,password);
if(getObjLogin!=null){
    String token = jwtUtil.createJwt(1, userName, "admin");
    return JsonRes.ok().data("token",token).data("getObjLogin",getObjLogin);
}else {
    return JsonRes.error();
}

vue验证token

		let _this = this
        _this.$http.get(_this.$apiUrl+'cutFood/login', { params: { userName: _this.loginData.userName, password: _this.loginData.password } }).then(function (response) {
          if (response.data.msg === '成功') {
            sessionStorage.setItem("token",response.data.data.token)//前端存储token
            _this.$message({
              type: 'success',
              message: '登录成功'
            })
            _this.$router.replace('/menu')
          } else {
            _this.$message({
              type: 'error',
              message: '账号密码错误'
            })
          }
        }).catch(function (error) { console.log(error) });

在main.js里面添加请求拦截器

axios.interceptors.request.use(
  config => {
    if (sessionStorage.getItem("token") != null || sessionStorage.getItem("token") != '') { // 判断是否存在token，如果存在的话，则每个http header都加上token
      var token = "dfbz_" + sessionStorage.getItem("token");//获取前端存储的token,拼接后端秘钥前缀
      config.headers.auth = token  //请求头与后端验证token的auth一致
      return config;
    } else {
      this.$router.replace("/")
    }
  },
  err => {
    return Promise.reject(err);
  }

)

响应拦截

axios.interceptors.response.use((success) => {
  if (success.status && success.status === 200) {
     if (success.data.code === 500 || success.data.code === 401 || success.data.code === 403) {   //接口请求成功，业务逻辑错误
        return;
     }
     if (success.data.msg==="请重新登录") {
        router.replace("/")
        return response;
     }
  }
  return success.data;
}, (error) => {
  if (error.response.code == 504 || error.response.code == 404) {
     Message.error({ message: '服务器被吃了( ╯□╰ )' });
  } else if (error.response.code == 403) {
     Message.error({ message: '权限不足，请联系管理员' });
  } else if (error.response.code == 401) {
     Message.error({ message: '请登录账号' });
     router.replace('/');
  } else {
     if (error.response.message) {
        Message({ message: error.response.message });
     } else {
        Message({ message: '该错误触及盲区(●ˇ∀ˇ●)' });
     }
  }
})

标签：拦截器,return,前后,springframework,token,error,使用,import,response
来源： https://blog.csdn.net/weixin_45598128/article/details/119379184

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。