springboot + vue 后台token生成 拦截器 redis实现 前台封装axios xueX 接口实现

本文主要是介绍springboot + vue 后台token生成 拦截器 redis实现 前台封装axios xueX 接口实现，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

后台
后台程序图片

1. 新建token的基础类

public class Constants {

	public final static String TOKEN = "token";

}

2. 配置redis
   pom.xml中添加依赖

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

application.yml中配置（注意在spring下）

server:
  port: 8088
spring:
  redis:
    database: 0
    host: localhost
    port: 6379
    timeout: 10000ms
    password:
    jedis:
      pool:
        max-active: 200
        max-wait: -1ms
        max-idle: 8
        min-idle: 0
token:
  #登录生成的token在redis中保存的有效期，单位：秒
  expires: 1000
  timeout: true
aes:
  #AES登录密码加密的私钥，要求长度必须为16位。
  key: hj7x89HTyuBI0452

添加redis工具类

/**
 * redis 数据操作工具类
 */
@Component
public class RsUtil {

  @Resource
  public RedisTemplate<String, String> redisTemplate;

  @Autowired
  public PropertiesConfig properties;

  /**
   * 将数据插入redis
   *
   * @param key   索引
   * @param value 值
   */
  public void set(String key, String value) {
    ValueOperations<String, String> valueOperations = redisTemplate.opsForValue();
    if (properties.isTimeout()) {
      valueOperations.set(key, value, properties.getTokenExpires().longValue(), TimeUnit.SECONDS);
    } else {
      valueOperations.set(key, value);
    }
  }

  /**
   * 删除redis中数据
   *
   * @param key 索引
   */
  public void del(String key) {
    ValueOperations<String, String> vo = redisTemplate.opsForValue();
    RedisOperations<String, String> operations = vo.getOperations();
    operations.delete(key);
  }

  /**
   * 查询redis中数据
   *
   * @param key 索引
   * @return 查询结果
   */
  public String get(String key) {
    ValueOperations<String, String> valueOperations = redisTemplate.opsForValue();
    String value = valueOperations.get(key);
    if (value != null && !value.equals("")) {
      set(key, value);
    }
    return value;
  }

}

至此redis已配置完，接下来开始配置拦截器
首先配置下依赖 fastjson 依赖 （json-object数据转换）

<dependency>
	      <groupId>com.alibaba</groupId>
	      <artifactId>fastjson</artifactId>
	      <version>1.2.69</version>
	    </dependency>

先写一个请求信息获取类ServletUtils

/**
 * 请求信息获取工具类
 */
public class ServletUtils {

	/**
	 * 获取配置信息
	 * @return 配置信息
	 */
	public static ServletRequestAttributes getRequestAttributes() {
		RequestAttributes attributes = RequestContextHolder.getRequestAttributes();
		return (ServletRequestAttributes) attributes;
	}

	/**
	 * 获取请求信息
	 * @return 请求信息
	 */
	public static HttpServletRequest getRequest() {
		return getRequestAttributes().getRequest();
	}

	/**
	 * 获取返回信息
	 * @return 返回信息
	 */
	public static HttpServletResponse getResponse() {
		return getRequestAttributes().getResponse();
	}

	/**
	 * 获取指定header信息
	 * @param header 指定header信息
	 * @return header信息
	 */
	public static String getHeader(String header) {
		return getRequestAttributes().getRequest().getHeader(header);
	}

	/**
	 * 获取session信息
	 * @return session信息
	 */
	public static HttpSession getSession() {
		return getRequest().getSession();
	}
}

再在config包下新建一个系统配置信息读取类PropertiesConfig

/**
 * 系统配置信息读取类
 */
@Component
public class PropertiesConfig {

  /**
   * token有效时间
   **/
  @Value("${token.expires}")
  private Integer tokenExpires;

  /**
   * 密码加密私钥
   **/
  @Value("${aes.key}")
  private String aesKey;

  /**
   * 是否设置token超时
   */
  @Value("${token.timeout}")
  private boolean timeout;

