Factory Method Pattern

Factory Method Pattern

 

        factory method pattern 是一种对象创建型模式，通常用于将对象的创建与使用进行解耦，使得对象的使用方式不依赖对象的创建方式。下面使用一个日志应用说明factory method pattern 。

 

        日志应用是软件系统中比较常见一种功能，实现该功能也比较简单，例如：

public class Logger { public static void log(String logMessage) { System.out.println(logMessage); } public static void main(String[] args) { Logger.log("console log message"); } } 

        以上代码实现了一个简单的控制台日志功能，怎么样实现一个控制台日志应用够简单吧！ ：）大牛们多多包含！

 

        以上日志实现是非常简单的，但是真实环境下日志应用不是如此的简单，应用可能要求想多种消息接受目标系统发送日志消息，例如，文件系统、数据库系统或者只是简单的抛弃该日志消息，就像是消息发送到linux下的/dev/null设备文件一样。这种时候一种简单的常规的实现如下：

package cn.ak4fyou.factorymethodpattern; import java.io.FileWriter; import java.io.Writer; import java.util.LinkedHashMap; import java.util.Map; public class Logger { public static final int FILE_LOG = 0; public static final int DATABASE_LOG = 1; public static final int NULL_LOG = 2; private static LogDatabase logDatabase = new LogDatabase(); private static String fileName = "log.txt"; //将日志消息写入文件中， private static void writeFileLog(String message) { try { Writer writer = new FileWriter(fileName,true); writer.write(message+ "/n"); writer.close(); } catch (Exception ex) { ex.printStackTrace(); } } //将日志消息写入数据库中 private static void writeDatabaseLog(String message) { logDatabase.insert(message); } //简单的丢弃该消息 private static void writeNullLog(String message) { //nothing } public static void Log(int type,String message) { switch(type) { case FILE_LOG: writeFileLog(message); break; case DATABASE_LOG: writeDatabaseLog(message); break; case NULL_LOG: writeNullLog(message); break; default: break; } } //模拟数据库 static class LogDatabase { private Map<Integer,LogDataUnit> database = new LinkedHashMap<Integer,LogDataUnit>(); private int count; public void insert(String message) { database.put(count++,new LogDataUnit(message)); } } static class LogDataUnit { private String message; LogDataUnit(String message) { this.message = message ; } public String getMessage() { return message; } } }

package cn.ak4fyou.factorymethodpattern; public class LoggerTester { public static void main(String[] args) { Logger.Log(Logger.FILE_LOG, "Logger Tester Log"); Logger.Log(Logger.DATABASE_LOG, "Logger Tester Log"); Logger.Log(Logger.NULL_LOG, "Logger Tester Log"); } }

该代码实现了想多种消息接受目标系统发送日志消息 ，似乎该日志应用非常之强啊。但是我们来想一想下面2个问题：

• 如果以后增减新的消息接受目标系统是该怎么做？
• 如果应用初期系统中的日志消息都是发送到文件系统，现在要求发送到数据库，对系统有什么影响？

      在回答以上两个问题之前，我们先来看看增加一个控制台日志应用，Logger类有什么变化。

package cn.ak4fyou.factorymethodpattern; import java.io.FileWriter; import java.io.Writer; import java.util.LinkedHashMap; import java.util.Map; public class Logger { public static final int FILE_LOG = 0; public static final int DATABASE_LOG = 1; public static final int NULL_LOG = 2; public static final int CONSOLE_LOG = 3; private static LogDatabase logDatabase = new LogDatabase(); private static String fileName = "log.txt"; //将日志消息写入文件中， private static void writeFileLog(String message) { try { Writer writer = new FileWriter(fileName,true); writer.write(message+ "/n"); writer.close(); } catch (Exception ex) { ex.printStackTrace(); } } //将日志消息写入数据库中 private static void writeDatabaseLog(String message) { logDatabase.insert(message); } //简单的丢弃该消息 private static void writeNullLog(String message) { //nothing } //将日志消息打印到控制台 private static void writeConsoleLog(String message) { System.out.println(message); } public static void Log(int type,String message) { switch(type) { case FILE_LOG: writeFileLog(message); break; case DATABASE_LOG: writeDatabaseLog(message); break; case NULL_LOG: writeNullLog(message); break; case CONSOLE_LOG: writeConsoleLog(message); break; default: break; } } //模拟数据库 static class LogDatabase { private Map<Integer,LogDataUnit> database = new LinkedHashMap<Integer,LogDataUnit>(); private int count; public void insert(String message) { database.put(count++,new LogDataUnit(message)); } } static class LogDataUnit { private String message; LogDataUnit(String message) { this.message = message ; } public String getMessage() { return message; } } }  

 

      在添加控制台日志应用之后，我们可以发现代码中有三处被修改了，其一是添加了常用CONSOLE_LOG，其二是增减了一个方法writeConsoleLog,其三是修改了log方法中的switch语句。

 

      现在我们回答第一个问题，为了增加一个消息接受目标系统，我们改动了Logger类的三处代码，这样有什么问题呢？如果我们需要在怎么一个将日志消息发送到远程日志服务器，那么对Logger作出相似的改动，此时存在以下2个问题：

 

• 违背了开闭原则。
• 产生大量相似代码。

   现在我们来回答第二个问题，显然如果修改代码就违背了开闭原则，其次需要修改代码就是存在变化，而这个变化将引起系统内多个部分被修改，因该被封装起来。

 

      吼！！！，怎么办呢？ 别急！！！，有了问题才好啊，求助超人！！！超人也不行啊，哈哈这个是后就得GOF来帮忙了，

 

模式名：factory method pattern

   意图：定义一个用户创建对象的接口，让子类决定实例化哪一个类。Factory Method使一个类的实例化延迟到其子类 。

结构图：

 

 

 

 

      现在，我们用factory method pattern 对Logger类进行重构。

 

      首先，既然为了添加新的消息接受系统，需要添加相似的代码，那么就可以将相似的代码提取出来形成一个继承体系结构。结构图如下：

 

 

package cn.ak4fyou.factorymethodpattern; public interface Log { public void log(String message); }package cn.ak4fyou.factorymethodpattern; public interface Log { public void log(String message); } 

 

package cn.ak4fyou.factorymethodpattern; import java.io.FileWriter; import java.io.Writer; public class FileSystemLog implements Log { private String fileName = "log.txt"; public FileSystemLog() { } public void log(String message) { try { Writer writer = new FileWriter(fileName,true); writer.write(message+ "/n"); writer.close(); } catch (Exception ex) { ex.printStackTrace(); } } }  

 

package cn.ak4fyou.factorymethodpattern; import java.util.LinkedHashMap; import java.util.Map; public class DatabaseLog implements Log { private LogDatabase database = new LogDatabase(); public DatabaseLog() { } public void log(String message) { database.insert(message); } //模拟数据库 static class LogDatabase { private Map<Integer,LogDataUnit> database = new LinkedHashMap<Integer,LogDataUnit>(); private int count; public void insert(String message) { database.put(count++,new LogDataUnit(message)); } } static class LogDataUnit { private String message; LogDataUnit(String message) { this.message = message ; } public String getMessage() { return message; } } }  

 

package cn.ak4fyou.factorymethodpattern; public class NullLog implements Log { public NullLog() { } public void log(String message) { } }  

 

      完成以上工作，我们来看看，怎样使用这些类：

 

 

package cn.ak4fyou.factorymethodpattern; public class LogTester { public static void main(String[] args) { Log logFS = new FileSystemLog(); logFS.log("File System Log"); Log logDB = new DatabaseLog(); logDB.log("Database Log"); Log logN = new NullLog(); logN.log("Null Log"); } } 

 

       由以上代码可以看出，虽然我们提取一个继承结构出来，但是还没能够消除违背开闭原则的问题，因为如果我们要在不同的接受系统之间替换时，就不可避免的要修改代码。那么要怎样消除这些问题呢？以上代码，我们使用的只是factory method pattern的一部分，也就是“Prohuct”部分，要想解决以上问题，我们必须将对象的创建和使用解耦。使得对象的使用不依赖于其创建。因此我们需要对对象的创建过程进行抽象，使得对象的使用和创建分离。由此我们的得到完整的结构图。

 

 

 

下面我们来看看具体实现：

package cn.ak4fyou.factorymethodpattern; public interface LogFactory { public Log create(); } 

 

package cn.ak4fyou.factorymethodpattern; public class NullLogFactory implements LogFactory { public Log create() { return new NullLog(); } }  

 

package cn.ak4fyou.factorymethodpattern; public class FileSystemLogFactory implements LogFactory { public Log create() { return new FileSystemLog(); } } 

 

package cn.ak4fyou.factorymethodpattern; public class DataBaseLogFactory implements LogFactory { public Log create() { return new DatabaseLog(); } } 

 

       我们来看一下怎么使用这些类：

 

package cn.ak4fyou.factorymethodpattern; public class LogFactoryTester { public static void main(String[] args) { LogFactory logFactoryFS = new FileSystemLogFactory(); Log logFS = logFactoryFS.create(); logFS.log("File System Log"); } } 

 

      咋一看！好像跟LogTester类没有太大的区别，反而怎家代码的复杂度，引入LogFactory的主要目的是将对象的创建过程使得对象的使用与创建分离，来达到解耦的目的。但是解耦的目的达到了，代码也没有违背开闭原则，需要增加新的日志消息接受系统，是要实现Log和LogFactory接口就可以了。但是我们的代码如要在多个日志消息接受系统之间替换的话，就不免要修改代码，这种修改或许是大量的，也是不可忍受的。这也是factory method pattern 的缺点。怎么样来避免这种缺点呢？

 

      我们将使用java反射来解决factory method pattern 引入的新的依赖问题。在Log应用中引入一个config.properties文件，在其中加入

LogTargetSystemClass 属性。修改LogFacotry的实现，如一下结构图所示：

 

 

 

代码实现如下：

 

 

package cn.ak4fyou.factorymethodpattern; import java.io.FileInputStream; import java.io.IOException; import java.io.InputStream; import java.util.Properties; public abstract class LogFactory { private static LogFactory instance ; private static String logFactoryClass; private static Object synObject; static { InputStream fin = null; try { fin = new FileInputStream("config.properties file path"); Properties pro = new Properties(); pro.load(fin); logFactoryClass = pro.getProperty("LogTargetSystemClass"); } catch (Exception ex) { ex.printStackTrace(); } finally { try { fin.close(); } catch (IOException ex) { ex.printStackTrace(); } } } public static LogFactory getInstance() { if(instance == null) { synchronized(synObject) { if(instance == null) { try { instance = (LogFactory) Class.forName(logFactoryClass).newInstance(); } catch (Exception ex) { ex.printStackTrace(); } } } } return instance; } public abstract Log create(); } 

 

对LogFactory作出更改以后，我们完美地解决了最后的依赖问题，现在如果在应用中使用我们的日志应用，将是非常爽的。完全可重用，可扩展的日志系统哦，yes！！！