首页 Java Java中保持扩展性的几种套路和实现

Java中保持扩展性的几种套路和实现

Author: 阿里云开发者 · 分类： Java ·    2023年11月 · tags:

阿里妹导读

在日常的开发中，作者总结了平常用到的一些低成本、保持扩展性的套路，分享出来，欢迎大家讨论。

前言

SOLID(单一、开闭、里式替换、接口隔离、依赖倒置)五大原则和23种设计模式(常见的单例、构建者、装饰、适配、代理、组合、模板等等)，小伙伴们对这些肯定都很熟悉。这些原则和设计模式能够辅助我们，让我们在设计的时候有所抉择，从而达到高内聚、低耦合的目的。

那说到设计，肯定会提到架构两个字，常见的架构名词：分层架构、六边形架构、SOA架构、CQRS架构、EDA架构等等。我个人对架构的理解是边界的确认以及边界内部元素的组合，其实只要是程序员，他就一定是架构师，只不过是好的架构师还是不那么好的架构师；人人都是架构师，我认为这句话是没有问题的，区别在于他的认知决定了他所能确认的边界、如何更高效的组合内部元素；技术的架构师肯定侧重于技术，业务的架构师肯定侧重于业务，商品的架构师所能看到的边界大概率还是局限在商品域，ICBU架构组的架构师更多考虑是横向的业务支撑。以上是我个人对架构两个字的理解，今天我们不讨论具体架构，我们讨论一些套路，在日常的开发中，我总结了些我平常用到的一些低成本、保持扩展性的套路，分享出来，欢迎大家讨论。

基于管道(pipeline)的套路

关键点

  • 管道(Pipeline)—-用于串联阀门的管道通路
  • 阀门(PipelineValue)—-用于每一个节点处理实际业务诉求
  • 管道上下文(PipelineContext)—-用于管道上下文中数据的扭转

适用场景

  • 当你的数据流需要经过很多同等逻辑处理时，可以考虑使用此套路，便于后续扩展

实现代码

  • Pipeline/StandardPipeline

    package com.example.ownertest.dm.pipelline; 
/** 
* @Author: linear.zw 
* @Date: 2023/10/25 19:46 
*/ 
public interface Pipeline { 
/** 
 * 执行 
 * 
 * @return 
 */ 
boolean invoke(PipelineContext pipelineContext); 
/** 
 * 添加值 
 * 
 * @param pipelineValue 
 * @return 
 */ 
boolean addValue(PipelineValue pipelineValue); 
/** 
 * 移除值 
 * 
 * @param pipelineValue 
 * @return 
 */ 
boolean removeValue(PipelineValue pipelineValue); 
} 
package com.example.ownertest.dm.pipelline; 
import java.util.List; 
import com.google.common.collect.Lists; 
import lombok.Data; 
import lombok.extern.slf4j.Slf4j; 
/** 
* @Author: linear.zw 
* @Date: 2023/10/25 19:46 
*/ 
@Data 
@Slf4j 
public class StandardPipeline implements Pipeline { 
private List<PipelineValue> pipelineValueList = Lists.newArrayList(); 
@Override 
public boolean invoke(PipelineContext pipelineContext) { 
    boolean isResult = true; 
    for (PipelineValue pipelineValue : 
        pipelineValueList) { 
        try { 
            isResult = pipelineValue.execute(pipelineContext); 
            if (!isResult) { 
                log.error("{},exec is wrong", pipelineValue.getClass().getSimpleName()); 
            } 
        } catch (Exception e) { 
            log.error(e.getMessage(), e); 
        } 
    } 
    return isResult; 
} 
@Override 
public boolean addValue(PipelineValue pipelineValue) { 
    if (pipelineValueList.contains(pipelineValue)) { 
        return true; 
    } 
    return pipelineValueList.add(pipelineValue); 
} 
@Override 
public boolean removeValue(PipelineValue pipelineValue) { 
    return pipelineValueList.remove(pipelineValue); 
} 
}

  • PipelineContext/StandardPipelineContext

    package com.example.ownertest.dm.pipelline; 
