定义切面注解

定义切面注解AiPassiveMsg

  1. package com.iwhalecloud.aiFactory.common.aspect;
  3. import java.lang.annotation.Documented;
  4. import java.lang.annotation.ElementType;
  5. import java.lang.annotation.Retention;
  6. import java.lang.annotation.RetentionPolicy;
  7. import java.lang.annotation.Target;
  9. /**
  10.  * @description:
  11.  * @author: hasee
  12.  * @create: 2022-04-24 18:16
  13.  **/
  14. @Target(ElementType.METHOD)
  15. @Retention(RetentionPolicy.RUNTIME)
  16. @Documented
  17. public @interface AiPassiveMsg {
  18.     /** 场景类型,具体场景和环节使用对应的类型前缀,用点拼接.系统=sys,安全=security,审核=audit.xxx.xxxx; */
  19.     String sceneType() default "";
  21.     /** 替换参数json字符串 */
  22.     String param() default "";
  24.     /** 用户id ["1001","1002","1003"] */
  25.     String[] users() default {};
  26. }

定义切面类

  1. package com.iwhalecloud.aiFactory.aspect;
  3. import com.iwhalecloud.aiFactory.aspect.msghandler.AiPassiveMsgHandler;
  4. import com.iwhalecloud.aiFactory.aspect.msghandler.MsgHandlerContext;
  5. import com.iwhalecloud.aiFactory.auth.CurrentUserHolder;
  6. import com.iwhalecloud.aiFactory.common.aspect.AiPassiveMsg;
  7. import com.iwhalecloud.aiFactory.common.util.LoggerUtil;
  8. import com.iwhalecloud.aiFactory.system.service.api.dto.response.UserInfoDto;
  9. import org.aspectj.lang.JoinPoint;
  10. import org.aspectj.lang.annotation.AfterReturning;
  11. import org.aspectj.lang.annotation.Aspect;
  12. import org.aspectj.lang.annotation.Pointcut;
  13. import org.aspectj.lang.reflect.MethodSignature;
  14. import org.springframework.beans.factory.annotation.Autowired;
  15. import org.springframework.stereotype.Component;
  17. import java.io.IOException;
  18. import java.lang.reflect.Method;
  19. import java.util.HashMap;
  21. /**
  22.  * @author hasee
  23.  * @Description 消息中心埋点
  24.  * @since 2022/3/14 14:30
  25.  */
  26. @Aspect
  27. @Component
  28. public class AiPassiveMsgAspect {
  31.     @Autowired
  32.     MsgHandlerContext msgHandlerContext;
  34.     @Pointcut("@annotation(com.iwhalecloud.aiFactory.common.aspect.AiPassiveMsg)")
  35.     public void cut() {
  36.         LoggerUtil.info("被动消息切面切入");
  37.     }
  39.     @AfterReturning("cut()")
  40.     public void addAiInformation(JoinPoint joinPoint) throws IOException {
  41.         MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
  42.         Method method = methodSignature.getMethod();
  43.         // 获取注解参数
  44.         AiPassiveMsg annotation = method.getAnnotation(AiPassiveMsg.class);
  45.         // 通过枚举值或者方法的调用
  46.         String sceneType = annotation.sceneType();
  47.         String[] users = annotation.users();
  50.         UserInfoDto currentUser = CurrentUserHolder.getCurrentUser();
  51.         Object[] joinPointArgs = joinPoint.getArgs();
  54.         AiPassiveMsgHandler instance = msgHandlerContext.getInstance(sceneType);
  55.         HashMap<String, Object> map = new HashMap<>();
  56.         map.put("sceneType",sceneType);
  57.         map.put("currentUser",currentUser);
  58.         map.put("joinPointArgs",joinPointArgs);
  60.         instance.handle(map);
  61.     }
  64. }

其中@AfterReturning("cut()")执行切入点动作
但是MsgHandlerContext是什么？

定义业务类

