设计模式之工厂模式

工厂模式包括3种形式：简单工厂、工厂方法、抽象工厂。

工厂模式的目的：将类的实例生成，跟类接口的具体实现分离，实现解耦。这些类通常是具有继承和多态特点的约束关系，以便可以在抽象层调用统一的接口。

• 简单工厂

简单工厂是最简单的一种工厂模式，一般就是在工厂类的静态方法中，根据传入的参数生成相应的产品实现类的对象。
在产品类的种类单一，且个数比较少的场景下可以考虑使用简单工厂。

以下的工厂模式介绍，均以电子厂商，手机、平板电脑等产品作为例子说明。

抽象产品类：

public abstract class Product {
    /**
     *  打印产品的描述信息
     */
    public abstract void printDesc();
}

具体产品——手机：

public class Phone extends Product {
    @Override
    public void printDesc() {
        System.out.println("我是手机");
    }
}

具体产品——平板电脑：

public class Tablet extends Product {
    @Override
    public void printDesc() {
        System.out.println("我是平板电脑");
    }
}

简单工厂类：

public class SimpleFactory {
    // 产品类型：手机
    public static final int TYPE_PHONE = 0;
    // 产品类型：平板电脑
    public static final int TYPE_TABLET = 1;

    /**
     * 根据类型参数生产产品
     * 
     * @param type 产品类型
     * @return 具体产品
     */
    public static Product createProduct(int type) {
        Product product = null;
        switch (type) {
        case TYPE_PHONE:
            product = new Phone();
            break;
        case TYPE_TABLET:
            product = new Tablet();
            break;
        default:
            break;
        }
        return product;
    }
}

客户端调用：

public class Client {
    public static void main(String[] args) {
        // 产品
        Product product = null;

        // 生产手机
        product = SimpleFactory.createProduct(SimpleFactory.TYPE_PHONE);
        product.printDesc();

        // 生产平板电脑
        product = SimpleFactory.createProduct(SimpleFactory.TYPE_TABLET);
        product.printDesc();
    }
}

可以看到简单工厂是比较简单的一种模式，其实跟static方法差不多。

• 工厂方法

简单工厂方式虽然使用简单，但是其实并没有实现真正的解耦。比如后面如果增加了一种新的产品笔记本电脑，那么还是需要修改SimpleFactory的代码，增加一个case或if判断，这与设计模式的六大法则之一的“开闭原则”是相违背的，因此可以考虑改用工厂方法模式。
工厂方法的核心思想是：为每一类产品都定义一个工厂类。这样做的好处是显而易见的，如果以后需要增加一类产品，那么同时也增加一个相应的工厂类，这样就不需要修改原来工厂类的接口了，而是新增。这就符合“对修改关闭，对增加开放”的原则。

相对于原来的SimpleFactory，我们先定义一个抽象的产品工厂类：

public abstract class ProductFactory {
    // 产品可以是手机、平板电脑或其他新增的
    public abstract Product createProduct();
}

对于手机产品，新增一个手机工厂类：

public class PhoneFactory extends ProductFactory {
    @Override
    public Product createProduct() {
        return new Phone();
    }
}

对于平板电脑，新增一个平板电脑工厂类：

public class TabletFactory extends ProductFactory {
    @Override
    public Product createProduct() {
        return new Tablet();
    }
}

客户端调用：

public class Client {
    public static void main(String[] args) {
        // 产品工厂
        ProductFactory factory = null;
        // 产品
        Product product = null;

        // 生产手机
        factory = new PhoneFactory();
        product = factory.createProduct();
        product.printDesc();

        // 生产平板电脑
        factory = new TabletFactory();
        product = factory.createProduct();
        product.printDesc();
    }
}

这样如果以后新增产品类型，只需要增加一个Product的子类和一个ProductFactory的实现类即可。

• 抽象工厂

我们看下简单工厂，只是对Product类进行了抽象（其实这种情况不抽象也可以，只要产品类有统一的接口），工厂类是static的方法。工厂方法对Product类和Factory类都进行了抽象，但它们是一对一的关系，即一个Product必定要由一个Factory来生成。

