学习设计模式之组合模式

最新推荐文章于 2024-05-28 09:25:21 发布

南淮北安

最新推荐文章于 2024-05-28 09:25:21 发布

阅读量193

点赞数

文章标签： java 设计模式组合模式

原文链接：https://bugstack.cn/md/develop/design-pattern/2020-06-08-%E9%87%8D%E5%AD%A6%20Java%20%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F%E3%80%8A%E5%AE%9E%E6%88%98%E7%BB%84%E5%90%88%E6%A8%A1%E5%BC%8F%E3%80%8B.html#%E5%85%AD%E3%80%81%E7%BB%84%E5%90%88%E6%A8%A1%E5%BC%8F%E

版权

设计模式学习专栏收录该内容

20 篇文章 2 订阅

订阅专栏

文章目录

一、定义

在这里插入图片描述

从上图可以看到这有点像螺丝🔩和螺母，通过一堆的链接组织出一棵结构树。而这种通过把相似对象(也可以称作是方法)组合成一组可被调用的结构树对象的设计思路叫做组合模式。

这种设计方式可以让你的服务组节点进行自由组合对外提供服务，例如你有三个原子校验功能(A：身份证、B：银行卡、C：手机号)服务并对外提供调用使用。

有些调用方需要使用AB组合，有些调用方需要使用到CBA组合，还有一些可能只使用三者中的一个。那么这个时候你就可以使用组合模式进行构建服务，对于不同类型的调用方配置不同的组织关系树，而这个树结构你可以配置到数据库中也可以不断的通过图形界面来控制树结构。

所以不同的设计模式用在恰当好处的场景可以让代码逻辑非常清晰并易于扩展，同时也可以减少团队新增人员对项目的学习成本。

二、问题背景

在这里插入图片描述
以上是一个非常简化版的营销规则决策树，根据性别、年龄来发放不同类型的优惠券，来刺激消费起到精准用户促活的目的。

虽然一部分小伙伴可能并没有开发过营销场景，但你可能时时刻刻的被营销着。比如你去经常浏览男性喜欢的机械键盘、笔记本电脑、汽车装饰等等，那么久给你推荐此类的优惠券刺激你消费。

那么如果你购物不多，或者钱不在自己手里。那么你是否打过车，有一段时间经常有小伙伴喊，为什么同样的距离他就10元，我就15元呢？

其实这些都是被营销的案例，一般对于不常使用软件的小伙伴，经常会进行稍微大力度的促活，增加用户粘性。

那么在这里我们就模拟一个类似的决策场景，体现出组合模式在其中起到的重要性。另外，组合模式不只是可以运用于规则决策树，还可以做服务包装将不同的接口进行组合配置，对外提供服务能力，减少开发成本

三、违背设计模式的设计实现

在这里插入图片描述

1. 工程结构

itstack-demo-design-8-01
└── src
    └── main
        └── java
            └── org.itstack.demo.design
                └── EngineController.java

公司里要都是这样的程序员绝对省下不少成本，根本不要搭建微服务，一个工程搞定所有业务！
但千万不要这么干！酒肉穿肠过，佛祖心中留。世人若学我，如同进魔道

2. 代码实现

public class EngineController {

    private Logger logger = LoggerFactory.getLogger(EngineController.class);

    public String process(final String userId, final String userSex, final int userAge) {

        logger.info("ifelse实现方式判断用户结果。userId：{} userSex：{} userAge：{}", userId, userSex, userAge);

        if ("man".equals(userSex)) {
            if (userAge < 25) {
                return "果实A";
            }

            if (userAge >= 25) {
                return "果实B";
            }
        }

        if ("woman".equals(userSex)) {
            if (userAge < 25) {
                return "果实C";
            }

            if (userAge >= 25) {
                return "果实D";
            }
        }

        return null;

    }

}

除了我们说的扩展性和每次的维护以外，这样的代码实现起来是最快的。而且从样子来看也很适合新人理解。
但是我劝你别写，写这样代码不是被扣绩效就是被开除。