/** 
* @Author: linear.zw 
* @Date: 2023/10/25 19:47 
*/ 
public interface PipelineContext { 
String FOR_TEST = "forTest"; 
/** 
 * 设置 
 * 
 * @param contextKey 
 * @param contextValue 
 */ 
void set(String contextKey, Object contextValue); 
/** 
 * 获取值 
 * 
 * @param contextKey 
 * @return 
 */ 
Object get(String contextKey); 
} 
package com.example.ownertest.dm.pipelline; 
import java.util.Map; 
import com.google.common.collect.Maps; 
/** 
* @Author: linear.zw 
* @Date: 2023/10/25 19:47 
*/ 
public class StandardPipelineContext implements PipelineContext { 
private Map<String, Object> contentMap = Maps.newConcurrentMap(); 
@Override 
public void set(String contextKey, Object contextValue) { 
    contentMap.put(contextKey, contextValue); 
} 
@Override 
public Object get(String contextKey) { 
    return contentMap.get(contextKey); 
} 
}

  • PipelineValue/AbstractPipelineValue/GraySwitchValue/ForTestValue

    package com.example.ownertest.dm.pipelline; 
/** 
* @Author: linear.zw 
* @Date: 2023/10/25 19:47 
*/ 
public interface PipelineValue { 
/** 
 * 节点执行 
 * 
 * @param pipelineContext 
 * @return 
 */ 
boolean execute(PipelineContext pipelineContext); 
} 
package com.example.ownertest.dm.pipelline; 
/** 
* @Author: linear.zw 
* @Date: 2023/10/25 19:48 
*/ 
public abstract class AbstractPipelineValue implements PipelineValue { 
@Override 
public boolean execute(PipelineContext pipelineContext) { 
    System.out.println(this.getClass().getSimpleName() + " start "); 
    boolean result = doExec(pipelineContext); 
    System.out.println(this.getClass().getSimpleName() + " end "); 
    return result; 
} 
protected abstract boolean doExec(PipelineContext pipelineContext); 
} 
package com.example.ownertest.dm.pipelline; 
/** 
* @Author: linear.zw 
* @Date: 2023/10/25 19:48 
*/ 
public class GraySwitchValue extends AbstractPipelineValue { 
@Override 
public boolean doExec(PipelineContext pipelineContext) { 
    pipelineContext.set(PipelineContext.FOR_TEST, true); 
    return true; 
} 
} 
package com.example.ownertest.dm.pipelline; 
/** 
* @Author: linear.zw 
* @Date: 2023/10/25 19:48 
*/ 
public class ForTestValue extends AbstractPipelineValue { 
@Override 
public boolean doExec(PipelineContext pipelineContext) { 
    return true; 
} 
}

  • PipelineClient

    package com.example.ownertest.dm.pipelline; 
/** 
* 入口类 
* 
* @Author: linear.zw 
* @Date: 2023/10/25 19:48 
*/ 
public class PipelineClient { 
public static void main(String[] args) { 
    // 管道初始化 
    Pipeline pipeline = new StandardPipeline(); 
    // value扩展 
    PipelineValue pipelineValue = new GraySwitchValue(); 
    PipelineValue pipelineValue2 = new ForTestValue(); 
    // 上下文 
    PipelineContext pipelineContext = new StandardPipelineContext(); 
    pipeline.addValue(pipelineValue); 
    pipeline.addValue(pipelineValue2); 
    // 调用管道 
    pipeline.invoke(pipelineContext); 
} 
}

常见框架中的应用

  • 网络层的扛把子netty框架中，例如ChannelPipeline、ChannelHandler、ChannelHandlerContext，分别用于处理tcp拆包、加解码等等之类。

基于责任链(filterchain)的套路

关键点



来源–https://www.oracle.com/java/technologies/intercepting-filter.html

  • 过滤器(Filter)—-实际处理业务的节点
  • 过滤链(FilterChain)—-串联过滤器的链条

适用场景

  • 例如常见的web请求场景

实现代码

  • Filter/ForTest1Filter/ForTest2Filter

    package com.example.ownertest.dm.filter; 
