登录情况下任何地方获取用户ID

「爱情、让人受尽委屈。」 2024-02-19 15:02 33阅读 0赞

Controller层自定义注解配上拦截器可以自动封装，但是比较复杂，且仅限于控制层。这里尝试了另一种，可以直接从Spring上下文中获取。

预先获取Spring上下文存于容器中：

import org.springframework.beans.BeansException;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.ApplicationContextAware;
    import org.springframework.stereotype.Component;
    
    @Component
    public class ApplicationContextRegister implements ApplicationContextAware {
    
        private static ApplicationContext APPLICATION_CONTEXT;
    
        static ApplicationContext getApplicationContext() {
            return APPLICATION_CONTEXT;
        }
    
        /**
         * 设置spring上下文
         *
         * @param applicationContext spring上下文
         * @throws BeansException
         */
        @Override
        public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
            APPLICATION_CONTEXT = applicationContext;
        }
    }

操作上下文工具类：

import java.util.Objects;
    
    import javax.servlet.http.HttpServletRequest;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.web.context.request.RequestContextHolder;
    import org.springframework.web.context.request.ServletRequestAttributes;
    
    /**
     * Spring Application 工具类
     *
     * @author Caratacus
     */
    public class ApplicationUtils {
    
        /**
         * 全局的ApplicationContext
         */
        private final static ApplicationContext applicationContext = ApplicationContextRegister.getApplicationContext();
    
        /**
         * 获取ApplicationContext
         */
        public static ApplicationContext getApplicationContext() {
            return applicationContext;
        }
    
        /**
         * 获取springbean
         *
         * @param beanName
         * @param requiredType
         * @param <T>
         * @return
         */
        public static <T> T getBean(String beanName, Class<T> requiredType) {
            if (containsBean(beanName)) {
                return applicationContext.getBean(beanName, requiredType);
            }
            return null;
        }
    
        /**
         * 获取springbean
         *
         * @param requiredType
         * @param <T>
         * @return
         */
        public static <T> T getBean(Class<T> requiredType) {
            return applicationContext.getBean(requiredType);
        }
    
        /**
         * 获取springbean
         *
         * @param beanName
         * @param <T>
         * @return
         */
        public static <T> T getBean(String beanName) {
            if (containsBean(beanName)) {
                Class<T> type = getType(beanName);
                return applicationContext.getBean(beanName, type);
            }
            return null;
        }
    
        /**
         * 依赖spring框架获取HttpServletRequest
         *
         * @return HttpServletRequest
         */
        public static HttpServletRequest getRequest() {
            HttpServletRequest request = null;
            try {
                ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
                if (Objects.nonNull(requestAttributes)) {
                    request = requestAttributes.getRequest();
                }
            } catch (Exception ignored) {
            }
            return request;
        }
    
        /**
         * ApplicationContext是否包含该Bean
         *
         * @param name
         * @return
         */
        public static boolean containsBean(String name) {
            return applicationContext.containsBean(name);
        }
    
        /**
         * ApplicationContext该Bean是否为单例
         *
         * @param name
         * @return
         */
        public static boolean isSingleton(String name) {
            return applicationContext.isSingleton(name);
        }
    
        /**
         * 获取该Bean的Class
         *
         * @param name
         * @return
         */
        public static <T> Class<T> getType(String name) {
            return (Class<T>) applicationContext.getType(name);
        }
    
    }

获取用户信息（UID）

import java.util.Objects;
    
    import org.crown.common.spring.ApplicationUtils;
    import org.crown.cons.APICons;
    import org.crown.framework.emuns.ErrorCodeEnum;
    import org.crown.framework.utils.ApiAssert;
    
    import io.jsonwebtoken.Claims;
    import lombok.AccessLevel;
    import lombok.NoArgsConstructor;
    import lombok.extern.slf4j.Slf4j;
    
    /**
     * API工具类
     *
     * @author Caratacus
     */
    @SuppressWarnings("ALL")
    @NoArgsConstructor(access = AccessLevel.PRIVATE)
    @Slf4j
    public abstract class ApiUtils {
    
        /**
         * 获取当前用户id
         */
        public static Integer currentUid() {
            Integer uid = (Integer) ApplicationUtils.getRequest().getAttribute(APICons.API_UID);
            if (Objects.isNull(uid)) {
                String token = ApplicationUtils.getRequest().getHeader("Authorization");
                ApiAssert.notNull(ErrorCodeEnum.UNAUTHORIZED, token);
                token = token.replaceFirst("Bearer ", "");
                Claims claims = JWTUtils.getClaim(token);
                ApiAssert.notNull(ErrorCodeEnum.UNAUTHORIZED, claims);
                return claims.get(JWTUtils.UID, Integer.class);
            }
            return uid;
        }
    
    }

：