SpringBoot项目 用户登录JWT技术，登录拦截

1.JWT技术

登录使用JWT技术。

jwt 可以生成 一个加密的token，做为用户登录的令牌，当用户登录成功之后，发放给客户端。

请求需要登录的资源或者接口的时候，将token携带，后端验证token是否合法。

jwt 有三部分组成：A.B.C

A：Header，{“type”:“JWT”,“alg”:“HS256”} 固定

B：playload，存放信息，比如，用户id，过期时间等等，可以被解密，不能存放敏感信息

C: 签证，A和B加上秘钥 加密而成，只要秘钥不丢失，可以认为是安全的。

jwt 验证，主要就是验证C部分 是否合法。

pom.xml导入依赖包：

 <dependency>
     <groupId>io.jsonwebtoken</groupId>
     <artifactId>jjwt</artifactId>
     <version>0.9.1</version>
 </dependency>

 <dependency> <!--md5加密的依赖包-->
     <groupId>commons-codec</groupId>
     <artifactId>commons-codec</artifactId>
 </dependency>

jwt工具类，一般放在utils目录包下

import com.fwind.blog.service.impl.LoginServiceImpl;
import io.jsonwebtoken.Jwt;
import io.jsonwebtoken.JwtBuilder;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.apache.commons.codec.digest.DigestUtils;

import java.util.Date;
import java.util.HashMap;
import java.util.Map;
//jwt token令牌分为 A.B.C 三部分
public class JWTUtils {

    private static final String jwtToken = "123456abc@##$"; //token密钥,可自定义

	//生成token
    public static String createToken(Long userId){	//参数为用户Id
        Map<String,Object> claims = new HashMap<>();
        claims.put("userId",userId);

        JwtBuilder jwtBuilder = Jwts.builder()
                .signWith(SignatureAlgorithm.HS256, jwtToken) // 签发算法，秘钥为jwtToken
                .setClaims(claims) // body数据，要唯一，自行设置
                .setIssuedAt(new Date()) // 设置签发时间
                .setExpiration(new Date(System.currentTimeMillis() + 24 * 60 * 60 * 60 * 1000));//过期时间 一天的有效时间

        String token = jwtBuilder.compact();
        return token;
    }

	//检查token是否合法，合法则取出数据
    public static Map<String, Object> checkToken(String token){
        try {
            Jwt parse = Jwts.parser().setSigningKey(jwtToken).parse(token);
            return (Map<String, Object>) parse.getBody();
        }catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }

	//以下是测试部分，可以删去
    public static void main(String[] args) {
        String token = JWTUtils.createToken(100l);
        System.out.println(token);
        Map<String, Object> map = JWTUtils.checkToken(token);
        System.out.println(map.get("userId"));
    }

}

2.登录注册-代码实现

前端请求参数
路径：/login
请求方式：POST

参数名	参数类型	说明
account	String	账号
password	String	密码

后端登录参数类

import lombok.Data;

@Data
public class LoginParam {

    private String account;

    private String password;

    private String nickname; //注册需要的参数
}

Controller层

@RestController
@RequestMapping("/")
public class LoginController {

    @Autowired
    private LoginService loginService;
	//用户登录
    @PostMapping("login")
    public Result login(@RequestBody LoginParam loginParam){
        return loginService.login(loginParam);
    }
	//退出登录
    @GetMapping("logout")	//Authorization为前端请求参数，保存在头部
    public Result logout(@RequestHeader("Authorization") String token){
        return loginService.logout(token);
    }
    //注册
    @PostMapping("register")
    public Result register(@RequestBody LoginParam loginParam){
        return loginService.register(loginParam);
    }
}

Service层

@Service
@Transactional //事务：若添加用户出错(如服务器崩了)，数据库不能有数据
public class LoginServiceImpl implements LoginService {

    private static final String slat = "rngnb!@###"; //加密盐

    @Autowired
    private SysUserService sysUserService;

    @Autowired
    private RedisTemplate<String,String> redisTemplate;

