Spring通过AOP在Service层注入用户信息

淩亂°似流年 2022-06-06 09:50 206阅读 0赞

使用基于注解形式的AOP配置，在Service层或其他层，注入用户登录信息，这样就不需要在用到用户登录信息时总是注入Http相关对象，不用手动setter用户信息，且用户登录信息会随着session失效而自动注销。  
.  
相关类如下:  
![相关类截图][SouthEast]

相关类说明:

1.  AppUserContextConfig：模块的配置类，负责扫描模块的Bean，当需要使用此模块时，用Import(AppUserContextConfig.class)的形式引入。
2.  UserEnv ：自定义注解，使用时标识在属性或者getter方法上，value指明要注入的用户信息的名称，未指定则使用属性名称首字母小写作为用户信息属性的名称。
3.  UserEnvAnnotationProcessor：@UserEnv注解的解析类，负责解析@UserEnv上的信息并从用户登录信息中获取相应的属性值。
4.  AopArchitecture：AOP结构类，定义了Spring容器内所有的切入点
5.  AspectAdviceConfig：切面通知定义类，引用了AopArchitecture的切入点，定义了Advice，即通知方法
6.  LoginUser：存储用户登录信息的Model，用户登录信息类是其属性的一个子集，用户登录后将登录信息拷贝到此Model中，@UserEnv的属性值就是从此Model中获取
7.  AppUser：工具类，负责提供静态存储用户登录信息及清空登录信息的方法，和静态的获取登录信息的方法

下面先看使用方法:

@RestController
    @RequestMapping("/users")
    public class UserController { 
    
        @Autowired
        private UserService userService;
    
        @RequestMapping(value = "/login", method = RequestMethod.POST)
        public boolean login(@RequestBody User user, HttpServletRequest request) {
            user = userService.login(user);
            if (user == null) {
                return false;
            }
            //拷贝用户登录信息
            AppUser.resideUserEnv(user);
            //设置session有效期，当失效时，LoginUser会自动销毁
            request.getSession().setMaxInactiveInterval(30);
            return true;
        }
    
        @RequestMapping(method = RequestMethod.PUT)
        //测试注入的方法
        public boolean testUserEnvInjection(@RequestBody User user) {
            return userService.modifyUser(user);
        }
    
        @RequestMapping(value = "/logout", method = RequestMethod.DELETE)
        public void logout() {
            System.out.println(AppUser.isLogin());
            //清空用户登录信息
            AppUser.clearUserEnv();
            System.out.println(AppUser.isLogin());
        }
    }

Service层很简单，仅仅是做一个登录验证:

@Service
    public class UserServiceImpl implements UserService { 
    
        @Autowired
        private UserMapper userMapper;
    
        @Override
        public User login(User user) {
            String userName = user.getUserName();
            String password = user.getPassword();
            User result = null;
            if (Character.isDigit(userName.charAt(0))) {
                result = userMapper.loginByTele(userName, password);
            } else {
                result = userMapper.loginByName(userName, password);
            }
            return result;
        }
    
        @Override
        public boolean modifyUser(@UserEnv User user) {
            return false;
        }
    }

以上就是使用此模块的方法，很简单。  
下面就开始看模块内各类的代码及注释:  
先看模块引入类: AppUserContextConfig

@Configuration
    @ComponentScan() // 当此注解内不指定扫描包路径时,会使用此类的包名作为扫描的路径,即"com.bob.config.mvc.userenv"
    public class AppUserContextConfig { 
    
    }

当需要使用此模块时，Import(AppUserContextConfig .class)就能使用，切记不适用时不要扫描到这些类.  
接下来看AOP结构定义类，此类定义了框架内所有的切入点，这么做仅仅是为了让所有的切入点配置在一起，不是强制的。

@Order(1)
    @Aspect
    @Component
    public class AopArchitecture { 
    
        /** * 面向Service层的切入点 */
        @Pointcut("execution(public * com.bob.config.mvc.service.*.*(..))")
        public void serviceMethod() {
        }
    
        /** * 面向{@code UserEnv }注解的切入点 */
        @Pointcut("@args(com.bob.config.mvc.userenv.ann.UserEnv)")
        public void injectMethod() {
        }
    
    }

