2. 工厂模式

工厂模式（使用频率：★★★★★）

简单工厂方法代码：

class LoggerFactory {
//静态工厂方法
public static Logger createLogger(String args) {
if(args.equalsIgnoreCase("db")) {
//连接数据库，代码省略
//创建数据库日志记录器对象
Logger logger = new DatabaseLogger();
//初始化数据库日志记录器，代码省略
return logger;
}
else if(args.equalsIgnoreCase("file")) {
//创建日志文件
//创建文件日志记录器对象
Logger logger = new FileLogger();
//初始化文件日志记录器，代码省略
return logger;
}
else {
return null;
}
}
}

虽然简单工厂模式实现了对象的创建和使用分离，但是仍然存在如下两个问题：

(1) 工厂类过于庞大，包含了大量的if…else…代码，导致维护和测试难度增大；

(2) 系统扩展不灵活，如果增加新类型的日志记录器，必须修改静态工厂方法的业务逻辑，违 反了“开闭原则”。

(3) ，在简单工厂模式中，所有的产品都由同一个工厂创建，工厂类职 责较重，业务逻辑较为复杂，具体产品与工厂类之间的耦合度高，严重影响了系统的灵活性 和扩展性，

而工厂方法模式则可以很好地解决这一问题。

1. 工厂方法模式概述（一个具体工厂对应一个具体产品）

在工厂方法模式中，我们不再提供一个统一的工厂类来创建所有的产品对象，而是针对不同 的产品提供不同的工厂，系统提供一个与产品等级结构对应的工厂等级结构。工厂方法模式 定义如下：

工厂方法模式(Factory Method Pattern)：定义一个用于创建对象的接口，让子类决定将哪一个 类实例化。工厂方法模式让一个类的实例化延迟到其子类。工厂方法模式又简称为工厂模式 (Factory Pattern)，又可称作虚拟构造器模式(Virtual Constructor Pattern)或多态工厂模式 (Polymorphic Factory Pattern)。工厂方法模式是一种类创建型模式。

工厂方法模式提供一个抽象工厂接口来声明抽象工厂方法，而由其子类来具体实现工厂方 法，创建具体的产品对象。

2. 工厂方法的角色

1. Product（抽象产品）
2. ConcreteProduct（具体产品）
3. Factory（抽象工厂）
4. ConcreteFactory（具体工厂）

典型抽象工厂代码

public interface Factory {
    public Product factoryMethod();
}

典型具体工厂

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

典型客户端代码

……
Factory factory;
factory = new ConcreteFactory(); //可通过配置文件和反射机制实现
Product product;
product = factory.factoryMethod();
……

通过抽象工厂赋值为具体工厂，再由具体工厂创建具体产品

3. 工厂方法例子

在未使用配置文件和反射机制之前，更换具体工厂类需修改客户端源代码，但无须修改类库代码

4. 配置文件

纯文本文件，例如XML文件，properties文件……等

通常是XML文件，可以将类名存储在配置文件中，例如具体工厂类的类名

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

xml读取

package designpatterns.factorymethod;

//XMLUtil.java
import javax.xml.parsers.*;
import org.w3c.dom.*;
import org.xml.sax.SAXException;
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(); //getBean()的返回类型为Object，需要进行强制类型转换
    logger = factory.createLogger();
    logger.writeLog();
    }
}

5. 增加新产品的步骤

增加新产品的步骤

(1) 增加一个新的具体产品类作为抽象产品类的子类

(2) 增加一个新的具体工厂类作为抽象工厂类的子类，该工厂用于创建新增的具体产品对象

(3) 修改配置文件，用新的具体工厂类的类名字符串替换原有工厂类类名字符串

(4) 编译新增具体产品类和具体工厂类，运行客户端代码，即可完成新产品的增加和使用

6. 工厂方法的重载

抽象工厂代码

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

public class DatabaseLoggerFactory implements LoggerFactory {
                   public Logger createLogger() {
	    //使用默认方式连接数据库，代码省略
	    Logger logger = new DatabaseLogger(); 
	    //初始化数据库日志记录器，代码省略
	    return logger;
	}

	 public Logger createLogger(String args) {
	    //使用参数args作为连接字符串来连接数据库，代码省略
	    Logger logger = new DatabaseLogger(); 
	    //初始化数据库日志记录器，代码省略
	    return logger;
	}
	
	 public Logger createLogger(Object obj) {
	    //使用封装在参数obj中的连接字符串来连接数据库，代码省略
	    Logger logger = new DatabaseLogger(); 
	    //使用封装在参数obj中的数据来初始化数据库日志记录器，代码省略
	    return logger;
	}	
}
//其他具体工厂类代码省略

7. 工厂方法的隐藏

目的：为了进一步简化客户端的使用

实现：在工厂类中直接调用产品类的业务方法，客户端无须调用工厂方法创建产品对象，直接使用工厂对象即可调用所创建的产品对象中的业务方法

抽象工厂类LoggerFactory示意代码：

//将接口改为抽象类
public abstract class LoggerFactory {
    //在工厂类中直接调用日志记录器类的业务方法writeLog()
    public void writeLog() {
        Logger logger = this.createLogger();
        logger.writeLog();
    }
	
    public abstract Logger createLogger();	
}

客户端代码

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

工厂方法优缺点

1. 模式优点

   • 工厂方法用来创建客户所需要的产品，同时还向客户隐藏了哪种具体产品类将被实例化这一细节
   • 能够让工厂自主确定创建何种产品对象，而如何创建这个对象的细节则完全封装在具体工厂内部
   • 在系统中加入新产品时，完全符合开闭原则

2. 缺点

   • 系统中类的个数将成对增加，在一定程度上增加了系统的复杂度，会给系统带来一些额外的开销

   • 增加了系统的抽象性和理解难度

使用工厂对象来调用产品对象的业务方法
}
}

# 工厂方法优缺点

1. 模式优点

   * 工厂方法用来创建客户所需要的产品，同时还向客户隐藏了哪种具体产品类将被实例化这一细节
   * 能够让工厂自主确定创建何种产品对象，而如何创建这个对象的细节则完全封装在具体工厂内部
   * 在系统中加入新产品时，完全符合开闭原则

2. 缺点

   * 系统中类的个数将成对增加，在一定程度上增加了系统的复杂度，会给系统带来一些额外的开销

   * 增加了系统的抽象性和理解难度