• cola架构：一种扩展点的实现思路浅析

    目录

    1.扩展点使用实例

    2.主要技术点

    2.1 注解加持

    2.2 注解解析

    2.3 扩展点路由

    在实际项目中，我们经常使用策略模式、或者状态模式来隔离同一接口下不同的实现逻辑，进而消除代码中ifelse硬编码分支，使代码结构更清晰，也大大提升了代码可读性；同时也满足了“开闭原则”，具备更高的可扩展性；

    在cola架构中，给出了一种“扩展点”的思路，本质还是策略模式的实现方式，通过“扩展点注解”的组装方式将策略模式实现类注册到容器中，供后续场景逻辑决策使用；

    1.扩展点使用实例

    首先通过实例了解下，cola 扩展点的使用方式：

    1.首先定义一个SomeExtPt接口，并实现ExtensionPointI接口

    1. public interface SomeExtPt extends ExtensionPointI {
    2.     
    3.     public void doSomeThing();
    4. }

    2.具体实现SomeExtPt接口，这里给出了2个实现类，如下：

    1. @Extension(bizId = "A")
    2. @Component
    3. public class SomeExtensionA implements SomeExtPt {
    4.  
    5.     @Override
    6.     public void doSomeThing() {
    7.         System.out.println("SomeExtensionA::doSomething");
    8.     }
    9.  
    10. }
    1. @Extension(bizId = "B")
    2. @Component
    3. public class SomeExtensionB implements SomeExtPt {
    4.  
    5.     @Override
    6.     public void doSomeThing() {
    7.         System.out.println("SomeExtensionB::doSomething");
    8.     }
    9.     
    10. }

    3.测试方法：

    1. @RunWith(SpringJUnit4ClassRunner.class)
    2. @SpringBootTest(classes = Application.class)
    3. public class ExtensionRegisterTest {
    4.     
    5.     @Resource
    6.     private ExtensionRegister register;
    7.  
    8.     @Resource
    9.     private ExtensionExecutor executor;
    10.  
    11.     @Test
    12.     public void test() {
    13.         SomeExtPt extA = new SomeExtensionA();
    14.         register.doRegistration(extA);
    15.  
    16.         SomeExtPt extB = CglibProxyFactory.createProxy(new SomeExtensionB());
    17.         register.doRegistration(extB);
    18.         
    19.         executor.executeVoid(SomeExtPt.class, BizScenario.valueOf("A"), SomeExtPt::doSomeThing);
    20.         executor.executeVoid(SomeExtPt.class, BizScenario.valueOf("B"), SomeExtPt::doSomeThing);
    21.     }
    22.     
    23. }
    1. public class CglibProxyFactory {
    2.  
    3.     public static  T createProxy(T object) {
    4.         Enhancer enhancer = new Enhancer();
    5.         enhancer.setSuperclass(object.getClass());
    6.         enhancer.setCallback(new ProxyCallback(object));
    7.         return (T) enhancer.create();
    8.     }
    9.  
    10.     public static class ProxyCallback implements MethodInterceptor {
    11.  
    12.         private Object target;
    13.     
    14.         public ProxyCallback(Object target) {
    15.             this.target = target;
    16.         }
    17.         
    18.         @Override
    19.         public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
    20.             System.out.println("ProxyObject::before");
    21.             Object object = proxy.invoke(target, args);
    22.             System.out.println("ProxyObject::after");
    23.             return object;
    24.         }
    25.     }
    26. }

    2.主要技术点

    2.1 注解加持

    上述具体策略接口实现方法标注了扩展点注解：@Extension

    1. @Inherited
    2. @Retention(RetentionPolicy.RUNTIME)
    3. @Target({ElementType.TYPE})
    4. @Repeatable(Extensions.class)
    5. @Component
    6. public @interface Extension {
    7.     String bizId()  default BizScenario.DEFAULT_BIZ_ID;
    8.     String useCase() default BizScenario.DEFAULT_USE_CASE;
    9.     String scenario() default BizScenario.DEFAULT_SCENARIO;
    10. }

    所有的具体实现方法都需要标注该注解，表明该类属于一个扩展点；同时，由于标注了@Component注解，表明每一个扩展点也是一个bean实例；

    2.2 注解解析

    扩展点注解的解析工作主要借助类ExtensionBootstrap和ExtensionRegister完成：

    1. @Component
    2. public class ExtensionBootstrap implements ApplicationContextAware {
    3.  
    4.     @Resource
    5.     private ExtensionRegister extensionRegister;
    6.  
    7.     private ApplicationContext applicationContext;
    8.  
    9.     @PostConstruct
    10.     public void init(){
    11.         Map extensionBeans = applicationContext.getBeansWithAnnotation(Extension.class);
    12.         extensionBeans.values().forEach(
    13.                 extension -> extensionRegister.doRegistration((ExtensionPointI) extension)
    14.         );
    15.  
    16.         // handle @Extensions annotation
    17.         Map extensionsBeans = applicationContext.getBeansWithAnnotation(Extensions.class);
    18.         extensionsBeans.values().forEach( extension -> extensionRegister.doRegistrationExtensions((ExtensionPointI) extension));
    19.     }
    20.  
    21.     @Override
    22.     public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
    23.         this.applicationContext = applicationContext;
    24.     }
    25. }
    1. @Component
    2. public class ExtensionRegister {
    3.  
    4.     /**
    5.      * 扩展点接口名称不合法
    6.      */
    7.     private static final String EXTENSION_INTERFACE_NAME_ILLEGAL = "extension_interface_name_illegal";
    8.     /**
    9.      * 扩展点不合法
    10.      */
    11.     private static final String EXTENSION_ILLEGAL = "extension_illegal";
    12.     /**
    13.      * 扩展点定义重复
    14.      */
    15.     private static final String EXTENSION_DEFINE_DUPLICATE = "extension_define_duplicate";
    16.  
    17.     @Resource
    18.     private ExtensionRepository extensionRepository;
    19.  
    20.     public final static String EXTENSION_EXTPT_NAMING = "ExtPt";
    21.  
    22.  
    23.     public void doRegistration(ExtensionPointI extensionObject) {
    24.         Class extensionClz = extensionObject.getClass();
    25.         if (AopUtils.isAopProxy(extensionObject)) {
    26.             extensionClz = ClassUtils.getUserClass(extensionObject);
    27.         }
    28.         Extension extensionAnn = AnnotationUtils.findAnnotation(extensionClz, Extension.class);
    29.         BizScenario bizScenario = BizScenario.valueOf(extensionAnn.bizId(), extensionAnn.useCase(), extensionAnn.scenario());
    30.         ExtensionCoordinate extensionCoordinate = new ExtensionCoordinate(calculateExtensionPoint(extensionClz), bizScenario.getUniqueIdentity());
    31.         ExtensionPointI preVal = extensionRepository.getExtensionRepo().put(extensionCoordinate, extensionObject);
    32.         if (preVal != null) {
    33.             String errMessage = "Duplicate registration is not allowed for :" + extensionCoordinate;
    34.             throw new ExtensionException(EXTENSION_DEFINE_DUPLICATE, errMessage);
    35.         }
    36.     }
    37.  
    38.     public void doRegistrationExtensions(ExtensionPointI extensionObject){
    39.         Class extensionClz = extensionObject.getClass();
    40.         if (AopUtils.isAopProxy(extensionObject)) {
    41.             extensionClz = ClassUtils.getUserClass(extensionObject);
    42.         }
    43.  
    44.         Extensions extensionsAnnotation = AnnotationUtils.findAnnotation(extensionClz, Extensions.class);
    45.         Extension[] extensions = extensionsAnnotation.value();
    46.         if (!ObjectUtils.isEmpty(extensions)){
    47.             for (Extension extensionAnn : extensions) {
    48.                 BizScenario bizScenario = BizScenario.valueOf(extensionAnn.bizId(), extensionAnn.useCase(), extensionAnn.scenario());
    49.                 ExtensionCoordinate extensionCoordinate = new ExtensionCoordinate(calculateExtensionPoint(extensionClz), bizScenario.getUniqueIdentity());
    50.                 ExtensionPointI preVal = extensionRepository.getExtensionRepo().put(extensionCoordinate, extensionObject);
    51.                 if (preVal != null) {
    52.                     String errMessage = "Duplicate registration is not allowed for :" + extensionCoordinate;
    53.                     throw new ExtensionException(EXTENSION_DEFINE_DUPLICATE, errMessage);
    54.                 }
    55.             }
    56.         }
    57.  
    58.         //
    59.         String[] bizIds = extensionsAnnotation.bizId();
    60.         String[] useCases = extensionsAnnotation.useCase();
    61.         String[] scenarios = extensionsAnnotation.scenario();
    62.         for (String bizId : bizIds) {
    63.             for (String useCase : useCases) {
    64.                 for (String scenario : scenarios) {
    65.                     BizScenario bizScenario = BizScenario.valueOf(bizId, useCase, scenario);
    66.                     ExtensionCoordinate extensionCoordinate = new ExtensionCoordinate(calculateExtensionPoint(extensionClz), bizScenario.getUniqueIdentity());
    67.                     ExtensionPointI preVal = extensionRepository.getExtensionRepo().put(extensionCoordinate, extensionObject);
    68.                     if (preVal != null) {
    69.                         String errMessage = "Duplicate registration is not allowed for :" + extensionCoordinate;
    70.                         throw new ExtensionException(EXTENSION_DEFINE_DUPLICATE, errMessage);
    71.                     }
    72.                 }
    73.             }
    74.         }
    75.     }
    76.  
    77.     /**
    78.      * @param targetClz
    79.      * @return
    80.      */
    81.     private String calculateExtensionPoint(Class targetClz) {
    82.         Class[] interfaces = ClassUtils.getAllInterfacesForClass(targetClz);
    83.         if (interfaces == null || interfaces.length == 0) {
    84.             throw new ExtensionException(EXTENSION_ILLEGAL, "Please assign a extension point interface for " + targetClz);
    85.         }
    86.         for (Class intf : interfaces) {
    87.             String extensionPoint = intf.getSimpleName();
    88.             if (extensionPoint.contains(EXTENSION_EXTPT_NAMING)) {
    89.                 return intf.getName();
    90.             }
    91.         }
    92.         String errMessage = "Your name of ExtensionPoint for " + targetClz +
    93.                 " is not valid, must be end of " + EXTENSION_EXTPT_NAMING;
    94.         throw new ExtensionException(EXTENSION_INTERFACE_NAME_ILLEGAL, errMessage);
    95.     }
    96.  
    97. }

    最终将扩展点和决策条件的映射关系存储到ExtensionRepository中：

    1. @Component
    2. public class ExtensionRepository {
    3.  
    4.     public Map getExtensionRepo() {
    5.         return extensionRepo;
    6.     }
    7.  
    8.     private Map extensionRepo = new HashMap<>();
    9.  
    10.  
    11. }

    2.3 扩展点路由

    在实际业务场景调度过程中，会调用ExtensionExecutor的方法locateExtension完成扩展点的查找，最终执行扩展点逻辑；

    1. @Component
    2. public class ExtensionExecutor extends AbstractComponentExecutor {
    3.  
    4.     private static final String EXTENSION_NOT_FOUND = "extension_not_found";
    5.  
    6.     private Logger logger = LoggerFactory.getLogger(ExtensionExecutor.class);
    7.  
    8.     @Resource
    9.     private ExtensionRepository extensionRepository;
    10.  
    11.     @Override
    12.     protected  C locateComponent(Class targetClz, BizScenario bizScenario) {
    13.         C extension = locateExtension(targetClz, bizScenario);
    14.         logger.debug("[Located Extension]: " + extension.getClass().getSimpleName());
    15.         return extension;
    16.     }
    17.  
    18.     /**
    19.      * if the bizScenarioUniqueIdentity is "ali.tmall.supermarket"
    20.      * 
    21.      * the search path is as below:
    22.      * 1、first try to get extension by "ali.tmall.supermarket", if get, return it.
    23.      * 2、loop try to get extension by "ali.tmall", if get, return it.
    24.      * 3、loop try to get extension by "ali", if get, return it.
    25.      * 4、if not found, try the default extension
    26.      *
    27.      * @param targetClz
    28.      */
    29.     protected  Ext locateExtension(Class targetClz, BizScenario bizScenario) {
    30.         checkNull(bizScenario);
    31.  
    32.         Ext extension;
    33.  
    34.         logger.debug("BizScenario in locateExtension is : " + bizScenario.getUniqueIdentity());
    35.  
    36.         // first try with full namespace
    37.         extension = firstTry(targetClz, bizScenario);
    38.         if (extension != null) {
    39.             return extension;
    40.         }
    41.  
    42.         // second try with default scenario
    43.         extension = secondTry(targetClz, bizScenario);
    44.         if (extension != null) {
    45.             return extension;
    46.         }
    47.  
    48.         // third try with default use case + default scenario
    49.         extension = defaultUseCaseTry(targetClz, bizScenario);
    50.         if (extension != null) {
    51.             return extension;
    52.         }
    53.  
    54.         String errMessage = "Can not find extension with ExtensionPoint: " +
    55.                 targetClz + " BizScenario:" + bizScenario.getUniqueIdentity();
    56.         throw new ExtensionException(EXTENSION_NOT_FOUND, errMessage);
    57.     }
    58.  
    59.     /**
    60.      * first try with full namespace
    61.      * 
    62.      * example:  biz1.useCase1.scenario1
    63.      */
    64.     private  Ext firstTry(Class targetClz, BizScenario bizScenario) {
    65.         logger.debug("First trying with " + bizScenario.getUniqueIdentity());
    66.         return locate(targetClz.getName(), bizScenario.getUniqueIdentity());
    67.     }
    68.  
    69.     /**
    70.      * second try with default scenario
    71.      * 
    72.      * example:  biz1.useCase1.#defaultScenario#
    73.      */
    74.     private  Ext secondTry(Class targetClz, BizScenario bizScenario) {
    75.         logger.debug("Second trying with " + bizScenario.getIdentityWithDefaultScenario());
    76.         return locate(targetClz.getName(), bizScenario.getIdentityWithDefaultScenario());
    77.     }
    78.  
    79.     /**
    80.      * third try with default use case + default scenario
    81.      * 
    82.      * example:  biz1.#defaultUseCase#.#defaultScenario#
    83.      */
    84.     private  Ext defaultUseCaseTry(Class targetClz, BizScenario bizScenario) {
    85.         logger.debug("Third trying with " + bizScenario.getIdentityWithDefaultUseCase());
    86.         return locate(targetClz.getName(), bizScenario.getIdentityWithDefaultUseCase());
    87.     }
    88.  
    89.     private  Ext locate(String name, String uniqueIdentity) {
    90.         final Ext ext = (Ext) extensionRepository.getExtensionRepo().
    91.                 get(new ExtensionCoordinate(name, uniqueIdentity));
    92.         return ext;
    93.     }
    94.  
    95.     private void checkNull(BizScenario bizScenario) {
    96.         if (bizScenario == null) {
    97.             throw new IllegalArgumentException("BizScenario can not be null for extension");
    98.         }
    99.     }
    100.  
    101. }

  • 相关阅读:
    jdk线程池ThreadPoolExecutor优雅停止原理解析（自己动手实现线程池）（二）
    STC单片机17——adc 8032
    领导大规模敏捷 - Leading SAFe认证,SAFe认证Leading SAFe官方认证培训班
    CountDownLatch
    【深度学习相关知识】
    测试开发工程师到底是做什么的？
    OpManager 帮助排查网络延迟问题
    m基于随机接入代价的异构网络速率分配算法matlab仿真
    C#实验二
    MySQL-函数
  • 原文地址：https://blog.csdn.net/supzhili/article/details/133843274