接下来看Advice定义类，此类定义了在AOP切入点执行的方法，我们在此使用注解的形式注入用户登录信息

/** * 面向切面的功能实现，对@UserEnv注解的属性使用用户信息填充 * * @since 2016年12月6日 下午4:52:22 * */
    @Order(2)
    @Aspect
    @Component
    public class AspectAdviceConfig { 
    
        final static Logger LOGGER = LoggerFactory.getLogger(AspectAdviceConfig.class);
    
        @Autowired
        private UserEnvAnnotationProcessor userEnvAnnotationProcessor;
    
        /** * Service层注入用户登录信息 * * {@link com.bob.config.mvc.userenv.aspect.AopArchitecture#serviceMethod} * * @param joinpoint * @throws Exception */
        @Before("com.bob.config.mvc.userenv.aspect.AopArchitecture.serviceMethod()")
        public void beforeServiceCall(JoinPoint joinpoint) throws Exception {
            Object[] args = joinpoint.getArgs();
            Signature sig = joinpoint.getSignature();
            MethodSignature msig = (MethodSignature) sig;
            Method method = msig.getMethod();
            boolean debug = LOGGER.isDebugEnabled();
            if (args != null && args.length != 0) {
                long t1 = System.nanoTime(), t2 = 0;
                boolean injected = false;
                StringBuilder sb = null;
                if (debug) {
                    sb = new StringBuilder(1024);
                    sb.append("触发Service方法执行前注入, 方法名称: [").append(sig.toLongString()).append("], ");
                    sb.append("注入参数列表: ");
                }
                Annotation[][] annotations = method.getParameterAnnotations();
                int i, j;
                for (i = 0; i < annotations.length; i++) {
                    Object bean = args[i];
                    if (bean == null) {
                        continue;
                    }
                    Annotation[] pa = annotations[i];
                    if (pa.length == 0) {
                        continue;
                    }
                    if (UserEnv.class.isInstance(pa[0])) {
                        injected = populateEnv(bean, debug, sb);
                        continue;
                    }
                    for (j = 1; j < pa.length; j++) {
                        if (UserEnv.class.isInstance(pa[j])) {
                            injected = populateEnv(bean, debug, sb);
                            break;
                        }
                    }
                }
                if (debug && injected) {
                    t2 = System.nanoTime();
                    sb.append("\n完成注入共计耗时: ").append((t2 - t1) / 1000000.0).append("ms");
                    LOGGER.debug(sb.toString());
                }
            }
    
        }
    
        /** * Service层方法执行过完之后 * * {@link com.bob.config.mvc.userenv.aspect.AopArchitecture#serviceMethod} * * @param joinpoint * @param retVal */
        @AfterReturning(pointcut = "com.bob.config.mvc.userenv.aspect.AopArchitecture.serviceMethod()", returning = "retVal")
        public void afterServiceCall(JoinPoint joinpoint, Object retVal) {
    
        }
    
        /** * 填充@UserEnv标识的变量 * * @param bean * @param debug * @param sb * @throws Exception * @return */
        private boolean populateEnv(Object bean, boolean debug, StringBuilder sb) throws Exception {
            boolean result = false;
            try {
                result = userEnvAnnotationProcessor.process(bean, sb);
            } catch (IllegalArgumentException | IllegalAccessException e) {
                throw e;
            }
            return result;
        }
    
    }

接下来看自定义注解，通过注解标识在属性上或者getter方法上，来指定待注入的属性。通过注解的value值，或者是待注入属性的名称，优先value，来从用户登录信息择取想要的信息。

/** * @since 2016年12月7日 下午2:01:13 */
    @Retention(RetentionPolicy.RUNTIME)
    @Target({ ElementType.TYPE, ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER })
    public @interface UserEnv { 
    
        /** * 环境变量的名称 * * @return */
        String value() default "";
    
    }