业务方法applyPublish

  1.     @Override
  2.     @Transactional(value = "inferenceTransactionManager", rollbackFor = Exception.class)
  3.     @AiPassiveMsg(sceneType = "audit.serviceVersion.publish")
  4.     public void applyPublish(AirServicePublishBeRequest request) {
  5.     ...
  6.     }

业务方法approvePublish

  1.     @Override
  2.     @Transactional("inferenceTransactionManager")
  3.     @AiPassiveMsg(sceneType = "audit.serviceVersion.publish.audit")
  4.     public void approvePublish(AirInferenceApprovedInfo request) {

策略模式

打在业务方法上的@AiPassiveMsg(sceneType = "audit.serviceVersion.publish") 或者 @AiPassiveMsg(sceneType = "audit.serviceVersion.publish.audit")我们应该做出怎么样的处理呢？这里就要定义抽象处理器Handler以及它的子类具体实现类， 即 AiPassiveMsgHandler，PublishServiceVersionMsgHandler，ApprovePublishServiceVersionMsgHandler

AiPassiveMsgHandler

image.png
AiPassiveMsgHandler

  1. package com.iwhalecloud.aiFactory.aspect.msghandler;
  3. import java.io.IOException;
  4. import java.util.Map;
  6. /**
  7.  * @description:
  8.  * @author: hasee
  9.  * @create: 2022-04-25 09:15
  10.  **/
  11. public abstract class AiPassiveMsgHandler {
  12.     public abstract Map<String, Object> handle(Map<String, Object> params) throws IOException;
  13. }

PublishServiceVersionMsgHandler

  1. package com.iwhalecloud.aiFactory.aspect.msghandler.process;
  3. import com.iwhalecloud.aiFactory.aiResource.aimessage.MsgTmplService;
  4. import com.iwhalecloud.aiFactory.aspect.msghandler.AiPassiveMsgHandler;
  5. import com.iwhalecloud.aiFactory.aspect.msghandler.PassiveMsgHandlerType;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.stereotype.Component;
  9. import java.io.IOException;
  10. import java.util.HashMap;
  11. import java.util.Map;
  13. /**
  14.  * @description:
  15.  * @author: hasee
  16.  * @create: 2022-04-25 09:23
  17.  **/
  18. @Component
  19. @PassiveMsgHandlerType("audit.serviceVersion.publish")
  20. public class PublishServiceVersionMsgHandler extends AiPassiveMsgHandler {
  21.     @Autowired
  22.     MsgTmplService msgTmplService;
  23.     @Override
  24.     public Map<String, Object> handle(Map<String, Object> params) {
  25.         try {
  26.             msgTmplService.serviceVersionPublishAspect(params);
  27.         }
  28.         catch (RuntimeException e) {
  29.         }
  31.         return new HashMap<>();
  32.     }
  33. }

ApprovePublishServiceVersionMsgHandler

  1. package com.iwhalecloud.aiFactory.aspect.msghandler.process;
  3. import com.iwhalecloud.aiFactory.aiResource.aimessage.MsgTmplService;
  4. import com.iwhalecloud.aiFactory.aspect.msghandler.AiPassiveMsgHandler;
  5. import com.iwhalecloud.aiFactory.aspect.msghandler.PassiveMsgHandlerType;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.stereotype.Component;
  9. import java.io.IOException;
  10. import java.util.HashMap;
  11. import java.util.Map;
  15. /**
  16.  * @description:
  17.  * @author: hasee
  18.  * @create: 2022-04-25 09:23
  19.  **/
  20. @Component
  21. @PassiveMsgHandlerType("audit.serviceVersion.publish.audit")
  22. public class ApprovePublishServiceVersionMsgHandler extends AiPassiveMsgHandler {
  23.     @Autowired
  24.     MsgTmplService msgTmplService;
  25.     @Override
  26.     public Map<String, Object> handle(Map<String, Object> params) {
  27.         try {
  28.             msgTmplService.serviceVersionAuditAspect(params);
  29.         }
  30.         catch (RuntimeException e) {
  31.         }
  32.         return new HashMap<>();
  33.     }
  34. }

MsgHandlerProcessor注册器

但是MsgHandlerContext当中的handlerMap也就是我们具体的一个个的实际hanlder是何时加入到容器的呢？这里就需要定义实现了Bean工厂的MsgHandlerProcessor即注册器，实现postProcessBeanFactory方法。定义包扫描，扫描hanlder所在包当中打上@PassiveMsgHandlerType注解的hanlder。使具体的hanlder处理器PublishServiceVersionMsgHandler和ApprovePublishServiceVersionMsgHandler在程序启动的时候就加载到Spring容器当中。
PublishServiceVersionMsgHandler和ApprovePublishServiceVersionMsgHandler要打上自定义注解@PassiveMsgHandlerType，并且注解@PassiveMsgHandlerType的value值要与业务内@AiPassiveMsg注解的sceneType值保持匹配，因为注册阶段MsgHandlerProcessor会根据@PassiveMsgHandlerType的value值作为key进行hanlder的注册，加载阶段MsgHandlerContext会根据@AiPassiveMsg的sceneType值作为key进行获取。**@PassiveMsgHandlerType**的**value**值和**@AiPassiveMsg**的**sceneType**值保持一致，能确保获取到的hanlder是符合预期的hanlder

  1. package com.iwhalecloud.aiFactory.aspect.msghandler;
  3. import com.google.common.collect.Maps;
  4. import com.iwhalecloud.aiFactory.common.aspect.AiPassiveMsg;
  5. import com.iwhalecloud.aiFactory.common.util.ClassScaner;
  6. import org.springframework.beans.BeansException;
  7. import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
  8. import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
  9. import org.springframework.stereotype.Component;
  11. import java.util.Map;
  13. /**
  14.  * @description:
  15.  * @author: hasee
  16.  * @create: 2019-06-14 15:02
  17.  **/
  18. @Component
  19. public class MsgHandlerProcessor implements BeanFactoryPostProcessor {
  21.     private static final String HANDLER_PACKAGE = "com.iwhalecloud.aiFactory.aspect.msghandler.process";
  23.     /**
  24.      * 扫描@PassiveMsgHandlerType，MsgHandlerContext，将其注册到spring容器
  25.      *
  26.      * @param beanFactory bean工厂
  27.      */
  28.     @Override
  29.     public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
  30.         Map<String, Class> handlerMap = Maps.newHashMapWithExpectedSize(3);
  31.         //只扫描带有@PassiveMsgHandlerType注解的handler
  32.         ClassScaner.scan(HANDLER_PACKAGE, PassiveMsgHandlerType.class).forEach(clazz -> {
  33.             // 获取注解中的类型值
  34.             String type = clazz.getAnnotation(PassiveMsgHandlerType.class).value();
  35.             // 将注解中的类型值作为key，对应的类作为value，保存在Map中
  36.             handlerMap.put(type, clazz);
  37.             beanFactory.registerSingleton(clazz.getName(),clazz);
  38.         });
  39.         // 初始化HandlerContext，将其注册到spring容器中
  40.         MsgHandlerContext context = new MsgHandlerContext(handlerMap);
  41.         beanFactory.registerSingleton(MsgHandlerContext.class.getName(), context);
  42.     }
  44. }

