组合模式实战以及规则树使用场景模拟

陈文龙536

已于 2024-07-22 16:01:48 修改

阅读量808

点赞数 32

文章标签：组合模式 java

于 2024-07-22 16:00:10 首次发布

本文链接：https://blog.csdn.net/weixin_74238318/article/details/140612324

版权

组合模式介绍

将所有服务结点链接出一棵结构树，而这种通过把相似对象(也可以称作是方法)组合成一组可被调用的结构树对象的设计思路叫做组合模式。
这种设计：可以让你的服务组节点进行自由组合对外提供服务，例如你有三个原子校验功能(A：身份证、B：银行卡、C：手机号)服务并对外提供调用使用。有些调用方需要使用AB组合，有些调用方需要使用到CBA组合，还有一些可能只使用三者中的一个。那么这个时候你就可以使用组合模式进行构建服务，对于不同类型的调用方配置不同的组织关系树，而这个树结构你可以配置到数据库中也可以不断的通过图形界面来控制树结构。

案例场景模拟：

一个非常简化版的营销规则决策树，根据性别、年龄来发放不同类型的优惠券，来刺激消费起到精准用户促活的目的。
代码实现：大量的ifelse嵌套分支

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;

    }

}

组合模式实现代码

工程结构

model：提供引擎处理后的返回结果EngineResult,TreeNode树节点，TreeNodeLink树节点之间的链接，完成链路判断和选择，TreeRoot根节点
service：
logic包下提供对外的接口服务，这里也就是树结点，每一个结点承载一个相应的服务，这里主要包括UserAgeFilter UserGenderFilter，LogicFilter定义服务的行为
engine包下提供模版接口IEngine，模版相关配置EngineConfig以及模版基类EngineBase

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	
    │                  │   ├── UserAgeFilter.java
    │                  │   └── UserGenderFilter.java
    │                  └── LogicFilter.java	
    └── test
         └── java
             └── org.itstack.demo.design.test
                 └── ApiTest.java

服务结点与树结构引擎之间的关系（服务结点在EngineConfig中配置）
在这里插入图片描述

代码实现

实体与基础对象

包路径	类	介绍
model.aggregates	TreeRich	聚合对象，包含组织树信息
model.vo	EngineResult	决策返回对象信息
model.vo	TreeNode	树节点；子叶节点、果实节点
model.vo	TreeNodeLink	树节点链接链路
model.vo	TreeRoot	树根信息
树节点：注意ruleKey以及nodeType treeNodeLinkList是结点链路，存放了一个链路集合

public class TreeNode {  
  
private Long treeId; //规则树ID  
private Long treeNodeId; //规则树节点ID  
private Integer nodeType; //节点类型；1子叶、2果实  
private String nodeValue; //节点值[nodeType=2]；果实值  
private String ruleKey; //规则Key  
private String ruleDesc; //规则描述  
private List<TreeNodeLink> treeNodeLinkList; //节点链路  
  
public Long getTreeId() {  
return treeId;  
}  
  
public void setTreeId(Long treeId) {  
this.treeId = treeId;  
}  
  
public Long getTreeNodeId() {  
return treeNodeId;  
}  
  
public void setTreeNodeId(Long treeNodeId) {  
this.treeNodeId = treeNodeId;  
}  
  
public Integer getNodeType() {  
return nodeType;  
}  
  
public void setNodeType(Integer nodeType) {  
this.nodeType = nodeType;  
}  
  
public String getNodeValue() {  
return nodeValue;  
}  
  
public void setNodeValue(String nodeValue) {  
this.nodeValue = nodeValue;  
}  
  
public String getRuleKey() {  
return ruleKey;  
}  
  
public void setRuleKey(String ruleKey) {  
this.ruleKey = ruleKey;  
}  
  
public String getRuleDesc() {  
return ruleDesc;  
}  
  
public void setRuleDesc(String ruleDesc) {  
this.ruleDesc = ruleDesc;  
}  
  
public List<TreeNodeLink> getTreeNodeLinkList() {  
return treeNodeLinkList;  
}  
  
public void setTreeNodeLinkList(List<TreeNodeLink> treeNodeLinkList) {  
this.treeNodeLinkList = treeNodeLinkList;  
}  
  
}

树链：

