第4章 工厂方法模式

4.1 工厂方法模式

image
修改为：
image
工厂方法模式（Factory Method Pattern）：定义一个用于创建对象的接口，但是让子类决定将哪一个类实例化。工厂方法模式让一个类的实例化延迟到其子类。

  • 其他称呼
    • 工厂模式（Factory Pattern）
    • 虚拟构造器模式（Virtual Constructor Pattern）
    • 多态工厂模式（Polymorphic Factory Pattern）
  • 类创建型模式
    • 工厂父类负责定义创建产品对象的公共接口
    • 工厂子类负责生成具体的产品对象
  • 将产品类的实例化操作延迟到工厂子类中完成，通过工厂子类来确定应该实例化哪一个具体产品类

4.2 工厂方法模式结构与实现

4.2.1 工厂方法模式结构

  1. Product（抽象产品）：它是定义产品的接口，是工厂方法模式所创建对象的超类型，也就是产品对象的公共父类。
  2. ConcreteProduct（具体产品）：它实现了抽象产品接口,某种类型的具体产品由专门的具体工厂创建,具体工厂和具体产品之间一一对应。
  3. Factory（抽象工厂）：在抽象工厂类中声明了工厂方法(Factory Method)，用于返回一个产品。抽象工厂是工厂方法模式的核心，所有创建对象的工厂类都必须实现该接口。
  4. ConcreteFactory（具体工厂）：它是抽象工厂类的子类，实现了在抽象工厂中声明的工厂方法，并可由客户端调用，返回一个具体产品类的实例。
    image

4.2.2 工厂方法模式设计

抽象工厂类/接口：

public interface Factory {
    public Product factoryMethod();
}

具体工厂类：

public class ConcreteFactory implements Factory{
    public Product factoryMethod(){
        return new ConcreteProduct();
    }
}

4.3 工厂方法模式应用实例

实例说明

       某系统运行日志记录器（Logger）可以通过多种途径保存系统的运行日志，例如通过文件记录或数据库记录。用户可以通过修改配置文件灵活地更换日志记录方式。在设计各类日志记录器时，开发人员发现需要对日志记录器进行一些初始化工作，初始化参数的设置过程较为复杂,而且某些参数的设置有严格的先后次序。否则可能会发生记录失败。
       为了更好地封装记录器的初始化过程并保证多种记录器切换的灵活性,现使用工厂方法模式设计该系统（注：在Java中常用的日志记录工具有SLF4J、Log4j、GCLogViewer、Logstash等）。

实例类图

image

  • 抽象产品类：Logger
  • 具体产品类：
    • DatabaseLogger
    • FileLogger
  • 抽象工厂类：LoggerFactory
  • 具体工厂类：
    • DatabaseLoggerFactory
    • FileLoggerFactory

实例代码

Logger：日志记录器接口，充当抽象产品角色 
package designpatterns.factorymethod;

public interface Logger {
    public void writeLog();
}
DatabaseLogger：数据库日志记录器，充当具体产品角色 
package designpatterns.factorymethod;

public class DatabaseLogger implements Logger{
    @Override
    public void writeLog() {
        System.out.println("数据库日志记录.");
    }
}
FileLogger：文件日志记录器，充当具体产品角色 
package designpatterns.factorymethod;

public class FileLogger implements Logger{
    @Override
    public void writeLog() {
        System.out.println("日志文件记录.");
    }
}
LoggerFactory：日志记录器工厂接口，充当抽象工厂角色 
package designpatterns.factorymethod;

public interface LoggerFactory {
    public Logger createLogger();
}
DatabaseLoggerFactory：数据库日志记录器工厂类，充当具体工厂角色 
package designpatterns.factorymethod;

public class DatabaseLogger implements Logger{
    @Override
    public void writeLog() {
        System.out.println("数据库日志记录.");
    }
}
FileLoggerFactory：文件日志记录器工厂类，充当具体工厂角色 
package designpatterns.factorymethod;

public class FileLoggerFactory implements LoggerFactory {
    @Override
    public Logger createLogger() {
        //创建文件日志记录器对象
        Logger logger = new FileLogger();
        //创建文件，代码省略
        return logger;
    }
}
Client：客户端测试类 
package designpatterns.factorymethod;

public class Client {
    public static void main(String[] args) {
        LoggerFactory factory;
        Logger logger;
        factory = new FileLoggerFactory();//可引入配置文件和反射机制实现
        logger = factory.createLogger();
        logger.writeLog();
    }
}

结果及分析

image

4.4 反射机制与配置文件

       在实际应用开发中可以对具体工厂类的实例化过程进行改进，在客户端代码中不直接使用new关键字来创建工厂对象,而是通过Java反射机制结合配置文件（例如XML文件）来生成具体工厂对象。在整个实现过程中需要用到两个技术，即Java反射机制与配置文件。

Java反射机制

       Java反射（Java Reflection） 是指在程序运行时获取已知名称的类或已有对象的相关信息的一种机制。
包括：

  • 方法
  • 属性
  • 父类
  • 实例的创建
  • 实例类型的判断
  • ...