ClassScaner包扫描

实现了ResourceLoaderAware接口的setResourceLoader(ResourceLoader var1)方法

  1. //
  2. // Source code recreated from a .class file by IntelliJ IDEA
  3. // (powered by FernFlower decompiler)
  4. //
  6. package org.springframework.context;
  8. import org.springframework.beans.factory.Aware;
  9. import org.springframework.core.io.ResourceLoader;
  11. public interface ResourceLoaderAware extends Aware {
  12.     void setResourceLoader(ResourceLoader var1);
  13. }

ClassScaner：

  1. package com.iwhalecloud.aiFactory.common.util;
  3. import org.apache.commons.lang3.ArrayUtils;
  4. import org.springframework.beans.factory.BeanDefinitionStoreException;
  5. import org.springframework.context.ResourceLoaderAware;
  6. import org.springframework.core.io.Resource;
  7. import org.springframework.core.io.ResourceLoader;
  8. import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
  9. import org.springframework.core.io.support.ResourcePatternResolver;
  10. import org.springframework.core.io.support.ResourcePatternUtils;
  11. import org.springframework.core.type.classreading.CachingMetadataReaderFactory;
  12. import org.springframework.core.type.classreading.MetadataReader;
  13. import org.springframework.core.type.classreading.MetadataReaderFactory;
  14. import org.springframework.core.type.filter.AnnotationTypeFilter;
  15. import org.springframework.core.type.filter.TypeFilter;
  16. import org.springframework.util.StringUtils;
  17. import org.springframework.util.SystemPropertyUtils;
  19. import java.io.IOException;
  20. import java.lang.annotation.Annotation;
  21. import java.util.HashSet;
  22. import java.util.LinkedList;
  23. import java.util.List;
  24. import java.util.Set;
  26. /**
  27.  * @description:
  28.  * @author: hasee
  29.  * @create: 2019-06-14 15:06
  30.  **/
  31. public class ClassScaner implements ResourceLoaderAware {
  33.     private final List<TypeFilter> includeFilters = new LinkedList<TypeFilter>();
  34.     private final List<TypeFilter> excludeFilters = new LinkedList<TypeFilter>();
  36.     private ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();
  37.     private MetadataReaderFactory metadataReaderFactory = new CachingMetadataReaderFactory(this.resourcePatternResolver);
  39.     @SafeVarargs
  40.     public static Set<Class<?>> scan(String[] basePackages, Class<? extends Annotation>... annotations) {
  41.         ClassScaner cs = new ClassScaner();
  43.         if (ArrayUtils.isNotEmpty(annotations)) {
  44.             for (Class anno : annotations) {
  45.                 cs.addIncludeFilter(new AnnotationTypeFilter(anno));
  46.             }
  47.         }
  49.         Set<Class<?>> classes = new HashSet<>();
  50.         for (String s : basePackages) {
  51.             classes.addAll(cs.doScan(s));
  52.         }
  54.         return classes;
  55.     }
  57.     @SafeVarargs
  58.     public static Set<Class<?>> scan(String basePackages, Class<? extends Annotation>... annotations) {
  59.         return ClassScaner.scan(StringUtils.tokenizeToStringArray(basePackages, ",; \t\n"), annotations);
  60.     }
  62.     public final ResourceLoader getResourceLoader() {
  63.         return this.resourcePatternResolver;
  64.     }
  66.     @Override
  67.     public void setResourceLoader(ResourceLoader resourceLoader) {
  68.         this.resourcePatternResolver = ResourcePatternUtils
  69.                 .getResourcePatternResolver(resourceLoader);
  70.         this.metadataReaderFactory = new CachingMetadataReaderFactory(
  71.                 resourceLoader);
  72.     }
  74.     public void addIncludeFilter(TypeFilter includeFilter) {
  75.         this.includeFilters.add(includeFilter);
  76.     }
  78.     public void addExcludeFilter(TypeFilter excludeFilter) {
  79.         this.excludeFilters.add(0, excludeFilter);
  80.     }
  82.     public void resetFilters(boolean useDefaultFilters) {
  83.         this.includeFilters.clear();
  84.         this.excludeFilters.clear();
  85.     }
  87.     public Set<Class<?>> doScan(String basePackage) {
  88.         Set<Class<?>> classes = new HashSet<>();
  89.         try {
  90.             String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX
  91.                     + org.springframework.util.ClassUtils
  92.                     .convertClassNameToResourcePath(SystemPropertyUtils
  93.                             .resolvePlaceholders(basePackage))
  94.                     + "/**/*.class";
  95.             Resource[] resources = this.resourcePatternResolver
  96.                     .getResources(packageSearchPath);
  98.             for (int i = 0; i < resources.length; i++) {
  99.                 Resource resource = resources[i];
  100.                 if (resource.isReadable()) {
  101.                     MetadataReader metadataReader = this.metadataReaderFactory.getMetadataReader(resource);
  102.                     if ((includeFilters.isEmpty() && excludeFilters.isEmpty()) || matches(metadataReader)) {
  103.                         try {
  104.                             classes.add(Class.forName(metadataReader
  105.                                     .getClassMetadata().getClassName()));
  106.                         }
  107.                         catch (ClassNotFoundException e) {
  108.                             LoggerUtil.info(e.getMessage());
  109.                         }
  110.                     }
  111.                 }
  112.             }
  113.         }
  114.         catch (IOException ex) {
  115.             throw new BeanDefinitionStoreException(
  116.                     "I/O failure during classpath scanning", ex);
  117.         }
  118.         return classes;
  119.     }
  121.     protected boolean matches(MetadataReader metadataReader) throws IOException {
  122.         for (TypeFilter tf : this.excludeFilters) {
  123.             if (tf.match(metadataReader, this.metadataReaderFactory)) {
  124.                 return false;
  125.             }
  126.         }
  127.         for (TypeFilter tf : this.includeFilters) {
  128.             if (tf.match(metadataReader, this.metadataReaderFactory)) {
  129.                 return true;
  130.             }
  131.         }
  132.         return false;
  133.     }
  135. }