/** 
* @Author: linear.zw 
* @Date: 2023/10/26 19:22 
*/ 
public interface Filter { 
void doFilter(HttpRequest httpRequest,FilterChain filterChain); 
} 
package com.example.ownertest.dm.filter; 
/** 
* @Author: linear.zw 
* @Date: 2023/10/26 19:22 
*/ 
public class ForTest1Filter implements Filter { 
@Override 
public void doFilter(HttpRequest httpRequest, FilterChain filterChain) { 
    // do 
    System.out.println(this.getClass().getSimpleName() + " before " + System.currentTimeMillis()); 
    filterChain.doFilter(httpRequest); 
    // after 
    System.out.println(this.getClass().getSimpleName() + " end " + System.currentTimeMillis()); 
} 
} 
package com.example.ownertest.dm.filter; 
/** 
* @Author: linear.zw 
* @Date: 2023/10/26 19:22 
*/ 
public class ForTest2Filter implements Filter { 
@Override 
public void doFilter(HttpRequest httpRequest, FilterChain filterChain) { 
    // do 
    System.out.println(this.getClass().getSimpleName() + " before " + System.currentTimeMillis()); 
    filterChain.doFilter(httpRequest); 
    // after 
    System.out.println(this.getClass().getSimpleName() + " end " + System.currentTimeMillis()); 
} 
}

  • FilterChain/StandardFilterChain

    package com.example.ownertest.dm.filter; 
/** 
* @Author: linear.zw 
* @Date: 2023/10/26 19:23 
*/ 
public interface FilterChain { 
void doFilter(HttpRequest httpRequest); 
void addFilter(Filter filter); 
} 
package com.example.ownertest.dm.filter; 
import java.util.List; 
import com.google.common.collect.Lists; 
/** 
* @Author: linear.zw 
* @Date: 2023/10/26 19:24 
*/ 
public class StandardFilterChain implements FilterChain { 
private List<Filter> filterList = Lists.newArrayList(); 
private int currentIndex = 0; 
@Override 
public void doFilter(HttpRequest httpRequest) { 
    if (currentIndex == filterList.size()) { return; } 
    Filter filter = filterList.get(currentIndex); 
    currentIndex = currentIndex + 1; 
    filter.doFilter(httpRequest, this); 
} 
@Override 
public void addFilter(Filter filter) { 
    if (filterList.contains(filter)) { 
        return; 
    } 
    filterList.add(filter); 
} 
}

  • HttpRequest/StandardHttpRequest

    package com.example.ownertest.dm.filter; 
/** 
* @Author: linear.zw 
* @Date: 2023/10/26 19:24 
*/ 
public interface HttpRequest { 
} 
package com.example.ownertest.dm.filter; 
/** 
* @Author: linear.zw 
* @Date: 2023/10/26 19:24 
*/ 
public class StandardHttpRequest implements HttpRequest { 
}

  • FilterClient—-入口测试

    package com.example.ownertest.dm.filter; 
/** 
* @Author: linear.zw 
* @Date: 2023/10/26 19:25 
*/ 
public class FilterClient { 
public static void main(String[] args) { 
    FilterChain filterChain = new StandardFilterChain(); 
    filterChain.addFilter(new ForTest1Filter()); 
    filterChain.addFilter(new ForTest2Filter()); 
    filterChain.doFilter(new StandardHttpRequest()); 
} 
}

常见框架中的应用

  • hsf的filter机制，服务端扩展的ServerFilter和客户端扩展的ClientFilter；

  • 开发过java web的小伙伴都知道的servlet，servlet的入口即是FilterChain、Filter；

基于组合/模板的套路

关键点

  • 处理器注册器—-用于存储处理器的集合
  • 处理器工厂—-用于创建处理器
  • 处理器—-实际的处理器以及扩展的实现
  • 处理器上下文—-处理器上下文，用于参数的传递

适用场景

  • 适合于有共性、后续持续扩展的场景

实现代码

  • PiiHandlerRegistry—-处理器注册器

    package com.example.ownertest.dm.comp; 