在反射中使用最多的类是Class
Class类的实例表示正在运行的Java应用程序中的类和接口。

  • forName(String className)方法可以返回与带有给定字符串名的类或接口相关联的Class对象。
  • newInstance()方法创建此对象所表示的类的一个新实例。
//通过类名生成示例对象并将其返回
Class c = Class.forName("java.lang.String");
Object obj = c.newInstance();
return obj;

配置文件

软件系统的配置文件通常为XML文件，可以使用DOM （Document Object Model）、SAX （Simple API for XML）、StAX（Streaming API for XMIL）等技术来处理XMI文件。

<!--config.xml-->
<?xml version="1.0"?>
<config>
    <className>designpatterns.factorymethod.FileLoggerFactory</className>
</config>

XMLUtil：读取配置文件，通过存储其中的类名字字符串生成对象。

package designpatterns.factorymethod;

import javax.xml.parsers.*;

import org.w3c.dom.*;

import java.io.*;

public class XMLUtil {
    //该方法用于从XML配置文件中提取具体类的类名,并返回一个实例对象
    public static Object getBean() {
        try {
            //创建DOM文档对象
            DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = dFactory.newDocumentBuilder();
            Document doc;
            doc = builder.parse(new File("src//designpatterns//factorymethod//config.xml"));

            //获取包含类名的文本结点
            NodeList nl = doc.getElementsByTagName("className");
            Node classNode = nl.item(0).getFirstChild();
            String cName = classNode.getNodeValue();

            //通过类名生成实例对象并将其返回
            Class c = Class.forName(cName);
            Object obj = c.newInstance();
            return obj;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

测试：

package designpatterns.factorymethod;

public class Client {
    public static void main(String[] args) {
        LoggerFactory factory;
        Logger logger;
        factory = (LoggerFactory) XMLUtil.getBean(); //可引入配置文件和反射机制实现
        logger = factory.createLogger();
        logger.writeLog();
    }
}

在引入XMUtill和XML配置文件之后，增加一种新类型的日志记录方式：

  1. 新的日志记录器（xxxLogger implements Logger）；
  2. 新的具体日志记录器工厂（xxxLoggerFactory implements LoggerFactory）；
  3. 修改配置文件config.xml；
  4. 编译新增的具体日志记录器和具体日志记录工厂。

4.5 工厂方法的重载

image

LoggerFactory：

package designpatterns.factorymethod;

public interface LoggerFactory {
    public Logger createLogger();

    public Logger createLogger(String args);

    public Logger createLogger(Object obj);
}

DatabaseLoggerFactory：

package designpatterns.factorymethod;

public class DatabaseLoggerFactory implements LoggerFactory {
    @Override
    public Logger createLogger() {
        //连接数据库，代码省略
        //创建数据库日志记录器对象
        Logger logger = new DatabaseLogger();
        //初始化数据库日志记录器，代码省略
        return logger;
    }

    @Override
    public Logger createLogger(String args) {
        //使用参数args作为连接字符串来连接数据库，代码省略
        Logger logger = new DatabaseLogger();
        //初始化数据库日志记录器，代码省略
        return logger;
    }

    @Override
    public Logger createLogger(Object obj) {
        //使用封装在参数obj中的连接字符串来连接数据库，代码省略
        Logger logger = new DatabaseLogger();
        //初始化封装在参数obj中的数据来初始化数据库日志记录器，代码省略
        return logger;
    }
}

       在抽象工厂中声明了多个重载的工厂方法，在具体工厂中实现了这些工厂方法，这些方法可以包含不同的业务逻辑，以满足产品对象的多样化创建需求。

4.6 工厂方法的隐藏

       有时候，为了进一步简化客户端的使用，还可以对客户端隐藏工厂方法，此时在工厂类中直接调用产品类的业务方法，客户端无须调用工厂方法创建产品对象，直接使用工厂对象即可调用所创建的产品对象中的业务方法。
image
LoggerFactory：

package designpatterns.factorymethod;

public abstract class LoggerFactory {
    public void writeLog() {
        Logger logger = this.createLogger();
        logger.writeLog();
    }
    public abstract Logger createLogger();
}

Client：

package designpatterns.factorymethod;

public class Client {
    public static void main(String[] args) {
        LoggerFactory factory;
        factory = (LoggerFactory) XMLUtil.getBean();
        factory.writeLog();//直接使用工厂对象来调用产品对象的业务方法
    }
}

4.7 工厂方法模式优/缺点与适用环境

4.7.1 工厂方法模式优点

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

4.7.2 工厂方法模式缺点

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

4.7.3 工厂方法模式适用缓解

  1. 客户端不知道它所需要的对象的类。在工厂方法模式中,客户端不需要知道具体产品类的类名,只需要知道所对应的工厂即可，具体产品对象由具体工厂类创建，可将具体工厂类的类名存储在配置文件或数据库中。
  2. 抽象工厂类通过其子类来指定创建哪个对象。在工厂方法模式中，对于抽象工厂类只需要提供一个创建产品的接口，而由其子类来确定具体要创建的对象。利用面可对家的多态性和里氏代换原则，在程序运行时子类对象将覆盖父类对象，从而使得系统更容易扩展。
posted @ 2022-03-30 16:04  手持六脉神剑的外星人  阅读(54)  评论(0)  编辑  收藏  举报