3. 测试验证

@Test
public void test_EngineController() {
    EngineController engineController = new EngineController();
    String process = engineController.process("Oli09pLkdjh", "man", 29);
    logger.info("测试结果：{}", process);
}

这里我们模拟了一个用户ID，并传输性别：man、年龄：29，我们的预期结果是：果实B。

实际对应业务就是给头秃的程序员发一张枸杞优惠券

四、问题改进

接下来的重构部分代码改动量相对来说会比较大一些，为了让我们可以把不同类型的决策节点和最终的果实组装成一棵可被运行的决策树，需要做适配设计和工厂方法调用，具体会体现在定义接口以及抽象类和初始化配置决策节点(性别、年龄)上。建议这部分代码多阅读几次，最好实践下。

1. 工程结构

itstack-demo-design-8-02
└── src
    ├── main
    │   └── java
    │      └── org.itstack.demo.design.domain
    │          ├── model
    │          │   ├── aggregates
    │          │   │   └── TreeRich.java
    │          │   └── vo
    │          │       ├── EngineResult.java
    │          │       ├── TreeNode.java
    │          │       ├── TreeNodeLink.java    
    │          │       └── TreeRoot.java	
    │          └── service
    │              ├── engine
    │              │   ├── impl	
    │              │   │   └── TreeEngineHandle.java	   
    │              │   ├── EngineBase.java 
    │              │   ├── EngineConfig.java       
    │              │   └── IEngine.java	
    │              └── logic
    │                  ├── impl	
    │                  │   ├── LogicFilter.java	 
    │                  │   └── LogicFilter.java	    
    │                  └── LogicFilter.java	
    └── test
         └── java
             └── org.itstack.demo.design.test
                 └── ApiTest.java

在这里插入图片描述
首先可以看下黑色框框的模拟指导树结构；1、11、12、111、112、121、122，这是一组树结构的ID，并由节点串联组合出一棵关系树树。

接下来是类图部分，左侧是从LogicFilter开始定义适配的决策过滤器，BaseLogic是对接口的实现，提供最基本的通用方法。UserAgeFilter、UserGenerFilter，是两个具体的实现类用于判断年龄和性别。

最后则是对这颗可以被组织出来的决策树，进行执行的引擎。同样定义了引擎接口和基础的配置，在配置里面设定了需要的模式决策节点。

2. 代码实现

（1）基础对象
在这里插入图片描述
（2）树节点逻辑过滤器接口

public interface LogicFilter {

    /**
     * 逻辑决策器
     *
     * @param matterValue          决策值
     * @param treeNodeLineInfoList 决策节点
     * @return 下一个节点Id
     */
    Long filter(String matterValue, List<TreeNodeLink> treeNodeLineInfoList);

    /**
     * 获取决策值
     *
     * @param decisionMatter 决策物料
     * @return 决策值
     */
    String matterValue(Long treeId, String userId, Map<String, String> decisionMatter);
}

这一部分定义了适配的通用接口，逻辑决策器、获取决策值，让每一个提供决策能力的节点都必须实现此接口，保证统一性

（3）决策抽象类提供基础服务

public abstract class BaseLogic implements LogicFilter {

    @Override
    public Long filter(String matterValue, List<TreeNodeLink> treeNodeLinkList) {
        for (TreeNodeLink nodeLine : treeNodeLinkList) {
            if (decisionLogic(matterValue, nodeLine)) return nodeLine.getNodeIdTo();
        }
        return 0L;
    }

    @Override
    public abstract String matterValue(Long treeId, String userId, Map<String, String> decisionMatter);

