JWT双令牌（双token）实现登录验证

目录

一、引入依赖

二、在service层下创建utils工具类包

三、颁发令牌

1. UserController类的login方法

2. UserService类中的login方法（刷新令牌）

3. UserService类中的loginForDts方法（双令牌）

4. 刷新accessToken

5. 删除refreshToken

6. 登录进行业务需验证短期令牌

四、总结

---

双令牌（Token）的原因：

如果用户在退出登录之后，token仍然处在有效期之内的话，那么用户仍然可以使用这个token去访问系统的资源，那这样的话，显然它不是一个正确的操作。所以退出登录的时候必须清除token。

用户退出登录之后，按理说他就不应该再访问到系统的任何跟用户相关的这种资源了。所以说为了防止这种情况呢，我们引入一个双token的机制，同时这种机制还可以用于对用户进行一个无感的这种有效时间的刷新，什么意思呢？比如说咱们这种单token的情况。可接入的，那么这个token呢它是一个有效期的一般会设置在一到两个小时，或者2~3个小时之内。那么当这个token快要过期的时候，如果没有我们所说的这个刷新token的话，那么这时候系统呢会直接提示用户，您已经您的投票已经过期，请重新登录。那这样的话，其实对用户造成一个不是很好的用户体验，那可能我正在看视频，或者说正在刷一些这种最新的资讯。系统突然跟我说，哎呀，你已经退出登录了，请重新登录，这样的话是不是会让我们很反感？

所以说为了应对这种情况呢，我们引入了这个refresh token，那么这个工作的原理是什么呢？其实也非常简单，就是在我们用户登录成功之后啊，我们除了access token也就是这个接入token啊。或者说资源访问的这个之外，我们加一个这个刷新token，那么这个刷新token它的有效时长一般会比我们的接入token的时间长很多。就比如说刚才说到了这个接入token有效时长一般是两到三个小时，但是这个刷新token可以一般是七天，也就是一周或者说是两周左右。这样一个有效的时长，那么只要我们的这个refresh token，也就是刷新token。它一直有效，那么我就可以在这个时间段之内用refresh token对我们用户的access token进行一个刷新，也就是延长我们这个token的有效期。虽然用户退出的时候短期token不一定被清除，但是相对于频繁弹出token过期的消息，无感延长短期token的做法是更好的。

一、引入依赖

        <!--JWT-->
        <dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>3.19.0</version>
        </dependency>

二、在service层下创建utils工具类包

1. 创建MD5Util类

import org.apache.commons.codec.digest.DigestUtils;

import java.io.UnsupportedEncodingException;

/**
 * MD5加密
 * 单向加密算法
 * 特点：加密速度快，不需要秘钥，但是安全性不高，需要搭配随机盐值使用
 *
 */
public class MD5Util {

	// 加密
	public static String sign(String content, String salt, String charset) {
		content = content + salt;
		return DigestUtils.md5Hex(getContentBytes(content, charset));
	}

	public static boolean verify(String content, String sign, String salt, String charset) {
		content = content + salt;
		String mysign = DigestUtils.md5Hex(getContentBytes(content, charset));
		return mysign.equals(sign);
	}

	private static byte[] getContentBytes(String content, String charset) {
		if (!"".equals(charset)) {
			try {
				return content.getBytes(charset);
			} catch (UnsupportedEncodingException var3) {
				throw new RuntimeException("MD5签名过程中出现错误,指定的编码集错误");
			}
		} else {
			return content.getBytes();
		}
	}
}

2.创建RSAUtil类

import org.apache.commons.codec.binary.Base64;

import javax.crypto.Cipher;
import java.nio.charset.StandardCharsets;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

/**
 * RSA加密
 * 非对称加密，有公钥和私钥之分，公钥用于数据加密，私钥用于数据解密。加密结果可逆
 * 公钥一般提供给外部进行使用，私钥需要放置在服务器端保证安全性。
 * 特点：加密安全性很高，但是加密速度较慢
 *
 */
public class RSAUtil {

	private static final String PUBLIC_KEY = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCQk33iNdA8Iey7J6XrBsidqn6u8EDLWPHsfEUgLQ3qiTikhPKDTzZkpAfU/O0x6NvSKa7Dp0+uqWT3vnW1De0+3u8mCYdVfOdH94VG4xg5U5UrRJei8HhPiXuvKQ+6NBtebCCW5adZ4pBgOiU14cJLhVmm+dYiLo3IDD5LqrlomQIDAQAB";

