Android设计模式—工厂模式

亦凉 2022-09-11 06:17 135阅读 0赞

工厂模式是一种创建者模式，是我们常用的模式之一，多用于需要生成复杂对象的地方。理论来说在任何使用A a = new A()的方式都可以使用工厂模式，虽然使用工厂模式可能需要多做一些工作，但是在后续的开发和维护都带来了方便。  
工厂模式降低了对象之间的耦合度，由于工厂模式依赖抽象的架构，实例化的任务交由子类去完成，所以有很好的扩展性。

工厂模式分为三类：  
①简单工厂模式  
②工厂方法模式  
③抽象工厂模式

三者之间的区别：  
①简单工厂模式只有一个工厂类、一个抽象产品类和多个具体产品类。在工厂类中生成各个具体产品。  
②工厂方法模式有一个抽象工厂类，派生出可以生产多种产品的工厂类；有一个抽象产品类，派生出多种具体的产品；一个工厂负责生产一种具体的产品。  
③工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。

1.简单工厂模式  
简单工厂模式，一个具体工厂类负责生产所有的具体产品。客户端只需要关注生成的具体产品。  
![简单工厂模式的uml图][uml]

*  Factory : 负责生产具体的产品工厂
 *  Product: 抽象的产品类
 *  P1: 具体的产品类P1
 *  P2: 具体的产品类P2

举个例子。  
汽车工厂造汽车的例子。  
比如你在大众厂里面上班，一开始被分配到了上海大众里面去了，只管Passat和polo两款车型，而且做的事很简单，就是简单开出去测试一下车子的性能。这个时候事务较少，用简单工厂就能搞定了。  
package图如下：  
![简单工厂模式][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3plbm1lbGEyMDEx_size_16_color_FFFFFF_t_70]

*  Volkswagen:抽象的大众汽车类
 *  Passat，Polo:具体的大众汽车类
 *  ShangHaiVolkswagenFactory: 上海大众汽车工厂
 *  Client: 客户端类

具体的代码：  
抽象产品类：  
public interface Volkswagen \{  
void drive();  
String getName();  
\}  
具体产品类：  
public class Passat implements Volkswagen \{  
public static final int ID = 0;

@Override  
public void drive() \{  
System.out.println(“Passat开出去咯，测试成功”);  
\}

@Override  
public String getName() \{  
return “Passat”;  
\}  
\}

public class Polo implements Volkswagen\{  
public static final int ID = 1;

@Override  
public void drive() \{  
System.out.println(“Polo开出去咯，测试成功”);  
\}

@Override  
public String getName() \{  
return “Polo”;  
\}  
\}

工厂类：  
public class ShangHaiVolkswagenFactory \{  
public Volkswagen createVolkswagen(int id)\{  
Volkswagen volkswagen = null;  
switch(id)\{  
case Passat.ID:  
volkswagen = new Passat();  
break;  
case Polo.ID:  
volkswagen = new Polo();  
break;  
default:  
volkswagen = null;  
\}  
return volkswagen;  
\}  
\}

客户端类：  
public class Client \{  
public static void main(String\[\] args) \{  
ShangHaiVolkswagenFactory factory = new ShangHaiVolkswagenFactory();

Volkswagen passat = factory.createVolkswagen(Passat.ID);  
passat.drive();

Volkswagen polo = factory.createVolkswagen(Polo.ID);  
System.out.println(polo.getName());  
\}  
\}  
每次测试的时候Client类都跑了一遍，似乎很简单，同样的也方便以后的扩展（添加新的车型的时候），只需要添加一个产品类，然后在工厂里添加响应的逻辑就行了。

注意：对于上面的工厂，可以采用反射的形式去创建产品类,代码如下：  
public class ShangHaiVolkswagenFactory \{  
//反射得到  
public Volkswagen createVolkswagen(Class <? extends Volkswagen> clazz)\{  
Volkswagen volkswagen = null;  
try \{  
volkswagen = clazz.newInstance();  
\} catch (InstantiationException e) \{  
e.printStackTrace();  
\} catch (IllegalAccessException e) \{  
e.printStackTrace();  
\}  
return volkswagen;  
\}  
\}

简单工厂模式优缺点：  
优点：客户端需要什么产品，可以直接得到，逻辑判断在工厂里面。  
缺点：扩展性一般，产品都是一个产品族下面的产品，对于不在产品族中的产品，没办法去扩展，另外获得具体某种产品的逻辑放在工厂里面，新添加产品的时候就需要修改工厂里面的代码。