    private boolean decisionLogic(String matterValue, TreeNodeLink nodeLink) {
        switch (nodeLink.getRuleLimitType()) {
            case 1:
                return matterValue.equals(nodeLink.getRuleLimitValue());
            case 2:
                return Double.parseDouble(matterValue) > Double.parseDouble(nodeLink.getRuleLimitValue());
            case 3:
                return Double.parseDouble(matterValue) < Double.parseDouble(nodeLink.getRuleLimitValue());
            case 4:
                return Double.parseDouble(matterValue) <= Double.parseDouble(nodeLink.getRuleLimitValue());
            case 5:
                return Double.parseDouble(matterValue) >= Double.parseDouble(nodeLink.getRuleLimitValue());
            default:
                return false;
        }
    }
}

在抽象方法中实现了接口方法，同时定义了基本的决策方法；1、2、3、4、5，等于、小于、大于、小于等于、大于等于的判断逻辑。
同时定义了抽象方法，让每一个实现接口的类都必须按照规则提供决策值，这个决策值用于做逻辑比对。

（4）树节点逻辑实现类

年龄节点：

public class UserAgeFilter extends BaseLogic {

    @Override
    public String matterValue(Long treeId, String userId, Map<String, String> decisionMatter) {
        return decisionMatter.get("age");
    }

}

性别节点：

public class UserGenderFilter extends BaseLogic {

    @Override
    public String matterValue(Long treeId, String userId, Map<String, String> decisionMatter) {
        return decisionMatter.get("gender");
    }

}

以上两个决策逻辑的节点获取值的方式都非常简单，只是获取用户的入参即可。实际的业务开发可以从数据库、RPC接口、缓存运算等各种方式获取。

（5）决策引擎接口定义

public interface IEngine {

    EngineResult process(final Long treeId, final String userId, TreeRich treeRich, final Map<String, String> decisionMatter);

}

对于使用方来说也同样需要定义统一的接口操作，这样的好处非常方便后续拓展出不同类型的决策引擎，也就是可以建造不同的决策工厂。
（6）决策节点配置

public class EngineConfig {

    static Map<String, LogicFilter> logicFilterMap;

    static {
        logicFilterMap = new ConcurrentHashMap<>();
        logicFilterMap.put("userAge", new UserAgeFilter());
        logicFilterMap.put("userGender", new UserGenderFilter());
    }

    public Map<String, LogicFilter> getLogicFilterMap() {
        return logicFilterMap;
    }

    public void setLogicFilterMap(Map<String, LogicFilter> logicFilterMap) {
        this.logicFilterMap = logicFilterMap;
    }

}

在这里将可提供服务的决策节点配置到map结构中，对于这样的map结构可以抽取到数据库中，那么就可以非常方便的管理

（7）基础决策引擎功能

public abstract class EngineBase extends EngineConfig implements IEngine {

    private Logger logger = LoggerFactory.getLogger(EngineBase.class);

    @Override
    public abstract EngineResult process(Long treeId, String userId, TreeRich treeRich, Map<String, String> decisionMatter);

    protected TreeNode engineDecisionMaker(TreeRich treeRich, Long treeId, String userId, Map<String, String> decisionMatter) {
        TreeRoot treeRoot = treeRich.getTreeRoot();
        Map<Long, TreeNode> treeNodeMap = treeRich.getTreeNodeMap();
        // 规则树根ID
        Long rootNodeId = treeRoot.getTreeRootNodeId();
        TreeNode treeNodeInfo = treeNodeMap.get(rootNodeId);
        //节点类型[NodeType]；1子叶、2果实
        while (treeNodeInfo.getNodeType().equals(1)) {
            String ruleKey = treeNodeInfo.getRuleKey();
            LogicFilter logicFilter = logicFilterMap.get(ruleKey);
            String matterValue = logicFilter.matterValue(treeId, userId, decisionMatter);
            Long nextNode = logicFilter.filter(matterValue, treeNodeInfo.getTreeNodeLinkList());
            treeNodeInfo = treeNodeMap.get(nextNode);
            logger.info("决策树引擎=>{} userId：{} treeId：{} treeNode：{} ruleKey：{} matterValue：{}", treeRoot.getTreeName(), userId, treeId, treeNodeInfo.getTreeNodeId(), ruleKey, matterValue);
        }
        return treeNodeInfo;
    }

}