import java.lang.reflect.Field; 
import java.util.List; 
import java.util.Map; 
import com.google.common.collect.Maps; 
import lombok.extern.slf4j.Slf4j; 
import org.apache.commons.collections4.CollectionUtils; 
import org.apache.commons.lang3.StringUtils; 
/** 
* @Author: linear.zw 
* @Date: 2023/10/31 20:45 
*/ 
@Slf4j 
public class PiiHandlerRegistry { 
private static Map<String, PiiDomainFieldHandler> piiDomainFieldHandlerMap = Maps.newHashMap(); 
public static void putHandler(String piiDomainFieldName, PiiDomainFieldHandler piiDomainFieldHandler) { 
    if (StringUtils.isEmpty(piiDomainFieldName)) { 
        log.warn(" piiDomainFieldName is null,continue"); 
        return; 
    } 
    if (piiDomainFieldHandler == null) { 
        log.warn(piiDomainFieldName + " piiDomainFieldHandler is null,continue"); 
        return; 
    } 
    if (!piiDomainFieldHandlerMap.containsKey(piiDomainFieldName)) { 
        piiDomainFieldHandlerMap.put(piiDomainFieldName, piiDomainFieldHandler); 
    } 
} 
public static <T extends Object> int handlerRead(T domain, Field domainField, PiiContent piiContent) { 
    int num = 0; 
    for (Map.Entry<String, PiiDomainFieldHandler> piiDomainFieldHandlerEntry : 
        piiDomainFieldHandlerMap.entrySet()) { 
        if (piiDomainFieldHandlerEntry.getValue().isSupport(domain, domainField)) { 
            piiDomainFieldHandlerEntry.getValue().handlerRead(domain, domainField, piiContent); 
        } 
    } 
    return num; 
} 
public static <T extends Object> int handlerWrite(T domain, Field domainField, PiiContent piiContent) { 
    int num = 0; 
    for (Map.Entry<String, PiiDomainFieldHandler> piiDomainFieldHandlerEntry : 
        piiDomainFieldHandlerMap.entrySet()) { 
        if (piiDomainFieldHandlerEntry.getValue().isSupport(domain, domainField)) { 
            piiDomainFieldHandlerEntry.getValue().handlerWrite(domain, domainField, piiContent); 
        } 
    } 
    return num; 
} 
public static Map<String, PiiDomainFieldHandler> getPiiDomainFieldHandlerMap() { 
    return piiDomainFieldHandlerMap; 
} 
public static void init() { 
    List<PiiDomainFieldHandler> piiDomainFieldHandlerList = PiiDomainFieldHandlerFactory 
        .createPiiDomainFieldHandler(); 
    if (CollectionUtils.isNotEmpty(piiDomainFieldHandlerList)) { 
        for (PiiDomainFieldHandler piiDomainFieldHandler : 
            piiDomainFieldHandlerList) { 
            putHandler(piiDomainFieldHandler.getPiiDomainMeta(), piiDomainFieldHandler); 
        } 
    } 
} 
}

  • PiiDomainFieldHandlerFactory—-处理器工厂

    package com.example.ownertest.dm.comp; 
import java.util.List; 
import com.google.common.collect.Lists; 
/** 
* @Author: linear.zw 
* @Date: 2023/10/31 20:46 
*/ 
public class PiiDomainFieldHandlerFactory { 
/** 
 * 创建领域处理器 
 * 
 * @return 
 */ 
public static List<PiiDomainFieldHandler> createPiiDomainFieldHandler() { 
    List<PiiDomainFieldHandler> piiDomainFieldHandlerList = Lists.newArrayList(); 
    // 
    piiDomainFieldHandlerList.add(new ForTestSupportFieldHandler()); 
    piiDomainFieldHandlerList.add(new ForTestNotSupportFieldHandler()); 
    return piiDomainFieldHandlerList; 
} 
}

  • PiiDomainFieldHandler/PiiDomainFieldHandlerBase/ForTestNotSupportFieldHandler/ForTestSupportFieldHandler—-处理器

    package com.example.ownertest.dm.comp; 
