设计模式-工厂方法

工厂方法模式

简单工厂的不足

上节的简单工厂，需要拓展时比如修改工厂类，违背了设计模式的开闭原则
简单工厂类直接生成各个子类产品，而工厂方法则有一个抽象工厂类，声明了创建产品的工厂方法，而各个不同的子类产品交由各个不同的具体工厂去完成创建，拓展时，只需要新建一个具体工厂即可，具有更好的灵活性和拓展性
在工厂方法模式中，存在4个角色：

• 抽象产品
  
• 具体产品
  
• 抽象工厂
  声明了创建产品的抽象方法，返回抽象产品，由具体工厂去实现创建具体产品的方法
  
• 具体工厂
  实现创建产品的抽象方法，创建并返回某一种具体产品
  

工厂方法模式下的多日志工厂

Log(抽象产品)

抽象Log声明了一个记录日志的方法

1. package com.example.fxfactory.model;
3. import java.io.IOException;
5. public abstract class Log {
7.     public abstract void doLog() throws IOException;
8. }

复制代码

ConsoleLog(具体产品)

Log的具体类，控制台日志，它将doLog重写为在控制台打印日志信息

1. package com.example.fxfactory.model;
3. import java.text.SimpleDateFormat;
4. import java.util.Date;
6. public class ConsoleLog extends Log{
7.     @Override
8.     public void doLog() {
9.         Date date = new Date();
10.         SimpleDateFormat pattern = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
11.         String str = pattern.format(date) + "  console log";
12.         System.out.println(str);
13.     }
14. }

复制代码

FileLog(具体产品)

Log的另一个具体类，文件日志，它将doLog重写为记录日志到filelog.txt文件中去

1. package com.example.fxfactory.model;
3. import java.io.File;
4. import java.io.FileWriter;
5. import java.io.IOException;
6. import java.text.SimpleDateFormat;
7. import java.util.Date;
9. public class FileLog extends Log {
10.     @Override
11.     public void doLog() throws IOException {
12.         File dir = new File("./log");
13.         if (!dir.exists()) {
14.             dir.mkdirs();
15.         }
17.         File checkFile = new File("./log","filelog.txt");
18.         FileWriter writer = null;
19.         try {
20.             if (!checkFile.exists()) {
21.                 checkFile.createNewFile();
22.             }
23.             writer = new FileWriter(checkFile, true);
24.             Date date = new Date();
25.             SimpleDateFormat pattern = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
26.             String str = pattern.format(date) + "  file log";
28.             writer.append(str);
29.             writer.flush();
30.         } catch (IOException e) {
31.             e.printStackTrace();
32.         } finally {
33.             if (null != writer)
34.                 writer.close();
35.         }
36.     }
37. }

复制代码

LogFactory(抽象工厂)

抽象的日志工厂，声明了一个创建日志的方法，返回类型为抽象的日志

1. package com.example.fxfactory.factory;
3. import com.example.fxfactory.model.Log;
5. public abstract class LogFactory {
7.     public abstract Log createLog();
8. }

复制代码

ConsoleLogFactory(具体工厂)

控制台日志工厂，重写创建日志方法，返回一个控制台日志实例

1. package com.example.fxfactory.factory;
3. import com.example.fxfactory.model.ConsoleLog;
4. import com.example.fxfactory.model.Log;
6. public class ConsoleLogFactory extends LogFactory {
7.     @Override
8.     public Log createLog() {
9.         return new ConsoleLog();
10.     }
11. }

复制代码

FileLogFactory(具体工厂)

文件日志工厂，重写创建日志方法，返回一个文件日志实例

1. package com.example.fxfactory.factory;
3. import com.example.fxfactory.model.FileLog;
4. import com.example.fxfactory.model.Log;
6. public class FileLogFactory extends LogFactory {
7.     @Override
8.     public Log createLog() {
9.         return new FileLog();
10.     }
11. }

复制代码

测试

Main.java

1. package com.example.fxfactory;
3. import com.example.fxfactory.factory.ConsoleLogFactory;
4. import com.example.fxfactory.factory.FileLogFactory;
5. import com.example.fxfactory.factory.LogFactory;
6. import com.example.fxfactory.model.Log;
8. import java.io.IOException;
10. public class Main {
12.     public static void main(String[] args) throws IOException {
13.         LogFactory logFactory = new ConsoleLogFactory();
14.         Log consoleLog = logFactory.createLog();
15.         consoleLog.doLog();
17.         logFactory = new FileLogFactory();
18.         Log fileLog = logFactory.createLog();
19.         fileLog.doLog();
20.     }
21. }

复制代码

看起来，我们似乎并不需要LogFactory，直接创建2个不同的具体Factory不也行吗？那我们尝试换一种写法:
空工厂

抽象工厂换为一个空工厂，createLog方法返回null，新增一个切换到具体工厂的方法，接收具体工厂名，将自己变为指定的具体工厂

1. package com.example.fxfactory.factory;
3. import com.example.fxfactory.model.Log;
5. public class LogFactory {
7.     public LogFactory siwtch(String logType){
8.         switch (logType){
9.             case "console":{
10.                 return new ConsoleLogFactory();
11.             }
12.             case "file":{
13.                 return new FileLogFactory();
14.             }
15.             default:{
16.                 return this;
17.             }
18.         }
19.     }
21.     public Log createLog(){
22.         return null;
23.     }
24. }

复制代码

测试

Main.java

1. LogFactory logFactory = new LogFactory();
2.         logFactory = logFactory.siwtch("console");
3.         Log consoleLog = logFactory.createLog();
4.         consoleLog.doLog();
6.         logFactory = logFactory.siwtch("file");
7.         Log fileLog = logFactory.createLog();
8.         fileLog.doLog();

复制代码

现在我们不需要知道具体工厂类了，只需要知道用于指定它们的名字就行。不过要拓展新的具体工厂，还需要维护空工厂的switch方法
总结

工厂方法的优点

★ 客户无须关心生成细节和具体产品的类名
★ 良好的多态性：创建细节完全封装在具体工厂内
★ 易拓展性：无须修改抽象工厂，新增基于抽象工厂的新具体工厂类即可
工厂方法的缺点

★ 新产品和新具体工厂成对，一定程度上增加了系统复杂性
★ 双重抽象(产品和工厂)，一定程度上增加了系统的抽象性和理解难度

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！