2.工厂方法模式  
特点：  
①一个抽象产品，派生出多种具体的产品  
②一个抽象工厂，派生出多种生产产品的工厂类  
③一个具体的工厂负责生产一种具体的产品

![工厂方法模式的uml图][uml 1]

*  AbstractProduct:抽象的产品类
 *  ProductA:具体的A产品
 *  ProductB:具体的B产品
 *  AbstractFactory:抽象工厂类
 *  FactoryA:具体的生产A产品的工厂类
 *  FactoryB:具体的生产B产品的工厂类
 *  Client: 客户端类

举个例子：  
还是上面的例子。你在负责上海大众的两款车型，本来就着简单工厂的模式测试车辆的时候，日子过的非常好，可是好景不长，突然有一天领导说：一汽大众厂最近较忙，看你比较清闲，你就顺便把一汽大众的迈腾，和速腾都测一下。本来也挺简单的，就是简单再添加一个Magotan和Sagitar，然后通过工厂生成就行了，可是等你一拿到测试的项目的时候，发现并不是只测试drive，Sagitar和Magotan不仅需要测试drive，而且需要测试brake。好吧，以前写的都不能够用了。这时候就需要将简单工厂模式升级到工厂方法模式，关注点也发生了改变，不再为具体的车辆的，而是一汽大众的车(Magotan和Sagitar)还是上海大众的车(Passat和 Polo)了。  
修改过后的package图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3plbm1lbGEyMDEx_size_16_color_FFFFFF_t_70 1]

*  Volkswagen： 抽象的汽车类
 *  ShangHaiVolkswagen:上海大众汽车的抽象类
 *  FAWVolkswagen:一汽大众汽车的抽象类
 *  Passat，Polo：上海大众厂汽车类的具体类
 *  Magotan，Sagitar：一汽大众厂汽车的具体类
 *  VolkswagenFactory：抽象的大众汽车工厂
 *  ShangHaiVolkswagenFactory：上海大众汽车工厂，主要负责测试Passat和Polo
 *  FAWVolkswagenFactory:一汽大众的工厂，主要负责测试Magotan和Sagitar

具体的代码：  
抽象类：  
产品类—Volkswagen类：  
public abstract interface Volkswagen \{  
public abstract void drive();  
public abstract String getName();  
\}  
产品类—ShangHaiVolkswagen—上海大众汽车的抽象类：  
public abstract class ShangHaiVolkswagen implements Volkswagen\{

\}  
产品类—FAWVolkswagen —一汽大众汽车的抽象类，多了一个brake()的方法：  
public abstract class FAWVolkswagen implements Volkswagen \{  
public abstract void brake();  
\}  
工厂类—VolkswagenFactory : 汽车工厂的抽象类,并将createVolkswagen(Class clazz)声明称final类型。供子类使用：  
public abstract class VolkswagenFactory \{

public abstract Volkswagen createVolkswagen(int productID);

public final Volkswagen createVolkswagen(Class <? extends Volkswagen> clazz)\{  
Volkswagen volkswagen = null;  
try \{  
volkswagen = clazz.newInstance();  
\} catch (InstantiationException e) \{  
e.printStackTrace();  
\} catch (IllegalAccessException e) \{  
e.printStackTrace();  
\}  
return volkswagen;  
\};  
\}  
实现类：  
产品类—上海大众的具体实现类：  
public class Passat extends ShangHaiVolkswagen \{  
public static final int ID = 0;

@Override  
public void drive() \{  
System.out.println(“Passat开出去咯，测试成功”);  
\}

@Override  
public String getName() \{  
return “Passat”;  
\}  
\}  
public class Polo extends ShangHaiVolkswagen\{  
public static final int ID = 1;

@Override  
public void drive() \{  
System.out.println(“Polo开出去咯，测试成功”);  
\}

@Override  
public String getName() \{  
return “Polo”;  
\}  
\}  
产品类—一汽大众的具体实现类：  
public class Sagitar extends FAWVolkswagen \{  
public static final int ID = 2;

@Override  
public void drive() \{  
System.out.println(“Sagitar 开出去了，测试成功了”);  
\}

@Override  
public String getName() \{  
return “Sagitar”;  
\}

@Override  
public void brake()\{  
System.out.println(“Sagitar 刹车挺好的，测试通过了”);  
\}  
\}

