一、用户是否在线校验（双重保障）
先经过注解进入全局拦截器；再通过异常处理器来处理
方式一：通过面向切面的思想，使用注解接口来拦截，需要传递request对象，才可以获取用户信息（全局拦截器处理）
方式二：通过全局对象（不需要传参），获取当前request对象，request对象再通过用户数据来判断用户是否在线（全局异常处理）
1.1 控制层(获取角色和权限数据)
/**
* 获取用户的角色和权限数据
* @author HuangJingNa
* @date 2019年12月22日 下午4:01:55
*
* @return
* @throws Exception
*/
@PostMapping("find_role_permission")
@CheckRoles({"role:student"})
@CheckPerssions({"permission:study", "permission:sleep"})
public Object findRolePerssion() throws Exception {
return userService.findRolePerssion();
}
1.2 进入全局拦截器（注解）
package cn.kooun.core.interceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
import cn.kooun.service.UserService;
/**
* 全局拦截器
* @author HuangJingNa
* @date 2019年12月22日 下午4:40:45
*
*/
public class GlobalInterceptor implements HandlerInterceptor{
@Autowired
private UserService userService;
@Override
public boolean preHandle(
HttpServletRequest request,
HttpServletResponse response,
Object handler) throws Exception {
if(handler instanceof HandlerMethod) {
HandlerMethod handlerMethod = (HandlerMethod) handler;
return baseHandler(request, response, handlerMethod);
}
return true;
}
private boolean baseHandler(
HttpServletRequest request,
HttpServletResponse response,
HandlerMethod handlerMethod) {
boolean flag = true;
flag = userService.checkOnline(request, response, handlerMethod);
if(!flag) {
return flag;
}
flag = userService.checkRoles(request, response, handlerMethod);
if(!flag) {
return flag;
}
flag = userService.checkPerssions(request, response, handlerMethod);
if(!flag) {
return flag;
}
return flag;
}
}
不管是否有该注解，都会进入全局拦截器中
1.3 service层CheckOnline()中需要将登录时封装的用户对象设置在request域中
/**
* 校验是否在线
* @author HuangJingNa
* @date 2019年12月22日 下午4:48:13
*
* @param request
* @param response
* @param handlerMethod
* @return
*/
public boolean checkOnline(
HttpServletRequest request,
HttpServletResponse response,
HandlerMethod handlerMethod) {
//获取方法上的注解，判断是否要进行校验
NotCheckOnline notCheckOnline = handlerMethod.getMethodAnnotation(NotCheckOnline.class);
if(notCheckOnline != null) {
//放行，不进行校验
return true;
}
//获取在线用户
Object user = RequestUtils.getUserLogin(request, response, redisService);
if(user == null) {
ResponseUtils.returnJson(
response,
ResultUtils.error("登录失效，请重新登录~", Result.JUMP_LOGIN));
return false;
}
//设置request.setAttribute()，方便全局校验获取用户数据
request.setAttribute(Dict.USER, user);
return true;
}
请求类RequestUtils
package cn.kooun.common.request;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.util.StringUtils;
import cn.kooun.common.redis.RedisService;
import cn.kooun.pojo.info.Dict;
/**
* 请求工具类
* @author HuangJingNa
* @date 2019年12月22日 下午4:52:10
*
*/
public class RequestUtils {
/**
* 校验用户是否在线（根据用户凭证）
* @author HuangJingNa
* @date 2019年12月22日 下午5:03:40
*
* @param request
* @param response
* @param redisService
* @return
*/
public static Object getUserLogin(
HttpServletRequest request,
HttpServletResponse response,
RedisService redisService) {
//登录校验
String userToken = request.getHeader(Dict.USER_TOKEN);
if(StringUtils.isEmpty(userToken)) {
return null;
}
//返回在线数据
return redisService.get(userToken);
}
}
相应类ReponseUtils
package cn.kooun.common.reponse;
import java.io.PrintWriter;
import javax.servlet.http.HttpServletResponse;
import com.alibaba.fastjson.JSON;
import cn.kooun.pojo.info.Dict;
/**
* 响应工具类
* @author HuangJingNa
* @date 2019年12月22日 下午4:52:24
*
*/
public class ResponseUtils {
/**
* response响应json数据格式
*
* @author HuangJingNa
* @date 2019年12月22日 下午4:52:24
* @param response
* @param result
*/
public static void returnJson(HttpServletResponse response, Object result) {
//创建json转换的类
PrintWriter writer = null;
try {
// 避免乱码
response.setCharacterEncoding(Dict.UTF8);
// 设置ContentType
response.setContentType(Dict.JSON_HEAD);
writer = response.getWriter();
writer.append(JSON.toJSONString(result));
writer.flush();
} catch (Exception e) {
e.printStackTrace();
}finally {
if(writer!=null) {
writer.close();
}
}
}
}
使用全局对象获取用户对象时才有值
/**
* 获取用户的角色和权限数据
* @author HuangJingNa
* @date 2019年12月22日 下午4:03:19
*
* @return
* @throws Exception
*/
public Object findRolePerssion() throws Exception {
//使用全局对象来判断用户是否在线
LoginUser user = (LoginUser) SecurityUtils.getCurrentUser();
return packageRolesAndPermissions(user);
}
/**
* 打包角色和权限数据
* @author HuangJingNa
* @date 2019年12月22日 下午4:30:49
*
* @param user
* @return
*/
private Object packageRolesAndPermissions(LoginUser user) {
//在线:获取权限和角色
List<String> roles = user.getRoles();
List<String> permissions = user.getPermissions();
Map<String, Object> result = new HashMap<String, Object>();
result.put("roles", roles);
result.put("permissions", permissions);
return ResultUtils.success(result);
}
1.4 权限工具SecurityUtils
package cn.kooun.common;
import javax.servlet.http.HttpServletRequest;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import cn.kooun.pojo.exception.OffLineException;
import cn.kooun.pojo.info.Dict;
/**
* 权限工具
* @author HuangJingNa
* @date 2019年12月23日 下午2:44:54
*
*/
public class SecurityUtils {
/**
* 获取当前用户
* 可以作为全局对象来获取当前request对象，
* 再使用request对象（通过用户key值）来获取用户数据，来判断用户是否登录
* 方式一：通过注解接口的方式来判断用户是否在线（根据用户凭证）；全局拦截器处理
* 方式二：使用全局对象来获取request对象；全局异常处理
* 以上两个方式，双重保障
* @author HuangJingNa
* @date 2019年12月23日 下午2:46:39
*
* @return
* @throws ffLineException
*/
public static Object getCurrentUser() throws Exception {
HttpServletRequest request =
((ServletRequestAttributes)RequestContextHolder.getRequestAttributes())
.getRequest();
Object user = request.getAttribute(Dict.USER);
if(user == null) {
throw new OffLineException("用户不在线~");
}
return user;
}
}
1.5 用户不在线异常处理OffLineException
package cn.kooun.pojo.exception;
/**
* 自定义异常，用户不在线抛出的异常
* @author HuangJingNa
* @date 2019年12月23日 下午2:55:38
*
*/
public class OffLineException extends Exception{
private static final long serialVersionUID = 7291020619358516087L;
public OffLineException() {
super();
}
public OffLineException(String message) {
super(message);
}
}
1.6 全局拦截器处理该自定义异常
package cn.kooun.core.exception;
import javax.servlet.http.HttpServletRequest;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import cn.kooun.common.result.Result;
import cn.kooun.common.result.ResultUtils;
import cn.kooun.pojo.exception.OffLineException;
/**
* 全局异常处理
* @author HuangJingNa
* @date 2019年12月21日 下午3:46:19
*
*/
@ControllerAdvice//标记此类为全局异常拦截器
public class GlobalExceptionHandler {
/**
* 系统异常处理，如404、500
* @author HuangJingNa
* @date 2019年12月21日 下午3:48:45
*
* @return
* @throws Exception
*/
@ExceptionHandler(value = Exception.class)//监听对应的异常对象
@ResponseBody
public Object defaultErrorHandler(HttpServletRequest req, Exception e) throws Exception{
//控制台输出错误信息
e.printStackTrace();
if(e instanceof OffLineException) {
return ResultUtils.error("登录失效，请重新登录~", Result.JUMP_LOGIN);
}
return ResultUtils.error("系统繁忙，请联系管理员~");
}
}