  /**
   * 取得加密私钥
   *
   * @return 加密私钥
   */
  public String getAesKey() {
    return aesKey;
  }

  /**
   * 设定加密私钥
   *
   * @param aesKey 加密私钥
   */
  public void setAesKey(String aesKey) {
    this.aesKey = aesKey;
  }


  /**
   * 取得token有效时间
   *
   * @return token有效时间
   */
  public Integer getTokenExpires() {
    return tokenExpires;
  }

  /**
   * 设定token有效时间
   *
   * @param tokenExpires token有效时间
   */
  public void setTokenExpires(Integer tokenExpires) {
    this.tokenExpires = tokenExpires;
  }

  /**
   * 取得token是否超时
   *
   * @return token是否超时
   */
  public boolean isTimeout() {
    return timeout;
  }

  /**
   * 设定token是否超时
   *
   * @param timeout 是否超时
   */
  public void setTimeout(boolean timeout) {
    this.timeout = timeout;
  }

}

新建包.handler添加拦截器的类RequestInterceptorHandler

/**
 * HTTP请求拦截器
 */
public class RequestInterceptorHandler implements HandlerInterceptor {

  private static Logger logger = LoggerFactory.getLogger(RequestInterceptorHandler.class);

  @Autowired
  public RsUtil rsUtil;

  /**
   * 拦截器拦截请求
   *
   * @param request  请求体
   * @param response 请求结果
   * @param handler  其他
   * @return 请求结果
   */
  @Override
  public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {

    try {
      response.setHeader("Access-Control-Allow-Origin", "*");
      response.setHeader("Access-Control-Allow-Headers", "content-type,token");
      response.setHeader("Access-Control-Allow-Method", "*");

      
      if (!request.getRequestURI().equals("/rest/admin/login")          // 特殊接口不拦截   登录接口
          && !request.getRequestURI().equals("/res/admin/logout")         // 特殊接口不拦截 登出接口

      ) {
        if (!request.getMethod().equals("OPTIONS")) {
          String token = request.getHeader(Constants.TOKEN);
          if (token == null || token.equals("") || rsUtil.get("token") == null) {
            response.setContentType("application/json;charset=utf-8");
            PrintWriter out = response.getWriter();
            Map<String, Object> message = new HashMap<>();
            message.put("msg", "用户信息已过期");
            message.put("code", "1101");
            out.write(new ObjectMapper().writeValueAsString(message));
            out.flush();
            out.close();
            return false; // 直接可以返回到前台 前后用response.code接受就等于1101
          }
        }
      }
      return HandlerInterceptor.super.preHandle(request, response, handler);
    } catch (Exception e) {
      logger.info(e.getMessage());
    }
    return false;

  }

}

然后配置装载上面的拦截器类，放入spring容器内运行

/**
 *拦截器
 */
@Configuration
public class WebMvcConfig implements WebMvcConfigurer {

  @Override
  public void addInterceptors(InterceptorRegistry registry) {
    registry.addInterceptor(getMyInterceptor()).addPathPatterns("/rest/**"); // 拦截所有/rest的请求
  }

  @Bean
  public RequestInterceptorHandler getMyInterceptor(){
    return new RequestInterceptorHandler();// 自己定义写的拦截器
  }
}

在controller中登录接口获取token保存到redis并返回给前台

    @ApiOperation("login")
    @ApiImplicitParams({})
    @ResponseBody
    @RequestMapping(value = "/login", method = RequestMethod.POST)
    public ReturnDto login(@RequestBody UserDto user) {
    	String token = CommonUtils.getRandom();
    	rsUtil.set("token", token);
        if (user.getUsername().equals("admin") && user.getPassword().equals("123456")) {
        	return CommonUtils.returnDto(rsUtil.get("token"));
        	}  else {
        	return new ReturnDto(ResultCodeUtil.FAIL);
        }
    }

这篇关于springboot + vue 后台token生成 拦截器 redis实现 前台封装axios xueX 接口实现的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！