这里主要提供决策树流程的处理过程，有点像通过链路的关系(性别、年龄)在二叉树中寻找果实节点的过程。
同时提供一个抽象方法，执行决策流程的方法供外部去做具体的实现。

（8）决策引擎的实现

public class TreeEngineHandle extends EngineBase {

    @Override
    public EngineResult process(Long treeId, String userId, TreeRich treeRich, Map<String, String> decisionMatter) {
        // 决策流程
        TreeNode treeNode = engineDecisionMaker(treeRich, treeId, userId, decisionMatter);
        // 决策结果
        return new EngineResult(userId, treeId, treeNode.getTreeNodeId(), treeNode.getNodeValue());
    }

}

这里对于决策引擎的实现就非常简单了，通过传递进来的必要信息；决策树信息、决策物料值，来做具体的树形结构决策

3. 测试验证

public class AppTest {
    private Logger logger = LoggerFactory.getLogger(AppTest.class);

    private TreeRich treeRich;

    @Before
    public void init() {
        TreeNode treeNode_01 = new TreeNode()
                .setTreeId(10001L)
                .setTreeNodeId(1L)
                .setNodeType(1)
                .setNodeValue(null)
                .setRuleKey("userGender")
                .setRuleDesc("用户性别[男/女]");
        TreeNodeLink treeNodeLink_11 = new TreeNodeLink()
                .setNodeIdFrom(1L)
                .setNodeIdTo(11L)
                .setRuleLimitType(1)
                .setRuleLimitValue("man");
        TreeNodeLink treeNodeLink_12 = new TreeNodeLink()
                .setNodeIdFrom(1L)
                .setNodeIdTo(12L)
                .setRuleLimitType(1)
                .setRuleLimitValue("woman");
        List<TreeNodeLink> treeNodeLinkList_1 = new ArrayList<>();
        treeNodeLinkList_1.add(treeNodeLink_11);
        treeNodeLinkList_1.add(treeNodeLink_12);
        treeNode_01.setTreeNodeLinkList(treeNodeLinkList_1);

        TreeNode treeNode_11 = new TreeNode()
                .setTreeId(10001L)
                .setTreeNodeId(11L)
                .setNodeType(1)
                .setNodeValue(null)
                .setRuleKey("userAge")
                .setRuleDesc("用户年龄");
        TreeNodeLink treeNodeLink_111 = new TreeNodeLink()
                .setNodeIdFrom(11L)
                .setNodeIdTo(111L)
                .setRuleLimitType(3)
                .setRuleLimitValue("25");
        TreeNodeLink treeNodeLink_112 = new TreeNodeLink()
                .setNodeIdFrom(11L)
                .setNodeIdTo(112L)
                .setRuleLimitType(5)
                .setRuleLimitValue("25");
        List<TreeNodeLink> treeNodeLinkList_11 = new ArrayList<>();
        treeNodeLinkList_11.add(treeNodeLink_111);
        treeNodeLinkList_11.add(treeNodeLink_112);
        treeNode_11.setTreeNodeLinkList(treeNodeLinkList_11);

        TreeNode treeNode_12 = new TreeNode()
                .setTreeId(10001L)
                .setTreeNodeId(12L)
                .setNodeType(1)
                .setNodeValue(null)
                .setRuleKey("userAge")
                .setRuleDesc("用户年龄");
        TreeNodeLink treeNodeLink_121 = new TreeNodeLink()
                .setNodeIdFrom(12L)
                .setNodeIdTo(121L)
                .setRuleLimitType(3)
                .setRuleLimitValue("25");
        TreeNodeLink treeNodeLink_122 = new TreeNodeLink()
                .setNodeIdFrom(12L)
                .setNodeIdTo(122L)
                .setRuleLimitType(5)
                .setRuleLimitValue("25");
        List<TreeNodeLink> treeNodeLinkList_12 = new ArrayList<>();
        treeNodeLinkList_12.add(treeNodeLink_121);
        treeNodeLinkList_12.add(treeNodeLink_122);
        treeNode_12.setTreeNodeLinkList(treeNodeLinkList_12);

        TreeNode treeNode_111 = new TreeNode()
                .setTreeId(10001L)
                .setTreeNodeId(111L)
                .setNodeType(2)
                .setNodeValue("果实A");
        TreeNode treeNode_112 = new TreeNode()
                .setTreeId(10001L)
                .setTreeNodeId(112L)
                .setNodeType(2)
                .setNodeValue("果实B");
        TreeNode treeNode_121 = new TreeNode()
                .setTreeId(10001L)
                .setTreeNodeId(121L)
                .setNodeType(2)
                .setNodeValue("果实C");
        TreeNode treeNode_122 = new TreeNode()
                .setTreeId(10001L)
                .setTreeNodeId(122L)
                .setNodeType(2)
                .setNodeValue("果实D");
        // 根节点
        TreeRoot treeRoot = new TreeRoot()
                .setTreeId(10001L)
                .setTreeRootNodeId(1L)
                .setTreeName("规则决策树");
        // 节点对应关系
        Map<Long, TreeNode> treeNodeMap = new HashMap<>();
        treeNodeMap.put(1L, treeNode_01);
        treeNodeMap.put(11L, treeNode_11);
        treeNodeMap.put(12L, treeNode_12);
        treeNodeMap.put(111L, treeNode_111);
        treeNodeMap.put(112L, treeNode_112);
        treeNodeMap.put(121L, treeNode_121);
        treeNodeMap.put(122L, treeNode_122);
        // 初始化到组织结构中
        treeRich = new TreeRich().setTreeRoot(treeRoot).setTreeNodeMap(treeNodeMap);
    }