    @Override
    public Result login(LoginParam loginParam) {
        /*
        1.检查参数是否合法
        2.根据用户名密码查询user是否存在
        3.不存在 登陆失败
        4.存在使用jwt 生成token返回给前端
        5.将token放入redis中，redis token:user信息，设置过期时间
        （登录认证先认证字符串是否合法，再去redis认证是否存在）
         */
        String account = loginParam.getAccount();
        String password = loginParam.getPassword();
        if(StringUtils.isBlank(account)||StringUtils.isBlank(password)){
            return Result.fail(ErrorCode.PARAMS_ERROR.getCode(),ErrorCode.PARAMS_ERROR.getMsg());
        }
        password = DigestUtils.md5Hex(password +slat); //密码加密(增加加密盐),因为数据库保存的密码经过了md5加密
        SysUser user = sysUserService.findUser(account, password);  //找到对应的user对象
        if(user == null){ //若用户不存在，返回错误信息（自定义错误码）
            return Result.fail(ErrorCode.ACCOUNT_PWD_NOT_EXIST.getCode(),ErrorCode.ACCOUNT_PWD_NOT_EXIST.getMsg());
        }
		//用户存在，则创建token
        String token = JWTUtils.createToken(user.getId());
        //将user对象转化为Json字符串放入redis
        redisTemplate.opsForValue().set("TOKEN_"+token, JSON.toJSONString(user),1, TimeUnit.DAYS); //1天过期时间

        return Result.success(token); //token返回给前端
    }

    //检验token，主要给拦截处理器使用
    @Override
    public SysUser checkToken(String token) {
        /*
        1.token合法性校验（是否为空，解析是否成功，redis是否存在）
        2.校验失败，返回错误；校验成功，返回结果LoginVo
         */
        if(StringUtils.isBlank(token)){
            return null;
        }
        //判断token是否能解析成功
        Map<String, Object> stringObjectMap = JWTUtils.checkToken(token);
        if(stringObjectMap == null){
            return null;
        }

        //从rides拿到对应user json字符串
        String userJSON = redisTemplate.opsForValue().get("TOKEN_" + token);
        if(StringUtils.isBlank(userJSON)){
            return null;
        }
        //把user json字符串解析为user对象
        SysUser sysUser = JSON.parseObject(userJSON, SysUser.class);
        return sysUser;
    }

    //退出登录
    @Override
    public Result logout(String token) {
        //后端只需要清除redis的token
        redisTemplate.delete("TOKEN_"+token);
        return Result.success(null);
    }

    //注册用户
    @Override
    public Result register(LoginParam loginParam) {
        String account = loginParam.getAccount();
        String password = loginParam.getPassword();
        String nickname = loginParam.getNickname();
        if(StringUtils.isBlank(account)||StringUtils.isBlank(password)||StringUtils.isBlank(nickname)){
            return Result.fail(ErrorCode.PARAMS_ERROR.getCode(),ErrorCode.PARAMS_ERROR.getMsg());
        }
        SysUser user = sysUserService.findUserByAccount(account);
        if(user != null){
            return Result.fail(ErrorCode.ACCOUNT_HAS_EXIST.getCode(), ErrorCode.ACCOUNT_HAS_EXIST.getMsg());
        }
        SysUser sysUser = new SysUser();
        sysUser.setNickname(nickname);
        sysUser.setAccount(account);
        sysUser.setPassword(DigestUtils.md5Hex(password+slat)); //密码加密
        sysUser.setCreateDate(System.currentTimeMillis());
        sysUser.setLastLogin(System.currentTimeMillis());
        sysUser.setAvatar("/static/img/logo.b3a48c0.png");
        sysUser.setAdmin(1); //1 为true
        sysUser.setDeleted(0); // 0 为false
        sysUser.setSalt("");
        sysUser.setStatus("");
        sysUser.setEmail("");
        this.sysUserService.save(sysUser); //mybatis-plus有自己的save方法 加了this用的是自己的save方法，id会自动增加

        //保存用户后，自动登录（同上）
        String token = JWTUtils.createToken(sysUser.getId());
        //将user对象转化为Json字符串放入redis
        redisTemplate.opsForValue().set("TOKEN_"+token, JSON.toJSONString(sysUser),1, TimeUnit.DAYS);

        return Result.success(token); //token返回给前端
    }


    //以下为测试，打印md5加密后的字符串，如密码123
    public static void main(String[] args) {
        System.out.println(DigestUtils.md5Hex("123" + LoginServiceImpl.slat));
    }
}

