Abstract factory pattern

Definition

Abstract factory pattern （Abstract FactoryPattern） Create other factories around one super factory . This super factory is also called the factory of other factories .

It is suggested to understand Simple factory model Understanding abstract factory patterns .

type

Create pattern

Example

We now have two ways to save data , Database and KeyValue localization .
But databases and KeyValue There are several kinds. , Different situations may require different libraries , In order to facilitate the extension, we define an interface unified capability .
Just like the simple factory model , For the time being, there is only one way to add data .

public interface IKeyValueData {
    

    void add();
}

Define its implementation class , And implement IKeyValueData Interface

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() {
    

    }
}

Here is actually a simple factory model , Just one factory is needed to establish . here , Don't rush to create a factory , Let's create another type first .

Define the interface of the database

public interface IDataBase {
    

    void insert();
}

Implementation class

MySql database

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

    }
}

Oracle database

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

    }
}

MongoDB database

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

    }
}

Now it's time to create a factory , Simple factory mode because there is only one product family （ Database and KeyValueData） So you can directly create a factory class . however , Abstract factory itself is the factory of many factories , Therefore, an interface is needed to define the product family of the factory .

Defining interfaces

public interface IDataFactory {
    

    IKeyValueData getKeyValueData();

    IDataBase getDataBase();
}

From this interface, it can be determined that there are two product families .

Create a factory

Database factory

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 factory

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;
    }


}

Usage mode

public class Test {
    


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

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

}

Class diagram

The abstract factory will be realized , Look at the diagram .

Advantages and disadvantages

advantage

• Product grade is easy to expand
• Conform to the principle of dependency abstraction
• Simplify callers , There is no need to pay attention to how the factory is created

shortcoming

• Product families are hard to expand
• Increases the abstractness of the system and the difficulty of understanding ;

Example

If one day I want to add a new product family , For example, I want to add IO To serialize local data directly , I need to change IDataFactory Interface .

public interface IDataFactory {
    

    IKeyValueData getKeyValueData();

    IDataBase getDataBase();
    
    IDataBase getIOData();
}

This led me to achieve all IDataFactory All classes of the interface should be rewritten getIOData Method .


Then you can realize yourself IO.

But it's very convenient if we only add one product grade

newly added SQLite database

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

Then modify the creation logic of the database factory .

difficulty

Understanding of product family and product grade . In this example, product families are databases and KeyValue.MySql Product grade .

summary

Abstract factories may not be used in many places , Need to make trade-offs and changes according to needs .