工厂方法模式(JAVA反射)

工厂方法模式(JAVA反射)
简单工厂模式的不足

  在简单工厂模式中，只提供了一个工厂类，该工厂类处于对产品类进行实例化的中心位置，它知道每一个产品对象的创建细节，并决定何时实例化哪一个产品类。简单工厂模式最大的缺点是当有新产品要加入到系统中时，必须修改工厂类，加入必要的处理逻辑，这违背了“开闭原则”。在简单工厂模式中，所有的产品都是由同一个工厂创建，工厂类职责较重，业务逻辑较为复杂，具体产品与工厂类之间的耦合度高，严重影响了系统的灵活性和扩展性，而工厂方法模式则可以很好地解决这一问题。

模式动机

  考虑这样一个系统，按钮工厂类可以返回一个具体的按钮实例，如圆形按钮、矩形按钮、菱形按钮等。在这个系统中，如果需要增加一种新类型的按钮，如椭圆形按钮，那么除了增加一个新的具体产品类之外，还需要修改工厂类的代码，这就使得整个设计在一定程度上违反了“开闭原则”。

现在对该系统进行修改，不再设计一个按钮工厂类来统一负责所有产品的创建，而是将具体按钮的创建过程交给专门的工厂子类去完成，我们先定义一个抽象的按钮工厂类，再定义具体的工厂类来生成圆形按钮、矩形按钮、菱形按钮等，它们实现在抽象按钮工厂类中定义的方法。这种抽象化的结果使这种结构可以在不修改具体工厂类的情况下引进新的产品，如果出现新的按钮类型，只需要为这种新类型的按钮创建一个具体的工厂类就可以获得该新按钮的实例，这一特点无疑使得工厂方法模式具有超越简单工厂模式的优越性，更加符合“开闭原则”。

使用工厂方法模式设计的按钮工厂:

模式定义

  工厂方法模式(Factory Method Pattern)又称为工厂模式，也叫虚拟构造器(Virtual Constructor)模式或者多态工厂(Polymorphic Factory)模式，它属于类创建型模式。在工厂方法模式中，工厂父类负责定义创建产品对象的公共接口，而工厂子类则负责生成具体的产品对象，这样做的目的是将产品类的实例化操作延迟到工厂子类中完成，即通过工厂子类来确定究竟应该实例化哪一个具体产品类。

模式结构

工厂方法模式包含如下角色：

  • Product：抽象产品

  • ConcreteProduct：具体产品

  • Factory：抽象工厂

  • ConcreteFactory：具体工厂

模式分析

  工厂方法模式是简单工厂模式的进一步抽象和推广。由于使用了面向对象的多态性，工厂方法模式保持了简单工厂模式的优点，而且克服了它的缺点。在工厂方法模式中，核心的工厂类不再负责所有产品的创建，而是将具体创建工作交给子类去做。这个核心类仅仅负责给出具体工厂必须实现的接口，而不负责哪一个产品类被实例化这种细节，这使得工厂方法模式可以允许系统在不修改工厂角色的情况下引进新产品。

  当系统扩展需要添加新的产品对象时，仅仅需要添加一个具体产品对象以及一个具体工厂对象，原有工厂对象不需要进行任何修改，也不需要修改客户端，很好地符合了“开闭原则”。而简单工厂模式在添加新产品对象后不得不修改工厂方法，扩展性不好。工厂方法模式退化后可以演变成简单工厂模式。

抽象工厂类代码：
```
1 public abstract class PayMethodFactory
2 {
3     public abstract AbstractPay getPayMethod();
4 }
```
具体工厂类代码：
```
1 public class CashPayFactory extends PayMethodFactory
2 {
3     public AbstractPay getPayMethod()
4     {
5         return new CashPay();
6     }
7 } 
```
客户类代码片段：
```
1 PayMethodFactory factory;
2 AbstractPay payMethod;
3 factory=new CashPayFactory();
4 payMethod =factory.getPayMethod();
5 payMethod.pay(); 
```
为了提高系统的可扩展性和灵活性，在定义工厂和产品时都必须使用抽象层，如果需要更换产品类，只需要更换对应的工厂即可，其他代码不需要进行任何修改。

