代码这种东西，机器不管你写的怎么样，肯定能识别， 人就不一样了，前人拉屎后人踩屎，一坨认栽，n坨就有点过分了哈
一般写代码也不用太高大上，很多接口还是很简单的，如果把各种设计模式搞上来那叫过度设计，叫逼王；就在多渠道，多河流的时候才能当逼王
满满干货哈，十分有助于大家整体代码设计，现在就和大家简单介绍一下下面四种模式的抽象设计
1. 注解式
2. 拼接式
3. 实现扩展接口式
4. 函数式接口式
大家不用担心，示例代码中我也基本加了注释，便于大家理解
注解式
核心用到的方式：单例模式+注解+反射+策略模式
直接上代码了哈，注释搞在代码中，大家直接体验
既然是注解，那就先定义一个注解吧
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface BizCode {String value() default "";}
然后定义一个执行接口
/*** 扩展点执行引擎* 真正的扩展点在ProcessExtension接口，实现此接口并注解即可，在外部接口使用过程中自然根据BizCode* 索引到类* 单例模式+注解+反射+策略模式*/
public interface Engine {String process(String bizCode, String params);}
然后定义一个实现类，大家可以看到ExtensionEngine的构造方法中有个单例的写法
为什么写在构造方法中？是为了在启动时就会执行并加载到一个全局变量中，等会我们往下看就知道了，当然了，此处用其他方式也行，能在启动时加载就好
/*** 执行引擎*/
@Component
public class ExtensionEngine implements Engine {public ExtensionEngine() {// 注册扩展 在启动时就被加载进来ExtensionBuilder.getInstance().build();}@Overridepublic String process(String bizCode, String params) {StringBuilder processRecord = new StringBuilder();//拿到对应的实例ProcessExtension processExtension = ExtensionBuilder.getInstance().getExt(bizCode);// 1、前置处理processExtension.beforeProcess(params, processRecord);// 2、统一处理System.out.println("统一处理流程");processRecord.append("统一处理 - ");// 3、后置处理processExtension.afterProcess(params, processRecord);return processRecord.toString();}
}
我们看到如果拿到了实例就会进行前中后的调用处理，其实就是多条分支策略的处理，定义一个接口
public interface ProcessExtension {/*** 前置处理* @param params 参数* @param processRecord 处理对象传递*/void beforeProcess(String params, StringBuilder processRecord);/*** 后置处理* @param params 参数* @param processRecord 处理对象传递*/void afterProcess(String params, StringBuilder processRecord);// 其他模板动作接口
}
定义两三个实现类，具体你说的算，这就用到我们上面定义的注解了，value用常量定义就行，后来我也试过用枚举，只不过只能用枚举本身，不能枚举.getValue，都可以
一般如果不定义value默认就是类名首字母小写jdProcessExtension，这个大家熟知一下
@BizCode(value = "jd")
public class JdProcessExtension implements ProcessExtension {@Overridepublic void beforeProcess(String params, StringBuilder processRecord) {System.out.println("京东活动前置处理流程");processRecord.append("京东活动前置处理流程 - ");}@Overridepublic void afterProcess(String params, StringBuilder processRecord) {System.out.println("京东活动后置处理流程");processRecord.append("京东活动后置处理流程");}
}
@BizCode(value = "tb")
public class TaobaoProcessExtension implements ProcessExtension {@Overridepublic void beforeProcess(String params, StringBuilder processRecord) {System.out.println("淘宝活动前置处理流程");processRecord.append("淘宝活动前置处理流程 - ");}@Overridepublic void afterProcess(String params, StringBuilder processRecord) {System.out.println("淘宝活动后置处理流程");processRecord.append("淘宝活动后置处理流程");}
}
下面我们就看下那个单例是如何注册的吧，这个比较关键了！标准单例写法，静态内部类的姿势。
- 把所有的BizCode注解通过反射识别并注入到了Map<String, ProcessExtension>中，即Map<枚举或String都可以, 接口>
- 再定义一个根据Key获取Value的就行了
/*** 业务注册处理类* 单例模式*/
@Slf4j
public class ExtensionBuilder {private ExtensionBuilder() {}public static ExtensionBuilder getInstance() {return ExtensionBuilderInstance.INSTANCE;}/*** 静态内部类方式*/private static class ExtensionBuilderInstance {private static final ExtensionBuilder INSTANCE = new ExtensionBuilder();}/*** bizcode => 业务扩展类实例*/private Map<String, ProcessExtension> extMap = new ConcurrentHashMap<>();/*** 注册业务扩展类实例*/public void build() {try {log.debug("找出所有注解了BizCode的类并注册");// 找出所有注解了BizCode的类Reflections extReflections = new Reflections("com.mtgg.laoxiang");Set<Class<?>> extClasses = extReflections.getTypesAnnotatedWith(BizCode.class);for (Class<?> extClass : extClasses) {BizCode[] annotationsByType = extClass.getAnnotationsByType(BizCode.class);if (annotationsByType != null && annotationsByType.length > 0) {BizCode bizCode = annotationsByType[0];// 构建 bizcode => 业务扩展类实例extMap.put(bizCode.value(), (ProcessExtension) extClass.newInstance());}}log.debug("ExtensionBuilder加载扩展实例：{}", extMap);} catch (Exception e) {e.printStackTrace();}}/*** 根据业务编码，获取对应的业务扩展类实例** @param bizCode* @return*/public ProcessExtension getExt(String bizCode) {return extMap.get(bizCode);}
}
调用的时候就直接注入Engine，然后调用process方法就好了，只要指定bizCode就没毛病
下面介绍第二种哈
拼接式
从代码多少上面看这个还真容易一点，优劣等会再说
话说在启动后Spring已经帮我们把该注册的都已经注册成Bean Map了，key就是类名（首字母小写），value就是这个类的实例，我们只要用就好了
以注解式jd，taobao两个实现类以及其实现的接口ProcessExtension为例，不需要自定义注解了
@Component
public class JdProcessExtension implements ProcessExtension {
}
@Component
public class TaobaoProcessExtension implements ProcessExtension {
}
直接注入使用，下面这个map就已经有数据了，其value就是子类返回的接口（此处是Spring加载bean的知识，大家可以搜一下Spring加载过程）
@Autowired
private Map<String, ProcessExtension> map;
这个map是什么形式呢，我直接演示下，比如这两个实现类的key就是前面说过的首字母小写的实现类
jdProcessExtension
taobaoProcessExtension
我们只要拿到key获取到value–>ProcessExtension，调用相关接口就能自己往下走了，所以问题是如何拿到key？
- 可以定义一个常量"%sProcessExtension"; 就是%s+实现类统一后缀；
- 传入bizCode用String.format替换一下%s就得到了key
比如我传个jd，得到了jdProcessExtension ，用map.get()拿到ProcessExtension实例后调用接口，走的就是jd的实现类，完毕！
下面介绍第三种
扩展接口式
说到底这个就是利用Spring的扩展接口或预加载注解，或构造方法来实现启动时将实例加载到一个Map中的，和第一个结构有点相似，有一个调用层处理。上菜，这里以支付为例
- 先定义一个Service
public interface PayCoreService {/*** @Author: 老乡* @Date: 2020/6/13 21:50* @Describe: 统一下单* 接入新的支付方式只需要增加枚举类，继承PayStrategyContent抽象类，重写支付等功能接口*/Result toPayCore(PayCoreDTO payCoreDTO);
- 定义一个抽象类实现Service，
- 定义抽象方法（下面会定义两个子类继承它并实现抽象方法）
- 然后大家可以看到这里也同样是定义了ConcurrentHashMap用来全局保存实例的，key为子类设置的枚举即子类实例，value为Service实例，这里就是为了抽象方法找到到底要调用哪个子类用的
/*** @Author: 老乡* @Describe: 当增加一个功能的时候可以在抽象类中实现接口，通过抽象方法让子类去实现* 如果有的子类没有用到这个功能也可以不重写，将类改为抽象类即可；* 不过一般抽象出来的功能都是共用的行为，所以即使暂时不用也可以先重写后放在那里* <p>* 此抽象类完成了对无法选择的延迟到子类实现，实现了PayStrategy接口，转化找到*/
@Slf4j
public abstract class PayCoreStrategyAbstract implements PayCoreService {/*** 各种支付策略实例预加载*/public static Map<Integer, PayCoreService> strategyMap = new ConcurrentHashMap<>();/*** @Author: 老乡* @Describe: 只在启动时加载一次，加载类别在子类中控制* this为当前PayStrategy，因为调用的时候取到具体的实例如支付宝实例，返回的是接口PayStrategy*/@PostConstructpublic void init() {Map<Integer, PayCoreService> integerPayStrategyMap = channelInit();for (Map.Entry<Integer, PayCoreService> m : integerPayStrategyMap.entrySet()) {strategyMap.put(m.getKey(), m.getValue());}log.info("所有支付方式初始化完成");}/*** @Author: 老乡* @Date: 2020/6/13 21:51* @Describe: 支付实现类，具体支付类别由子类实现，消除if else分支，接入其他支付时不违反开闭原则*/@Overridepublic Result toPayCore(PayCoreDTO payCoreDTO) {return payStrategy(payCoreDTO);}public abstract Result payStrategy(PayCoreDTO payCoreDTO);//获取初始化渠道keypublic abstract Map<Integer, PayCoreService> channelInit();
}
定义两个子类继承它，key就用枚举会优雅一些
@Slf4j
@Service
public class AliPayCoreStrategy extends PayCoreStrategyAbstract {@Overridepublic Result payStrategy(PayCoreDTO payCoreDTO) {//阿里支付业务return Result.errorMessage("支付异常");}//此处因为可能有多种支付方式，所以返回Map，如果只有一种就返回一个key就可以@Overridepublic Map<Integer, PayCoreService> channelInit() {Map<Integer, PayCoreService> map = new HashMap<>();map.put(PayChannelEnum.ALI_APP.getChannel(), this);map.put(PayChannelEnum.ALI_H5.getChannel(), this);return map;}
}
一个Service，一个abstract，两个继承类都定义好了，如何调用呢？
调用层定义一个Manager和实现类
public interface PayCoreManager {/*** @Author: 老乡* @Describe: pay*/Result payChoose(PayCoreDTO payCoreDTO);
@Service
public class PayCoreManagerImpl implements PayCoreManager {@Overridepublic Result payChoose(PayCoreDTO payCoreDTO) {//从静态map支付类别中取出对应的支付类别，对应的实例PayStrategy，若没有应检查是否对应//不同的类别获取到不同的支付实例PayCoreService p = PayCoreStrategyAbstract.strategyMap.get(payCoreDTO.getPayChannel());if (p == null) {return Result.errorMessage("payType is not valid");}//调用支付封装接口return p.toPayCore(payCoreDTO);}
可以看到传入payChannel，直接通过抽象类获取静态变量Map.get取到实例进行调用即可
函数式接口式
这种方式主要是对@FunctionalInterface的应用设计，在设计过程中有一些细节我会和大家说到，大家在看的过程中注意一下，并且这个看起来也是比较优雅，较前几种方式都复杂一些的设计，上干货代码示例
- 首先定义一个函数式接口，里面有个执行方法execute，注意函数式接口这里只能有一个方法，参数根据业务设置一个即可
@FunctionalInterface
public interface FruitFunctionExecute {void execute(FruitDTO fruitDTO);
}
- 定义一个业务接口和一个方法，该接口继承函数式接口，让它有后面的处理能力
public interface FruitService extends FruitFunctionExecute {void postEat(FruitDTO fruitDTO);
}
- 重点来了，定义一个抽象类BaseFruitAbstract实现FruitService，继承BaseHelper，此类可以作为基类提供统一的方法处理
该抽象类实现FruitService接口postEat
该抽象类实现RedService接口postAddRed，这个没有特殊理由哈，就是表演一下其他的关联业务可以在这里实现，并且此实现方法后面会被map搜集到（有应用的时候可以用此方式）
此抽象类实现函数式接口方法execute，此执行器可调用beforeExecute，doExecute和afterExecute
其他的东西我们后面继续说
@Slf4j
public abstract class BaseFruitAbstract extends BaseHelper implements FruitService, RedService {//子类map集合 可以直接类名.调用，也可以通过注入接口调用public static Map<String, FruitService> FRUIT_MAP = new ConcurrentHashMap<>();//函数式接口业务map集合 不用static修饰，因为上层有FRUIT_MAP传过来指定实例，此map可以拿到上下文实例，并找到子类执行器protected Map<String, FruitFunctionExecute> BUSINESS_MAP = new ConcurrentHashMap<>();@Autowiredprotected LxLoveDao lxLoveDao;/*** 初始化实例*/@PostConstructpublic void init(){setFruitMap(FRUIT_MAP);//此处的fruitDTO是函数式接口的入参表示BUSINESS_MAP.put(BusinessTypeEnum.WAIT_SUBMIT.getValue(), (fruitDTO)-> postEat(fruitDTO));BUSINESS_MAP.put(BusinessTypeEnum.WAIT_SURE.getValue(), (fruitDTO)-> postAddRed(fruitDTO));}/*** 函数式接口执行器*/@Overridepublic void execute(FruitDTO fruitDTO) {System.out.println("执行吧朋友们");beforeExecute();doExecute(fruitDTO);afterExecute();}private void beforeExecute(){}private void doExecute(FruitDTO fruitDTO){FruitFunctionExecute service = BUSINESS_MAP.get(fruitDTO.getBusinessType());service.execute(fruitDTO);}private void afterExecute(){}@Overridepublic void postEat(FruitDTO fruitDTO) {System.out.println("BaseFruitAbstract postEat");}//RedService接口实现，可用于相关调用@Overridepublic void postAddRed(FruitDTO fruitDTO) {System.out.println("BaseFruitAbstract postAddRed");}//--------------------------------------------------------------抽象方法----------------------------------------------------------//如果这个map是子类的，则延迟子类获取实例protected abstract void setFruitMap(Map<String, FruitService> map);}
- 定义一个苹果的处理器AppleHandler，继承抽象类BaseFruitAbstract，可以重写其方法，或者实现其抽象方法
@Component
public class AppleHandler extends BaseFruitAbstract {@Overridepublic void postEat(FruitDTO fruitDTO) {System.out.println("AppleHandler");lxLoveDao.getOne(1L);}@Overrideprotected void setFruitMap(Map<String, FruitService> map) {//key可以通过枚举控制map.put(FruitTypeEnum.APPLE.getValue(), this);}
}
同理
@Component
public class OrangeHandler extends BaseFruitAbstract {@Overridepublic void postEat(FruitDTO fruitDTO) {System.out.println("OrangeHandler");}@Overrideprotected void setFruitMap(Map<String, FruitService> map) {map.put(FruitTypeEnum.ORANGE.getValue(), this);}
}
-
重点来了，继续说抽象类BaseFruitAbstract，最上面定义了两个Map，大家也看到注释了是吧，其通过@PostConstruct在启动时期初始化，第一个FRUIT_MAP是外层要使用的map，此map的key可以自定义业务枚举管理，value为子类实例，所以通过setFruitMap延迟到子类中通过this设置进去即可；
将其设置为static对当前类生效 -
重点2，第二个BUSINESS_MAP是业务map，可以看到put的key也是可以通过枚举管理，value就是FruitFunctionExecute函数式接口，所以定义(fruitDTO)-> postEat(fruitDTO)表示要执行的函数式接口方法，此处的fruitDTO就是FruitFunctionExecute中execute的入参，可以看到此map也将RedService的实现方法加进去维护了起来
注意BUSINESS_MAP不能设置为static让其属于类，因为在调用层会先通过FRUIT_MAP获取实例并调用已经拿到了子类实例，此处可以直接拿到上下文实例，如果定义为static属于类就拿不到了 -
调用方式如下
@GetMapping("/t1")public void t1(String fruitType, String businessType){FruitService fruitService = BaseFruitAbstract.FRUIT_MAP.get(fruitType);FruitDTO fruitDTO = new FruitDTO();fruitDTO.setBusinessType(businessType);fruitService.execute(fruitDTO);System.out.println("execute 完毕");fruitService.postEat(fruitDTO);}
可以直接通过BaseFruitAbstract的FRUIT_MAP根据枚举拿到实例，然后调用FruitFunctionExecute的execute方法即可，这样走的就是BUSINESS_MAP中维护的方法postEat或postAddRed
如果通过实例直接调用postEat，则和BUSINESS_MAP无关，即和函数式接口无关，直接走子类方法
这是类关系
下面是请求后的日志
这时大家有疑问了，为什么直接调用postEat也可以，还要函数式接口干嘛？
因为首先它比较优雅，并且呢如果BUSINESS_MAP搜集的方法并不是外部实现的方法，而是内部根据不同枚举策略封装的方法，那外部就只能通过函数式接口的方法execute来执行了
并且controller层不一定知道要调用谁，而只是传枚举驱动后面的调用
对比
| 方式 | 优势 | 劣势 |
|---|---|---|
| 注解 | 分层，逼王，用到多种设计模式，反射等 | 每一个业务都要定义自己的注解，注解上无法用枚举.getValue来指定 |
| 拼接式 | 简单 | 和子类名耦合，需要自己按类名拼接，不够优雅 |
| 实现接口式 | 分层，优雅 | 调用链可能稍长一点 |
| 函数式接口式 | 分层，优雅，逼王，两种枚举控制Map，多中调用方式，扩展性好 | 设计稍复杂一点 |
推荐使用234，其实函数接口式就是实现接口式的升级版
以上就是如何抽象扩展的代码设计示例，大家快快实践起来！希望能够误导大家哈哈
赵客缦胡缨，吴钩霜月明，银鞍照白马，踏飒如流星！
![[日常折腾之码上归一]多种编程语言打印当前系统时间](https://img-blog.csdnimg.cn/84e384e5516a41b0bd2a2b48661c89c6.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA56eR5aSn5LqR54Ks,size_20,color_FFFFFF,t_70,g_se,x_16)