public class Magotan extends FAWVolkswagen\{  
public static final int ID = 3;

@Override  
public void drive() \{  
System.out.println(“Magotan 开出去咯，测试成功了”);  
\}

@Override  
public String getName() \{  
return “Magotan”;  
\}

@Override  
public void brake()\{  
System.out.println(“Magotan 刹车挺好的，测试通过”);  
\}  
\}  
工厂类—注意重载方法的返回类型已经修改称对应的产品类，不在是Volkswagen类型了。  
ShangHaiVolkswagenFactory—负责生产上海汽车的工厂类：  
public class ShangHaiVolkswagenFactory extends VolkswagenFactory \{

public ShangHaiVolkswagen createVolkswagen(int id)\{  
ShangHaiVolkswagen volkswagen = null;  
switch(id)\{  
case Passat.ID:  
volkswagen = new Passat();  
break;  
case Polo.ID:  
volkswagen = new Polo();  
break;  
default:  
volkswagen = null;  
\}  
return volkswagen;  
\}  
\}  
FAWVolkswagenFactory—负责生产一汽汽车的工厂类：  
public class FAWVolkswagenFactory extends VolkswagenFactory \{

@Override  
public FAWVolkswagen createVolkswagen(int productID) \{  
FAWVolkswagen volkswagen = null;  
switch(productID)\{  
case Magotan.ID:  
volkswagen = new Magotan();  
break;  
case Sagitar.ID:  
volkswagen = new Sagitar();  
break;  
default:  
volkswagen = null;  
\}  
return volkswagen;  
\}  
\}  
Client类：用来测试  
public class Client \{  
public static void main(String\[\] args) \{  
System.out.println(“开始测试上海大众的车辆”);  
ShangHaiVolkswagenFactory factory = new ShangHaiVolkswagenFactory();  
ShangHaiVolkswagen passat = factory.createVolkswagen(Passat.ID);  
passat.drive();

ShangHaiVolkswagen polo = factory.createVolkswagen(Polo.ID);  
polo.drive();

System.out.println(“开始测试一汽大众的车辆”);  
FAWVolkswagenFactory fawFactory = new FAWVolkswagenFactory();

FAWVolkswagen magotan = fawFactory.createVolkswagen(Magotan.ID);  
magotan.drive();  
magotan.brake();  
FAWVolkswagen sagitar = fawFactory.createVolkswagen(Sagitar.ID);  
sagitar.drive();  
sagitar.brake();  
\}  
\}  
可以看出，上例中将工厂抽象出生产上海大众的车子和一汽大众的车子的两个工厂，并将一汽大众和上海大众的车子做了区分，形成两个不同产品族的产品系列，并由两个工厂分别对应去生产。现在无论处理一汽大众的车子还是上海大众的车子，甚至于再加一个进口大众工厂的车子也够用了，以后的扩展也能得到了提升。

工厂模式的优缺点：  
优点：扩展性，能够处理不同产品系列的产品，通过具体的工厂去生成不同产品族的产品，扩展性较好。  
缺点：类的个数较多。另外一个工厂只能够生产一个具体的产品。

3.抽象工厂类  
特点：  
①多个抽象产品类，每个抽象产品类可以派生出多个具体产品类  
②一个抽象工厂类，可以派生出多个具体工厂类  
③每个具体工厂类可以创建多个具体产品类的实例  
![抽象工厂uml图][uml 2]

*  AbstractFactory:抽象工厂类
 *  ConcreteFactoryA:具体工厂A,负责生产A和B的
 *  ConcreteFactoryB:具体工厂b,负责生产A和B的
 *  AbstractProductA,AbstractProductB:抽象的产品类
 *  ConcreteProductA1,ConcreteProductA2:具体产品A
 *  ConcreteProductB1，ConcreteProductB1:具体产品B
 *  Client:客户端

举个例子：  
你在做完上面测试工作之后，领导觉得你工作很不错，想让你逐渐管理业务层的事（与人打交道），将你升级到了部门经理，同样责任也多了起来了,你不仅测试原先一些东西，而且需要做一个额外的事情，比如说保险之类。你查阅保险的相关书籍发现，一汽大众的车子需要一等保险，而上海大众的车子需要二等保险。 你会发现保险和车子不属于同一个产品。为了处理事务方便你需要将原先的系统给升级一下。

