【51】java设计模式-工厂设计模式剖析

时间：2016-05-27 11:31:59 阅读：162 评论：0 收藏：0 [点我收藏+]

标签：

工厂设计设计模式的分类：

工厂模式在《Java与模式》中分为三类：

1）简单工厂模式（Simple Factory）：不利于产生系列产品；

2）工厂方法模式（Factory Method）：又称为多形性工厂；

3）抽象工厂模式（Abstract Factory）：又称为工具箱，产生产品族，但不利于产生新的产品；

这三种模式从上到下逐步抽象，并且更具一般性。

GOF在《设计模式》一书中将工厂模式分为两类：工厂方法模式（Factory Method）与抽象工厂模式（Abstract Factory）。将简单工厂模式（Simple Factory）看为工厂方法模式的一种特例，两者归为一类。

举例：

1）还没有工厂时代：假如还没有工业革命，如果一个客户要一款宝马车,一般的做法是客户去创建一款宝马车，然后拿来用。
2）简单工厂模式：后来出现工业革命。用户不用去创建宝马车。因为客户有一个工厂来帮他创建宝马.想要什么车，这个工厂就可以建。比如想要320i系列车。工厂就创建这个系列的车。即工厂可以创建产品。
3）工厂方法模式时代：为了满足客户，宝马车系列越来越多，如320i，523i,30li等系列一个工厂无法创建所有的宝马系列。于是由单独分出来多个具体的工厂。每个具体工厂创建一种系列。即具体工厂类只能创建一个具体产品。但是宝马工厂还是个抽象。你需要指定某个具体的工厂才能生产车出来。
4）抽象工厂模式时代：随着客户的要求越来越高，宝马车必须配置空调。于是这个工厂开始生产宝马车和需要的空调。

最终是客户只要对宝马的销售员说：我要523i空调车，销售员就直接给他523i空调车了。而不用自己去创建523i空调车宝马车.

这就是工厂模式。

区别：

工厂方法模式：
一个抽象产品类，可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类只能创建一个具体产品类的实例。
抽象工厂模式：
多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类可以创建多个具体产品类的实例。
区别：
工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。
工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。
两者皆可。

简单工厂模式

技术分享

public class BMW320 {  
    public BMW320(){  
        System.out.println("制造-->BMW320");  
    }  
}  

public class BMW523 {  
    public BMW523(){  
        System.out.println("制造-->BMW523");  
    }  
}  

public class Customer {  
    public static void main(String[] args) {  
        BMW320 bmw320 = new BMW320();  
        BMW523 bmw523 = new BMW523();  
    }  
}

把创建宝马的操作细节都放到了工厂里面去,客户直接使用工厂的创建工厂方法,传入想要的宝马车型号就行了,而不必去知道创建的细节.这就是工业革命了：简单工厂模式

技术分享

产品类：

[java] view plain copy print?在CODE上查看代码片派生到我的代码片
abstract class BMW {  
    public BMW(){  

    }  
}  

public class BMW320 extends BMW {  
    public BMW320() {  
        System.out.println("制造-->BMW320");  
    }  
}  
public class BMW523 extends BMW{  
    public BMW523(){  
        System.out.println("制造-->BMW523");  
    }  
}  
工厂类：

[java] view plain copy print?在CODE上查看代码片派生到我的代码片
public class Factory {  
    public BMW createBMW(int type) {  
        switch (type) {  

        case 320:  
            return new BMW320();  

        case 523:  
            return new BMW523();  

        default:  
            break;  
        }  
        return null;  
    }  
}  

客户类：

[java] view plain copy print?在CODE上查看代码片派生到我的代码片
public class Customer {  
    public static void main(String[] args) {  
        Factory factory = new Factory();  
        BMW bmw320 = factory.createBMW(320);  
        BMW bmw523 = factory.createBMW(523);  
    }  
}

它的组成：