配置文件代码：

• 在实际的应用开发中，一般将具体工厂类的实例化过程进行改进，不直接使用new关键字来创建对象，而是将具体类的类名写入配置文件中，再通过Java的反射机制，读取XML格式的配置文件，根据存储在XML文件中的类名字符串生成对象。
```
1 <?xml version="1.0"?>
2 <config>
3   <className>CashPayFactory</className>
4 </config>
```
Java反射(Java Reflection)：

• 是指在程序运行时获取已知名称的类或已有对象的相关信息的一种机制，包括类的方法、属性、超类等信息，还包括实例的创建和实例类型的判断等。可通过Class类的forName()方法返回与带有给定字符串名的类或接口相关联的Class对象，再通过newInstance()方法创建此对象所表示的类的一个新实例，即通过一个类名字符串得到类的实例。
```
1 //创建一个字符串类型的对象
2 Class c = Class.forName(“String”);
3 Object obj = c.newInstance();
4 return obj;
```
工具类XMLUtil代码片段：
```
 1 //创建DOM文档对象
 2 DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();
 3 DocumentBuilder builder = dFactory.newDocumentBuilder();
 4 Document doc;                            
 5 doc = builder.parse(new File("config.xml")); 
 6 
 7 //获取包含类名的文本节点
 8 NodeList nl = doc.getElementsByTagName("className");
 9 Node classNode=nl.item(0).getFirstChild();
10 String cName=classNode.getNodeValue();
11             
12  //通过类名生成实例对象并将其返回
13 Class c=Class.forName(cName);
14 Object obj=c.newInstance();
15 return obj;
```
模式实例与解析

实例一：电视机工厂

• 将原有的工厂进行分割，为每种品牌的电视机提供一个子工厂，海尔工厂专门负责生产海尔电视机，海信工厂专门负责生产海信电视机，如果需要生产TCL电视机或创维电视机，只需要对应增加一个新的TCL工厂或创维工厂即可，原有的工厂无须做任何修改，使得整个系统具有更加的灵活性和可扩展性。