升级后的系统的package图：  
![在抽象工厂package][package]  
新加了几个类:  
Insurance:保险的抽象类  
OneLevelInsurance:一等保险的实现类  
TwoLevelInsurance:二等保险的实现类

public abstract class Insurance \{  
public abstract String getName();  
\}

public class OneLevellnsurance extends Insurance\{

@Override  
public String getName() \{  
return “一级保险”;  
\}  
\}

public class TwoLevelInsurance extends Insurance \{

@Override  
public String getName() \{  
return “二级保险”;  
\}  
\}

同时修改ShangHaiVolkswagenFactory和FAWVolkswagenFactory以及VolkswagenFactory的代码。  
具体如下：  
VolkswagenFactory 添加一个生成Insurance类的方法:  
public abstract class VolkswagenFactory \{

public abstract Volkswagen createVolkswagen(int productID);

public abstract Insurance bindInsurance();

public final Volkswagen createVolkswagen(Class <? extends Volkswagen> clazz)\{  
Volkswagen volkswagen = null;  
try \{  
volkswagen = clazz.newInstance();  
\} catch (InstantiationException e) \{  
e.printStackTrace();  
\} catch (IllegalAccessException e) \{  
e.printStackTrace();  
\}  
return volkswagen;  
\};  
\}  
ShangHaiVolkswagenFactory绑定一等保险的对象:  
public class ShangHaiVolkswagenFactory extends VolkswagenFactory \{

@Override  
public Insurance bindInsurance() \{  
return new OneLevellnsurance();  
\}  
\}  
FAWVolkswagenFactory类：绑定二等保险的对象:  
public class FAWVolkswagenFactory extends VolkswagenFactory \{

@Override  
public Insurance bindInsurance() \{  
return new TwoLevelInsurance();  
\}  
\}  
Client客户端测试的类:  
public class Client \{  
public static void main(String\[\] args) \{  
System.out.println(“开始测试上海大众的车辆”);  
ShangHaiVolkswagenFactory factory = new ShangHaiVolkswagenFactory();  
ShangHaiVolkswagen passat = factory.createVolkswagen(Passat.ID);  
passat.drive();

ShangHaiVolkswagen polo = factory.createVolkswagen(Polo.ID);  
polo.drive();  
Insurance shanghaiInsurance = factory.bindInsurance();  
System.out.println(shanghaiInsurance.getName());

System.out.println(“开始测试一汽大众的车辆”);  
FAWVolkswagenFactory fawFactory = new FAWVolkswagenFactory();

FAWVolkswagen magotan = fawFactory.createVolkswagen(Magotan.ID);  
magotan.drive();  
magotan.brake();  
FAWVolkswagen sagitar = fawFactory.createVolkswagen(Sagitar.ID);  
sagitar.drive();  
sagitar.brake();  
Insurance fawInsurance = fawFactory.bindInsurance();  
System.out.println(fawInsurance.getName());  
\}  
\}  
现在系统已经很健全了，不再只为了测试车辆，只要与车辆相关的事宜的对象，由不同的工厂具体去实现就可以。

4.总结  
在工厂模式分别的对应使用中，简单工厂模式，注重具体生成的产品；而工厂方法模式，注重同一个产品下的不同产品族的产品，如例子中上海大众的汽车和一汽大众的汽车；抽象工厂模式更多是在与整体产品的架构上，不再是单一一个抽象产品类。  
工厂方法模式：一个抽象产品派生出去多个具体的产品，一个抽象工厂派生出多个具体的工厂，而一个具体的工厂对应生成的是一个具体的产品。  
抽象工厂模式：多个抽象产品分别派生出多个具体的产品，一个抽象工厂派生成出多个具体的工厂，一个工厂对应生成多个具体的产品，这些多个抽象产品之间存在着联系。

[uml]: /images/20220828/4ea574c40c6e4ab58bb2ea2fb77a248b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3plbm1lbGEyMDEx_size_16_color_FFFFFF_t_70]: /images/20220828/264ad55f40d44846b8d34c65fef2256d.png
[uml 1]: /images/20220828/7f381a6a04ce4abaa60a6f4eaee4791a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3plbm1lbGEyMDEx_size_16_color_FFFFFF_t_70 1]: /images/20220828/79eae8c5f84244198fadf7e445932c8b.png
[uml 2]: /images/20220828/d04fa613a95f4d2e8d87f0282464ee36.png
[package]: /images/20220828/34b019b0e2594d73a42f1b99cba741cc.png