简单工厂模式

• 简单工厂模式(Simple Factory Pattern)：又称为静态工厂方法(Static Factory Method)模式，它属于创建型模式。在简单工厂模式中，可以根据参数的不同返回不同类的实例,生产出来的产品是具体的。

---

模式结构

简单工厂模式包含如下角色：

• Factory：工厂角色
  工厂角色负责实现创建所有实例的内部逻辑

• Product：抽象产品角色
  抽象产品角色是所创建的所有对象的父类，负责描述所有实例所共有的
  公共接口

• ConcreteProduct：具体产品角色
  具体产品角色是创建目标，所有创建的对象都充当这个角色的某个具体类的实例。

示例

数据可以用数据库、文件、Xml来进行保存，以此为例进行简单工厂设计。
1. 产品抽象角色

public interface IIoHandler {
    void add(String id,String name);
    void remove(String id);
    void update(String id,String name);
    String query(String id);
}

2. 具体产品角色

public class DbHandler implements IIoHandler {

    @Override
    public void add(String id, String name) {

    }

    @Override
    public void remove(String id) {

    }

    @Override
    public void update(String id, String name) {

    }

    @Override
    public String query(String id) {
        return "DbHandler";
    }

}

public class FileHandler implements IIoHandler {

    @Override
    public void add(String id, String name) {

    }

    @Override
    public void remove(String id) {

    }

    @Override
    public void update(String id, String name) {

    }

    @Override
    public String query(String id) {
        return "fileHanlder";
    }

}

public class XmlHandler implements IIoHandler {

    @Override
    public void add(String id, String name) {

    }

    @Override
    public void remove(String id) {

    }

    @Override
    public void update(String id, String name) {

    }

    @Override
    public String query(String id) {
        return "XmlHandler";
    }

}

3. 工厂角色

public class IoFactory {
    public static <T extends IIoHandler> T getIoHandler(Class<T> clz){
        IIoHandler newInstance = null;
        try {
//          newInstance = clz.newInstance();
            newInstance = (IIoHandler) Class.forName(clz.getName()).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        } 
        
        return (T) newInstance;
    }
}

4.使用

IIoHandler ioHandler = IoFactory.getIoHandler(FileHandler.class);
String query = ioHandler.query("123");
System.out.println(query);

优缺点

1. 简单工厂模式的优点

a.工厂类含有必要的判断逻辑，可以决定在什么时候创建哪一个产品类的实例，客户端可以免除直接创建产品对象的责任，而仅仅“消费”产品；简单工厂模式通过这种做法实现了对责任的分割，它提供了专门的工厂类用于创建对象。
b.客户端无须知道所创建的具体产品类的类名，只需要知道具体产品类所对应的参数即可，对于一些复杂的类名，通过简单工厂模式可以减少使用者的记忆量。
c.通过引入配置文件，可以在不修改任何客户端代码的情况下更换和增加新的具体产品类，在一定程度上提高了系统的灵活性。

2. 简单工厂模式的缺点

a.由于工厂类集中了所有产品创建逻辑，一旦不能正常工作，整个系统都要受到影响。
b.使用简单工厂模式将会增加系统中类的个数，在一定程序上增加了系统的复杂度和理解难度。
c.系统扩展困难，一旦添加新产品就不得不修改工厂逻辑，在产品类型较多时，有可能造成工厂逻辑过于复杂，不利于系统的扩展和维护。
d.简单工厂模式由于使用了静态工厂方法，造成工厂角色无法形成基于继承的等级结构。

---

工厂方法模式

工厂方法使用一个抽象工厂角色作为核心来代替在简单工厂模式中使用具体类作为核心。
工厂方法模式是简单工厂模式的进一步抽象和推广。由于使用了面向对象的多态性，工厂方法模式保持了简单工厂模式的优点，而且克服了它的缺点。在工厂方法模式中，核心的工厂类不再负责所有产品的创建，而是将具体创建工作交给子类去做。这个核心类仅仅负责给出具体工厂必须实现的接口，而不负责哪一个产品类被实例化这种细节，这使得工厂方法模式可以允许系统在不修改工厂角色的情况下引进新产品。