public class TreeNodeLink {  
  
private Long nodeIdFrom; //节点From  
private Long nodeIdTo; //节点To  
private Integer ruleLimitType; //限定类型；1:=;2:>;3:<;4:>=;5<=;6:enum[枚举范围]  
private String ruleLimitValue; //限定值  
  
public Long getNodeIdFrom() {  
return nodeIdFrom;  
}  
  
public void setNodeIdFrom(Long nodeIdFrom) {  
this.nodeIdFrom = nodeIdFrom;  
}  
  
public Long getNodeIdTo() {  
return nodeIdTo;  
}  
  
public void setNodeIdTo(Long nodeIdTo) {  
this.nodeIdTo = nodeIdTo;  
}  
  
public Integer getRuleLimitType() {  
return ruleLimitType;  
}  
  
public void setRuleLimitType(Integer ruleLimitType) {  
this.ruleLimitType = ruleLimitType;  
}  
  
public String getRuleLimitValue() {  
return ruleLimitValue;  
}  
  
public void setRuleLimitValue(String ruleLimitValue) {  
this.ruleLimitValue = ruleLimitValue;  
}  
}

其余实体不多赘述

树节点过滤器(服务结点)

接口定义过滤器行为
- 逻辑决策器：判断决策值与哪一条决策链路符合，并返回路径上的下一个链路结点
- 获取决策值：获取物料中具体的值，例如年龄为25，性别为男等等

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);  
  
}

决策抽象类提供接口服务：实现filter方法。判断决策值与哪一条决策链路符合，并返回路径上的下一个链路结点

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;
        }
    }

}

树节点逻辑实现类

年龄节点

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接口、缓存运算等各种方式获取。

决策引擎

接口配置：定义process方法，传入树结构，决策物料进行判断，并返回EngineResult作为结果

public interface IEngine {

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

}

EngineConfig
这里将过滤服务配置进行，便于使用

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;
    }

}

基础决策引擎：BaseEngine
定义决策的流程：总的来说就是随着规则树一条链路不断向下决策，直到找到果实结点，并返回果实结点

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;
    }

}

决策引擎实现：

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

}

测试

组装树关系
后续你需要做任何业务的扩展都可以在里面添加相应的节点，并做动态化的配置。