	private static final String PRIVATE_KEY = "MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAJCTfeI10Dwh7LsnpesGyJ2qfq7wQMtY8ex8RSAtDeqJOKSE8oNPNmSkB9T87THo29IprsOnT66pZPe+dbUN7T7e7yYJh1V850f3hUbjGDlTlStEl6LweE+Je68pD7o0G15sIJblp1nikGA6JTXhwkuFWab51iIujcgMPkuquWiZAgMBAAECgYA1UT9mciQWWQh9yNRmhXzssFjB2TZ8B5RIe1fe0t7D9NEf0yvAgzDzEo8U3CX5dv/CVL7vxr8bEbt7phCwsa8hJiLEOr7hLZaJzXVTbvfqb91oCZGNkqDQ3NJfGBMVgUmltEYF2Bbk3U0NDyat+Gu54tRd2OH+adJYKsD0XYeDBQJBAN5FE8E04A4FA1q8mQbVTSVJDYIEJwOrdC0r3iZ7za5CyXGk+br8pFalRePFaksRGdN32+mYhDKVNrNHspAObVMCQQCmhBsD+xiWrmpnrzeIfCW1cX8qRC3/RMkq0ACw3l6YedNFdN2Tb5WsRHmcbCI9y8mfLHiG/X1R+zHZKG67EKjjAkAmvAkGSY2mQ89i160fWLq5/bIh71FRPWbgnF15fWfJr4/lgyeWI4MMKn80g2nTrSZACQpE+jRHkGNY+OywWCNLAkEAli5nvztkfeJpDYK2b16pE/B9ZL2BTs3XMcnQFbU5VAPsTKSOgz8MmwZXOIE+kMWP3wPY4McXlC0eVGFnHUh1SQJAeAl3RPk+XbZDMYfPkStRJwocG9Ap+88mwTgR1I7uPzZ1aM84/WsQskiVMXv2SZLmMWvYtnhIKosL6IACp2AcDA==";

	public static void main(String[] args) throws Exception{
		String str = RSAUtil.encrypt("123456");
		System.out.println(str);
	}

	public static String getPublicKeyStr(){
		return PUBLIC_KEY;
	}

	public static RSAPublicKey getPublicKey() throws Exception {
		byte[] decoded = Base64.decodeBase64(PUBLIC_KEY);
		return (RSAPublicKey) KeyFactory.getInstance("RSA")
				.generatePublic(new X509EncodedKeySpec(decoded));
	}

	public static RSAPrivateKey getPrivateKey() throws Exception {
		byte[] decoded = Base64.decodeBase64(PRIVATE_KEY);
		return (RSAPrivateKey) KeyFactory.getInstance("RSA")
				.generatePrivate(new PKCS8EncodedKeySpec(decoded));
	}

	// 生成公钥和私钥
	public static RSAKey generateKeyPair() throws NoSuchAlgorithmException {
		KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
		keyPairGen.initialize(1024, new SecureRandom());
		KeyPair keyPair = keyPairGen.generateKeyPair();
		RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
		RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
		String publicKeyString = new String(Base64.encodeBase64(publicKey.getEncoded()));
		String privateKeyString = new String(Base64.encodeBase64(privateKey.getEncoded()));
		return new RSAKey(privateKey, privateKeyString, publicKey, publicKeyString);
	}

	public static String encrypt(String source) throws Exception {
		byte[] decoded = Base64.decodeBase64(PUBLIC_KEY);
		RSAPublicKey rsaPublicKey = (RSAPublicKey) KeyFactory.getInstance("RSA")
				.generatePublic(new X509EncodedKeySpec(decoded));
		Cipher cipher = Cipher.getInstance("RSA");
		cipher.init(1, rsaPublicKey);
		return Base64.encodeBase64String(cipher.doFinal(source.getBytes(StandardCharsets.UTF_8)));
	}

	public static Cipher getCipher() throws Exception {
		byte[] decoded = Base64.decodeBase64(PRIVATE_KEY);
		RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) KeyFactory.getInstance("RSA")
				.generatePrivate(new PKCS8EncodedKeySpec(decoded));
		Cipher cipher = Cipher.getInstance("RSA");
		cipher.init(2, rsaPrivateKey);
		return cipher;
	}

	public static String decrypt(String text) throws Exception {
		Cipher cipher = getCipher();
		byte[] inputByte = Base64.decodeBase64(text.getBytes(StandardCharsets.UTF_8));
		return new String(cipher.doFinal(inputByte));
	}
	
	public static class RSAKey {
		  private RSAPrivateKey privateKey;
		  private String privateKeyString;
		  private RSAPublicKey publicKey;
		  public String publicKeyString;

		  public RSAKey(RSAPrivateKey privateKey, String privateKeyString, RSAPublicKey publicKey, String publicKeyString) {
		    this.privateKey = privateKey;
		    this.privateKeyString = privateKeyString;
		    this.publicKey = publicKey;
		    this.publicKeyString = publicKeyString;
		  }

		  public RSAPrivateKey getPrivateKey() {
		    return this.privateKey;
		  }

		  public void setPrivateKey(RSAPrivateKey privateKey) {
		    this.privateKey = privateKey;
		  }

		  public String getPrivateKeyString() {
		    return this.privateKeyString;
		  }

		  public void setPrivateKeyString(String privateKeyString) {
		    this.privateKeyString = privateKeyString;
		  }

		  public RSAPublicKey getPublicKey() {
		    return this.publicKey;
		  }

		  public void setPublicKey(RSAPublicKey publicKey) {
		    this.publicKey = publicKey;
		  }

		  public String getPublicKeyString() {
		    return this.publicKeyString;
		  }

		  public void setPublicKeyString(String publicKeyString) {
		    this.publicKeyString = publicKeyString;
		  }
		}
}

