Java那几种很不错的代码抽象设计

Posted 2023-03-02 洛雪眸眸

代码这种东西，机器不管你写的怎么样，肯定能识别， 人就不一样了，前人拉屎后人踩屎，一坨认栽，n坨就有点过分了哈
一般写代码也不用太高大上，很多接口还是很简单的，如果把各种设计模式搞上来那叫过度设计，叫逼王；就在多渠道，多河流的时候才能当逼王

看到过几位写的不错的同事搞的设计，和大家简单介绍一下

1. 注解式
2. 拼接式
3. 实现扩展接口式

下面介绍下这三种方式

注解式

核心用到的方式：单例模式+注解+反射+策略模式

直接上代码了哈，注释搞在代码中，大家直接体验

既然是注解，那就先定义一个注解吧

@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();
    

    @Override
    public 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，都可以

@BizCode(value = "jd")
public class JdProcessExtension implements ProcessExtension 

    @Override
    public void beforeProcess(String params, StringBuilder processRecord) 
        System.out.println("京东活动前置处理流程");
        processRecord.append("京东活动前置处理流程 - ");
    

    @Override
    public void afterProcess(String params, StringBuilder processRecord) 
        System.out.println("京东活动后置处理流程");
        processRecord.append("京东活动后置处理流程");
    

@BizCode(value = "tb")
public class TaobaoProcessExtension implements ProcessExtension 

    @Override
    public void beforeProcess(String params, StringBuilder processRecord) 
        System.out.println("淘宝活动前置处理流程");
        processRecord.append("淘宝活动前置处理流程 - ");
    

    @Override
    public 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就已经有数据了，

@Autowired
private Map<String, ProcessExtension> map;

这个map是什么形式呢，我直接演示下

jdProcessExtension JdProcessExtension

taobaoProcessExtension TaobaoProcessExtension

好了我们只要拿到key获取到value–>ProcessExtension，调用相关接口就能自己往下流了，所以说我们用到了拼接

可以定义一个常量"%sProcessExtension"; 就是%s+实现类统一后缀；然后传入bizCode用String.format替换一下%s就好了，比如我传个jd，得到了jdProcessExtension ，用map.get()拿到实例后调用接口，完毕！

下面介绍第三种

扩展接口式

说到底这个就是利用Spring的扩展接口或预加载注解，或构造方法来实现启动时将实例加载到一个Map中的，和第一个结构有点相似，有一个调用层处理。上菜，以支付为例，先定义一个Service

public interface PayCoreService 

    /**
     * @Author: 老乡
     * @Date: 2020/6/13 21:50
     * @Describe: 统一下单
     * 接入新的支付方式只需要增加枚举类，继承PayStrategyContent抽象类，重写支付等功能接口
     */
    Result toPayCore(PayCoreDTO payCoreDTO);

再定义一个抽象类实现Service，既然叫抽象类那就要有抽象方法，将payCore需要子类自行实现的封装为抽象方法即可（下面会定义两个子类继承它），然后大家可以看到这里也同样是定义了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
     */
    @PostConstruct
    public 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分支，接入其他支付时不违反开闭原则
     */
    @Override
    public Result toPayCore(PayCoreDTO payCoreDTO) 
        return payStrategy(payCoreDTO);
    

    public abstract Result payStrategy(PayCoreDTO payCoreDTO);

    //获取初始化渠道key
    public abstract Map<Integer, PayCoreService> channelInit();

定义两个子类继承它，key就用枚举会优雅一些

@Slf4j
@Service
public class AliPayCoreStrategy extends PayCoreStrategyAbstract 
    
    @Override
    public Result payStrategy(PayCoreDTO payCoreDTO) 
		//阿里支付业务
        return Result.errorMessage("支付异常");
    
    
    //此处因为可能有多种支付方式，所以返回Map，如果只有一种就返回一个key就可以
    @Override
    public 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 

    @Override
    public 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取到实例进行调用即可

对比

方式	优势	劣势
注解	分层，逼王，用到多种设计模式，反射等	每一个业务都要定义自己的注解，注解上无法用枚举.getValue来指定
拼接式	简单	和子类名耦合，需要自己按类名拼接，不够优雅
实现接口式	分层，优雅	调用链可能稍长一点

推荐使用2和3，当然了，只要你开心

以上就是如何抽象扩展的代码设计示例，希望能够误导大家哈哈