import java.lang.reflect.Field; 
/** 
* @Author: linear.zw 
* @Date: 2023/10/31 20:46 
*/ 
public interface PiiDomainFieldHandler { 
/** 
 * 处理实际操作 
 * 读----从PiiContent获取数据回填domain 
 * 
 * @param domain 
 * @param domainField 
 * @param piiContent 
 * @param <T> 
 * @return 
 */ 
<T extends Object> boolean handlerRead(T domain, Field domainField, PiiContent piiContent); 
/** 
 * 处理实际操作 
 * 写----将domain中需要写入pii的字段数据写入PiiContent 
 * 
 * @param domain 
 * @param domainField 
 * @param piiContent 
 * @param <T> 
 * @return 
 */ 
<T extends Object> boolean handlerWrite(T domain, Field domainField, PiiContent piiContent); 
/** 
 * 当前处理器是否支持该领域对象 
 * 
 * @param domain 
 * @param domainField 
 * @param <T> 
 * @return 
 */ 
<T extends Object> boolean isSupport(T domain, Field domainField); 
/** 
 * 获取处理器对应的元信息 
 * 
 * @return 
 */ 
String getPiiDomainMeta(); 
} 
package com.example.ownertest.dm.comp; 
import java.lang.reflect.Field; 
import lombok.extern.slf4j.Slf4j; 
/** 
* @Author: linear.zw 
* @Date: 2023/10/31 20:47 
*/ 
@Slf4j 
public abstract class PiiDomainFieldHandlerBase implements PiiDomainFieldHandler { 
@Override 
public <T extends Object> boolean handlerRead(T domain, Field domainField, PiiContent piiContent) { 
    // to do business read 
    return true; 
} 
@Override 
public <T extends Object> boolean handlerWrite(T domain, Field domainField, PiiContent piiContent) { 
    // to do business write 
    return true; 
} 
} 
package com.example.ownertest.dm.comp; 
import java.lang.reflect.Field; 
/** 
* @Author: linear.zw 
* @Date: 2023/10/31 20:47 
*/ 
public class ForTestSupportFieldHandler extends PiiDomainFieldHandlerBase { 
@Override 
public <T> boolean isSupport(T domain, Field domainField) { 
    if (this.getClass().getSimpleName().equalsIgnoreCase(domain.getClass().getSimpleName())) { 
        // to do business 
        System.out.println(this.getClass().getSimpleName() + " is support, to do some business"); 
        return true; 
    } 
    return false; 
} 
@Override 
public String getPiiDomainMeta() { 
    return this.getClass().getSimpleName(); 
} 
} 
package com.example.ownertest.dm.comp; 
import java.lang.reflect.Field; 
/** 
* @Author: linear.zw 
* @Date: 2023/10/31 20:48 
*/ 
public class ForTestNotSupportFieldHandler extends PiiDomainFieldHandlerBase { 
@Override 
public <T> boolean isSupport(T domain, Field domainField) { 
    if (this.getClass().getSimpleName().equalsIgnoreCase(domain.getClass().getSimpleName())) { 
        // to do business 
        System.out.println(this.getClass().getSimpleName() + " is support, to do some business"); 
        return true; 
    } 
    return false; 
} 
@Override 
public String getPiiDomainMeta() { 
    return this.getClass().getSimpleName(); 
} 
}

  • PiiContent—-上下文

    package com.example.ownertest.dm.comp; 
import java.util.Map; 
import com.google.common.collect.Maps; 
import lombok.Data; 
/** 
* @Author: linear.zw 
* @Date: 2023/10/31 20:48 
*/ 
@Data 
public class PiiContent { 
public static String FORTEST="fortest"; 
private Map<String, Object> piiDataMap = Maps.newHashMap(); 
private Map<String, Object> piiContextMap = Maps.newHashMap(); 
public void putPiiData(String domainFieldName, Object domainFieldValue) { 
    piiDataMap.put(domainFieldName, domainFieldValue); 
} 
public Object getPiiData(String domainFieldName) { 
    return piiDataMap.get(domainFieldName); 
} 
public void putPiiContext(String contextName, Object contextNameValue) { 
    piiContextMap.put(contextName, contextNameValue); 
} 
public Object getPiiContext(String contextName) { 
    return piiContextMap.get(contextName); 
} 
}

  • PiiClient—-入口的测试类

    package com.example.ownertest.dm.comp; 
import java.util.Map; 
/** 
* @Author: linear.zw 
* @Date: 2023/10/31 20:48 
*/ 
public class PiiClient { 
public static void main(String[] args) { 
    PiiHandlerRegistry.init(); 
    // 遍历处理器 
    for (Map.Entry<String, PiiDomainFieldHandler> entryHandler : 
        PiiHandlerRegistry.getPiiDomainFieldHandlerMap().entrySet()) { 
        System.out.println(entryHandler.getKey() + "t" + entryHandler.getValue().getPiiDomainMeta()); 
    } 
    // 
    PiiContent piiContent = new PiiContent(); 
    piiContent.putPiiContext(PiiContent.FORTEST, PiiContent.FORTEST); 
    // 请求处理 
    System.out.println("ForTestSupportFieldHandler start"); 
    PiiHandlerRegistry.handlerRead(new ForTestSupportFieldHandler(), null, piiContent); 
    System.out.println("ForTestSupportFieldHandler end"); 
    // 请求处理 
    System.out.println("ForTestNotSupportFieldHandler start"); 
    PiiHandlerRegistry.handlerRead(new ForTestNotSupportFieldHandler(), null, piiContent); 
    System.out.println("ForTestNotSupportFieldHandler end"); 
} 
}