PassiveMsgHandlerType注解

PassiveMsgHandlerType注解，各个具体的hanlder实现类跟据PassiveMsgHandlerType标识，包扫描工具类就是根据此注解找到我们各个具体的hanlder实现类。

  1. package com.iwhalecloud.aiFactory.aspect.msghandler;
  3. import java.lang.annotation.Documented;
  4. import java.lang.annotation.ElementType;
  5. import java.lang.annotation.Inherited;
  6. import java.lang.annotation.Retention;
  7. import java.lang.annotation.RetentionPolicy;
  8. import java.lang.annotation.Target;
  10. @Target(ElementType.TYPE)
  11. @Retention(RetentionPolicy.RUNTIME)
  12. @Documented
  13. @Inherited
  14. public @interface PassiveMsgHandlerType {
  15.     String value();
  16. }

MsgHandlerContext加载器

怎么从容器中读取这些hanlder处理器呢？
这里就需要定义加载器，即上下文类MsgHandlerContext。
AiPassiveMsgHandler instance = msgHandlerContext.getInstance(sceneType);以sceneType名为key获取到hanlder的clazz对象

  1. package com.iwhalecloud.aiFactory.aspect.msghandler;
  3. import com.iwhalecloud.aiFactory.common.web.SpringContextUtil;
  5. import java.util.Map;
  7. /**
  8.  * @description:
  9.  * @author: hasee
  10.  * @create: 2022-04-25 09:13
  11.  **/
  12. public class MsgHandlerContext {
  14.     private Map<String, Class> handlerMap;
  16.     public MsgHandlerContext(Map<String, Class> handlerMap) {
  17.         this.handlerMap = handlerMap;
  18.     }
  20.     public AiPassiveMsgHandler getInstance(String type) {
  21.         Class clazz = handlerMap.get(type);
  22.         if (clazz == null) {
  23.             throw new IllegalArgumentException("not found handler for type: " + type);
  24.         }
  26.         return (AiPassiveMsgHandler) SpringContextUtil.getBean(clazz);
  27.     }
  28. }

策略模式优势

我们在写代码的时候，常常会遇到不同的情况不同处理，通常情况下我们会使用if…else if ….else…. 但随着程序的不断扩展，可能if…else if 会越来越多，可维护性就会不断降低，而且代码的可读性也会越来越差，所以这里推荐大家使用策略模式。在这里以Java的项目来进行演示。
image.png
以订单的多状态处理来进行设计：

  • 提供 IHander类进行统一的handler的定义
  • 抽象AbstractOrderStatusHandler进行handler的默认的一些方法的定义
  • OrderCommitStatusHandler（具体的实现handler）
  • OrderPayStatusHandler
  • Order…StatusHandler
  • 通过Strategy进行控制，利用Map的特性根据handler的键获取对应的真正的处理handler实现的常用的策略模式

[

](https://blog.csdn.net/qq_34798605/article/details/123321434)