备案控制台
开发者社区 开发与运维 文章 正文

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

2023-11-17 1852
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 在日常的开发中，作者总结了平常用到的一些低成本、保持扩展性的套路，分享出来，欢迎大家讨论。

来源｜阿里云开发者公众号

作者｜高止

前言

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@Slf4jpublic 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 */@Slf4jpublic 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 */@Slf4jpublic 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 */@Datapublic 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)@Componentpublic @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 */@Componentpublic 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 */@ForTestAnnotationpublic 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的实现目录；


文章标签：
Java
架构师
Spring
设计模式
网络协议
关键词：
Java扩展性
阿里开发者
目录
相关文章
源码星辰
|
6天前
|
存储 运维 Java
Java智慧云HIS医院信息化系统源码 更具灵活性、扩展性
云HIS平台采用SaaS服务模式，软件使用者无需购置额外硬件设备、软件许可证及安装和维护软件系统，通过互联网浏览器在任何时间、任何地点都可以轻松使用软件。 云HIS具有可扩展、易共享、区域化、易协同、低成本、易维护、体验好等特性。由卫健局牵头建立区域云HIS数据中心，实现各医院无机房、无服务器、无系统、免维护的云平台应用，彻底解决基层医疗机构信息化建设的“三缺三难”问题.
源码星辰
104 2
众所周知
|
4天前
|
Java 测试技术
Java多线程的一些基本例子
【5月更文挑战第17天】Java多线程允许并发执行任务。示例1展示创建并启动两个`MyThread`对象，各自独立打印&quot;Hello World&quot;。示例2的`CounterExample`中，两个线程（IncrementThread和DecrementThread）同步地增加和减少共享计数器，确保最终计数为零。这些例子展示了Java线程的基本用法，包括线程同步，还有如Executor框架和线程池等更复杂的用例。
众所周知
11 0
老板这功能得加钱
|
4天前
|
缓存 安全 Java
7张图带你轻松理解Java 线程安全，java缓存机制面试
7张图带你轻松理解Java 线程安全，java缓存机制面试
老板这功能得加钱
12 0
长梦
|
2天前
|
Java
Java一分钟之-并发编程：线程间通信(Phaser, CyclicBarrier, Semaphore)
【5月更文挑战第19天】Java并发编程中，Phaser、CyclicBarrier和Semaphore是三种强大的同步工具。Phaser用于阶段性任务协调，支持动态注册；CyclicBarrier允许线程同步执行，适合循环任务；Semaphore控制资源访问线程数，常用于限流和资源池管理。了解其使用场景、常见问题及避免策略，结合代码示例，能有效提升并发程序效率。注意异常处理和资源管理，以防止并发问题。
长梦
25 2
长梦
|
2天前
|
安全 Java 容器
Java一分钟之-并发编程：线程安全的集合类
【5月更文挑战第19天】Java提供线程安全集合类以解决并发环境中的数据一致性问题。例如，Vector是线程安全但效率低；可以使用Collections.synchronizedXxx将ArrayList或HashMap同步；ConcurrentHashMap是高效线程安全的映射；CopyOnWriteArrayList和CopyOnWriteArraySet适合读多写少场景；LinkedBlockingQueue是生产者-消费者模型中的线程安全队列。注意，过度同步可能影响性能，应尽量减少共享状态并利用并发工具类。
长梦
17 2
肥猪肥猪-17824
|
2天前
|
Java 程序员 调度
Java中的多线程编程：基础知识与实践
【5月更文挑战第19天】多线程编程是Java中的一个重要概念，它允许程序员在同一时间执行多个任务。本文将介绍Java多线程的基础知识，包括线程的创建、启动和管理，以及如何通过多线程提高程序的性能和响应性。
肥猪肥猪-17824
14 2
技术混子
|
3天前
|
Java
深入理解Java并发编程：线程池的应用与优化
【5月更文挑战第18天】本文将深入探讨Java并发编程中的重要概念——线程池。我们将了解线程池的基本概念，应用场景，以及如何优化线程池的性能。通过实例分析，我们将看到线程池如何提高系统性能，减少资源消耗，并提高系统的响应速度。
技术混子
13 5
1941623231718325
|
3天前
|
消息中间件 安全 Java
理解Java中的多线程编程
【5月更文挑战第18天】本文介绍了Java中的多线程编程，包括线程和多线程的基本概念。Java通过继承Thread类或实现Runnable接口来创建线程，此外还支持使用线程池（如ExecutorService和Executors）进行更高效的管理。多线程编程需要注意线程安全、性能优化和线程间通信，以避免数据竞争、死锁等问题，并确保程序高效运行。
1941623231718325
18 5
你都不懂
|
3天前
|
存储 Java
【Java】实现一个简单的线程池
，如果被消耗完了就说明在规定时间内获取不到任务，直接return结束线程。
你都不懂
11 0
肥猪肥猪-17824
|
3天前
|
安全 Java 容器
深入理解Java并发编程：线程安全与性能优化
【5月更文挑战第18天】随着多核处理器的普及，并发编程变得越来越重要。Java提供了丰富的并发编程工具，如synchronized关键字、显式锁Lock、原子类、并发容器等。本文将深入探讨Java并发编程的核心概念，包括线程安全、死锁、资源竞争等，并分享一些性能优化的技巧。
肥猪肥猪-17824
9 1

热门文章

最新文章

  • 1
    使用Redis进行Java缓存策略设计
  • 2
    Java语言开发的AI智慧导诊系统源码springboot+redis 3D互联网智导诊系统源码
  • 3
    【JAVA】Java 中什么叫单例设计模式？请用 Java 写出线程安全的单例模式
  • 4
    基于Java的公司员工工作日志办公系统的设计与实现(源码+lw+部署文档+讲解等)
  • 5
    【JAVA】线程的run()和start()有什么区别？
  • 6
    高德地图爬虫实践：Java多线程并发处理策略
  • 7
    [AIGC] 21世纪Java与Go的相爱相杀
  • 8
    Java多线程实战-CompletableFuture异步编程优化查询接口响应速度
  • 9
    打造个人的Minecraft服务器：Java+cpolar实现我的世界联机游戏
  • 10
    Java 开发者必备：JDK 版本详解与选择策略(含安装与验证)
  • 1
    Java中的集合框架：深入理解与应用
    46
  • 2
    Java并发编程：理解并使用Future和Callable接口
    24
  • 3
    性能工具之 Java 调试工具 JDB
    51
  • 4
    JAVA云HIS系统医院信息管理源码
    35
  • 5
    Java基于物联网技术的智慧工地云管理平台源码 依托丰富的设备接口标准库，快速接入工地现场各类型设备
    156
  • 6
    [Java基础]——类的生命周期
    20
  • 7
    [java进阶]——泛型类、泛型方法、泛型接口、泛型的通配符
    34
  • 8
    【java进阶】Java中线程的实现方式
    27
  • 9
    【java进阶】集合的三种遍历(迭代器、增强for、Lambda)
    22
  • 10
    [java进阶]——方法引用改写Lambda表达式
    37

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 语言入门-1：环境构建
  • 阿里云平台上进行Java程序的编译与运行
  • 使用Java面向对象编写网络通信程序应用
  • Elasticsearch Java API Client 开发
  • 手动部署Java Web环境（Alibaba Cloud Linux 2）
  • 搭建Java Web开发环境（Anolis OS）
    • 下一篇
    2024年阿里云免费云服务器及学生云服务器申请教程参考