3.创建TokenUtil类

import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTVerifier;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.exceptions.TokenExpiredException;
import com.auth0.jwt.interfaces.DecodedJWT;
import com.yygs.bilibili.domain.constant.CodeConstant;
import com.yygs.bilibili.domain.constant.TokenConstant;
import com.yygs.bilibili.exception.ConditionException;

import java.util.Calendar;
import java.util.Date;

public class TokenUtil {

    public static String generateToken(Long userId) throws Exception {
        Algorithm algorithm = Algorithm.RSA256(RSAUtil.getPublicKey(), RSAUtil.getPrivateKey());
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(new Date());

        //第二个参数为自定义的常量Constant，token过期时间，为60*60=1小时
        calendar.add(Calendar.SECOND, TokenConstant.EXPIRE_TIME_60_60); 

        // 生成含userId的token,以后登录都只通过Header携带的token解析出userId进行业务
        return JWT.create().withKeyId(String.valueOf(userId))
                .withIssuer(TokenConstant.ISSUER)
                .withExpiresAt(calendar.getTime())
                .sign(algorithm);
    }

    public static Long verifyToken(String token) {
        Algorithm algorithm = null;
        try {
            algorithm = Algorithm.RSA256(RSAUtil.getPublicKey(), RSAUtil.getPrivateKey());
            JWTVerifier verifier = JWT.require(algorithm).build();
            DecodedJWT jwt = verifier.verify(token);
            String userId = jwt.getKeyId();
            return Long.valueOf(userId);
        } catch (TokenExpiredException e) {
            throw new ConditionException(CodeConstant.TOKEN_OVERDUE,"token已过期！");
        } catch (Exception e) {
            throw new ConditionException("非法用户token！");
        }
    }

    public static String generateRefreshToken(Long userId) throws Exception {
        Algorithm algorithm = Algorithm.RSA256(RSAUtil.getPublicKey(),RSAUtil.getPrivateKey());
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(new Date());

        // refreshToken的过期时间持续比较长，为60*60*24*7=7天
        calendar.add(Calendar.SECOND, TokenConstant.EXPIRE_TIME_60_60_24_7);
        return JWT.create().withKeyId(String.valueOf(userId))
                .withIssuer(TokenConstant.ISSUER)
                .withExpiresAt(calendar.getTime())
                .sign(algorithm);
    }
}

三、颁发令牌

1. UserController类的login方法

在login中，登陆成功则给用户发单个token

    @PostMapping("/user-tokens")
    public JsonResponse<String> login(@RequestBody User user) throws Exception {
        String token = userService.login(user);
        return new JsonResponse<>(token);
    }

2. UserService类中的login方法（刷新令牌）

//  加密算法的盐值，新增用户的时候和解析密码的时候用到
String salt = String.valueOf(now.getTime());

    public String login(User user) throws Exception {
        
        ..
        登录需要的条件判断
        ..

        String password = user.getPassword();
        String rawPassword;
        try {
            rawPassword =  RSAUtil.decrypt(password);
        } catch (Exception e) {
            throw new ConditionException("密码解析失败！");
        }
        String salt = dbUser.getSalt();
        String md5Password = MD5Util.sign(rawPassword, salt, "UTF-8");
        if (!md5Password.equals(dbUser.getPassword())) {
            throw new ConditionException("密码错误！");
        }
        
        //验证通过所有条件，则颁发携带userId的token给前端
        String Token = TokenUtil.generateToken(dbUser.getId());    
        return accessToken;
    }

3. UserService类中的loginForDts方法（双令牌）

