此前，我写过一篇《我是怎么做App Token认证的》 的文章，使用的是PHP技术，这次将本人的SpringBoot版本分享一下，其中使用了Apache的Shiro作为权限管理组件。老规矩，关于基础的知识比如Shiro的原理及应用，同学们请自行百度。
在这里，我简单介绍一下我是怎么具体实现的，重点描述结合Shiro，如何实现token生成、token校验及token缓存。
生成Token
服务端接收客户端传递的username和password等请求，在数据库中检查，如果用户名密码匹配的话，表示登录成功，服务端生成并返回一个token访问令牌。
@PostMapping("/login/wechat")
public R loginWechat(@RequestParam String openid, @RequestParam(required = false) String nickname,
@RequestParam(required = false, defaultValue = "0") int gender, @RequestParam(required = false) String avatar,
HttpServletRequest request) {
Auth auth = new Auth();
auth.setIdentify(openid).setIdentifyType(Constants.AuthType.WECHAT);
auth.setLastLoginTime(LocalDateTime.now());
OAuthUserVO oAuthUserVO = new OAuthUserVO();
oAuthUserVO.setAvatar(avatar);
oAuthUserVO.setGender(gender);
oAuthUserVO.setUsername(nickname);
return loginThird(auth, oAuthUserVO, generateToken(request));
}
private R loginThird(Auth auth, OAuthUserVO oAuthUserVO, UserToken userToken) {
User user = userService.loginThird(auth, oAuthUserVO); // 真正的登录，数据校验，这里使用第三方登录，Auth是第三方登录的信息。
if (user == null) {
return R.fail("用户不存在");
}
AuthUser authUser = BeanCopierUtils.copy(user, AuthUser.class);
// 登录成功，发放令牌，写入缓存
authManager.onLoginSuccess(authUser, userToken);
// 通知第三方权限框架进行认证和授权
authManager.login(authUser, userToken);
LoginVO data = new LoginVO();
data.setToken(userToken.getToken());
data.setUser(BeanCopierUtils.copy(user, UserVO.class));
return R.ok(data);
}
在上面的Controller代码中，登录成功，服务端向客户端返回token和user信息。token是通过AuthManager类的generateToken方法+onLoginSucess来生成的。
// 收集客户端数据
public UserToken generateToken(HttpServletRequest request) {
String ip = HttpRequestUtils.getIpAddr(request);
String uuid = HttpRequestUtils.getParam(request, "uuid");
String client = HttpRequestUtils.getParam(request, "client");
UserToken userToken = new UserToken();
userToken.setClient(client);
userToken.setIp(ip);
userToken.setUuid(uuid);
userToken.setCreatedAt(LocalDateTime.now());
return userToken;
}
public void onLoginSuccess(AuthUser authUser, UserToken userToken) {
// 刷新用户Token
Wrapper<UserToken> wrapper = Wrappers.<UserToken>lambdaQuery().eq(UserToken::getUserId, authUser.getId());
userTokenService.remove(wrapper);
userToken.setUserId(authUser.getId());
// 使用随机UUID生成一个token
userToken.setToken(CommonUtils.randomUUID());
userTokenService.save(userToken);
// 用户附带设备信息
authUser.additional(userToken);
// token写入缓存
redisCache.set(userToken.getToken(), authUser, Constants.Second.A_DAY);
}
这里主要有3个步骤
- 收集设备uuid, ip等信息生成一个UserToken实例，后续随机生成一个字符串作为token令牌
- 根据用户id查询用户登录表，不管用户原来是否已经存在token，新的token将替换旧的token
- 将token写入缓存，因为token是每个请求都会解析，如果不使用缓存的话，会导致数据库访问瓶颈。
- 用户的UserToken会附加到AuthUser（作为Shiro的Principal)
客户端应该保存token，然后在后续的访问中都要带上这个token（PHP版本中是可选的），后台配置一个过滤器，将解析并校验token的合法性。
解析token
服务端接收客户端传递的token，需要从中解析出相关的用户及设备信息。
@Override
public boolean isAccessAllowed(HttpServletRequest request, HttpServletResponse response) {
String token = HttpRequestUtils.getParam(request, Constants.Http.AUTHORIZE_NAME);
if (!StringUtils.isEmpty(token)) {
Object o = redisCache.get(token);
AuthUser loginUser = (AuthUser)getLoginUser();
UserToken newToken = generateToken(request);
newToken.setToken(token);
return verifyToken((AuthUser)o, loginUser, newToken);
}
return false;
}
过程很简单，从请求中获取token，并生成一份新的UserToken，再取出缓存和shiro的当前登录用户信息，进入token验证方法。
验证token
private boolean loginWithToken(String token) {
Wrapper<UserToken> wrapper = Wrappers.<UserToken>lambdaQuery().eq(UserToken::getToken, token);
UserToken userToken = userTokenService.getOne(wrapper);
if (userToken != null && userToken.isExpired()) {
log.info("AuthFilter 数据库中Token有效");
// TODO 判断UUID，IP是否一致
User user = userService.getById(userToken.getUserId());
if (user != null) {
log.info("AuthFilter 数据库中用户有效，重新登录并且更新缓存及数据库中的token信息");
userTokenService.updateById(userToken);
AuthUser authUser = BeanCopierUtils.copy(user, AuthUser.class);
// 用户附带设备信息
authUser.additional(userToken);
// token写入缓存
redisCache.set(userToken.getToken(), authUser, Constants.Second.A_DAY);
// 通知第三方权限框架进行认证和授权
login(authUser, userToken);
return true;
}
}
return false;
}
public boolean verifyToken(AuthUser cacheUser, AuthUser loginUser, UserToken comingToken) {
if (loginUser == null) {
log.info("AuthFilter 用户未登录，检查缓存");
if (cacheUser == null) {
log.info("AuthFilter 缓存中没有Token，检查数据库");
return loginWithToken(comingToken.getToken());
} else {
log.info("AuthFilter 缓存中有Token");
// TODO 判断UUID，IP是否一致
login(cacheUser, comingToken);
return true;
}
} else {
log.info("AuthFilter 用户已登录");
if (loginUser.getToken().equals(comingToken.getToken())) {
log.info("AuthFilter token相同，通过");
return true;
} else {
log.info("AuthFilter token不一致，先注销，再登录");
logout();
return loginWithToken(comingToken.getToken());
}
}
}
缓存
缓存相对简单，缓存的key为token值，也即登录成功后，服务端向客户端发送的token值。缓存有效值为1天，如果token校验通过，则应该在更新缓存有效期（上面的代码中没有）。
// token写入缓存
redisCache.set(userToken.getToken(), authUser, Constants.Second.A_DAY);
备注
以上仅为代码片断，核心代码为我对shiro的二次封装库。此库反向依赖于start模块的IAuthManager实现。
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* @author jamling
*/
public interface IAuthManager {
/**
* 登录，交第三方权限框架去登录（认证）
*
* @param user 当前用户
* @param credentials 凭据
*/
void login(IAuthUser user, Object credentials);
void logout();
/**
* 获取当前登录的用户信息
*
* @return 用户信息
*/
IAuthUser getLoginUser();
/**
* 从原始请求中检查用户token，由权限过滤器调用
*
* @param request http请求
* @param response http响应
* @return 检查结果 true表示检查通过
*/
boolean isAccessAllowed(HttpServletRequest request, HttpServletResponse response);
boolean verifyToken(String token);
/**
* 检查token不通过，使用何种方式登录
*
* @param request http请求
* @param response http响应
* @return 处理结果 true表示已处理，不会再继续提交父类处理
*/
boolean executeLogin(HttpServletRequest request, HttpServletResponse response);
/**
* 第三方权限框架执行授权
*
* @param principal 当前用户
* @return
* @see org.apache.shiro.realm.AuthorizingRealm#doGetAuthorizationInfo(org.apache.shiro.subject.PrincipalCollection)
*/
IAuthUser doGetAuthorizationInfo(Object principal);
}