接下来看注解的解析类，解析结果将被缓存，设置缓存的大小，使用LinkedHashMap进行缓存淘汰，注入前验证类型符合，

/** * {@link @UserEnv}注解的解析器 * * @since 2016年12月7日 下午5:03:15 * @version $Id$ * @author JiangJibo * */
    @Component
    public class UserEnvAnnotationProcessor { 
    
        final static Logger LOGGER = LoggerFactory.getLogger(UserEnvAnnotationProcessor.class);
    
        private static final int CACHE_LIMIT = 256;
    
        private static final Object INJECTION_LOCK = new Object();
    
        private final Set<Class<? extends Annotation>> autowiredAnnotationTypes = new LinkedHashSet<Class<? extends Annotation>>();
    
        private final Set<Class<?>> nonAnnotatedClass = new HashSet<Class<?>>();
    
        /** * 解析Class后生成的InjectionElement缓存 */
        @SuppressWarnings("serial")
        private volatile Map<Class<?>, Set<InjectionElement>> injectionMetadataCache =
    
                new LinkedHashMap<Class<?>, Set<InjectionElement>>(64, 0.75f, true) {
    
                    /* (non-Javadoc) * @see java.util.LinkedHashMap#removeEldestEntry(java.util.Map.Entry) */
                    @Override
                    protected boolean removeEldestEntry(Entry<Class<?>, Set<InjectionElement>> eldest) {
                        return size() > getCacheLimit();
                    }
    
                };
    
        /** * 默认注入的注解为{@link @UserEnv} */
        public UserEnvAnnotationProcessor() {
            autowiredAnnotationTypes.add(UserEnv.class);
        }
    
        /** * 处理Bean,注入{@link @UserEnv}注解 * * @param bean * @param sb * @return * @throws IllegalArgumentException * @throws IllegalAccessException */
        public boolean process(Object bean, StringBuilder sb) throws IllegalArgumentException, IllegalAccessException {
            Assert.notNull(bean, "被注入对象不能为空");
            Class<?> beanClass = bean.getClass();
            if (!beanClass.isAnnotationPresent(UserEnv.class)) {
                LOGGER.warn("[{}]未标识有[{}]注解", beanClass.getSimpleName(), UserEnv.class.getSimpleName());
                return false;
            }
            if (nonAnnotatedClass.contains(beanClass)) {
                LOGGER.warn("[{}]内部不含指定的[{}]注解属性或方法", beanClass.getSimpleName(), UserEnv.class.getSimpleName());
                return false;
            }
            Set<InjectionElement> injectionElements = injectionMetadataCache.get(beanClass);
            if (injectionElements == null) {
                synchronized (INJECTION_LOCK) {
                    injectionElements = injectionMetadataCache.get(beanClass);
                    if (injectionElements == null) {
                        injectionElements = buildAutowiredMetadata(beanClass);
                        if (injectionElements.isEmpty()) {
                            LOGGER.warn("未找到标注[{}]注解的属性或方法", autowiredAnnotationTypes.toString());
                            nonAnnotatedClass.add(beanClass);
                            return false;
                        }
                        injectionMetadataCache.put(beanClass, injectionElements);
                    }
                }
            }
            return injectByField(bean, injectionElements, sb) | injectByMethod(bean, injectionElements, sb);
        }
    
        /** * 根据属性注入 * * @param bean * @param sb * @return * @throws IllegalArgumentException * @throws IllegalAccessException */
        private boolean injectByField(Object bean, Set<InjectionElement> injectionElements, StringBuilder sb)
                throws IllegalArgumentException, IllegalAccessException {
            boolean success = false;
            for (InjectionElement injectionElement : injectionElements) {
                if (!injectionElement.isField) {
                    continue;
                }
                Field field = (Field) injectionElement.member;
                ReflectionUtils.makeAccessible(field);
                String fieldName = field.getName();
                String key = injectionElement.key;
                key = StringUtils.hasText(key) ? key : fieldName;
                if (!isTypeMatch(field.getType(), key, fieldName)) {
                    continue;
                }
                Object value = AppUser.getUserEnv(key);
                field.set(bean, value);
                sb.append("[" + fieldName + "] = [" + value + "],");
                success = true;
            }
            return success;
        }
    
        /** * 根据getter()方法注入 * * @param bean * @param sb * @return * @throws SecurityException * @throws NoSuchMethodException */
        private boolean injectByMethod(Object bean, Set<InjectionElement> injectionElements, StringBuilder sb) {
            boolean success = false;
            for (InjectionElement injectionElement : injectionElements) {
                if (injectionElement.isField) {
                    continue;
                }
                Method method = (Method) injectionElement.member;
                PropertyDescriptor proDesc = BeanUtils.findPropertyForMethod(method);
                String fieldName = proDesc.getName();
                String key = injectionElement.key;
                key = StringUtils.hasText(key) ? key : fieldName;
                if (!isTypeMatch(method.getReturnType(), key, fieldName)) {
                    continue;
                }
                Object value = AppUser.getUserEnv(key);
                ReflectionUtils.invokeMethod(proDesc.getWriteMethod(), bean, value);
                sb.append("[" + fieldName + "] = [" + value + "],");
                success = true;
            }
            return success;
        }
    
        /** * 校验待注入的成员的类型 * * @param fieldType * @param key * @param fieldName * @return */
        private boolean isTypeMatch(Class<?> fieldType, String key, String fieldName) {
            if (!fieldType.isAssignableFrom(String.class) && !fieldType.isAssignableFrom(Integer.class)) {
                LOGGER.warn("环境变量[{}]注入失败,暂时只支持String和int类型的注入", fieldName);
                return false;
            }
            Object value = AppUser.getUserEnv(key);
            if (null == value) {
                LOGGER.warn("环境变量[{}]注入失败,未查询到指定名称的环境变量", fieldName);
                return false;
            }
            if (!value.getClass().isAssignableFrom(fieldType)) {
                LOGGER.warn("环境变量:[{}]的类型不匹配待注入的属性:[{}]", key.getClass().getName(), fieldName);
                return false;
            }
            return true;
        }
    
        /** * 获取类上标注了{@link @UserEnv}注解的成员信息 * * @param clazz * @return */
        private Set<InjectionElement> buildAutowiredMetadata(final Class<?> clazz) {
    
            final Set<InjectionElement> injectionElements = new HashSet<InjectionElement>();
    
            ReflectionUtils.doWithLocalFields(clazz, new ReflectionUtils.FieldCallback() {
    
                @Override
                public void doWith(Field field) throws IllegalArgumentException, IllegalAccessException {
                    AnnotationAttributes ann = findAutowiredAnnotation(field);
                    if (ann != null) {
                        if (Modifier.isStatic(field.getModifiers())) {
                            LOGGER.warn("[{}]注解不适用于静态方法:[{}]", autowiredAnnotationTypes.toString(), field);
                            return;
                        }
                        injectionElements.add(new InjectionElement(field, ann.getString("value")));
                    }
                }
            });
    
            ReflectionUtils.doWithLocalMethods(clazz, new ReflectionUtils.MethodCallback() {
    
                @Override
                public void doWith(Method method) throws IllegalArgumentException, IllegalAccessException {
    
                    AnnotationAttributes ann = findAutowiredAnnotation(method);
                    if (ann != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
                        if (Modifier.isStatic(method.getModifiers())) {
                            LOGGER.warn("注解不适用于静态方法: [{}]", autowiredAnnotationTypes.toString(), method);
                            return;
                        }
                        if (!method.getName().startsWith("get") || method.getParameterTypes().length > 0) {
                            LOGGER.warn("[{}]注解只适用于getter方法,而非: [{}]方法", autowiredAnnotationTypes.toString(), method);
                            return;
                        }
                        injectionElements.add(new InjectionElement(method, ann.getString("value")));
                    }
                }
            });
    
            return injectionElements;
        }
    
        /** * 获取一个成员成标注了{@link @UserEnv}注解(或元注解)的注解数据 * * @param ao * @return */
        private AnnotationAttributes findAutowiredAnnotation(AnnotatedElement ao) {
            if (ao.getAnnotations().length > 0) {
                for (Class<? extends Annotation> type : this.autowiredAnnotationTypes) {
                    AnnotationAttributes attributes = AnnotatedElementUtils.getMergedAnnotationAttributes(ao, type);
                    if (attributes != null) {
                        return attributes;
                    }
                }
            }
            return null;
        }
    
        /** * 获取缓存容量 * * @return */
        public int getCacheLimit() {
            return CACHE_LIMIT;
        }
    
        /** * 清空缓存 */
        public void clearCache() {
            this.injectionMetadataCache.clear();
        }
    
        /** * 待注入的成员信息 * * @since 2017年1月22日 上午9:12:19 * @version $Id$ * @author JiangJibo * */
        private static class InjectionElement { 
    
            private Member member;
            private boolean isField;
            private String key;
    
            /** * @param member * @param key */
            public InjectionElement(Member member, String key) {
                this.member = member;
                this.isField = (member instanceof Field);
                this.key = key;
            }
    
        }
    
    }

