利用枚举来实现工厂模式，多态的实现。多个实现类实现一个接口的各个方法。枚举的用法

╰半夏微凉° 2023-10-10 15:05 16阅读 0赞

**核心思想也就是：一个执行类，调用接口类的方法，再多个实现类去实现该接口类。关键在于如何new执行类的时候，将对应的实现类传进去。**

**1.new一个接口**

IApprovePostStrategy strategy = null;

/**
     * 审核后置处理的策略接口
     */
    public interface IApprovePostStrategy {
    
        /**
         * 新增操作的审核通过后处理策略
         */
        AjaxResult add(KbApproveManagement kbApproveManagement);
    
        /**
         * 修改操作的审核通过后处理策略
         */
        AjaxResult edit(KbApproveManagement kbApproveManagement);
    
        /**
         * 删除操作的审核通过后处理策略
         */
        AjaxResult delete(KbApproveManagement kbApproveManagement);
    
        /**
         * 举报操作的审核通过后处理策略
         */
        AjaxResult report(KbApproveManagement kbApproveManagement);
    
    }

**2.再通过传过来的参数去匹配对应注解的信息**

Integer approveType = kbApproveManagement.getApproveType();
    ApproveType approveTypeObject = ApproveType.getApproveTypeByValue(approveType);

public enum ApproveType {
    
        FUNCTION(1, "系统功能政策", "sys_function_policy", "kb:policy:skipApprove"),
        DATAQUALITY(2, "数据质量政策", "sys_dataquality_policy", "kb:policy:skipApprove"),
        SOURCETYPE(3, "解读来源类型", "kb_explain_source_type", "kb:sourceType:skipApprove"),
        EXPLAIN(4, "解读示例", "kb_explain_example", "kb:explain:skipApprove"),
        CATEGORY(5, "医院软件类型", "kb_software_category", "kb:category:skipApprove"),
        SOFTWARE(6, "医院软件信息", "kb_software_management", "kb:management:skipApprove"),
        KNOWLEDGE(7, "知识分享", "kb_sharing_knowledge", "kb:knowledge:skipApprove"),
        KS_DOCUMENT(8, "知识库文档", "emr_check.ks_document_info", "ks:document:skipApprove");
    
        private final int value;
        private final String name;
        private final String tableName;
        private final String skipPermission;
        ApproveType(int value, String name, String tableName, String skipPermission) {
            this.value = value;
            this.name = name;
            this.tableName = tableName;
            this.skipPermission = skipPermission;
        }
    
        public int getValue() {
            return value;
        }
    
        public String getName() {
            return name;
        }
    
        public String getTableName() {
            return tableName;
        }
    
        public String getSkipPermission() {
            return skipPermission;
        }
    
        public static ApproveType getApproveTypeByValue(Integer value) {
            if(value == null) {
                return null;
            }
    
            ApproveType[] approveTypes = values();
            ApproveType current = null;
            for(ApproveType approveType : approveTypes) {
                if(approveType.getValue() == value) {
                    current = approveType;
                    break;
                }
            }
            return current;
        }
    
    }

**3.利用switch一个个匹配枚举类中所有的枚举，同时把所有的实现类注入到这个类里面，匹配上了直接将注入的实现类赋值给接口，就可以调用对应的实现类了**

//匹配对应枚举，赋值对应的实现类
    switch (approveTypeObject) {
                case FUNCTION:
                    strategy = functionApproveProcessor;
                    break;
                case DATAQUALITY:
                    strategy = dataqualityApproveProcessor;
                    break;
                case SOURCETYPE:
                    strategy = sourceTypeApproveProcessor;
                    break;
                case EXPLAIN:
                    strategy = explainApproveProcessor;
                    break;
                case CATEGORY:
                    strategy = categoryApproveProcessor;
                    break;
                case SOFTWARE:
                    strategy = softwareApproveProcessor;
                    break;
                case KNOWLEDGE:
                    strategy = knowledgeApproveProcessor;
                    break;
                case KS_DOCUMENT:
                    strategy = ksDocumentApproveProcessor;
                    break;
     }
    //通过对应的实现类去new一个执行类，就可以执行对应实现类的方法了
    ApprovePostProcessor approvePostProcessor = new ApprovePostProcessor(strategy);
    return approvePostProcessor.process(kbApproveManagement);

3.1 所有的实现类都会注入到该类，供switch匹配

@Autowired
        private DataqualityApproveProcessor dataqualityApproveProcessor;
    
        @Autowired
        private ExplainSourceTypeApproveProcessor sourceTypeApproveProcessor;
    
        @Autowired
        private ExplainExampleApproveProcessor explainApproveProcessor;
    
        @Autowired
        private SoftwareCategoryApproveProcessor categoryApproveProcessor;
    
        @Autowired
        private SoftwareManagementApproveProcessor softwareApproveProcessor;

3.2这里面有个执行类，定义了该接口，去执行接口的方法。

public class ApprovePostProcessor {
    
        private IApprovePostStrategy strategy;
    
        public ApprovePostProcessor(IApprovePostStrategy strategy) {
            this.strategy = strategy;
        }
    
        /**
         * 审核后处理
         * @param kbApproveManagement
         * @return
         */
        public AjaxResult process(KbApproveManagement kbApproveManagement) {
            Integer businessType = kbApproveManagement.getBusinessType();
            if(kbApproveManagement.getApproveState() == 1) {
                if (businessType == BusinessType.UPDATE.ordinal()) {
                    return strategy.edit(kbApproveManagement);
                }
                else if (businessType == BusinessType.DELETE.ordinal()) {
                    return strategy.delete(kbApproveManagement);
                }
                else if (businessType == BusinessType.FORCE.ordinal()) {
                    return strategy.report(kbApproveManagement);
                }
                else {
                    return strategy.add(kbApproveManagement);
                }
            }
            return AjaxResult.success();
        }
    
    }