设计模式之工厂模式

前言

最近在看设计模式相关的一些知识，看了一些感觉还是要做一些记录的，一方面用来记录当前情况下个人对设计模式的理解程度，使得这块知识更加深刻，另一方面也是方便把自己的一些拙见拿出来希望能够共同进步，得到众人的指正。

引入

工厂模式应该说最常见的模式，看一些介绍模式的书里工厂模式基本都是第一个被提到的，它应用场景比较多，也容易被理解。它是名如其模式，先来分析下它的名字，“工厂”用来生产各种产品，我们可以直接通过工厂来获得需要的各种产品，而不需要来考虑其具体的实现，所谓的“工厂”就类似于“商店”，提供我们需要所需产品。那么“工厂”的产品是怎么样获得的呢，“工厂”会根据我们具体的需求来利用具体的“材料”来“生产”具体的产品，到这里来看图说话。

factory

上图就是对上面文字的一个概括，这里先又了这个概念就OK了，下面深入到代码层面来说明。

代码实现

这里用引入中最原始的提到的工厂、产品和消费者举例。
例子在android studio中android项目中开发。

工厂、产品和消费者

factory

创建一个工厂类(Factory),提供一个获得产品的方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class Factory {

    /**
     * 获得产品对象实例
     *
     * @param clazz clazz
     * @param <P    extends BaseProduct>   p
     * @return p
     */
    public static <P extends BaseProduct> P getProduct(Class<P> clazz) {
        P p = null;
        try {
            p = (P) Class.forName(clazz.getName()).newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        return p;
    }
}

创建一个接口(IProduct)，商品类将实现produce()方法

1
2
3
4
5
public interface IProduct {

    public BaseProduct produce();

}

分别创建商品类(BaseProduct、ProductOne、ProductTwo、ProductThree和ProductFour)

1
2
3
4
5
6
public abstract class BaseProduct implements IProduct {

    public void makeBaseComponents() {
        //制作基础组件
    }
}
1
2
3
4
5
6
7
8
9
public class ProductOne extends BaseProduct implements IProduct {

    @Override
    public BaseProduct produce() {
        makeBaseComponents();
        Log.d("ProductOne", "make ProductOne");
        return this;
    }
}
1
2
3
4
5
6
7
8
9
public class ProductTwo extends BaseProduct implements IProduct {

    @Override
    public BaseProduct produce() {
        makeBaseComponents();
        Log.d("ProductTwo", "make ProductTwo");
        return this;
    }
}
1
2
3
4
5
6
7
8
9
public class ProductThree extends BaseProduct implements IProduct {

    @Override
    public BaseProduct produce() {
        makeBaseComponents();
        Log.d("ProductThree", "make ProductThree");
        return this;
    }
}
1
2
3
4
5
6
7
8
9
public class ProductFour extends BaseProduct implements IProduct {

    @Override
    public BaseProduct produce() {
        makeBaseComponents();
        Log.d("ProductFour", "make ProductFour");
        return this;
    }
}

在MainActivity类中获得需要的商品类实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }


    public void onGetProduct(int productType) {
        Class<? extends BaseProduct> clazz = null;
        switch (productType) {
            case 1:
                clazz = ProductOne.class;
                break;
            case 2:
                clazz = ProductTwo.class;
                break;
            case 3:
                clazz = ProductThree.class;
                break;
            case 4:
                clazz = ProductFour.class;
                break;
        }

        BaseProduct product = Factory.getProduct(clazz);
        Toast.makeText(this, product.produce(), Toast.LENGTH_LONG).show();
    }

    public void onGetProductThree(View view) {
        onGetProduct(3);
    }

    public void onGetProductTwo(View view) {
        onGetProduct(2);
    }

    public void onGetProductOne(View view) {
        onGetProduct(1);
    }

    public void onGetProductFour(View view) {
        onGetProduct(4);
    }
}

最终我们实现在activity中获得了产品的实例对象

github

为什么要用工厂模式

在开发过程中常常会独立做一些模块供其他的开发者来用，这种情况下，其实对于其他的开发者来说要求在使用功能时尽量的简单、调用方便，他们不需要去了解里面的具体实现，只要简单调用就可以拿到对应的实例，这个时候对于工厂模式时一个可行的方案，当然在实际开发中可以会和其他的模式混用来达到效果，这个还要具问具析。对于我们可以在什么场景下利用工厂模式，这里列出一些它的利弊，以便在考虑使用时参考：

利:

  1. 多类型扩展好，如果新增了一种商品只要实现它的具体类和方法，即可根据类来获取其实例
  2. 具体实现是封闭的、不对外的
  3. 调用方便，可通过一个类型或者类名就可以获得具体实例

弊
产品类创建方式单一，因为是通过类命来创建实例，这样创建不会像常见的直接new灵活
不适合单一产品时使用