常见框架中的应用

  • 这个就太多了，例如spring最核心的BeanPostProcessor机制，通过org.springframework.beans.factory.support.AbstractBeanFactory#beanPostProcessors管理一些列的beanPostProcessors，在spring上下文org.springframework.context.support.AbstractApplicationContext#refresh的时候，进行bean的init(InitDestroyAnnotationBeanPostProcessor)、解析注解(ScheduledAnnotationBeanPostProcessor、AutowiredAnnotationBeanPostProcessor)、解析aop（AnnotationAwareAspectJAutoProxyCreator）等等。

基于注解的套路

关键点

  • 注解元定义—-用来定义通用的元信息；
  • 注解解析器—-解析类上是否有指定的注解，进而进行对应的扩展操作；
  • spring的BeanPostProcessor—-这里是借用spring的BeanPostProcessor机制，在spring容器初始化的时候，进行回调，完成预期的扩展行为；

适用场景

  • 简化内部使用

实现代码

  • ForTestAnnotation—-注解元定义

    package com.example.ownertest.dm.annotation; 
import java.lang.annotation.ElementType; 
import java.lang.annotation.Retention; 
import java.lang.annotation.RetentionPolicy; 
import java.lang.annotation.Target; 
import org.springframework.stereotype.Component; 
/** 
* 用于测试的标识注解 
* 
* @Author: linear.zw 
* @Date: 2023/11/1 10:21 
*/ 
@Target({ElementType.TYPE, ElementType.METHOD}) 
@Retention(RetentionPolicy.RUNTIME) 
@Component 
public @interface ForTestAnnotation { 
}

  • ForTestAnnotationProcessor—-注解解析器

    package com.example.ownertest.dm.annotation; 
import org.springframework.aop.support.AopUtils; 
import org.springframework.beans.BeansException; 
import org.springframework.beans.factory.config.BeanPostProcessor; 
import org.springframework.core.annotation.AnnotationUtils; 
import org.springframework.stereotype.Component; 
/** 
* 注解解析器 
* @Author: linear.zw 
* @Date: 2023/11/1 10:25 
*/ 
@Component 
public class ForTestAnnotationProcessor implements BeanPostProcessor { 
@Override 
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { 
    // 获取目标类是否有ForTestAnnotation注解 
    ForTestAnnotation annotation = AnnotationUtils.findAnnotation(AopUtils.getTargetClass(bean), 
        ForTestAnnotation.class); 
    if (annotation == null) { 
        return bean; 
    } 
    // 处理想要的扩展 
    System.out.println(beanName + " has ForTestAnnotation"); 
    return bean; 
} 
@Override 
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { 
    return bean; 
} 
}

  • ForTestBean—-测试bean

    package com.example.ownertest.dm.annotation; 
/** 
* @Author: linear.zw 
* @Date: 2023/11/1 10:26 
*/ 
@ForTestAnnotation 
public class ForTestBean { 
public ForTestBean() { 
    System.out.println(ForTestBean.class.getSimpleName() + " init"); 
} 
}

  • ForTestClient—测试入口

    package com.example.ownertest.dm.annotation; 
import org.springframework.context.annotation.AnnotationConfigApplicationContext; 
/** 
* @Author: linear.zw 
* @Date: 2023/11/1 10:26 
*/ 
public class ForTestClient { 
public static void main(String[] args) { 
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext( 
        "com.example.ownertest.dm.annotation"); 
    System.out.println(ForTestClient.class.getSimpleName()); 
} 
}

常见框架中的应用

  • 例如集团内部的spring-boot-alibaba-diamond-autoconfigure

基于事件分发的套路

关键点



  • 事件源–事件触发者
  • 事件–标识产生的来源
  • 事件监听器–事件的关注者，即处理者
  • 事件分发器–用于将事件源的事件转发给事件监听器

实现代码

  • EventSource/EventSourceForTest/EventSourceForTest2

    package com.example.ownertest.dm.event; 
/** 
* 发出事件 
* @Author: linear.zw 
* @Date: 2023/11/1 14:12 
*/ 
public interface EventSource { 
/** 
 * 发出事件 
 * 
 * @return 
 */ 
Event fireEvent(); 
} 
package com.example.ownertest.dm.event; 
/** 
* @Author: linear.zw 
* @Date: 2023/11/1 14:14 
*/ 
public class EventSourceForTest implements EventSource { 
@Override 
public Event fireEvent() { 
    Event event = new EventForTest(); 
    System.out.println(getClass().getSimpleName() + " t fireEvent " + event.getName()); 
    return event; 
} 
} 
package com.example.ownertest.dm.event; 
/** 
* @Author: linear.zw 
* @Date: 2023/11/1 14:15 
*/ 
public class EventSourceForTest2 implements EventSource { 
@Override 
public Event fireEvent() { 
    Event event = new EventForTest2(); 
    System.out.println(getClass().getSimpleName() + " t fireEvent " + event.getName()); 
    return event; 
} 
}

  • Event/EventForTest/EventForTest2

    package com.example.ownertest.dm.event; 
