抽象工厂模式

抽象工厂模式是对工厂方法模式的补充。工厂方法模式中的每个工厂只生产一类产品，可能会导致系统中存在大量的工厂类，势必会增加系统的开销。所有将采用将一些相关的产品组成一个“产品族”，由同一个工厂来统一生产。
抽象工厂模式：提供一个创建一系列相关或互相依赖的接口，而无需指定它们具体的类。
抽象工厂模式中的两个概念：
1.产品结构等级：如手机有华为手机，小米手机，苹果手机；电脑有华为电脑，小米电脑，苹果电脑等；抽象手机和抽象电脑为父类，具体的厂商生产的手机和电脑为子类。
2.产品族：产品族是指同一工厂生产，位于不同产品结构等级的一组产品。如华为厂商，小米厂商，苹果厂商；各自构成一个产品族。
手机接口：

public interface IPhone {
    void use();
}

电脑接口：

public interface IComputer {
    void use();
}

华为手机实现类：

public class HuaWeiPhone implements IPhone {
    @Override
    public void use() {
        System.out.println("使用华为手机");
    }
}

华为电脑实现类：

public class HuaWeiComputer implements IComputer {
    @Override
    public void use() {
        System.out.println("使用华为电脑");
    }
}

小米手机实现类：

public class XiaoMiPhone implements IPhone {
    @Override
    public void use() {
        System.out.println("使用小米手机");
    }
}

小米电脑实现类：

public class XiaoMiComputer implements IComputer {
    @Override
    public void use() {
        System.out.println("使用小米电脑");
    }
}

产品工厂接口：

public interface ProductFactory {
    IComputer createComputer();

    IPhone createPhone();
}

华为工厂实现类：

public class HuaWeiProductFactory implements ProductFactory {
    @Override
    public IComputer createComputer() {
        return new HuaWeiComputer();
    }

    @Override
    public IPhone createPhone() {
        return new HuaWeiPhone();
    }
}

小米工厂实现类：

public class XiaoMiProductFactory implements ProductFactory {
    @Override
    public IComputer createComputer() {
        return new XiaoMiComputer();
    }

    @Override
    public IPhone createPhone() {
        return new XiaoMiPhone();
    }
}

客户端代码：

public class client {
    public static void main(String[] args) {
        ProductFactory productFactory = new XiaoMiProductFactory();
        IComputer computer = productFactory.createComputer();
        IPhone phone = productFactory.createPhone();
        computer.use();
        phone.use();
    }
}

客户端可以根据修改不同的厂商产品工厂类，获得不同厂商的一系列产品实现类。
由于客户端代码需要修改不同的厂商产品工厂类，可以通过反射机制+配置文件优化。
在application.properties中增加配置

productFactoryName=com.factoryPattern.AbstractFactoryPattern.XiaoMiProductFactory

客户端代码也做相应的修改：

public class client {
    public static void main(String[] args) {
        ProductFactory productFactory = getProductFactory();
        if (null != productFactory) {
            IComputer computer = productFactory.createComputer();
            IPhone phone = productFactory.createPhone();
            computer.use();
            phone.use();
        }
    }

    public static ProductFactory getProductFactory() {
        Properties properties = PropertiesUtils.getProperties();
        //获得类的全限定名（包名+类名）
        String productFactoryName = properties.getProperty("productFactoryName");
        ProductFactory productFactory = null;
        if (null != productFactoryName) {
            try {
                productFactory = (ProductFactory) Class.forName(productFactoryName).newInstance();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return productFactory;
    }
}

抽象工厂模式优化了工厂方法模式需要创建大量工厂类的问题。但抽象工厂模式也有其缺点，就是如果需要在产品工厂接口增加新的产品等级结构，如增加电视机，则需要华为工厂和小米工厂中增加相应创建电视机的方法，还需要修改客户端。所以在抽象工厂模式中增加新的产品族很方便，但是增加新的产品等级结构很麻烦，抽象工厂模式的这种性质称为“开闭原则”的倾斜性。

1. 主要优点

   抽象工厂模式的主要优点如下：
   
   (1) 抽象工厂模式隔离了具体类的生成，使得客户并不需要知道什么被创建。由于这种隔离，更换一个具体工厂就变得相对容易，所有的具体工厂都实现了抽象工厂中定义的那些公共接口，因此只需改变具体工厂的实例，就可以在某种程度上改变整个软件系统的行为。
   
   (2) 当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一个产品族中的对象。
   
   (3) 增加新的产品族很方便，无须修改已有系统，符合“开闭原则”。
   
   
   
   2. 主要缺点
   
   抽象工厂模式的主要缺点如下：
   
   增加新的产品等级结构麻烦，需要对原有系统进行较大的修改，甚至需要修改抽象层代码，这显然会带来较大的不便，违背了“开闭原则”。
   
   
   
   3. 适用场景
   
   在以下情况下可以考虑使用抽象工厂模式：
   
   (1) 一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节，这对于所有类型的工厂模式都是很重要的，用户无须关心对象的创建过程，将对象的创建和使用解耦。
   
   (2) 系统中有多于一个的产品族，而每次只使用其中某一产品族。可以通过配置文件等方式来使得用户可以动态改变产品族，也可以很方便地增加新的产品族。
   
   (3) 属于同一个产品族的产品将在一起使用，这一约束必须在系统的设计中体现出来。同一个产品族中的产品可以是没有任何关系的对象，但是它们都具有一些共同的约束，如同一操作系统下的按钮和文本框，按钮与文本框之间没有直接关系，但它们都是属于某一操作系统的，此时具有一个共同的约束条件：操作系统的类型。
   
   (4) 产品等级结构稳定，设计完成之后，不会向系统中增加新的产品等级结构或者删除已有的产品等级结构。
   

通过反射+简单工厂模式：
在application.properties中增加配置

company=HuaWei

工具类：

public class PropertiesUtils {
    public static Properties getProperties() {
        String sysPath = System.getProperty("user.dir");
        String path = sysPath + "/src/application.properties";
        Properties properties = new Properties();
        // 使用InPutStream流读取properties文件
        try {
            BufferedReader bufferedReader = new BufferedReader(new FileReader(path));
            properties.load(bufferedReader);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return properties;
    }

    public static String getCompanyName() {
        Properties properties = PropertiesUtils.getProperties();
        return properties.getProperty("company");
    }

    public static Object getProduct(String path) {
        Object object = null;
        try {
            object = Class.forName(path).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return object;
    }
}

产品工厂类：

public class ProductFactory {

    public static IComputer createComputer() {
        String companyName = PropertiesUtils.getCompanyName();
        String path = "com.factoryPattern.AbstractFactoryPattern." + companyName + "Computer";
        return (IComputer) PropertiesUtils.getProduct(path);
    }

    public static IPhone createPhone() {
        String companyName = PropertiesUtils.getCompanyName();
        String path = "com.factoryPattern.AbstractFactoryPattern." + companyName + "Phone";
        return (IPhone) PropertiesUtils.getProduct(path);
    }
}

客户端代码：

public class client {
    public static void main(String[] args) {
        IComputer computer = ProductFactory.createComputer();
        IPhone phone = ProductFactory.createPhone();
        computer.use();
        phone.use();
    }
}