抽象工厂模式

定义

抽象工厂模式（Abstract FactoryPattern）围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。

建议先理解简单工厂模式在理解抽象工厂模式。

类型

创建型模式

示例

我们现在有两种保存数据的方式，数据库和KeyValue本地化。
但是数据库和KeyValue有好几种，不同情况可能需要不同的库，为了方便扩展我们定义一个接口统一能力。
就像简单工厂模式一样，暂时只有一个添加数据的方法。

public interface IKeyValueData {
    

    void add();
}

定义它的实现类，并实现IKeyValueData 接口

SharedPreferences

public class SharedPreferences implements IKeyValueData {
    
    @Override
    public void add() {
    

    }
}

DataStore

public class DataStore implements IKeyValueData{
    
    @Override
    public void add() {
    

    }
}

MMKV

public class MMKV implements IKeyValueData{
    
    @Override
    public void add() {
    

    }
}

到这里其实就是一个简单工厂模式，就差一个工厂来创建了。这里，先不急创建工厂，我们先创建另一个类型。

定义数据库的接口

public interface IDataBase {
    

    void insert();
}

实现类

MySql 数据库

public class MySql implements IDataBase{
    
    @Override
    public void insert() {
    

    }
}

Oracle 数据库

public class Oracle implements IDataBase{
    
    @Override
    public void insert() {
    

    }
}

MongoDB数据库

public class MongoDB implements IDataBase{
    
    @Override
    public void insert() {
    

    }
}

现在到创建工厂的时候了，简单工厂模式因为只有一个产品族（数据库和KeyValueData）所以直接创建了工厂类即可。但是，抽象工厂本身就是很多工厂的工厂，所以需要一个接口来定义工厂的产品族有哪些。

定义接口

public interface IDataFactory {
    

    IKeyValueData getKeyValueData();

    IDataBase getDataBase();
}

从这个接口可以确定的是有两个产品族。

创建工厂

数据库工厂

public class DataBaseFactory implements IDataFactory {
    

    private boolean isMysql;
    private boolean isMongoDB;
    @Override
    public IKeyValueData getKeyValueData() {
    
        return null;
    }

    @Override
    public IDataBase getDataBase() {
    
        if (isMysql) {
    
            return new MySql();
        }
        if (isMongoDB) {
    
            return new MongoDB();
        }

        return new Oracle();
    }
}

KeyValue工厂

public class KeyValueIDataFactory implements IDataFactory {
    
    private boolean isMMKV;
    private boolean isDataStore;


    @Override
    public IKeyValueData getKeyValueData() {
    
        if (isMMKV) {
    
            return new MMKV();
        }
        if (isDataStore) {
    
            return new DataStore();
        }
        return new SharedPreferences();
    }

    @Override
    public IDataBase getDataBase() {
    

        return null;
    }


}

使用方式

public class Test {
    


    public static void main(String[] args) {
    
        IDataBase dataBase = new DataBaseFactory().getDataBase();
        IKeyValueData keyValueData = new KeyValueIDataFactory().getKeyValueData();

        dataBase.insert();
        keyValueData.add();
    }

}

类关系图

到这抽象工厂就实现了，看一下关系图。

优缺点

优点

• 产品等级易扩展
• 符合依赖抽象原则
• 简化调用者，无需关注工厂如何创建

缺点

• 产品族难扩展
• 增加了系统的抽象性和理解难度；

示例

如果有一天我要新增一个产品族，比如我要增加IO来直接序列化本地数据，我需要改IDataFactory接口。

public interface IDataFactory {
    

    IKeyValueData getKeyValueData();

    IDataBase getDataBase();
    
    IDataBase getIOData();
}

这样导致我所有实现了IDataFactory 接口的所有类都要重写getIOData方法。


然后才能实现自己IO。

但是我们要是只去增加一个产品等级就非常方便

新增SQLite 数据库

public class SQLite implements IDataBase{
    
    @Override
    public void insert() {
    
        
    }
}

然后再数据库的工厂修改创建逻辑即可。

难点

对产品族和产品等级的理解。 在这个示例中产品族就是数据库和KeyValue。MySql就是产品等级。

总结

抽象工厂可能使用的地方不多，需要根据需求取舍和更改。