实例代码(JAVA):
```
  1 //抽象产品类 TV
  2 public interface TV
  3 {
  4     public void play();
  5 }
  6 
  7 //具体产品类 HaierTV
  8 public class HaierTV implements TV
  9 {
 10     public void play()
 11     {
 12         System.out.println("海尔电视机播放中......");
 13     }
 14 }
 15 
 16 //具体产品类 HisenseTV
 17 public class HisenseTV implements TV
 18 {
 19     public void play()
 20     {
 21         System.out.println("海信电视机播放中......");
 22     }    
 23 }
 24 
 25 //抽象工厂类 TVFactory
 26 public interface TVFactory
 27 {
 28     public TV produceTV();
 29 }
 30 
 31 //具体工厂类 HaierTVFactory
 32 public class HaierTVFactory implements TVFactory
 33 {
 34     public TV produceTV()
 35     {
 36         System.out.println("海尔电视机工厂生产海尔电视机...");
 37         return new HaierTV();
 38     }
 39 }
 40 
 41 //具体工厂类 HisenseTVFactory
 42 public class HisenseTVFactory implements TVFactory
 43 {
 44     public TV produceTV()
 45     {
 46         System.out.println("海信电视机工厂生产海信电视机...");
 47         return new HisenseTV();
 48     }
 49 }
 50 
 51 //配置文件 config.xml
 52 <?xml version="1.0"?>
 53 <config>
 54     <className>HisenseTVFactory</className>
 55 </config>
 56 
 57 //通过反射获得具体工厂的实例 XMLUtil
 58 import javax.xml.parsers.*;
 59 import org.w3c.dom.*;
 60 import org.xml.sax.SAXException;
 61 import java.io.*;
 62 public class XMLUtil
 63 {
 64 //该方法用于从XML配置文件中提取具体类类名，并返回一个实例对象
 65     public static Object getBean()
 66     {
 67         try
 68         {
 69             //创建文档对象
 70             DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();
 71             DocumentBuilder builder = dFactory.newDocumentBuilder();
 72             Document doc;                            
 73             doc = builder.parse(new File("config.xml")); 
 74         
 75             //获取包含类名的文本节点
 76             NodeList nl = doc.getElementsByTagName("className");
 77             Node classNode=nl.item(0).getFirstChild();
 78             String cName=classNode.getNodeValue();
 79             
 80             //通过类名生成实例对象并将其返回
 81             Class c=Class.forName(cName);
 82               Object obj=c.newInstance();
 83             return obj;
 84            }   
 85                catch(Exception e)
 86                {
 87                    e.printStackTrace();
 88                    return null;
 89                }
 90         }
 91 }
 92 
 93 //客户端 Client
 94 public class Client
 95 {
 96     public static void main(String args[])
 97     {
 98          try
 99          {
100              TV tv;
101              TVFactory factory;
102              factory=(TVFactory)XMLUtil.getBean();
103              tv=factory.produceTV();
104              tv.play();
105          }
106          catch(Exception e)
107          {
108              System.out.println(e.getMessage());
109          }
110     }
111 }
```
实例代码(C++):
```
 1 // 工厂方法模式
 2 #include <iostream>
 3 using namespace std;
 4 
 5 //抽象产品TV
 6 class TV
 7 {
 8 public:
 9     virtual void play() = 0;
10 };
11 
12 //具体产品类 HaierTV
13 class HaierTV:public TV
14 {
15 public:
16     void play() override
17     {
18         cout << "海尔电视机播放中..." << endl;
19     }
20 };
21 
22 //具体产品类HisenseTV
23 class HisenseTV:public TV
24 {
25 public:
26     void play() override
27     {
28         cout << "海信电视机播放中..." << endl;
29     }
30 };
31 
32 //抽象工厂类 TVFactory
33 class TVFactory
34 {
35 public:
36     virtual TV* productTV() = 0;
37 };
38 
39 //具体工厂类 HaierTVFactory
40 class HaierTVFactory:public TVFactory
41 {
42 public:
43     TV* productTV() override
44     {
45         cout << "海尔工厂生产海尔电视机..." << endl;
46         return new HaierTV();
47     }
48 };
49 
50 //具体工厂类 HisenseTVFactory
51 class HisenseTVFactory:public TVFactory
52 {
53 public:
54     TV* productTV() override
55     {
56         cout << "海信工厂生产海信电视机..." << endl;
57         return new HisenseTV();
58     }
59 };
60 
61 //客户端
62 int main()
63 {
64     TV* tv = nullptr;
65     TVFactory* factory = nullptr;
66     factory = new HaierTVFactory();
67     tv = factory->productTV();
68     tv->play();
69     factory = new HisenseTVFactory();
70     tv = factory->productTV();
71     tv->play();
72     return 0;
73 }
```
运行结果:

模式优缺点

优点

  • 在工厂方法模式中，工厂方法用来创建客户所需要的产品，同时还向客户隐藏了哪种具体产品类将被实例化这一细节，用户只需要关心所需产品对应的工厂，无须关心创建细节，甚至无须知道具体产品类的类名。

  • 基于工厂角色和产品角色的多态性设计是工厂方法模式的关键。它能够使工厂可以自主确定创建何种产品对象，而如何创建这个对象的细节则完全封装在具体工厂内部。工厂方法模式之所以又被称为多态工厂模式，是因为所有的具体工厂类都具有同一抽象父类。

  • 使用工厂方法模式的另一个优点是在系统中加入新产品时，无须修改抽象工厂和抽象产品提供的接口，无须修改客户端，也无须修改其他的具体工厂和具体产品，而只要添加一个具体工厂和具体产品就可以了。这样，系统的可扩展性也就变得非常好，完全符合“开闭原则”。