1) 工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑，用来创建产品
2) 抽象产品角色：它一般是具体产品继承的父类或者实现的接口。
3) 具体产品角色：工厂类所创建的对象就是此角色的实例。在Java中由一个具体类实现。

当有新的车加入时，需要更新代码也实现对新车的支持。这就违反了开闭原则（Open-Close Principle）。可以利用反射（Reflection）解决该问题。

使用反射实现扩展性：

技术分享 “`
public class CarFactory2 {

private static final Logger LOG = LoggerFactory.getLogger(CarFactory2.class);

public static Car newCar() {
Car car = null;
String name = null;
try {
XMLConfiguration config = new XMLConfiguration(“car.xml”);
name = config.getString(“factory2.class”);
} catch (ConfigurationException ex) {
LOG.error(“Parsing xml configuration file failed”, ex);
}

try {
  car = (Car)Class.forName(name).newInstance();
  LOG.info("Created car class name is {}", name);
} catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
  LOG.error("Instantiate car {} failed", name);
}
return car;

}

从上面代码中可以看到，之后如果需要引入新的Car，只需要在配置文件中指定该Car的完整类名（包括package名），CarFactory2即可通过反射将其实例化。实现了对扩展的开放，同时保证了对修改的关闭。熟悉Spring的读者应该会想到Spring IoC的实现。

简单工厂模式优点：
---------

1.工厂类是整个简单工厂模式的关键所在。它包含必要的判断逻辑，能够根据外界给定的信息（配置，或者参数），决定究竟应该创建哪个具体类的对象。用户在使用时可以直接根据工厂类去创建所需的实例，而无需了解这些对象是如何创建以及如何组织的。有利于整个软件体系结构的优化。
2.通过引入配置文件和反射，可以在不修改任何客户端代码的情况下更换和增加新的具体产品类，在一定程度上提高了系统的灵活性（如CarFactory2）。
3.客户端无须知道所创建的具体产品类的类名，只需要知道具体产品类所对应的参数即可，对于一些复杂的类名，通过简单工厂模式可以减少使用者的记忆量（如CarFactory3）。

简单工厂模式缺点：
---------

1.由于工厂类集中了所有实例的创建逻辑，这就直接导致一旦这个工厂出了问题，所有的客户端都会受到牵连。
2.由于简单工厂模式的产品是基于一个共同的抽象类或者接口，这样一来，产品的种类增加的时候，即有不同的产品接口或者抽象类的时候，工厂类就需要判断何时创建何种接口的产品，这就和创建何种种类的产品相互混淆在了一起，违背了单一职责原则，导致系统丧失灵活性和可维护性。
3.正如上文提到的，一般情况下（如CarFactory1），简单工厂模式违背了“开放-关闭原则”，因为当我们新增加一个产品的时候必须修改工厂类，相应的工厂类就需要重新编译一遍。但这一点可以利用反射（CarFactory3在本质上也是利用反射）在一定程度上解决（如CarFactory2）。
使用反射可以使简单工厂在一定条件下满足“开放-关闭原则”，但这仅限于产品类的构造及初始化相同的场景。对于各产品实例化或者初始化不同的场景，很难利用反射满足“开放-关闭”原则。
4.简单工厂模式由于使用了静态工厂方法，造成工厂角色无法形成基于继承的等级结构。这一点笔者持保留态度，因为继承不是目的，如果没有这样的需求，这一点完全不算缺点，例如JDBC的DriverManager。

工厂方法模式 ：
==
 工厂方法模式去掉了简单工厂模式中工厂方法的静态属性，使得它可以被子类继承。这样在简单工厂模式里集中在工厂方法上的压力可以由工厂方法模式里不同的工厂子类来分担。 

工厂方法模式组成：
---------

 1)抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。 
 2)具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。 
 3)抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。 
 4)具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。 
       工厂方法模式使用继承自抽象工厂角色的多个子类来代替简单工厂模式中的“上帝类”。正如上面所说，这样便分担了对象承受的压力；而且这样使得结构变得灵活 起来——当有新的产品产生时，只要按照抽象产品角色、抽象工厂角色提供的合同来生成，那么就可以被客户使用，而不必去修改任何已有 的代码。可以看出工厂角色的结构也是符合开闭原则的！

产品类：

[java] view plain copy print?在CODE上查看代码片派生到我的代码片
abstract class BMW {
public BMW(){

}
public class BMW320 extends BMW {
public BMW320() {
System.out.println(“制造–>BMW320”);
}
}
public class BMW523 extends BMW{
public BMW523(){
System.out.println(“制造–>BMW523”);
}
}

创建工厂类：

[java] view plain copy print?在CODE上查看代码片派生到我的代码片
interface FactoryBMW {
BMW createBMW();
}

public class FactoryBMW320 implements FactoryBMW{

@Override  
public BMW320 createBMW() {  

    return new BMW320();  
}

}
public class FactoryBMW523 implements FactoryBMW {
@Override
public BMW523 createBMW() {

    return new BMW523();  
}

}

客户类：

[java] view plain copy print?在CODE上查看代码片派生到我的代码片
public class Customer {
public static void main(String[] args) {
FactoryBMW320 factoryBMW320 = new FactoryBMW320();
BMW320 bmw320 = factoryBMW320.createBMW();

    FactoryBMW523 factoryBMW523 = new FactoryBMW523();  
    BMW523 bmw523 = factoryBMW523.createBMW();  
}

}


抽象工厂模式：
==
当每个抽象产品都有多于一个的具体子类的时候（空调有型号A和B两种，发动机也有型号A和B两种），工厂角色怎么知道实例化哪一个子类呢？比如每个抽象产品角色都有两个具体产品（产品空调有两个具体产品空调A和空调B）。抽象工厂模式提供两个具体工厂角色（宝马320系列工厂和宝马230系列工厂），分别对应于这两个具体产品角色，每一个具体工厂角色只负责某一个产品角色的实例化。每一个具体工厂类只负责创建抽象产品的某一个具体子类的实例。
## 抽象工厂模式代码 ##

产品类：

[java] view plain copy print?在CODE上查看代码片派生到我的代码片
//发动机以及型号
public interface Engine {

}
public class EngineA extends Engine{
public EngineA(){
System.out.println(“制造–>EngineA”);
}
}
public class EngineBextends Engine{
public EngineB(){
System.out.println(“制造–>EngineB”);
}
}

//空调以及型号
public interface Aircondition {

}
public class AirconditionA extends Aircondition{
public AirconditionA(){
System.out.println(“制造–>AirconditionA”);
}
}
public class AirconditionB extends Aircondition{
public AirconditionB(){
System.out.println(“制造–>AirconditionB”);
}
}

创建工厂类：

[java] view plain copy print?在CODE上查看代码片派生到我的代码片
//创建工厂的接口
public interface AbstractFactory {
//制造发动机
public Engine createEngine();
//制造空调
public Aircondition createAircondition();
}

//为宝马320系列生产配件
public class FactoryBMW320 implements AbstractFactory{

@Override    
public Engine createEngine() {      
    return new EngineA();    
}    
@Override    
public Aircondition createAircondition() {    
    return new AirconditionA();    
}

}
//宝马523系列
public class FactoryBMW523 implements AbstractFactory {

 @Override    
public Engine createEngine() {      
    return new EngineB();    
}    
@Override    
public Aircondition createAircondition() {    
    return new AirconditionB();    
}

}

客户:

[java] view plain copy print?在CODE上查看代码片派生到我的代码片
public class Customer {
public static void main(String[] args){
//生产宝马320系列配件
FactoryBMW320 factoryBMW320 = new FactoryBMW320();
factoryBMW320.createEngine();
factoryBMW320.createAircondition();

    //生产宝马523系列配件    
    FactoryBMW523 factoryBMW523 = new FactoryBMW523();    
    factoryBMW320.createEngine();  
    factoryBMW320.createAircondition();  
}

}

“`