接下来看存储用户登录信息的LoginUser类，我们将此类定义成一个Bean，作用域是session，因此此Bean到时候会存储在HttpSession中，会随着session的失效而销毁。且对生成这个Bean的构造函数做了限制，实例化此Bean是一定要将用户的原始信息对象作为参数，LoginUser将会拷贝用户的原始登录信息。

@Component()
    @Scope("session")
    public class LoginUser implements Serializable { 
    
        private static final long serialVersionUID = 8555472524102629901L;
    
        private volatile Integer id;
        private volatile String userName;
        private volatile String password;
        private volatile Integer age;
        private volatile String telephone;
        private volatile String adress;
    
        @Autowired()
        public LoginUser(Object userInfo) {
            BeanUtils.copyProperties(userInfo, this);
        }
    
        setter,getter ....
    
    }

最后看工具类AppUser，此类负责将登录信息存入LoginUser，及从LoginUser从获取指定的信息，从Spring容器中获取LoginUser Bean。

@Component
    public class AppUser implements BeanFactoryAware { 
    
        final static Logger LOGGER = LoggerFactory.getLogger(AppUser.class);
    
        private static BeanFactory beanFactory;
    
        public static final String USER_ENV_BEAN_NAME = ClassUtils.getShortNameAsProperty(LoginUser.class);
    
        /** * 获取当前Bean实例 * * @return */
        public static AppUser getAppUser() {
            return beanFactory.getBean("appUser", AppUser.class);
        }
    
        /** * 根据用户属性名称获取登录用户信息 * * @param name * @return */
        public static Object getUserEnv(String name) {
            LoginUser loginUser = beanFactory.getBean(USER_ENV_BEAN_NAME, LoginUser.class);
            try {
                Field field = ReflectionUtils.findField(LoginUser.class, name);
                field.setAccessible(true);
                return field.get(loginUser);
            } catch (Exception e) {
                LOGGER.error("尝试注入属性:[{}]时出现异常", name, e);
                throw new CustomizedException(e);
            }
        }
    
        /** * 将用户的登录信息寄存在应用(session)中 * * @param user */
        public static void resideUserEnv(Object user) {
            beanFactory.getBean(LoginUser.class, user);
        }
    
        /** * 清除用户登录信息 */
        public static void clearUserEnv() {
            ((DefaultListableBeanFactory) beanFactory).destroyScopedBean(USER_ENV_BEAN_NAME);
        }
    
        /** * 验证是否有用户登录 * * @return */
        public static boolean isLogin() {
            try {
                beanFactory.getBean(USER_ENV_BEAN_NAME);
                return true;
            } catch (Exception e) {
                return false;
            }
        }
    
        @Override
        public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
            AppUser.beanFactory = beanFactory;
        }
    
    }

[SouthEast]: /images/20220606/ac6419174d954252bf569b109cec7106.png