缺点

  • 在添加新产品时，需要编写新的具体产品类，而且还要提供与之对应的具体工厂类，系统中类的个数将成对增加，在一定程度上增加了系统的复杂度，有更多的类需要编译和运行，会给系统带来一些额外的开销。

  • 由于考虑到系统的可扩展性，需要引入抽象层，在客户端代码中均使用抽象层进行定义，增加了系统的抽象性和理解难度，且在实现时可能需要用到DOM、反射等技术，增加了系统的实现难度。

模式适用环境

在以下情况下可以使用工厂方法模式：

  • 一个类不知道它所需要的对象的类：在工厂方法模式中，客户端不需要知道具体产品类的类名，只需要知道所对应的工厂即可，具体的产品对象由具体工厂类创建；客户端需要知道创建具体产品的工厂类。

  • 一个类通过其子类来指定创建哪个对象：在工厂方法模式中，对于抽象工厂类只需要提供一个创建产品的接口，而由其子类来确定具体要创建的对象，利用面向对象的多态性和里氏代换原则，在程序运行时，子类对象将覆盖父类对象，从而使得系统更容易扩展。

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

模式应用

(1) java.util.Collection接口的iterator()方法：

(2) Java消息服务JMS(Java Messaging Service) ：
```
 1 //使用上下文和JNDI得到连接工厂的引用，ctx是上下文Context类型的对象
 2 QueueConnectionFactory qConnFact=(QueueConnectionFactory)ctx.lookup("cfJndi");
 3 //使用连接工厂创建一个连接
 4 QueueConnection qConn=qConnFact.createQueueConnection();
 5 //使用连接创建一个会话
 6 QueueSession qSess=qConn.createQueueSession(false,javax.jms.QueueSession. AUTO_ACKNOWLEDGE);
 7 //使用上下文和JNDI得到消息队列的引用
 8 Queue q=(Queue)ctx.lookup("myQueue");
 9 //使用连接创建一个需要发送的消息类型的实例
10 QueueSender qSend=qSess.createSender(q);
11 System.out.println("开始发送消息......");
```
(3) JDBC中的工厂方法：
```
1 Connection conn=DriverManager.getConnection("jdbc:microsoft:sqlserver://localhost:1433; DatabaseName=DB;user=sa;password=");
2 Statement statement=conn.createStatement();
3 ResultSet rs=statement.executeQuery("select * from UserInfo");
```
模式扩展

  使用多个工厂方法：在抽象工厂角色中可以定义多个工厂方法，从而使具体工厂角色实现这些不同的工厂方法，这些方法可以包含不同的业务逻辑，以满足对不同的产品对象的需求。

  产品对象的重复使用：工厂对象将已经创建过的产品保存到一个集合（如数组、List等）中，然后根据客户对产品的请求，对集合进行查询。如果有满足要求的产品对象，就直接将该产品返回客户端；如果集合中没有这样的产品对象，那么就创建一个新的满足要求的产品对象，然后将这个对象在增加到集合中，再返回给客户端。

  多态性的丧失和模式的退化：如果工厂仅仅返回一个具体产品对象，便违背了工厂方法的用意，发生退化，此时就不再是工厂方法模式了。一般来说，工厂对象应当有一个抽象的父类型，如果工厂等级结构中只有一个具体工厂类的话，抽象工厂就可以省略，也将发生了退化。当只有一个具体工厂，在具体工厂中可以创建所有的产品对象，并且工厂方法设计为静态方法时，工厂方法模式就退化成简单工厂模式。
相关阅读:
常用验证函数isset()/empty()/is_numeric()函数
 jquery select取option的value值发生变化事件
 （转）浅谈HTML5与css3画饼图！
文本框输入值文字消失常用的两种方法
 简洁的滚动代码（上下滚动）
（转）PHP的语言结构和函数的区别
 兼容ie7的导航下拉菜单
 jquery中each()函数
 tomcat源码导入eclipse
weblogic linux环境下新建domain
原文地址：https://www.cnblogs.com/WindSun/p/10252800.html

工厂方法模式(JAVA反射)

模式动机

模式定义

模式结构

模式分析

模式实例与解析

模式优缺点

模式适用环境

模式应用

模式扩展