工厂模式结合模板设计模式实现文件元数据解析

概述

定义一个操作中算法的框架，而将一些步骤延迟到子类中，模板方法模式使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

角色

AbstractClass(抽象类)

每一个基本操作对应算法的一个步骤，在其子类中可以重定义或实现这些步骤，在抽象类中实现了一个模板方法(Template Method)，用于定义一个算法的框架，模板方法不仅可以调用在抽象类中实现的基本方法，也可以调用在抽象类的子类中实现的基本方法，还可以调用其他对象中的方法。

ConcreteClass(具体子类)

抽象类的子类，用于实现在父类中声明的抽象基本操作以完成子类特定算法的步骤，也可以覆盖在父类中已经实现的具体基本操作

案例

定义接口

public interface FileMetaDecode {

    void decode(String filePath);
    String type();
}

定义抽象类

@Slf4j
public abstract class AbstractMetaDecode implements FileMetaDecode{
    @Override
    public void decode(String filePath) {
        before();
        checkFileExist(filePath);
        FileMeta fileMeta = parse(filePath);
        saveMeta(fileMeta);
        after();
    }

    public abstract void before();

    public abstract void after();

    public void checkFileExist(String filePath) {
        log.info("检查文件是否存在");
    }

    public abstract FileMeta parse(String filePath);

    public void saveMeta(FileMeta meta) {
        log.info("保存数据库 {}",meta);
    }
}

子类基础抽象类，实现抽象方法

@Slf4j
@Component
public class KFBMetaDecode extends AbstractMetaDecode{
    @Override
    public void before() {
        log.info("KFB前置处理");
    }

    @Override
    public void after() {
        log.info("KFB后置处理");
    }

    @Override
    public FileMeta parse(String filePath) {
        log.info("KFB格式文件解析元数据");
        return new FileMeta(10000,10000,20);
    }

    @Override
    public String type() {
        return "KFB";
    }
}

@Slf4j
@Component
public class TMAPMetaDecode extends AbstractMetaDecode{
    @Override
    public void before() {
        log.info("TMAP前置处理");
    }

    @Override
    public void after() {
        log.info("TMAP后置处理");
    }

    @Override
    public FileMeta parse(String filePath) {
       log.info("TMAP格式元数据解析");
        return new FileMeta(20000,2000,40);
    }

    @Override
    public String type() {
        return "TMAP";
    }
}

定义元数据解析工厂类

@Component
public class MetaDecodeFactory {

    private Map<String,FileMetaDecode> META_DECODE_MAP ;

    public MetaDecodeFactory(List<FileMetaDecode> decodes) {
        META_DECODE_MAP = new HashMap<>(decodes.size());
        decodes.forEach(fileMetaDecode -> {
            META_DECODE_MAP.putIfAbsent(fileMetaDecode.type(),fileMetaDecode);
        });
    }

    @SneakyThrows
    public FileMetaDecode getMetaDecode(String fileType) {
        FileMetaDecode decode = META_DECODE_MAP.get(fileType);
        if (decode == null) {
            throw new NotSupportedException("不支持的文件格式");
        }
        return decode;
    }

}

UML 示例

测试

    @Autowired
    private MetaDecodeFactory metaDecodeFactory;

    @Test
    public void template() {
        FileMetaDecode decode = metaDecodeFactory.getMetaDecode("TMAP");
        decode.decode("D://test//1.tmap");
        log.info("==============================");
        FileMetaDecode kfb = metaDecodeFactory.getMetaDecode("KFB");
        kfb.decode("D://test//1.kfb");
    }