使用枚举和map和mapstruct优化将两个方法封装为通用的方法 private static ListObject convertSheetPositionDetailDatafinal ComputeResultExportDTO result final Map

首先，我们可以使用枚举来定义需要封装的字段的顺序和名称。假设我们有一个枚举类FieldEnum，包含了所有需要封装的字段，可以按照顺序列出它们的名称：

public enum FieldEnum {
    DEPT_NAME("deptName"),
    EMP_NAME("empName"),
    EMP_CODE("empCode"),
    LEVEL_GROUP("levelGroup"),
    SCORE_GROUP("scoreGroup"),
    SUGGESTED_LEVEL("suggestedLevel"),
    HONEST_SCORE_GROUP("honestScoreGroup"),
    TOTAL_SCORE("totalScore"),
    WEIGHT_GROUP_NAME("weightGroupName"),
    LEVEL_NAME("levelName"),
    EXAMINE_EVALUATION_ID("examineEvaluationId");

    private String fieldName;

    FieldEnum(String fieldName) {
        this.fieldName = fieldName;
    }

    public String getFieldName() {
        return fieldName;
    }
}

接下来，我们可以使用MapStruct来生成转换器代码。我们需要定义两个@Mapper接口，分别用于转换ComputeResultExportDTO到List<Object>的方法：

@Mapper
public interface ComputeResultExportMapper {
    ComputeResultExportMapper INSTANCE = Mappers.getMapper(ComputeResultExportMapper.class);

    @Mapping(target = "field", source = "result.deptName")
    List<Object> convertSheetPositionDetailData(ComputeResultExportDTO result, @Context Map<String, List<BigDecimal>> scoreGroup, @Context Map<String, List<BigDecimal>> honestScoreGroup);

    @Mapping(target = "field", source = "result.levelName")
    List<Object> convertSheetPositionData(ComputeResultExportDTO result, @Context Map<String, List<BigDecimal>> scoreGroup);
}

然后，我们可以使用一个通用的方法来封装转换过程。我们将字段名称和对应的方法定义为一个Map，然后根据传入的参数动态调用对应的方法：

public class ExportUtil {
    private static final Map<FieldEnum, Function<ComputeResultExportDTO, List<Object>>> fieldMapping = new HashMap<>();

    static {
        fieldMapping.put(FieldEnum.DEPT_NAME, result -> Collections.singletonList(result.getDeptName()));
        fieldMapping.put(FieldEnum.EMP_NAME, result -> Collections.singletonList(result.getEmpName()));
        fieldMapping.put(FieldEnum.EMP_CODE, result -> Collections.singletonList(result.getEmpCode()));
        fieldMapping.put(FieldEnum.LEVEL_GROUP, result -> Collections.singletonList(result.getLevelGroup()));
        fieldMapping.put(FieldEnum.SCORE_GROUP, result -> CollectionUtils.emptyIfNull(scoreGroup.get(result.getExamineEvaluationId())));
        fieldMapping.put(FieldEnum.SUGGESTED_LEVEL, result -> Collections.singletonList(result.getSuggestedLevel()));
        fieldMapping.put(FieldEnum.HONEST_SCORE_GROUP, result -> CollectionUtils.emptyIfNull(honestScoreGroup.get(result.getExamineEvaluationId())));
        fieldMapping.put(FieldEnum.TOTAL_SCORE, result -> Collections.singletonList(result.getTotalScore()));
        fieldMapping.put(FieldEnum.WEIGHT_GROUP_NAME, result -> Collections.singletonList(result.getWeightGroupName()));
        fieldMapping.put(FieldEnum.LEVEL_NAME, result -> Collections.singletonList(result.getLevelName()));
    }

    public static List<Object> convertSheetData(ComputeResultExportDTO result, Map<String, List<BigDecimal>> scoreGroup, Map<String, List<BigDecimal>> honestScoreGroup, FieldEnum... fields) {
        List<Object> sheetData = new ArrayList<>();
        for (FieldEnum field : fields) {
            sheetData.addAll(fieldMapping.get(field).apply(result));
        }
        return sheetData;
    }
}

最后，我们可以使用这个通用的方法来封装原始的两个方法：

public class Main {
    public static void main(String[] args) {
        ComputeResultExportDTO result = new ComputeResultExportDTO();
        Map<String, List<BigDecimal>> scoreGroup = new HashMap<>();
        Map<String, List<BigDecimal>> honestScoreGroup = new HashMap<>();

        List<Object> sheetData1 = ExportUtil.convertSheetData(result, scoreGroup, honestScoreGroup, FieldEnum.DEPT_NAME, FieldEnum.EMP_NAME, FieldEnum.EMP_CODE, FieldEnum.LEVEL_GROUP, FieldEnum.SCORE_GROUP, FieldEnum.SUGGESTED_LEVEL, FieldEnum.HONEST_SCORE_GROUP, FieldEnum.TOTAL_SCORE, FieldEnum.WEIGHT_GROUP_NAME);
        List<Object> sheetData2 = ExportUtil.convertSheetData(result, scoreGroup, honestScoreGroup, FieldEnum.LEVEL_NAME, FieldEnum.SCORE_GROUP, FieldEnum.SUGGESTED_LEVEL, FieldEnum.TOTAL_SCORE, FieldEnum.WEIGHT_GROUP_NAME);
    }
}

通过这种方式，我们可以将两个原始的方法封装为通用的方法，可以根据需要动态选择需要封装的字段。