关于抽象工厂类的另一个实现方法，采用配置类的固定bean。

Dear 丶 2023-10-10 15:52 9阅读 0赞

需求分析：

一种题型，有4中选项类型，分为文字定性，选项定性，文字定量，选项定量。

所以需要一个抽象类，再创建4个实体类实现这个抽象类。关于如何调用某个具体的实现类

采取1，2，3，4的传参来识别。

同时每个类型，会有自己固定的参数呀一并存储，如若是1，则还需要传系统id，与类型名称如

定性文字型，当然最重要的是对应的实现类的class。

第一步先创建一个常量类，里面存储4个类型的固定值，如对应的1，2，3，4.和一些基础信息，但是最关键的是private Class clazz;这个字段需要存储对应的实现类class.

@Data
    public class MetricsDict {
    
    
        public static final Map<String, MetricsDict> metricsDictMap;
    
        /**
         * 定性文字型
         */
        public static final MetricsDict QUALITATIVE_TEXT = new MetricsDict("1", "31", "1", "text", "定性文字型", QualitativeTextMetricsOperation.class);
    
        /**
         * 定性文字选项型
         */
        public static final MetricsDict QUALITATIVE_TEXT_AND_OPTION = new MetricsDict("2", "31", "1", "text_and_option", "定性文字选项型", QualitativeTextAndOptionMetricsOperation.class);
    
        /**
         * 定量计算方法型
         */
        public static final MetricsDict QUANTITATIVE_CALCULATION = new MetricsDict("3", "31", "2", "calculation", "定量计算方法型", QuantitativeCalculationMetricsOperation.class);
    
        /**
         * 定量文字型
         */
        public static final MetricsDict QUANTITATIVE_TEXT = new MetricsDict("4", "29", "2", "text", "定量文字型", null);
    
        static {
            metricsDictMap = new HashMap<>();
            metricsDictMap.put("1", QUALITATIVE_TEXT);
            metricsDictMap.put("2", QUALITATIVE_TEXT_AND_OPTION);
            metricsDictMap.put("3", QUANTITATIVE_CALCULATION);
            metricsDictMap.put("4", QUANTITATIVE_TEXT);
        }
    
    
        private String id;
    
        /**
         * 评测体系（29电子病历，30互联互通，31三级医院等级评审）支持一种类型的指标属于多个评测体系
         */
        private List<String> evaluationSystem;
    
        /**
         * 评价类型（1定性，2定量）
         */
        private String evaluationType;
    
        /**
         * 指标字典code
         */
        private String metricsDictCode;
    
        /**
         * 指标字典名称
         */
        private String metricsDictName;
    
        private Class clazz;
    
        public MetricsDict(String id, String evaluationSystem, String evaluationType, String metricsDictCode, String metricsDictName, Class clazz) {
            this.id = id;
            this.evaluationSystem = Collections.singletonList(evaluationSystem);
            this.evaluationType = evaluationType;
            this.metricsDictCode = metricsDictCode;
            this.metricsDictName = metricsDictName;
            this.clazz = clazz;
        }
    
        public MetricsDict() {
        }
    
    }

第二步，写一个配置类创建4个选项的实现类的bean，抽象类必须写这常量类，因为需要获取该常量类中的class属性的对应实体类。通过创建的实现类再将对应的常量类MetricsDict 赋值到实现类中的MetricsDict属性中，然后在创建一个工厂类存储4个属性类的bean，这个工厂类也就二个方法，一个存储map值，一个通过1，2，3，4去获取对应的属性类的bean,这样通过1，2，3，4就可以获取对应的bean以及对应的固定属性值。

@Configuration
    public class MetricsOperationConfig {
    
        @Bean
        public QualitativeTextMetricsOperation qualitativeTextMetricsOperation(){
            QualitativeTextMetricsOperation operation = new QualitativeTextMetricsOperation();
            operation.setMetricsDict(MetricsDict.QUALITATIVE_TEXT);
            return operation;
        }
    
        @Bean
        public QualitativeTextAndOptionMetricsOperation qualitativeTextAndOptionMetricsOperation(){
            QualitativeTextAndOptionMetricsOperation operation = new QualitativeTextAndOptionMetricsOperation();
            operation.setMetricsDict(MetricsDict.QUALITATIVE_TEXT_AND_OPTION);
            return operation;
        }
    
        @Bean
        public QuantitativeCalculationMetricsOperation quantitativeCalculationMetricsOperation(){
            QuantitativeCalculationMetricsOperation operation = new QuantitativeCalculationMetricsOperation();
            operation.setMetricsDict(MetricsDict.QUANTITATIVE_CALCULATION);
            return operation;
        }
    
        @Bean
        public QuantitativeTextMetricsOperation quantitativeTextMetricsOperation(){
            QuantitativeTextMetricsOperation operation = new QuantitativeTextMetricsOperation();
            operation.setMetricsDict(MetricsDict.QUANTITATIVE_TEXT);
            return operation;
        }
    
        @Bean
        public MetricsOperationFactory metricsOperationFactory(){
            MetricsOperationFactory factory = new MetricsOperationFactory();
            factory.addMetricsOperation(MetricsDict.QUALITATIVE_TEXT.getId(), qualitativeTextMetricsOperation());
            factory.addMetricsOperation(MetricsDict.QUALITATIVE_TEXT_AND_OPTION.getId(), qualitativeTextAndOptionMetricsOperation());
            factory.addMetricsOperation(MetricsDict.QUANTITATIVE_CALCULATION.getId(), quantitativeCalculationMetricsOperation());
            factory.addMetricsOperation(MetricsDict.QUANTITATIVE_TEXT.getId(), quantitativeTextMetricsOperation());
            return factory;
        }
    
    }

public class MetricsOperationFactory {
    
    
        private final Map<String, AbstractMetricsOperation> metricsOperationMap = new HashMap<>();
    
        public AbstractMetricsOperation getMetricsOperation(String key){
            AbstractMetricsOperation metricsOperation = metricsOperationMap.get(key);
            if (metricsOperation == null){
                throw new RuntimeException("不支持的指标类型");
            }
            return metricsOperation;
        }
    
        public void addMetricsOperation(String key, AbstractMetricsOperation metricsOperation){
            metricsOperationMap.put(key, metricsOperation);
        }
    
    
    
    }

第三步，调用不同的实现类

//创建对应的实现类
    AbstractMetricsOperation metricsOperation = metricsOperationFactory.getMetricsOperation(metrics.getMetricsType());
    //调用对应的实现类的方法。
    metricsOperation.deleteMetricsContent(nodeDTO.getId());

抽象类中必须有该常量

public abstract class AbstractMetricsOperation {
        private final CopyOptions copyOption = CopyOptions.create(null, true);
    
        /**
         * 当前指标类型的字典信息
         */
        @Getter
        @Setter
        private MetricsDict metricsDict;