Spring实现CurrentUser注解获取当前登录用户

2021-12-21

Spring实现@CurrentUser自定义注解获取当前登录用户。

为了在方法中使用当前用户参数，实现自定义注解@CurrentUser，将用户数据注入到方法。

当不需要@CurrentUser注解做拦截获取当前用户时，增加@DisableToken注解，放行用户请求。

引入依赖

1
2
3

// javax.validation
// https://mvnrepository.com/artifact/javax.validation/validation-api
implementation group: 'javax.validation', name: 'validation-api', version: '2.0.1.Final'

自定义注解

@CurrentUser

import java.lang.annotation.*;

/**
 * 自定义CurrentUser注解
 * 该注解只能被声明在一个方法参数前
 * 运行时注解，保留到代码运行时
 */
@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface CurrentUser {
}

@DisableToken

import java.lang.annotation.*;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Documented
@Inherited
public @interface DisableToken {
    String value() default "";
}

Web配置类

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.method.support.HandlerMethodArgumentResolver;
import org.springframework.web.servlet.config.annotation.InterceptorRegistration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import java.util.List;

/**
 * Web配置类
 * 参数解析器
 * 指定CurrentUserMethodArgumentResolver解析
 * 配置拦截器
 */
@Configuration
public class WebConfig implements WebMvcConfigurer {

    /**
     * 注入CurrentUserMethodArgumentResolver类为Bean
     * @return
     */
    @Bean
    CurrentUserMethodArgumentResolver currentUserMethodArgumentResolver() {
        return new CurrentUserMethodArgumentResolver();
    }

    /**
     * 指定参数解析器
     * @param argumentResolvers
     */
    @Override
    public void addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {
        argumentResolvers.add(currentUserMethodArgumentResolver());
    }

    /**
     * 注册拦截器
     * @param registry
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        InterceptorRegistration registration = registry.addInterceptor(new CurrentUserInterceptor());
        // 所有路径都被拦截
        // registration.addPathPatterns("/**");
        // 添加不拦截路径
        // registration.excludePathPatterns("/","/error","/static/**");
    }

}

拦截器注入数据

import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/** 拦截器 注入当前登录用户信息数据到request */
public class CurrentUserInterceptor implements HandlerInterceptor {

    /**
     * 该方法将在请求处理之前进行调用，只有该方法返回true，才会继续执行后续的Interceptor和Controller。
     * 当返回值为true时就会继续调用下一个Interceptor的preHandle 方法。 如果已经是最后一个Interceptor，则调用当前请求的Controller方法。
     */
    @Override
    public boolean preHandle(
            HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {

        /** DisableToken注解检验 * */
        if (handler instanceof HandlerMethod) {
            HandlerMethod method = (HandlerMethod) handler;
            DisableToken auth = method.getMethod().getAnnotation(DisableToken.class);
            // System.out.println("TokenInterceptor: " + request.getRequestURI() + " || " +
            // method.getMethod());
            if (auth != null) {
                return true;
            }
        } else {
            // System.out.println("TokenInterceptor: " + request.getRequestURI());
        }

        // 从cookie，session，token，redis中获取用户后注入到request中
        // User user = ..
        // 增加具体的业务逻辑

        // 直接实例化测试
        User user = new User(1, "曳戈泰尔", 1, "yegetaier");
        request.setAttribute("currentUser", user);

        return true;

        /** 用户token非法，返回false */
        // return false;
    }
}

自定义配套解析器

import org.springframework.core.MethodParameter;
import org.springframework.web.bind.support.WebDataBinderFactory;
import org.springframework.web.context.request.NativeWebRequest;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.method.support.HandlerMethodArgumentResolver;
import org.springframework.web.method.support.ModelAndViewContainer;
import org.springframework.web.multipart.support.MissingServletRequestPartException;

/**
 * 自定义配套解析器
 * 把当前登录用户信息实例化到User
 * 将request获得的用户信息返回给@CurrentUser
 */
public class CurrentUserMethodArgumentResolver implements HandlerMethodArgumentResolver {

    /**
     * 用于判断是否支持对某种参数的解析
     * @param parameter
     * @return
     */
    @Override
    public boolean supportsParameter(MethodParameter parameter) {
        return parameter.getParameterType().isAssignableFrom(User.class)
                && parameter.hasParameterAnnotation(CurrentUser.class);
    }

    /**
     * 将请求中的参数值解析为某种对象
     * 将User数据传递给@CurrentUser
     * @param parameter
     * @param mavContainer
     * @param webRequest
     * @param binderFactory
     * @return
     * @throws Exception
     */
    @Override
    public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
        User user = (User) webRequest.getAttribute("currentUser", RequestAttributes.SCOPE_REQUEST);
        if (user != null) {
            return user;
        }
        throw new MissingServletRequestPartException("currentUser");
    }
}

用户实体

/**
 * 用户实体类
 */
public class User {

    /**
     * 用户ID
     */
    private Integer userId;

    /**
     * 用户名
     */
    private String userName;

    /**
     * 用户角色ID
     */
    private Integer roleID;

    /**
     * 用户密码
     */
    private String password;

    /**
     * 构造函数
     * @param userId
     * @param userName
     * @param roleID
     * @param password
     */
    public User(Integer userId, String userName, Integer roleID, String password) {
        this.userId = userId;
        this.userName = userName;
        this.roleID = roleID;
        this.password = password;
    }
}

控制层

import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import java.util.Map;

/** 控制层 */
@RestController
public class Controller {

    /**
     * @CurrentUser 注解测试API
     *
     * @param user
     * @return
     */
    @PostMapping("/api/test")
    public String getTest(@CurrentUser User user) {
        System.out.println(user);
        return user.toString();
    }

    /** 通过@DisableToken 
     * request请求跳过拦截器 
     * request请求参数传入控制层方法 
     * 通过@RequestBody接收request参数 
     * */
    @PostMapping("/api/test2")
    @DisableToken
    public String getTest2(@RequestBody Map<String, String> data) {
        System.out.println(data);
        return data.toString();
    }
}