    @Test
    public void testTree() {
        logger.info("决策树组合结构信息：\r\n" + JSON.toJSONString(treeRich));
        IEngine treeEngineHandle = new TreeEngineHandle();
        // 两个约束条件
        Map<String, String> decisionMatter = new HashMap<>();
        decisionMatter.put("gender", "man");
        decisionMatter.put("age", "29");
        final EngineResult yolo = treeEngineHandle.process(10001L, "yolo", treeRich, decisionMatter);
        logger.info("测试结果：{}", JSON.toJSONString(yolo));
    }
}

五、总结

从以上的决策树场景来看，组合模式的主要解决的是一系列简单逻辑节点或者扩展的复杂逻辑节点在不同结构的组织下，对于外部的调用是仍然可以非常简单的。

这部分设计模式保证了开闭原则，无需更改模型结构你就可以提供新的逻辑节点的使用并配合组织出新的关系树。但如果是一些功能差异化非常大的接口进行包装就会变得比较困难，但也不是不能很好的处理，只不过需要做一些适配和特定化的开发。

很多时候因为你的极致追求和稍有倔强的工匠精神，即使在面对同样的业务需求，你能完成出最好的代码结构和最易于扩展的技术架构。不要被远不能给你指导提升能力的影响到放弃自己的追求！

南淮北安

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
学习设计模式之组合模式

文章目录一、定义二、问题背景三、违背设计模式的设计实现1. 工程结构2. 代码实现3. 测试验证四、问题改进1. 工程结构2. 代码实现3. 测试验证五、总结一、定义从上图可以看到这有点像螺丝🔩和螺母，通过一堆的链接组织出一棵结构树。而这种通过把相似对象(也可以称作是方法)组合成一组可被调用的结构树对象的设计思路叫做组合模式。这种设计方式可以让你的服务组节点进行自由组合对外提供服务，例如你有三个原子校验功能(A：身份证、B：银行卡、C：手机号)服务并对外提供调用使用。有些调用方需要使用AB组合，有
复制链接

扫一扫