GOF23之工厂模式详解

介绍

工厂模式是我们最常用的实例化对象模式了，是用工厂方法代替new操作的一种模式。著名的Jive论坛 ,就大量使用了工厂模式，工厂模式在Java程序系统可以说是随处可见。该模式满足了开闭原则，依赖倒转原则，迪米勒法则，实现了实现创建者和调用者分离。

1、简单工厂模式

1）、介绍

简单工厂模式是创建型模式，是工厂模式中的一种。该模式是由一个工厂对象决定创建出那种产品类的实例，该模式是工厂模式的最简单实现。

2）、使用方式

定义一个 创建对象的类，由该类来封装实例化对象的行为。
步骤
（1）、创建对象接口
（2）、创建接口实现类
（3）、创建一个工厂，生成基于给定信息的实体类的对象。
（4）、使用该工厂，通过传递类型信息来获取实体类的对象。
（5）、测试

3、结构图

实现

4）、优缺点

优点：
1、一个调用者想创建一个对象，只要知道其名称就可以了。
2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。
3、屏蔽产品的具体实现，调用者只关心产品的接口。
缺点：
每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。

5）、实现代码

package factory.simple;

public interface Car {
    void name();
}

package factory.simple;


public class BaomaCar implements Car {
    @Override
    public void name() {
        System.out.println("宝马Q6！");
    }

}

package factory.simple;


public class WulingCar implements Car {
    @Override
    public void name() {
        System.out.println("五菱宏光！");
    }
}

package factory.simple;

//静态工厂
public class Factory {
    public static Car getCar(String car){
        if (car.equals("五菱")){
            return new WulingCar();
        }else if (car.equals("宝马")){
            return new BaomaCar();
        }else {
            return null;
        }
    }
}

package factory.simple;

public class Consumer {
    public static void main(String[] args) {
        Car car = Factory.getCar("五菱");
        Car car1 = Factory.getCar("宝马");
        car.name();
        car1.name();
    }
}

2、工厂方法模式

由于上面的简单工厂方法的不足，每增加一个实现类就必须修改工厂，不满足开闭原则。因此工厂方法模式对此进行了优化。

1）、优化

将每一个实例都增加一个独立的工厂来实现工厂接口，让各个工厂之间互不干扰。

具体实现

2）、代码

基本与上面一致，多了两个具体工厂

package factory.factorymothod;

public class WulingFactory implements CarFactory {
    @Override
    public Car getCar() {
        return new WulingCar();
    }
}

package factory.factorymothod;

public class BaomaFactory implements CarFactory {
    @Override
    public Car getCar() {
        return new BaomaCar();
    }
}

3、抽象工厂模式

1）、介绍

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

2）、使用场景

强调一系列相关产品对象一起使用创建对象需要大量的重复代码。

3）、使用流程

（1）定义具体的工厂
（2）定义抽象工厂将具体工厂收纳进去抽象工厂，
（3）实现具体工厂
（4）实现抽象工厂
（5）测试用例

4)、优缺点

优点：
（1）、具体产品在应用层的代码隔离，无需关心创建细节
（2）、将一个系列的产品统一到一起创建
缺点：
（1）、规定了所有可能被创建的产品集合，产品族中扩展新产品困难
（2）、增加了系统的抽象性和理解难度

5）、结构

具体用例实现

6）、代码

package factory.abstractfactory;
//具体产品工厂：路由器
public interface IRouterPrudct {
    void connectWifi();
}

package factory.abstractfactory;
//具体产品工厂：手机
public interface IPhonePruduct {
    void call();
    void sendSms();

}

package factory.abstractfactory;

//抽象工厂：包含具体工厂
public interface ProductFactory {
    IPhonePruduct iphonProduct();
    IRouterPrudct iRouterProduct();
}

package factory.abstractfactory;
//具体工厂实现
public class XiaomiRouter implements IRouterPrudct {
    @Override
    public void connectWifi() {
        System.out.println("小米路由器连接WiFi");
    }
}

package factory.abstractfactory;
//具体工厂实现
public class XiaomiPhone implements IPhonePruduct {
    @Override
    public void call() {
        System.out.println("小米手机打电话");
    }

    @Override
    public void sendSms() {
        System.out.println("小米手机发信息");
    }
}

package factory.abstractfactory;

//具体工厂实现
public class HuaWeiIPhone implements IPhonePruduct {
    @Override
    public void call() {
        System.out.println("华为手机打电话");
    }

    @Override
    public void sendSms() {
        System.out.println("华为手机发信息");
    }
}

package factory.abstractfactory;
//具体工厂实现
public class HuaWeiRouter implements IRouterPrudct {
    @Override
    public void connectWifi() {
        System.out.println("华为路由器连接WiFi");
    }
}

package factory.abstractfactory;

//抽象工厂实现
public class HuaWeiFactory implements ProductFactory {
    @Override
    public IPhonePruduct iphonProduct() {
        return new HuaWeiIPhone();
    }

    @Override
    public IRouterPrudct iRouterProduct() {
        return new HuaWeiRouter();
    }
}

package factory.abstractfactory;
//抽象工厂实现
public class XiaomiFactory implements ProductFactory {
    @Override
    public IPhonePruduct iphonProduct() {
        return new XiaomiPhone();
    }

    @Override
    public IRouterPrudct iRouterProduct() {
        return new XiaomiRouter();
    }
}

4、总结

简单工厂模式：虽然不符合开闭原则，但是实际使用最多
工厂方法模式：在不修改已有类的前提下，增加了业务，符合开闭原则。
抽象工厂：在多变动业务的情况下使用会很麻烦。
应用场景：
JDK中的Calendar的getInstance方法
JDBC中的Connection对象获取
Spring的IOC容器创建管理Bean对象
反射中的Class对象的NewInstance方法