Redian新闻
>
Java中保持扩展性的几种套路和实现

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

科技

阿里妹导读


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

前言

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的实现目录;

最后

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

欢迎加入【阿里云开发者公众号】读者群


这是一个专门面向“阿里云开发者”公众号的读者交流空间
💡 在这里你可以探讨技术和实践,我们也会定期发布群福利和活动~
欢迎扫码或者添加微信:argentinaliu 加入我们👇



微信扫码关注该文公众号作者

戳这里提交新闻线索和高质量文章给我们。
相关阅读
咀外文嚼汉字(286)翻译和通译留英还是回国?一年硕留英的几种可能.....男人爱上你的几种反应对谈上千家母婴店,行业的出路和机会就藏在这两大趋势里【无忧买房】Lexington独栋别墅出售,优质学区,近2号公路和Arlington黄奇帆:到底是什么掣肘了房地产和实体经济的发展?GPT-4+物理引擎加持扩散模型,生成视频逼真、连贯、合理复仇爽片的“千层套路”,到底是什么套路?中信:超大型综合集团的碳中和实践打破学术和实际商业世界的gap,普华永道高中生项目要做些什么?东阿阿胶无厘头再现《甄嬛传》,比亚迪发明河蚌青年:品牌年轻化的套路与反套路|中国案例她们不只是最有代表性的东方面孔,也写下了亚洲女性的传奇坦白了!全新“三高”共识,主打的就是一个权威和实用美国室温超导论文被撤回:论文中的材料来源和实验测量不准确如何获得免费或低成本的医疗保险:美国的几种途径天各一方 (2)瞬間的永恆留英真的那么难?英国秋招正式开启,零基础快速拿offer的几种方法......毛岸英 伟大的气魄反套路反英雄,这样突破性的作品极稀缺在人群中保持真我 | 人间日签「专题速递」RTC云网端联合优化、弱网对抗策略、QUIC协议的能力和实践凶猛的犬儿谁才是黑眼圈和细纹的救星?这支小金管眼霜用成分和实力说话变态语文老师开脑洞:巴以问题解决的几种路径免费试听|数据分析、机器学习、A/B实验基础理论和实践知识全覆盖,华丽转身为集万千宠爱的大数据人才!信息分享 | 伍斯特州立大学,缅因,近期枪击案频发,如何在枪击案中保护自己?她支持扩大中国投票权,美方暗示“否决”!现在的湾区如何高性价比买房?技巧和实际案例总结都在这了DoorDash如何通过重构缓存来提升性能和可扩展性如何在咖啡烘焙过程中保护地球?中央金融工作会议重磅定调!更好发挥资本市场枢纽功能,活跃资本市场更好支持扩大内需…信息量巨大→特别策划丨企业该如何在AI的新浪潮中保持创新力与竞争力?教育部公示义务教育教学改革实验区和实验校名单GauHuman开源:基于Gaussian Splatting,高质量3D人体快速重建和实时渲染框架
logo
联系我们隐私协议©2024 redian.news
Redian新闻
Redian.news刊载任何文章,不代表同意其说法或描述,仅为提供更多信息,也不构成任何建议。文章信息的合法性及真实性由其作者负责,与Redian.news及其运营公司无关。欢迎投稿,如发现稿件侵权,或作者不愿在本网发表文章,请版权拥有者通知本网处理。