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

需求分析：

        一种题型，有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;