Android设计模式-工厂模式-创建型-(2)

创建型模式 (3)

简单工厂、工厂法、抽象工厂模式、单例模式、建造者模式

行为型模式 (2)

观察者模式、策略模式

结构型模式 (3)

适配器模式、代理模式、装饰模式

• Android设计模式Github项目地址： 点击跳转

---

0. 什么是工厂模式？

1、对客户端隐藏创建对象的逻辑，客户端只需要知道名称即可动态的通过一个共同接口，但是不同的选择来创建不同的对象。

工厂模式对应三种模式：简单工厂法（Simple Factory）、工厂方法模式（Factory Method）、抽象工厂法（Abstract Factory）

---

1. 优缺点

优点：

1、一个调用者想创建一个对象，只要知道其名称就可以了。
2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。
3、屏蔽产品的具体实现，调用者只关心产品的接口。

缺点：

每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。

使用场景：

1、日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方。
2、数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。
3、设计一个连接服务器的框架，需要三个协议，“POP3”、“IMAP”、“HTTP”，可以把这三个作为产品类，共同实现一个接口。

2. 哪些库或方法使用工厂模式来实现的？

BitmapFactory、MediaPlayerFactory、Executors线程池工厂类

---

3. 举例说明

1.简单工厂法（Simple Factory）

1、只开设一家肉工厂，可以生产牛肉，猪肉。

角色： 工厂、实体产品、抽象产品接口

MeetProduct可生产的肉类产品抽象类
PorkProduct产品的具体接口实现类-猪肉
BeefProduct产品的具体接口实现类-牛肉
MeetFactory工厂类,根据客户端的信息，来选择生产不同的产品
SimpleFactoryPatternActivity activity（担任客户端角色）

• 1-1.MeetProduct

/**
 * 产品抽象类-定义制作的产品内容
 */
public abstract class MeetProduct {
    public abstract String make();
}

• 1-2.BeefProduct

/**
 * 产品抽象类的具体实现-产品为牛肉
 */
public class BeefProduct extends Product {
    @Override
    public String make() {
        return "牛肉";
    }
}

• 1-3.PorkProduct

/**
 * 产品抽象类的具体实现-产品为猪肉
 */
public class PorkProduct extends Product {
    @Override
    public String make() {
        return "猪肉";
    }
}

• 1-4.MeetFactory

/**
 * 工厂角色-用于客户调用，只需要传递想要生产什么肉即可
 */
public class MeetFactory {
    public MeetFactory(){
        System.out.println(SimpleFactoryPatternActivity.TAG+"创建了个肉厂");
    }
    //可生产的种类
    public enum ProductStyle{
        猪肉,牛肉
    }
    public Product makeProduct(ProductStyle productStyle){
        Product product = null;
        switch (productStyle){
            case 牛肉:
                product =  new BeefProduct();
                break;
            case 猪肉:
                product =  new PorkProduct();
                break;
        }
        return product;
    }
}

• 1-5.SimpleFactoryPatternActivity

public class SimpleFactoryPatternActivity extends AppCompatActivity {
    public static String TAG ="工厂模式:>> ";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_factory_pattern);
        //创建个工厂对象，(开了个肉厂)
        MeetFactory meetFactory = new MeetFactory();
        //指定肉厂生产的产品(我想要生产牛肉)
        Product product = meetFactory.makeProduct(MeetFactory.ProductStyle.牛肉);
        System.out.println(TAG+"生产的产品是:>> "+product.make());
    }

运行后的结果是：

如果想要工厂生产羊肉的话，只需要再具体实现个MeetProduct类作为羊肉产品，并在MeetFactory工厂类中添加选择即可。

优点：简单工厂类中包含了必要的逻辑判断能力和所有产品的创建权利，它可以根据客户端的选择条件动态实例化相关的类，对于客户端来说，去除了与具体产品的依赖。这样的话，当产品的类名更换或者增加产品时我们都无需修改客户端代码，只需要在简单工厂类上增加一个分支判断代码即可。使用起来似乎非常的方便。

缺点：没有遵守“开放—封闭”原则。所谓的“开放-封闭”原则就是开放接口，封闭修改。我们每次想要增加一种新产品的时候，都必须修改SimpleFactory的源码。其次，当我们拥有很多很多产品的时候，而且产品之间又存在复杂的层次关系的时候，这个类必须拥有复杂的逻辑判断能力，这会导致这个简单工厂类很庞大臃肿、耦合性高，不利于维护和扩展。而且整个系统严重依赖SimpleFactory类，一旦此类出现问题，则整个系统将会崩溃。

---

2.工厂方法模式（Factory Method）

当简单工厂法的工厂出现问题时，我们的牛肉、猪肉都不能继续生产。为了解决这个问题，我们就需要对简单工厂模式进行解藕
以多态的形式消弱工厂的职责，把简单庞大的简单工厂类，拆分成一个个单独的工厂类。这样所有的代码就不会全藕合在一个工厂类中了。大大降低了简单工厂模式的一些风险，提高日后的可维护性和可扩展性。