用这个方法生成时间一长一短的两个令牌返回给前端，同时将长时间的token存到数据库中。短的令牌accessToken过期的时候，前端可以再次通过长时间的令牌refreshToken访问后端来刷新短时间的令牌。

    public Map<String, Object> loginForDts(User user) throws Exception {
        
        ..
        登录的条件验证
        ..

        String password = user.getPassword();
        String rawPassword;
        try {
            rawPassword =  RSAUtil.decrypt(password);
        } catch (Exception e) {
            throw new ConditionException("密码解析失败！");
        }
        String salt = dbUser.getSalt();
        String md5Password = MD5Util.sign(rawPassword, salt, "UTF-8");
        if (!md5Password.equals(dbUser.getPassword())) {
            throw new ConditionException("密码错误！");
        }
        Long userId = dbUser.getId();

        // 生成双Token，access和refresh
        String accessToken = TokenUtil.generateToken(userId);
        String refreshToken = TokenUtil.generateRefreshToken(userId);

        // 保存refresh token到数据库
        userDao.deleteRefreshToken(refreshToken, userId);
        userDao.addRefreshToken(refreshToken, userId, new Date());
        Map<String, Object> result =new HashMap<>();
        
        //  将双token返回给前端
        result.put("accessToken", accessToken);
        result.put("refreshToken", refreshToken);
        return result;
    }

4. 刷新accessToken

当短时间的token过期，前端需要通过长时间的token来访问后端，并且生成一个短时间的token返回给前端，也就是刷新短时间的token。

在UserController类创建刷新token的方法

    @PostMapping("/access-tokens")
    public JsonResponse<String> refreshAccessToken(HttpServletRequest request) throws Exception {
        String refreshToken = request.getHeader("refreshToken");
        String accessToken = userService.refreshAccessToken(refreshToken);
        return new JsonResponse<>(accessToken);
    }

UserService类中实现刷新方法

同时也可以在刷新短期令牌的时候对refreshToken进行一个刷新，此时需要给前台发短期令牌的同时也发一个长期令牌，而且此时也必须要对数据库的长期令牌进行更新！！！

    public String refreshAccessToken(String refreshToken) throws Exception {
        
        //  从数据库中查询refreshToken
        RefreshTokenDetail refreshTokenDetail = userDao.getRefreshAccessToken(refreshToken);
        if (refreshTokenDetail == null) {
            throw new ConditionException(CodeConstant.TOKEN_OVERDUE,"token已过期！");
        }
        
        // 没过期则生成一个新的token返回给前端
        Long userId = refreshTokenDetail.getUserId();
        String accessToken = TokenUtil.generateToken(userId);

        /**
        *同时也可以在刷新短期令牌的时候对refreshToken进行一个刷新
        *此时需要给前台发短期令牌的同时也发一个长期令牌
        *而且此时必须要对数据库的长期令牌进行更新！！！
        */        

        return accessToken；
    }

5. 删除refreshToken

当用户退出的时候我们需要删除数据库中的refreshToken。

UserController类中的logout方法

    @DeleteMapping("/refresh-tokens")
    public JsonResponse<String> logout(HttpServletRequest request) {
        String refreshToken = request.getHeader("refreshToken");
        Long userId = userSupport.getCurrentUserId();
        userService.logout(refreshToken, userId);
        return JsonResponse.success();
    }

UserService类实现删除数据库中的refreshToken操作

    public void logout(String refreshToken, Long userId) {
        userDao.deleteRefreshToken(refreshToken, userId);
    }

6. 登录进行业务需验证短期令牌

除了刷新短期令牌需要用到refreshToken之外，其他的业务访问都先需要通过下面的UserSupport的getCurrentUserId()方法来通过短期令牌来获取userId，再进行业务操作。

import com.yygs.bilibili.exception.ConditionException;
import com.yygs.bilibili.service.utils.TokenUtil;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

@Component
public class UserSupport {

    public Long getCurrentUserId() {
        ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        String token = requestAttributes.getRequest().getHeader("accessToken");
        Long userId = TokenUtil.verifyToken(token);
        if (userId < 0) {
            throw new ConditionException("非法用户！");
        }
        return userId;
    }
}

四、总结

以上的双令牌验证也有跟网上的有些许差别，有的是所有的访问都同时携带双令牌，如果是短期令牌过期，又再去验证长期令牌，那么短期令牌就没有存在的意义。

也有些是说，每次刷新的时候，长期令牌也刷新，这种看个人的应用场景，这种场景只需要在刷新短期令牌的时候对给前端也返回一个新生成的长期令牌，而且必须更新数据库中的令牌！

再说回来以上的个人理解的双令牌可能存在一些小问题，如果是颁发长短期双令牌，而到了短期令牌过期的时候，前端需要重新去后端刷新短期令牌，而这个时候用户刚好进行业务操作需要访问后端，如果此时后端还没颁发短期令牌给前端，那么用户的这次访问就没有携带短期令牌，前端就会弹出token已过期！的消息，如果用户基数大的话，那么出现这种情况的概率也会变大，那么双令牌的作用也就消失了，用户体验也会有可能变差，但是这也远比单令牌的场景体验要好的多。