/** 
* @Author: linear.zw 
* @Date: 2023/11/1 14:15 
*/ 
public interface Event { 
/** 
 * 事件名称 
 * 
 * @return 
 */ 
String getName(); 
} 
package com.example.ownertest.dm.event; 
/** 
* @Author: linear.zw 
* @Date: 2023/11/1 14:17 
*/ 
public class EventForTest implements Event { 
@Override 
public String getName() { 
    return getClass().getSimpleName(); 
} 
} 
package com.example.ownertest.dm.event; 
/** 
* @Author: linear.zw 
* @Date: 2023/11/1 14:17 
*/ 
public class EventForTest2 implements Event { 
@Override 
public String getName() { 
    return getClass().getSimpleName(); 
} 
}

  • EventListener/EventListenerForTest

    package com.example.ownertest.dm.event; 
/** 
* @Author: linear.zw 
* @Date: 2023/11/1 14:17 
*/ 
public interface EventListener { 
/** 
 * 是否支持此事件 
 * 
 * @param event 
 * @return 
 */ 
boolean supportEvent(Event event); 
/** 
 * 处理事件 
 * 
 * @return 
 */ 
boolean handlerEvent(Event event); 
} 
package com.example.ownertest.dm.event; 
/** 
* @Author: linear.zw 
* @Date: 2023/11/1 14:18 
*/ 
public class EventListenerForTest implements EventListener { 
@Override 
public boolean supportEvent(Event event) { 
    return event.getName().contains("Test"); 
} 
@Override 
public boolean handlerEvent(Event event) { 
    System.out.println(this.getClass().getSimpleName() + "t handler " + event.getName()); 
    return true; 
} 
}

  • EventDispatcher/EventListenerManager

    package com.example.ownertest.dm.event; 
import org.apache.commons.collections4.CollectionUtils; 
/** 
* @Author: linear.zw 
* @Date: 2023/11/1 14:18 
*/ 
public class EventDispatcher { 
/** 
 * 单例模式 
 */ 
private static EventDispatcher eventDispatcher = new EventDispatcher(); 
private EventDispatcher() { 
} 
/** 
 * 分发事件 
 * 
 * @param event 
 * @return 
 */ 
public static boolean dispatchEvent(Event event) { 
    if (CollectionUtils.isNotEmpty(EventListenerManager.getEventListenerList())) { 
        for (EventListener eventListener : 
            EventListenerManager.getEventListenerList()) { 
            if (eventListener.supportEvent(event)) { 
                eventListener.handlerEvent(event); 
            } 
        } 
    } 
    return true; 
} 
} 
package com.example.ownertest.dm.event; 
import java.util.List; 
import com.google.common.collect.Lists; 
/** 
* @Author: linear.zw 
* @Date: 2023/11/1 14:18 
*/ 
public class EventListenerManager { 
private static List<EventListener> eventListenerList = Lists.newArrayList(); 
/** 
 * 添加事件监听器 
 * 
 * @param eventListener 
 * @return 
 */ 
public static boolean addEventListener(EventListener eventListener) { 
    if (!eventListenerList.contains(eventListener)) { 
        return eventListenerList.add(eventListener); 
    } 
    return true; 
} 
/** 
 * 移除事件监听器 
 * 
 * @param eventListener 
 * @return 
 */ 
public static boolean removeEventListener(EventListener eventListener) { 
    if (eventListenerList.contains(eventListener)) { 
        return eventListenerList.remove(eventListener); 
    } 
    return true; 
} 
public static List<EventListener> getEventListenerList() { 
    return eventListenerList; 
} 
}

  • EventClient

    package com.example.ownertest.dm.event; 