抽象工厂是一种抽象层次更高的模式，它跟工厂方法一样，对Product类和Factory类都进行抽象，只不过对于这两个抽象，都是和具体工厂本身挂钩的，或者说抽象的时候，考虑的不再是单一的产品，而是多种产品的聚合。

以上面工厂方法的例子，它的工厂是对产品进行抽象的：手机工厂、平板电脑工厂。比如现在有两个公司：苹果和三星，那么对抽象工厂模式来说，它的工厂是对这两个公司抽象的：苹果工厂、三星工厂，而这两个工厂，对外的接口都有两个：生产手机、生产平板电脑。可以这样认为，有多少类产品，在工厂类中就要定义多少个接口。

工厂方法是产品-->工厂类的映射，而抽象工厂是产品-->工厂类的接口的映射，这样做的话，工厂类本身可以携带更多的信息：苹果的工厂类，三星的工厂类，不再是某类特定产品的工厂类。

抽象产品类——手机：

public abstract class Phone {
    // 打印手机信息
    public abstract void printPhone();
}

抽象产品类——平板电脑：

public abstract class Tablet {
    // 打印平板电脑信息
    public abstract void printTablet();
}

抽象工厂类：

public abstract class AbsFactory {
    /**
     * 生产手机
     */
    public abstract Phone createPhone();

    /**
     * 生产平板电脑
     */
    public abstract Tablet createTablet();
}

对于苹果和三星两家公司，分别定义具体的产品类和具体的工厂类。

苹果手机：

public class ApplePhone extends Phone {
    public void printPhone() {
        System.out.println("我是苹果手机");
    }
}

苹果平板电脑：

public class AppleTablet extends Tablet {
    @Override
    public void printTablet() {
        System.out.println("我是苹果平板电脑");
    }
}

三星手机：

public class SamsungPhone extends Phone {
    @Override
    public void printPhone() {
        System.out.println("我是三星手机");
    }
}

三星平板电脑：

public class SamsungTablet extends Tablet {
    @Override
    public void printTablet() {
        System.out.println("我是三星平板电脑");
    }
}

苹果工厂：

public class AppleFactory extends AbsFactory {
    @Override
    public Phone createPhone() {
        return new ApplePhone();
    }

    @Override
    public Tablet createTablet() {
        return new AppleTablet();
    }
}

三星工厂：

public class SamsungFactory extends AbsFactory {
    @Override
    public Phone createPhone() {
        return new SamsungPhone();
    }

    @Override
    public Tablet createTablet() {
        return new SamsungTablet();
    }
}

可见这两个具体的工厂，都有生产手机和平板电脑的能力了。

接下来是客户端调用：

public class Client {
    public static void main(String[] args) {
        // 工厂
        AbsFactory factory = null;
        // 手机
        Phone phone = null;
        // 平板电脑
        Tablet tablet = null;

        // 生产苹果公司的手机和平板电脑
        factory = new AppleFactory();
        phone = factory.createPhone();
        phone.printPhone();
        tablet = factory.createTablet();
        tablet.printTablet();

        // 生产三星公司的手机和平板电脑
        factory = new SamsungFactory();
        phone = factory.createPhone();
        phone.printPhone();
        tablet = factory.createTablet();
        tablet.printTablet();
    }
}

看下后面需求变化的情况：

• 如果增加一个新的公司比如Google，需要增加以下3个类：
  GooglePhone、GoogleTablet、GoogleFactory
• 如果增加一类新产品笔记本电脑，需要增加以下的类：
  抽象产品：Notebook
  苹果笔记本：AppleNotebook
  三星笔记本：SamsungNotebook

可见新增的这些类，都没有改变原来类的接口，也不会对既有的类造成影响，因为仅仅是新增，并没有做修改。

不过这里面也有一个问题，随着产品类或者公司的增多，需要新增加的类也会越来越多，虽然不会造成指数级的上升，不过3x3还是会比2x2多了不少，因此随着时间的推移，最后也许会感叹简单工厂其实挺好使的^^_^