3.登录拦截

使用拦截器，进行登录拦截，遇到需要登录才能访问的接口时，若未登录，拦截器直接返回，并跳转登录页面。

WebMvcConfig.class
配置类，增加拦截器 ,一般在/config包下

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebMvcConfig implements WebMvcConfigurer {

    @Autowired
    private LoginInterceptor loginInterceptor;

    @Override   //跨域配置
    public void addCorsMappings(CorsRegistry registry) {
        //跨域配置，不可设置为*，不安全, 前后端分离项目，可能域名不一致
        //本地测试 端口不一致 也算跨域                        //允许该网址（8080端口）访问本域名
        registry.addMapping("/**").allowedOrigins("http://localhost:8080");
        
    }

    @Override  //增加拦截器
    public void addInterceptors(InterceptorRegistry registry) {
        /* 拦截所有路径，除了登录和注册接口 */
        registry.addInterceptor(loginInterceptor)
        .addPathPatterns("/**")
        .excludePathPatterns("/login")
        .excludePathPatterns("/register");
    }
}

登录拦截处理类，一般放/handler包下。
LoginInterceptor.class

import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@Component
@Slf4j  //日志
public class LoginInterceptor implements HandlerInterceptor {

    @Autowired
    private LoginService loginService;

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //在执行controller方法(handler)之前进行执行
        /**
         * 1.需要判断请求的接口路径是否为HandlerMethod（controller方法）
         * 2.判断token是否为空，如果为空 未登录
         * 3.token不为空，登录验证 loginService checkToken
         * 4.如果认证成功，放行
         */
        if(!(handler instanceof HandlerMethod)){
            //有可能是资源handler 如RequestResourceHandler，访问静态资源，直接放行
            return true;
        }
        String token = request.getHeader("Authorization"); //获取浏览器头部token

		//打印日志
        log.info("=================request start===========================");
        String requestURI = request.getRequestURI();
        log.info("request uri:{}",requestURI);
        log.info("request method:{}",request.getMethod());
        log.info("token:{}", token);
        log.info("=================request end===========================");

        if(StringUtils.isBlank(token)){ //检查token是否为空
            Result result = Result.fail(ErrorCode.NO_LOGIN.getCode(), "未登录");
            response.setContentType("application/json;charset=utf-8");
            response.getWriter().print(JSON.toJSONString(result)); //未登录,传给前端信息
            return false;
        }

        SysUser sysUser = loginService.checkToken(token);
        if(sysUser == null){  //检查token是否有用户信息
            Result result = Result.fail(ErrorCode.NO_LOGIN.getCode(), "未登录");
            response.setContentType("application/json;charset=utf-8");
            response.getWriter().print(JSON.toJSONString(result)); //未登录,传给前端信息
            return false;
        }
        //登录成功，放行，并将用户信息保存在 本地用户类（后面有介绍）
        UserThreadLocal.put(sysUser); //放入本地local
        return true;
    }

    @Override  //所以的方法都执行完之后，收尾工作
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        //如果不删除 ThreadLocal中用完的信息，会有内存泄露的风险
        UserThreadLocal.remove();
    }
}

4.本地用户信息

拦截处理后，把用户信息保存在本地，可能存在多个用户同时登录，这里采用多线程，这样互不干扰。

//保存登录后的用户信息（多线程）
public class UserThreadLocal {

    private UserThreadLocal(){} //私有构造方法

    //线程变量隔离（每个线程都有各自的LOCAL，互不干扰）  ThreadLocal屏蔽了线程间的通讯，避免了多线程问题
    private static final ThreadLocal<SysUser> LOCAL = new ThreadLocal<>(); //唯一初始化变量LOCAL

    public static void put(SysUser sysUser){
        LOCAL.set(sysUser);   //将user放入
    }

    public static SysUser get(){
        return LOCAL.get();
    }

    public static void remove(){
        LOCAL.remove();
    }
}

其他service层有逻辑需要可以直接获取本地用户，但要保证该controller层的路径增加了拦截，否则不会把用户信息保存在UserThreadLocal，如果前面拦截了所有路径则不用考虑了。

SysUser sysUser = UserThreadLocal.get();//要增加路径拦截，否则拿不到用户