/** 
* @Author: linear.zw 
* @Date: 2023/11/1 14:19 
*/ 
public class EventClient { 
public static void main(String[] args) { 
    // 创建事件源 
    EventSource eventSourceForTest = new EventSourceForTest(); 
    EventSource eventSourceForTest2 = new EventSourceForTest2(); 
    // 创建事件监听器 
    EventListener eventListener = new EventListenerForTest(); 
    EventListenerManager.addEventListener(eventListener); 
    // 发布事件 
    EventDispatcher.dispatchEvent(eventSourceForTest.fireEvent()); 
    EventDispatcher.dispatchEvent(eventSourceForTest2.fireEvent()); 
} 
}

基于SPI机制的套路

关键点

  • 服务调用方
  • 服务实现方—-以接口名称为文件名称，放在META-INF/services，值为该接口的实现

  • 标准服务接口

适用场景



实现代码

  • SpiServiceLoaderHelper

    package com.example.ownertest.dm.spi; 
import java.util.Iterator; 
import java.util.Objects; 
import java.util.ServiceLoader; 
/** 
* @Author: linear.zw 
* @Date: 2023/11/1 15:32 
*/ 
public class SpiServiceLoaderHelper { 
public static ProductPackageRemoteServiceInterface getProductPackageRemoteServiceInterface() { 
    // 先从缓存中加载 
    Object serviceCache = DependServiceRegistryHelper.getDependObject(ProductPackageRemoteServiceInterface.class); 
    if (serviceCache != null) { 
        return (ProductPackageRemoteServiceInterface) serviceCache; 
    } 
    // spi 方式加载 
    ProductPackageRemoteServiceInterface serviceInterface = loadSpiImpl(ProductPackageRemoteServiceInterface.class); 
    // 防止注入的bean为空 提前进行判断 以免业务执行出现问题 
    boolean isExist = true; 
    if (Objects.isNull(serviceInterface)) { 
        isExist = false; 
    } else if (Objects.isNull(serviceInterface.getProductPackageRemoteService())) { 
        isExist = false; 
    } 
    if (!isExist) { 
        throw new RuntimeException("getProductPackageRemoteService load impl failed,please check spi service"); 
    } 
    // 添加进统一的依赖管理 
    DependServiceRegistryHelper.registry(ProductPackageRemoteServiceInterface.class, serviceInterface); 
    return serviceInterface; 
} 
/** 
 * 以spi的方式加载实现类 
 * 
 * @param cls 
 * @param <P> 
 * @return 
 */ 
private static <P> P loadSpiImpl(Class<P> cls) { 
    ServiceLoader<P> spiLoader = ServiceLoader.load(cls); 
    Iterator<P> iaIterator = spiLoader.iterator(); 
    if (iaIterator.hasNext()) { 
        return iaIterator.next(); 
    } 
    return null; 
} 
}

  • DependServiceRegistryHelper

    package com.example.ownertest.dm.spi; 
import java.util.Map; 
import com.google.common.collect.Maps; 
/** 
* @Author: linear.zw 
* @Date: 2023/11/1 15:35 
*/ 
public class DependServiceRegistryHelper { 
/** 
 * 存储策略依赖的服务,统一管理 
 */ 
private static Map<String, Object> dependManagerMap = Maps.newHashMap(); 
public static boolean registryMap(Map<Class, Object> dependManagerMap) { 
    for (Map.Entry<Class, Object> dependEntry : 
        dependManagerMap.entrySet()) { 
        registry(dependEntry.getKey(), dependEntry.getValue()); 
    } 
    return true; 
} 
public static boolean registry(Class cls, Object dependObject) { 
    dependManagerMap.put(cls.getCanonicalName(), dependObject); 
    return true; 
} 
public static Object getDependObject(Class cls) { 
    return dependManagerMap.get(cls.getCanonicalName()); 
} 
}

  • SpiServiceLoaderClientTest

    package com.example.ownertest.dm.spi; 
/** 
* @Author: linear.zw 
* @Date: 2023/11/1 15:37 
*/ 
public class SpiServiceLoaderClientTest { 
public static void main(String[] args) { 
    ProductPackageRemoteServiceInterface productPackageRemoteServiceInterface 
        = SpiServiceLoaderHelper.getProductPackageRemoteServiceInterface(); 
} 
}

常见框架中的应用

  • 目前大多数中台的策略包，都是基于spi方式的，动态加载业务的实现，进而达到扩展的目的；
  • 例如google开源的auto-service，通过注解的方式，自动生成spi的实现目录；

最后

程序员大多数都是实干派，所以，你的套路有哪些，评论区有你的位置，Show me the code。

4