设计模式——（一）工厂模式1

一.  什么是工厂模式？

工厂模式是常用的实例化对象的模式，它替代了new操作。核心思想就是：如何实例化一个合适的对象。

 工厂模式分为三类：简单工厂、工厂模式、抽象工厂模式。

二.  三种工厂模式

2.1 简单工厂模式

2.1.1 定义

简单工厂模式（Simple Factory Pattern），又叫做静态工厂方法模式（Static FactoryMethod Pattern），是通过专门定义一个工厂类来创建其他类的实例，通常被创建的实例都具有共同的父亲。实现了算法和界面的分离，也就是将业务逻辑和界面逻辑分来了，降低了耦合度。但是违背了“开放—关闭”原则。

如何实现的？

通过一个工厂类，根据已有信息，使得实例对象的创建在子类进行。

好处：

• 一个调用者想创建一个对象，只要知道其名称就可以了。
• 扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以
• 屏蔽产品的具体实现，调用者只关心产品的接口。

主要解决的问题：主要解决接口选择的问题，根据信息创建不同的对象。

 

在实际的的使用中，抽闲产品和具体产品之间往往是多层次的产品结构，如下图所示

2.1.2 简单工厂模式中包含了三种角色：

1. 工厂角色（Creator）：核心，由它负责创建所有类的内部逻辑，根据不同的信息调用子类创建所需要的对象，并且能够被外界调用

2. 抽象产品（Product）：简单工厂对象所创建的所有对象的父亲（可以使抽象类，也可以是接口），它是所有子类的公共接口。

3. 具体产品（Concrete Product）：简单工厂所创建的具体实例对象。

2.1.3 应用场景：

• 日志记录器：记录可能记录到本地磁盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方
• 数据库访问：当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化的时候：

　　Java程序通过JDBC（数据库编程接口API）可以执行SQL语句，对获取的数据进行处理吗，并将变化的数据存到数据库中，JDBC是Java应用程序与各种关系数据库进行对话的一种机制：

• 设计一个连接服务器的框架，需要三个协议：“POP3”、“IMAP”、“HTTP”，可以把这三个作为产品类，共同实现一个接口

2.1.4 具体实现

1. 创建一个接口——抽象产品（product）：

Shape.java

public interface Shape(){
    void draw();
}

2. 创建实现接口的实体类——Concrete Product具体产品

Rectangle.java

public class Rectangle implements Shape{
    @Override
    public void draw(){
        System.out.println("Inside Rectangle::draw() method");
    }
}

Circle.java

public class Circle implements Shape{
    @Override
    public void draw(){
        System.out.println("Inside Circle::draw() method");
    }
}

Square.java

public class Square implements Shape{
    @Override
    public void draw(){
        System.out.println("Inside Square::draw() method");
    }
}

3. 不同之处开始了！

如果没有使用工厂模式，我们在对特定的类产生实例时我们需要：

Circle circle = new Circle();
Square square = new Square();
Rectangle rectangle = new Rectangle();

也就是说，我们如果要生成Shape的儿子，则要一个个去找那个特定的儿子然后实例化，但是如果我们用了工厂模式，我们可以明确地根据不同条件信息来创建不同的实例。也就是说，

• 当一个调用者要创建一个对象时，只要知道了他的信息（比如名字）就可以了。
• 屏蔽了这个对象具体创建的过程，只关心接口
• 如果要增加一个类，扩展工厂就可以了。——同样导致了：每增加一个产品，就需要同时增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。

具体实现如下：

创建一个工厂，生成基于信息的实体类对象 —— 工厂角色（Creator）

shapeFactory.java

public class ShapeFactory{
    
    //使用getShape()方法根据已有的信息，生成特定的对象
    public Shape getShape(String shapeType){
        if (shapeType == null)
            return null;
        if (shapeType.equalsIgnoreCase("CIRCLE")){
            return new Circle();
        }
        else if (shapeType.equalsIgnoreCase("RECTANFGLE")) {
            return new Rectangle();
        }
        else if (shapeType.equalsIgnoreCase("SQUARE")){
            return new Square();
        }
    }
}

4. 使用该工厂，通过传递类型信息来获取实体类的对象

FactoryPatternDemo.java

public class FactoryPatternDemo{
    public static void main(String[] args){
        ShapeFactory shapeFactory = new ShapeFactory();
        
        // 获取Circle类的对象，并调用它的draw()方法
        shape shape1 = shapeFactory.getShape("CIRCLE");
        shape1.draw();
        
        //获取Rectangle的对象，并调用它的draw()方法
        Shape shape2 = shapeFactory.getShape("Rectangle");
        shape2.draw();
        
        //获取Square对象，并调用它的draw()方法
        Shape shape3 = shapeFactory.getShape("Square");
        shape3.draw();
    }

5. 验证输出：

最后建立测试客户端，结果如下：

Inside Circle::draw() method.
Inside Rectangle::draw() method.
Inside Square::draw() method.

2.1.5 优缺点

优点：工厂类包含必要的判断逻辑，更够根据外界给定的信息，决定创建哪一个实例对象，而无需了解对象具体的创建、组织过程，有利于整个软件体系结构的优化。

缺点：

1. 由于工厂类集中所有实例的创建逻辑，导致一旦这个工厂类出现问题，所有客户端都会收到牵连

2. 因为所有的产品都基于一个公共的抽象类或者接口，一旦产品的种类增加，工厂类不仅需要判断这个产品所属的具体产品，还需要判断他属于哪个抽象产品，违背了单一职责，导致系统丧失灵活性和可维护性。

3. 当增加一个产品的时候，不仅需要添加具体产品类，还需要修改工厂类，违反了开闭原则。

开闭原则：

（1）模块的行为可以扩展。这意味着模块的行为是可以扩展的。（2）对于修改是关闭的（Closed for modification）。对模块行为进行扩展时，不必改动模块的源代码或者二进制代码。

也就是说：作为系统设计的抽象层，要预见所有可能的扩展，从而使得在任何扩展情况下，系统的抽象底层不需修改；同时，由于可以从抽象底层导出一个或多个新的具体实现，可以改变系统的行为，因此系统设计对扩展是开放的。

在简单工厂模式中：如果增加了一个新的产品类别，我们需要修改产品类，还需要修改工厂类。