【设计模式】工厂系列-FactoryMethod，AbstractFactory，Spring IOC

行百里者行百里er

今天来说一下设计模式的工厂系列。这一系列主要包括工厂方法、抽象工厂，最后再看看Spring的利器IOC。

何为工厂

任何可以产生对象的方法或类，都可以叫做工厂。
so，单例模式 getInstance 也是一种工厂。

那为什么有了new之后，还要工厂呢？

灵活控制生产过程；
权限、日志、管理
...

下面我就用生产防护用品来举例说明为什么要使用工厂：

任意定制口罩

继承ProtectiveEquip

任意定制生产过程

ProtectiveEquip xxxFactory.create()

任意定制产品一族

工厂方法

作为一个饱受新冠病毒疫情影响的人，想通过戴口罩来减少被感染的机会，当然来自漂亮国的人可能不需要口罩，或者戴这样的口罩：

作为有需求的客户端Client，new一个口罩出来：

public class Client {
    public static void main(String[] args) {
        FaceMask fm = new FaceMask();
        fm.protect();
    }
}

定义一个口罩类：

public class FaceMask {
    public void protect() {
        System.out.println("face masks don't let the virus enter");
    }
}

如果client自我保护意识比较强，还需要定制一双防护手套，那么就需要再定义一个防护手套类HandMask，也提供一个protect方法；

client需求又升级了，他还要防护衣服ProtectiveSuit...

如果一直这样new下去，那就有点不太好了，要是有工厂能生产就好了。

工厂来了：

/**
 * 简单工厂 生产防护用品
 * 简单工厂的可扩展性不好，比如需要造新的防护用品的时候，需要加方法
 * @author 行百里者
 */
public class SimpleProtectiveEquipFactory {
    
    FaceMask createFaceMask() {
        return new FaceMask();
    }
    
    HandMask createHandMask() {
        return new HandMask();
    }
    
    //如果还需要生产其他防护用品，就接着写createXXX方法
}

这就是简单工厂，能够生产你需要的东西，前提是你得往这个工厂里写方法。这也不太方便啊，而且不好扩展。

那就每个工厂各司其职，自己生产自己的东西，口罩工厂生产口罩，手套工厂生产手套。。。

口罩工厂：

public class FaceMaskFactory {
    FaceMask create() {
        System.out.println("业务逻辑...");
        return new FaceMask();
    }
}

防护手套工厂：

public class HandMaskFactory {
    HandMask create() {
        System.out.println("业务逻辑...");
        return new HandMask();
    }
}

等等，需要造什么，就创建什么工厂。

客户Client这里：

public class Client {
    public static void main(String[] args) {
        FaceMaskFactory factory = new FaceMaskFactory();
        //保护我
        factory.create().protect();
    }
}

由此，可以看出，工厂方法既能满足任意制定防护工具，又能任意制定生产过程——create方法由你的工厂实现。

那么，如果我是个大厂，想搞宇宙化战略，既能生产正常人类的防护用品，又能生产其他种族的防护用品，比如漂亮国的人，火星人等等的防护用品，我该怎么办？

像工厂方法那样建造很多个工厂也能实现，但是有点繁琐了。。。

抽象工厂

如何解决上面的宇宙化战略问题呢？建造生产产品一族的工厂，我们称之为抽象工厂。

刚才提到的产品一族，比如HumanFactory生产防护用品是FaceMask、食物是Rice；UsaFactory生产防护用品是Rags、食物是Junk等等

HumanFactory是正常人类一族；UsaFactory是漂亮国一族。

他们各自生产本族的不同类别的产品。

这时我们可以弄一个抽象工厂叫BaseFactory，它能生产食物、防护用品：

public abstract class BaseFactory {
    abstract Food createFood();
    abstract ProtectiveEquip createProtectiveEquip();
}

具体的产品族分别实现这个抽象工厂：

public class HumanFactory extends BaseFactory {
    @Override
    Food createFood() {
        //生产大米饭
        return new Rice();
    }

    @Override
    ProtectiveEquip createProtectiveEquip() {
        //生产口罩
        return new FaceMask();
    }
}

public class UsaFactory extends BaseFactory {
    @Override
    Food createFood() {
        //生产Junk Food
        return new Junk();
    }

    @Override
    ProtectiveEquip createProtectiveEquip() {
        //生产破布条
        return new Rags();
    }
}

一个抽象的工厂，可以生产两个抽象的产品；两个具体的工厂分别生产自己的产品。

如此，便可实现可以定制任意产品族。

这就是抽象工厂模式。

抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。

我们来看看抽象工厂的通用源代码，首先有两个互相影响的产品线（也叫做产品族），例如制造汽车的左侧门和右侧门，这两个应该是数量相等的——两个对象之间的约束，每个型号的车门都是不一样的，这是产品等级结构约束的。

Spring Bean工厂

Spring IOC其实也是一种工厂---生产各种Bean的工厂，这里我们只简单说一下它的用法。

pom.xml引入Spring的包

<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.5</version>
</dependency>

<!-- https://mvnrepository.com/artifact/org.springframework/spring-core -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>5.2.6.RELEASE</version>
</dependency>

<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.2.6.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-aop -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
    <version>5.2.6.RELEASE</version>
</dependency>

在Spring配置文件app.xml中定义想要被Spring托管的类：

<bean id="rice" class="com.traveler100.dp.abstractfactory.Rice"></bean>

Client可直接使用：

ApplicationContext ctx = new ClassPathXmlApplicationContext("app.xml");
Rice rice = (Rice) ctx.getBean("rice");
rice.printName();

牛逼不？省去了很多代码吧，什么xxxFactory啊，什么继承啊等等，都不用我们自己去写了，我们可以把很多类直接扔给Spring，让它帮我们实例化，把Bean的控制权交给Spring，这就是所谓的控制反转，Spring IOC
我们可以把它看成造各种Bean的工厂，也就是Spring Bean工厂。

继续滑动看下一个