---

结构模式：

• Product：抽象产品
• ConcreteProduct：具体产品
• Factory：抽象工厂

• ConcreteFactory：具体工厂

  
  

示例：

1. 定义抽象产品类

public interface IBrake {
    void brake();
}

public interface IEngine {
    void engine();
}

public interface ITire {
    void tire();
}

2. 抽象工厂类

public interface ICarFactory {
    ITire createTire();
    IEngine createEngine();
    IBrake createBraek();
}

3. 具体的产品集合

public class ImportBrake implements IBrake {

    @Override
    public void brake() {
        System.out.println("进口制动系统");
    }

}
public class NormalBrake implements IBrake {

    @Override
    public void brake() {
        System.out.println("普通制动系统");
    }

}

public class ImportEngine implements IEngine {

    @Override
    public void engine() {
        System.out.println("进口发动机");
    }

}
public class NormalEngine implements IEngine {
    @Override
    public void engine() {
        System.out.println("普通发动机");
    }
}

public class ImportTire implements ITire {

    @Override
    public void tire() {
        System.out.println("进口轮胎");
    }

}
public class NormalTire implements ITire {

    @Override
    public void tire() {
        System.out.println("普通轮胎");
    }

}

4. 具体的工厂类

public class Q3CarFactory implements ICarFactory {

    @Override
    public ITire createTire() {
        return new NormalTire();
    }

    @Override
    public IEngine createEngine() {
        return new NormalEngine();
    }

    @Override
    public IBrake createBraek() {
        return new NormalBrake();
    }

}

public class Q7CarFactory implements ICarFactory {

    @Override
    public ITire createTire() {
        return new ImportTire();
    }

    @Override
    public IEngine createEngine() {
        return new ImportEngine();
    }

    @Override
    public IBrake createBraek() {
        return new ImportBrake();
    }

}

5. 工厂的管理类，相当于简单工厂中具体的工厂类
工厂的管理类用来创建具体的工厂。

public class CarFactoryManager {
    public static <T extends ICarFactory> T getCarFactory(Class<T> clz){
        ICarFactory factory = null;
        try {
            factory = clz.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        } 
        
        return (T) factory;
    }
}

6. 使用

ICarFactory q3Factory = CarFactoryManager.getCarFactory(Q3CarFactory.class);
q3Factory.createEngine().engine();
q3Factory.createBraek().brake();
q3Factory.createTire().tire();

ICarFactory q7CarFactory = CarFactoryManager.getCarFactory(Q7CarFactory.class);
q7CarFactory.createEngine().engine();
q7CarFactory.createBraek().brake();
q7CarFactory.createTire().tire();

Paste_Image.png

优缺点

1. 工厂方法模式的优点

a.在工厂方法模式中，工厂方法用来创建客户所需要的产品，同时还向客户隐藏了哪种具体产品类将被实例化这一细节，用户只需要关心所需产品对应的工厂，无须关心创建细节，甚至无须知道具体产品类的类名。
b.基于工厂角色和产品角色的多态性设计是工厂方法模式的关键。它能够使工厂可以自主确定创建何种产品对象，而如何创建这个对象的细节则完全封装在具体工厂内部。工厂方法模式之所以又被称为多态工厂模式，是因为所有的具体工厂类都具有同一抽象父类。
c.在系统中加入新产品时，无须修改抽象工厂和抽象产品提供的接口，无须修改客户端，也无须修改其他的具体工厂和具体产品，而只要添加一个具体工厂和具体产品就可以了。这样，系统的可扩展性也就变得非常好，完全符合“开闭原则”。

2. 工厂方法模式的缺点

a.在添加新产品时，需要编写新的具体产品类，而且还要提供与之对应的具体工厂类，系统中类的个数将成对增加，在一定程度上增加了系统的复杂度，有更多的类需要编译和运行，会给系统带来一些额外的开销。
b.由于考虑到系统的可扩展性，需要引入抽象层，在客户端代码中均使用抽象层进行定义，增加了系统的抽象性和理解难度，且在实现时可能需要用到DOM、反射等技术，增加了系统的实现难度。