1、将简单工厂拆分，变为猪肉工厂和牛肉工厂。

角色： 工厂抽象类接口（作为母工厂）、实体猪肉工厂（实现工厂接口）、实体牛肉工厂（实现工厂接口）实体产品、抽象产品接口

Factory工厂抽象类接口（作为母工厂）
BeefFactory牛肉厂
PorkFactory猪肉厂
FactoryMethodPatternActivity activity（担任客户端角色）

• 2-1.Factory

/**
 * 为了将单个简单工厂拆分，需要创建个抽象工厂接口类，作为母工厂。
 * 猪肉工厂和牛肉工厂分别具体实现该抽象即可
 */
public abstract class Factory {
    public abstract MeetProduct createProduct();
}

• 2-2.BeefFactory

/**
 * 牛肉工厂-实现母工厂抽象类
 */
public class BeefFactory extends Factory{
    public BeefFactory(){
        System.out.println(FactoryMethodPatternActivity.TAG+" 牛肉工厂");
    }
    @Override
    public MeetProduct createProduct() {
        return new BeefProduct();
    }
}

• 2-3.PorkFactory

/**
 * 将简单工厂，拆分成2个子工厂- 猪肉工厂
 */
public class PorkFactory extends Factory{
    public PorkFactory(){
        System.out.println(FactoryMethodPatternActivity.TAG+" 猪肉工厂");
    }
    @Override
    public MeetProduct createProduct() {
        return new PorkProduct();
    }
}

• 2-4.FactoryMethodPatternActivity

public class FactoryMethodPatternActivity extends AppCompatActivity {
    public static String TAG ="工厂法模式:>> ";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_factory_method_pattern);
        //创建牛肉工厂-生产牛肉
        Factory factoryA = new BeefFactory();
        System.out.println(TAG+"生产的产品是:>> "+ factoryA.createProduct().make());
        //创建猪工厂-生产猪肉
        Factory factoryB = new PorkFactory();
        System.out.println(TAG+"生产的产品是:>> "+ factoryB.createProduct().make());
    }
}

运行后的结果是：

这样一来，即使牛肉工厂出问题了，猪肉工厂还是能继续生产。

优点：不同产品的实例对象的创建，没有耦合在同一个工厂类里，实现了对简单工厂模式的解耦，并且遵循了“发放-封闭”原则。

缺点：每增加一个产品类，就需要增加一个对应的工厂类，增加了额外的开发量。

---

3.抽象工厂模式（Abstract Factory）

一个工厂下可以生产多个产品，可以理解为对产品再一次的细分。

简单工厂模式下，只有一个工厂生产所有的肉类，猪肉、牛肉。
工厂法模式下，将工厂拆分为2个工厂，猪厂生产猪肉、牛厂生产牛肉。
抽象工厂模式下，猪厂不仅可以生产猪肉、还可以生产猪脚等多个产品。

AbstractFactory 工厂抽象类，定义多个生产
PorkAbstractFactory猪肉工厂具体实现类，实现具体生产什么产品
PorkFeetProduct猪脚- MeetProduct的具体实现类

• 3-1.AbstractFactory

/**
 * 工厂抽象接口，猪肉工厂不光是能生产猪肉，还能生产指定的部位，猪脚
 */
public abstract class AbstractFactory {
    public abstract MeetProduct createProduct();
    public abstract MeetProduct createProductPart();
}

• 3-2.PorkAbstractFactory

/**
 * 猪肉工厂-实现母工厂抽象类
 */
public class PorkAbstractFactory extends AbstractFactory {
    public PorkAbstractFactory(){
        System.out.println(AbstractFactoryPatternActivity.TAG+" 猪肉工厂");
    }
    @Override
    public MeetProduct createProduct() {
        return new PorkProduct();
    }

    @Override
    public MeetProduct createProductPart() {
        return new PorkFeetProduct();
    }
}

• 3-1.PorkFeetProduct

/**
 * 产品抽象类的具体实现-产品为牛肉
 */
public class PorkFeetProduct extends MeetProduct {
    @Override
    public String make() {
        return "猪脚";
    }
}

运行后的结果是：

---

4. 与工厂模式的区别

总体而言建造者模式是交由客户端，可以自由的一步步的将简单对象组合在一起，最后建造出一个复杂的对象，并生成复杂对象的实例。
而工厂模式也可以理解成是用一个个简单的对象组合起来，最后造出一个复杂的对象。不同的是工厂是把组合建造出一个复杂的对象的整个流程在自己内部定义好，最后让客户端直接创建生产一个复杂对象的实例。

---

5. Android技术生活交流

微信

---

[1]* 参考文章
[2]* 参考文章
[3]* 参考文章
[4]* 参考文章
[5]* 参考文章
[6]* 参考文章
[7]* 参考文章
[8]* 参考文章
[9]* 参考文章
[10]* 参考文章