@Before
public void init() {
    // 节点：1
    TreeNode treeNode_01 = new TreeNode();
    treeNode_01.setTreeId(10001L);
    treeNode_01.setTreeNodeId(1L);
    treeNode_01.setNodeType(1);
    treeNode_01.setNodeValue(null);
    treeNode_01.setRuleKey("userGender");
    treeNode_01.setRuleDesc("用户性别[男/女]");
    // 链接：1->11
    TreeNodeLink treeNodeLink_11 = new TreeNodeLink();
    treeNodeLink_11.setNodeIdFrom(1L);
    treeNodeLink_11.setNodeIdTo(11L);
    treeNodeLink_11.setRuleLimitType(1);
    treeNodeLink_11.setRuleLimitValue("man");
    // 链接：1->12
    TreeNodeLink treeNodeLink_12 = new TreeNodeLink();
    treeNodeLink_12.setNodeIdTo(1L);
    treeNodeLink_12.setNodeIdTo(12L);
    treeNodeLink_12.setRuleLimitType(1);
    treeNodeLink_12.setRuleLimitValue("woman");
    List<TreeNodeLink> treeNodeLinkList_1 = new ArrayList<>();
    treeNodeLinkList_1.add(treeNodeLink_11);
    treeNodeLinkList_1.add(treeNodeLink_12);
    treeNode_01.setTreeNodeLinkList(treeNodeLinkList_1);
    // 节点：11
    TreeNode treeNode_11 = new TreeNode();
    treeNode_11.setTreeId(10001L);
    treeNode_11.setTreeNodeId(11L);
    treeNode_11.setNodeType(1);
    treeNode_11.setNodeValue(null);
    treeNode_11.setRuleKey("userAge");
    treeNode_11.setRuleDesc("用户年龄");
    // 链接：11->111
    TreeNodeLink treeNodeLink_111 = new TreeNodeLink();
    treeNodeLink_111.setNodeIdFrom(11L);
    treeNodeLink_111.setNodeIdTo(111L);
    treeNodeLink_111.setRuleLimitType(3);
    treeNodeLink_111.setRuleLimitValue("25");
    // 链接：11->112
    TreeNodeLink treeNodeLink_112 = new TreeNodeLink();
    treeNodeLink_112.setNodeIdFrom(11L);
    treeNodeLink_112.setNodeIdTo(112L);
    treeNodeLink_112.setRuleLimitType(5);
    treeNodeLink_112.setRuleLimitValue("25");
    List<TreeNodeLink> treeNodeLinkList_11 = new ArrayList<>();
    treeNodeLinkList_11.add(treeNodeLink_111);
    treeNodeLinkList_11.add(treeNodeLink_112);
    treeNode_11.setTreeNodeLinkList(treeNodeLinkList_11);
    // 节点：12
    TreeNode treeNode_12 = new TreeNode();
    treeNode_12.setTreeId(10001L);
    treeNode_12.setTreeNodeId(12L);
    treeNode_12.setNodeType(1);
    treeNode_12.setNodeValue(null);
    treeNode_12.setRuleKey("userAge");
    treeNode_12.setRuleDesc("用户年龄");
    // 链接：12->121
    TreeNodeLink treeNodeLink_121 = new TreeNodeLink();
    treeNodeLink_121.setNodeIdFrom(12L);
    treeNodeLink_121.setNodeIdTo(121L);
    treeNodeLink_121.setRuleLimitType(3);
    treeNodeLink_121.setRuleLimitValue("25");
    // 链接：12->122
    TreeNodeLink treeNodeLink_122 = new TreeNodeLink();
    treeNodeLink_122.setNodeIdFrom(12L);
    treeNodeLink_122.setNodeIdTo(122L);
    treeNodeLink_122.setRuleLimitType(5);
    treeNodeLink_122.setRuleLimitValue("25");
    List<TreeNodeLink> treeNodeLinkList_12 = new ArrayList<>();
    treeNodeLinkList_12.add(treeNodeLink_121);
    treeNodeLinkList_12.add(treeNodeLink_122);
    treeNode_12.setTreeNodeLinkList(treeNodeLinkList_12);
    // 节点：111
    TreeNode treeNode_111 = new TreeNode();
    treeNode_111.setTreeId(10001L);
    treeNode_111.setTreeNodeId(111L);
    treeNode_111.setNodeType(2);
    treeNode_111.setNodeValue("果实A");
    // 节点：112
    TreeNode treeNode_112 = new TreeNode();
    treeNode_112.setTreeId(10001L);
    treeNode_112.setTreeNodeId(112L);
    treeNode_112.setNodeType(2);
    treeNode_112.setNodeValue("果实B");
    // 节点：121
    TreeNode treeNode_121 = new TreeNode();
    treeNode_121.setTreeId(10001L);
    treeNode_121.setTreeNodeId(121L);
    treeNode_121.setNodeType(2);
    treeNode_121.setNodeValue("果实C");
    // 节点：122
    TreeNode treeNode_122 = new TreeNode();
    treeNode_122.setTreeId(10001L);
    treeNode_122.setTreeNodeId(122L);
    treeNode_122.setNodeType(2);
    treeNode_122.setNodeValue("果实D");
    // 树根
    TreeRoot treeRoot = new TreeRoot();
    treeRoot.setTreeId(10001L);
    treeRoot.setTreeRootNodeId(1L);
    treeRoot.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(treeRoot, treeNodeMap);
}

测试及结果

@Test
public void test_tree() {
    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");
    
    EngineResult result = treeEngineHandle.process(10001L, "Oli09pLkdjh", treeRich, decisionMatter);
    
    logger.info("测试结果：{}", JSON.toJSONString(result));
}

结果

23:35:05.711 [main] INFO  o.i.d.d.d.service.engine.EngineBase - 决策树引擎=>规则决策树 userId：Oli09pLkdjh treeId：10001 treeNode：11 ruleKey：userGender matterValue：man
23:35:05.712 [main] INFO  o.i.d.d.d.service.engine.EngineBase - 决策树引擎=>规则决策树 userId：Oli09pLkdjh treeId：10001 treeNode：112 ruleKey：userAge matterValue：29
23:35:05.715 [main] INFO  org.itstack.demo.design.test.ApiTest - 测试结果：{"nodeId":112,"nodeValue":"果实B","success":true,"treeId":10001,"userId":"Oli09pLkdjh"}

Process finished with exit code 0