Java设计模式-工厂模式-优快云博客

1、为什么引进工厂模式

对于简单工厂模式，当我们需要增加新的产品。那么我们势必需要对工厂类进行修改，在一定程度上，这违反类封闭原则。

与简单工厂模式相比，工厂模式不在提供统一的工厂类来负责所有产品的创建，而是将具体产品的创建过长交给专门的工厂子类去完成。

2、工厂模式的结构

（1）Product（抽象产品）定义产品的接口，是工厂方法模式所创建对象的超类型，也就是产品对象的公共父类。

package com.huawei.factory.factorymethod.product;

/**
 * @author admin
 * @date 2018/11/17
 */

public interface Logger {
   public void writeLog();
}

（2）ConcreteProduct（具体产品）实现了抽象产品接口，某种类型的具体产品由专门的具体工厂所创建，具体工厂和具体产品一一对应。

package com.huawei.factory.factorymethod.product;

/**
 * @author admin
 * @date 2018/11/17
 */

public class FileLogger implements Logger {
    @Override
    public void writeLog() {
        System.out.println("文件日记记录");
    }
}

//==================

package com.huawei.factory.factorymethod.product;

/**
 * @author admin
 * @date 2018/11/17
 */

public class DatabaseLogger implements Logger {
    @Override
    public void writeLog() {
        System.out.println("数据库日记记录");
        
    }
}

（3）Factory（抽象工厂）：在抽象工厂中类中声明工厂方法（Factory Method），用于返回一个产品。抽象工厂方法模式的核心，所有创建对象的工厂类都必须实现该接口。

package com.huawei.factory.factorymethod.factory;

import com.huawei.factory.factorymethod.product.Logger;

/**
 * @author admin
 * @date 2018/11/17
 * 抽象工厂类
 */

public interface LoggerFactory {
    public Logger createLogger();
}

（4）ConcreteFactory（具体工厂）：是抽象工厂的子类，实现了在抽象工厂中声明的工厂方法，并可由客户端调用，返回一个具体产品类的实例

package com.huawei.factory.factorymethod.factory;

import com.huawei.factory.factorymethod.product.DatabaseLogger;
import com.huawei.factory.factorymethod.product.Logger;

/**
 * @author admin
 * @date 2018/11/17
 * 文件日志记录器
 */

public class DatabaseLoggerFactory implements LoggerFactory {
    @Override
    public Logger createLogger() {
        Logger logger=new DatabaseLogger();
        return logger;
    }
}

//================

package com.huawei.factory.factorymethod.factory;

import com.huawei.factory.factorymethod.product.FileLogger;
import com.huawei.factory.factorymethod.product.Logger;

/**
 * @author admin
 * @date 2018/11/17
 */

public class FileLoggerFactory implements LoggerFactory {
    @Override
    public Logger createLogger() {
        Logger logger=new FileLogger();
        return logger;
    }
}

（5）客户端测试类

package com.huawei.factory.factorymethod.client;

import com.huawei.factory.factorymethod.factory.FileLoggerFactory;
import com.huawei.factory.factorymethod.factory.LoggerFactory;
import com.huawei.factory.factorymethod.product.Logger;

/**
 * @author admin
 * @date 2018/11/17
 */

public class Client {
    public static void main(String[] args) {
        LoggerFactory loggerFactory;
        Logger logger;
        loggerFactory = new FileLoggerFactory();
        logger = loggerFactory.createLogger();
        logger.writeLog();
    }
}

4、结构分析

如果需要修改日志记录器，只需要修改客户端代码中的具体工厂类就可以；增加新的日志记录器并使用，需要对应增加一个新的工厂类，相比较不需改变原有的代码。

5、工厂方法的重载

通过多种方式来初始化同一个产品类，简单说通过传递不同类型参数进行初始化。

引入重载方法后，抽象工厂类LoggerFactory的代码修改如下：

package com.huawei.factory.factorymethod.factory;

import com.huawei.factory.factorymethod.product.Logger;

/**
 * @author admin
 * @date 2018/11/17
 * 抽象工厂类
 */

public interface LoggerFactory {
    public Logger createLogger();
    public Logger createLogger(String args);
    public Logger createLogger(Object obj);

}

具体工厂类

package com.huawei.factory.factorymethod.factory;

import com.huawei.factory.factorymethod.product.FileLogger;
import com.huawei.factory.factorymethod.product.Logger;

/**
 * @author admin
 * @date 2018/11/17
 */

public class FileLoggerFactory implements LoggerFactory {
    @Override
    public Logger createLogger() {
        Logger logger=new FileLogger();
        return logger;
    }

    @Override
    public Logger createLogger(String args) {

        Logger logger=new FileLogger();
        //省其他业务代码
        return logger;
    }

    @Override
    public Logger createLogger(Object obj) {
        Logger logger=new FileLogger();
        //省其他业务代码
        return logger;
    }
}

6、优缺点分析
优点：
1、多态性：客户代码可以做到与特定应用无关，适用于任何实体类。
2、子类提供挂钩。基类为工厂方法提供缺省实现，子类可以重写新的实现，也可以继承父类的实现。— 加一层间接性，增加了灵活性
3、连接并行的类层次结构。
4、良好的封装性，代码结构清晰。
5、扩展性好，在增加产品类的情况下，只需要适当修改具体的工厂类或扩展一个工厂类，就可“拥抱变化”。
6、屏蔽产品类。产品类的实现如何变化，调用者都不需要关心，只需关心产品的接口，只要接口保持不变，系统中的上层模块就不会发生变化。
7、典型的解耦框架。高层模块只需要知道产品的抽象类，其他的实现类都不需要关心，符合迪米特法则，符合依赖倒置原则，符合里氏替换原则。
缺点：
需要Creator和相应的子类作为factory method的载体，如果应用模型确实需要creator和子类存在，则很好；否则的话，需要增加一个类层次。

7、使用环境

（1）、一个类不知道它所需要的对象的类：

客户端不需要知道具体产品类的类名，只需要知道对应的工厂即可，具体的产品的对象由具体的工厂类创建；客户端需要知道创建具体产品的工厂类。

（2）、一个类通过其子类来指定创建哪个对象：

（3）、将创建对象的任务委托给多个工厂子类中的某一个，客户端在使用时可以无须关心是哪一个工厂子类创建产品子类，，需要时再动态指定，可将具体工厂类的类名存储在配置文件中或数据库中。