前言
前面写了几篇鉴权框架SaToken的使用的文章，用这个框架我们很容易就实现了多端登录、单点登录、鉴权等这些功能（详情可以看看这两篇链接）
【SaToken使用】springboot+redis+satoken权限认证
【SaToken使用】SpringBoot整合SaToken（一）token自动续期+token定期刷新+注解鉴权
然后又写了如果项目中没有权限这些东西，不使用SaToken，如何实现多端登录、防重登录、token续期等需求的文章：
现在我闲来无事，我想在多端登录、防重登录、token续期这些基础上再实现注解鉴权，而且不使用SaToken，我们自定义注解+拦截器去实现。在实现的过程中，我尝试参考SaToken的源码，边阅读边自己去实现，奈何自己能力有限，啃源码的过程还是挺吃力的。。。那些具体实现要一层一层找过去，大大增加了阅读难度。。。不说了，再说下去要被自己菜哭了😭我们还是说正事吧。
思路
1、登录、token相关
首先，我按照SaToken的方式，将登录相关、退出、token相关的这些操作，全部抽出来，放到一个自定义的@Component组件中，在这里实现具体过程，其他地方我们不用关心实现步骤，只需要直接调用这里面的相关方法就行。
登录时在redis中，我们需要存三个东西：一个是token，一个是登录用户信息，还有一个是token的创建时间（用于定期刷新token）。
2、鉴权相关
一般权限设计都是用角色进行关联的，我们需要考虑每次鉴权时：用户对应的角色——>角色对应的权限，这两个东西从哪里拿？
如果从数据库拿，请求数据库是否过于频繁？
如果从缓存中拿，那么每次修改角色或菜单的权限标识时，就要更新对应的缓存，操作是否过于麻烦？
上面这两个大概就是两种获取方式的缺点，然后综合考虑之下，我选择了第二种方式，从缓存中拿角色和权限，虽然更新麻烦一点，但不用每校验一次就查一遍数据库，可以减轻数据库的压力。
既然有了思路和解决方式，那就开干！
实现
一、登录
1、先定义一个Component组件
用于实现登录和token相关的操作
import cn.hutool.crypto.digest.DigestUtil;
import cn.hutool.extra.spring.SpringUtil;
import com.common.base.BaseConstant;
import com.common.vo.ExceptionVo;
import com.entity.sys.SysRoleMenu;
import com.entity.sys.SysUser;
import com.service.sys.SysRoleMenuService;
import org.springframework.stereotype.Component;
import javax.servlet.http.HttpServletRequest;
import java.util.*;
import java.util.stream.Collectors;
/**
* 登录、token相关组件工具类
*/
@Component
public class LoginUtil {
private RedisUtil redisUtil = SpringUtil.getBean(RedisUtil.class);
private SysRoleMenuService sysRoleMenuService = SpringUtil.getBean(SysRoleMenuService.class);
private long tokeTime = 3600;
/**
* 登录
* @param user 登录的用户信息
*/
public String login(SysUser user){
return login(user,null,tokeTime);
}
/**
* 登录（指定登录类型）
* @param user 登录的用户信息
* @param loginType 登录类型
*/
public String login(SysUser user,String loginType){
return login(user,loginType,tokeTime);
}
/**
* 登录（指定登录类型和有效时长）
* @param user 登录的用户信息
* @param loginType 登录类型
* @param time token有效期
*/
public String login(SysUser user,String loginType,long time){
String str = DigestUtil.md5Hex(String.valueOf(user.getId())); // userId加密
//获取所有包含当前用户id加密后的字符串开头的key
redisUtil.del(redisUtil.allKey(BaseConstant.cachePrefix + str + "*")); // 将旧的key删除
if (loginType != null) str = loginType + "_" + str;
String token = str + EncryptionUtil.generateRandom(32,false); // token组成为 用户id加密字符串+随机32为字符串
Map<String,Object> map = new HashMap<>();
map.put("token",token);
map.put("createTime",System.currentTimeMillis());
map.put("user",user);
redisUtil.hmset(BaseConstant.cachePrefix+token,map,time);
return token;
}
/**
* 退出（根据token退出）
*/
public void logout(String token){
redisUtil.del(token);
}
/**
* 获取当前登录用户的token
*/
public String getToken(HttpServletRequest request){
String token = request.getHeader(BaseConstant.tokenHeader);
if (token == null || token.length() == 0 || !redisUtil.hasKey(BaseConstant.cachePrefix+token)){
throw new ExceptionVo(1003,"用户未登录");
}
return token;
}
/**
* 获取当前用户的剩余有效时长
*/
public long getTimeOut(String token){
return redisUtil.getExpire(BaseConstant.cachePrefix+token);
}
/**
* 获取当前登录信息
*/
public Map<String,Object> getLogin(String token){
return redisUtil.hmget(BaseConstant.cachePrefix+token);
}
/**
* 获取当前用户
*/
public SysUser getLoginUser(String token){
return (SysUser) redisUtil.hget(BaseConstant.cachePrefix+token,"user");
}
/**
* 获取当前用户token的创建时间
*/
public long getCreateTime(String token){
return (Long) redisUtil.hget(BaseConstant.cachePrefix+token,"createTime");
}
/**
* 获取当前用户的所有权限集合
*/
public List<String> getPermList(String token,List<String> roleList){
if (roleList == null){
roleList = getRoleList(token);
}
List<String> permList = new ArrayList<>();
if (redisUtil.hasKey(BaseConstant.rolePermList)) {
// 如果redis中有所有角色对应的所有权限，直接从redis中拿
Map<String, Object> map = redisUtil.hmget(BaseConstant.rolePermList);
for (String role : roleList) {
permList.addAll((List<String>) map.get(role));
}
}else {
// redis没有，则去数据库查询，并将查询到的数据设置到redis中
List<SysRoleMenu> allRolePerm = sysRoleMenuService.listAll();
Map<String, List<SysRoleMenu>> group = allRolePerm.stream().collect(Collectors.groupingBy(SysRoleMenu::getRoleId));
Map<String, List<String>> map = new HashMap<>();
for (String key : group.keySet()) {
List<String> perms = group.get(key).stream().map(SysRoleMenu::getMenuId).collect(Collectors.toList());
map.put(key,perms);
if (roleList.contains(key)){
permList.addAll(perms);
}
}
redisUtil.hmset(BaseConstant.rolePermList,map);
}
return permList;
}
/**
* 获取当前用户的所有角色集合
*/
public List<String> getRoleList(String token){
String[] roleIds = getLoginUser(token).getRoleIds();
return Arrays.asList(roleIds);
}
/**
* 刷新过期时间
*/
public void updateTimeOut(String token){
updateTimeOut(token,tokeTime);
}
/**
* 刷新过期时间（指定过期时间）
*/
public void updateTimeOut(String token,long time){
redisUtil.hmset(BaseConstant.cachePrefix+token,getLogin(token),time);
}
/**
* 更新用户信息
*/
public void updateUser(String token,SysUser user){
redisUtil.hset(BaseConstant.cachePrefix+token,"user",user);
}
}
2、登录、退出
登录
@Resource
private LoginUtil loginUtil;
/** 登录 */
@PostMapping("/login")
public ResultUtil login(String userName, String password, String code,HttpServletRequest request){
try {
code = code.toUpperCase();
Object verCode = redisUtil.get(BaseConstant.verCode+code);
if (Objects.isNull(verCode)) {
return ResultUtil.error("验证码已失效，请重新输入");
}
redisUtil.del(BaseConstant.verCode+code);
password = RSAUtil.decrypt(password); //密码私钥解密
SysSafe safe = sysSafeService.list().get(0);
SysUser user = passwordErrorNum(userName, password,safe);// 校验用户名密码是否正确
int i = safe.getIdleTimeSetting(); //如果系统闲置时间为0，设置token和session永不过期
String token = "";
if (i==0){
token = loginUtil.login(user,null,-1);
}else {
token = loginUtil.login(user);
}
return ResultUtil.success(token);
} catch (ExceptionVo e) {
return ResultUtil.error(e.getCode(),e.getMessage());
}catch (Exception e) {
e.printStackTrace();
return ResultUtil.error(BaseConstant.UNKNOWN_EXCEPTION);
}
}
退出
/** 退出登录 */
@DeleteMapping("/logout")
public ResultUtil logout(HttpServletRequest request){
String token = request.getHeader(BaseConstant.tokenHeader);
//根据token退出登录
loginUtil.logout(token);
return ResultUtil.success("退出登录成功");
}
获取当前登录用户信息
/**
* 获取当前登录用户信息
*/
@GetMapping("/getLoginUser")
public ResultUtil getLoginUserInfo() {
Map<String,Object> map = new HashMap<>();
SysUser user = getLoginUser();
map.put("user",user);
//查询角色和权限
map.put("permissions",loginUtil.getPermList(token(),Arrays.asList(user.getRoleIds())));
return ResultUtil.success(map);
}
公共的controller类
import com.common.util.LoginUtil;
import com.entity.sys.SysUser;
import org.springframework.beans.factory.annotation.Autowired;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
public abstract class BaseController<S extends BaseService, E extends BaseEntity>{
@Autowired(required=false)
protected S service;
@Resource
protected LoginUtil loginUtil;
@Resource
protected HttpServletRequest httpServletRequest;
public String token(){
return service.token();
}
/**
* 获取当前登录的用户
*/
public SysUser getLoginUser(){
return service.getLoginUser();
}
public String loginId(){
return service.loginId();
}
}
公共的service类
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.common.util.LoginUtil;
import com.common.util.RedisUtil;
import com.entity.sys.SysUser;
import com.entity.sys.query.SysQuery;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public abstract class BaseService<M extends BaseMapper<E>, E extends BaseEntity> extends ServiceImpl<M, E>{
@Resource
protected RedisUtil redisUtil;
@Resource
protected LoginUtil loginUtil;
@Resource
protected HttpServletRequest httpServletRequest;
/**
* 获取当前token
*/
public String token(){
return loginUtil.getToken(httpServletRequest);
}
/**
* 获取当前登录的用户
*/
public SysUser getLoginUser(){
return loginUtil.getLoginUser(token());
}
/**
* 获取当前登录用户的id
*/
public String loginId(){
return getLoginUser().getId();
}
/**
* 更新redis中的权限标识
*/
public void updatePerm(String oldPerm,String newPerm){
Map<String, Object> map = redisUtil.hmget(BaseConstant.rolePermList);
for (String key : map.keySet()) {
List<String> permList = (List<String>) map.get(key);
int index = permList.indexOf(oldPerm); // 获取旧权限标识的索引
if (index != -1){
permList.set(index,newPerm); // 更新新标识
}
}
redisUtil.hmset(BaseConstant.rolePermList,map);
}
/**
* 删除redis中的角色与权限关联
*/
public void deleteRolePerm(String roleId){
redisUtil.hdel(BaseConstant.rolePermList,roleId);
}
// ......省略其他代码
}
上面我们就实现了多端登录功能，token自动续期和定期刷新是在拦截器中实现的，和鉴权的拦截器是同一个，我们放到后面说。
二、鉴权、token相关
1、自定义注解
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* 权限校验
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface CheckPermission {
/** 拥有指定权限 */
String[] perm() default {
};
/** 拥有指定角色 */
String[] role() default {
};
/**
* 校验类型：
* 0： 只校验权限，多个权限需要同时满足；
* 1： 只校验权限，多个权限满足一个即可；
* 2： 只校验角色，多个角色需要同时满足；
* 3： 只校验角色，多个角色满足一个即可；
* 4： 校验权限和角色，需要权限和角色同时满足；
* 5： 校验权限和角色，权限和角色任意满足一个；
* @return
*/
int type() default 0;
}
2、拦截器鉴权、token续期和定期刷新
import cn.hutool.extra.spring.SpringUtil;
import com.common.anno.CheckPermission;
import com.common.base.BaseConstant;
import com.common.util.LoginUtil;
import com.common.vo.ExceptionVo;
import com.entity.sys.SysUser;
import com.entity.sys.SysUserRole;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
/**
* 自定义拦截器，实现注解鉴权和token验证
*/
public class CustomInterceptor implements HandlerInterceptor {
private LoginUtil loginUtil = SpringUtil.getBean(LoginUtil.class);
/** 设置响应头部信息 */
private void setHeader(HttpServletRequest request,HttpServletResponse response){
response.setHeader( "Set-Cookie" , "cookiename=httponlyTest;Path=/;Domain=domainvalue;Max-Age=seconds;HTTPOnly");
response.setHeader( "Content-Security-Policy" , "default-src 'self'; script-src 'self'; frame-ancestors 'self'");
response.setHeader("Access-Control-Allow-Origin", (request).getHeader("Origin"));
response.setHeader("Access-Control-Allow-Credentials", "true");
response.setHeader("Referrer-Policy","no-referrer");
response.setContentType("application/json");
response.setCharacterEncoding("UTF-8");
}
/** token有效期刷新和定期刷新 */
private void refreshToken(HttpServletResponse response,String tokenValue){
//判断token的创建时间是否大于2小时，如果是的话则需要刷新token
long time = System.currentTimeMillis() - loginUtil.getCreateTime(tokenValue);
long hour = time/1000/(60 * 60);
if (hour>2){
// TODO 获取当前用户信息，重新登录，生成新的token，将新token设置到响应头中
SysUser user = loginUtil.getLoginUser(tokenValue);
// TODO 这里重新登录（会把旧登录删除），生成新的token
String newToken = loginUtil.login(user);
response.setHeader(BaseConstant.tokenHeader, newToken);
}
long tokenTimeout = loginUtil.getTimeOut(tokenValue);// 获取过期时间
if (tokenTimeout != -1){
// token没过期，过期时间不是-1的时候，每次请求都刷新过期时间
loginUtil.updateTimeOut(tokenValue);
}
}
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler){
setHeader(request,response);
// 获取当前token（获取的是请求头的token），同时会校验token是否过期，过期了会直接抛出异常，所以这里不用做额外处理。
String tokenValue = loginUtil.getToken(request);
if (!checkPermisson(handler,tokenValue)){
// 鉴权
throw new ExceptionVo(-1,"没有操作权限");
}
refreshToken(response,tokenValue);
return true;
}
/** 校验注解权限或角色 */
private boolean checkPermisson(Object handler,String tokenValue){
boolean flag = true;
if (handler instanceof HandlerMethod){
// 获得请求的方法
Method method = ((HandlerMethod) handler).getMethod();
// 获得该方法上面的注解，如果没有注解，直接返回true，通过
CheckPermission annotation = method.getAnnotation(CheckPermission.class);
if (annotation != null) {
String[] perm = annotation.perm(); // 注解上指定的权限标识
String[] role = annotation.role(); // 注解上指定的角色
int type = annotation.type(); // 校验的类别方式
SysUser user = loginUtil.getLoginUser(tokenValue); //得到当前登录人的权限和角色
List<String> roleList = user.getRoleList().stream().map(SysUserRole.UserRoleVo::getRoleKey).collect(Collectors.toList());
List<String> permList = loginUtil.getPermList(tokenValue, Arrays.asList(user.getRoleIds()));
if(type == 0){
// 0： 只校验权限，多个权限需要同时满足；
flag = hasElement(permList, Arrays.asList(perm),true);
}else if(type == 1){
// 1： 只校验权限，多个权限满足一个即可；
flag = hasElement(permList, Arrays.asList(perm),false);
}else if(type == 2){
// 2： 只校验角色，多个角色需要同时满足；
flag = hasElement(roleList, Arrays.asList(role),true);
}else if(type == 3){
// 3： 只校验角色，多个角色满足一个即可；
flag = hasElement(roleList, Arrays.asList(role),false);
}else if(type == 4){
// 4： 校验权限和角色，需要权限和角色同时满足；
flag = hasElement(permList, Arrays.asList(perm),true);
if (flag){
// 满足权限时再校验角色，否则直接返回false
flag = hasElement(roleList, Arrays.asList(role),true);
}
}else if(type == 5){
// 5： 校验权限和角色，权限和角色任意满足一个；
flag = hasElement(permList, Arrays.asList(perm),true);
if (!flag){
// 不满足权限时再校验角色，否则直接返回true
flag = hasElement(roleList, Arrays.asList(role),true);
}
}
}
}
return flag;
}
/**
* 在list中判断指定元素是否存在
* @param list1 拥有的权限列表
* @param list2 给定的权限列表
* @param isAnd 是否要全部满足， true 全部满足，false 满足一个即可
*/
public static boolean hasElement(List<String> list1,List<String> list2,boolean isAnd){
boolean flag = true;
if (list1 != null && list1.size() != 0 && list2 != null && list2.size() != 0 && list1.size() >= list2.size()) {
if (list1.contains(list2)) {
return flag;
} else {
for (String element : list2) {
boolean b = hasElement(list1,element);
if (isAnd){
if (!b){
// 同时满足，当有一个不满足时，直接跳出，返回false
flag = false;
break;
}
}else {
if (b){
// 满足一个即可，当有一个满足时，直接跳出，返回true
flag = true;
break;
}
flag = false;
}
}
}
} else {
return false;
}
return flag;
}
/**
* 在list中判断指定元素是否存在
* @param list 拥有的权限列表
* @param element 给定的权限
*/
public static boolean hasElement(List<String> list,String element){
if (list != null && list.size() != 0) {
if (list.contains(element)) {
return true;
} else {
Iterator it = list.iterator();
String patt;
do {
if (!it.hasNext()) {
return false;
}
patt = (String) it.next();
} while(!hasElement(patt, element));
return true;
}
} else {
return false;
}
}
/**
* 判断两个元素是否匹配
* @param value1 拥有的
* @param value2 给定的需要匹配的元素
*/
private static boolean hasElement(String value1,String value2){
if (value1 == null && value2 == null) {
return true;
} else if (value1 != null && value2 != null) {
return value1.indexOf("*") == -1 ? value1.equals(value2) : Pattern.matches(value1.replaceAll("\\*", ".*"), value2);
} else {
return false;
}
}
}
测试：
3、新增/更新角色时，更新redis中角色对应的权限
SysMenuService
/**
* 更新redis中的角色与权限关联
*/
public void updateRolePerm(String roleId){
SysQuery query = new SysQuery();
query.setId(roleId);
List<SysMenu> menuList = selectPermsByRoleId(query);
List<String> permList = menuList.stream().map(SysMenu::getPerms).collect(Collectors.toList());
redisUtil.hset(BaseConstant.rolePermList,roleId,permList);
}
SysRoleController
/**
* 新增/修改角色
*/
@PostMapping("/insert")
@CheckPermission("system:role:edit")
public ResultUtil insert(@RequestBody SysRole role) {
// ......省略其他代码
sysMenuService.updateRolePerm(role.getId()); // 更新缓存中角色与菜单权限关联
return ResultUtil.success();
}
4、更新菜单权限标识时，更新redis中对应的权限标识
SysMenuController
/**
* 修改菜单
*/
@PostMapping("/update")
@CheckPermission("system:menu:update")
public ResultUtil update(@RequestBody SysMenu menu){
SysMenu m = service.getById(menu.getId());// 根据菜单id获取更新前的菜单
// ......省略其他代码
if (!m.getPerms().equals(menu.getPerms())){
// 如果更改了权限标识，在redis缓存中也需要更改
service.updatePerm(m.getPerms(),menu.getPerms());
}
return ResultUtil.success();
}
最后
源码
都看到最后了，不给博主一个赞再走嘛(づ￣ 3￣)づ
转载：https://blog.csdn.net/weixin_43165220/article/details/128404956
查看评论