设计模式-工厂模式Factory

b.工厂方法模式 (Factory Method) (重点)

一般情况下，工厂模式分为三种更加细分的类型：简单工厂、工厂方法和抽象工厂。

1) 简单工厂 Simple Factory

简单工厂叫作静态工厂方法模式（Static Factory Method Pattern）

现在有一个场景，需要一个资源加载器，要根据不用的url进行资源加载，但是如果我们将所有的加载实现代码全部封装在了一个load方法中，就会导致一个类很大，同时扩展性也非常差，当想要添加新的前缀解析其他类型的url时，发现需要修改大量的源代码。

定义两个需要之后会用到的类

/**
 * 事实上一个资源类会比这个负责
 */
@NoArgsConstructor
@AllArgsConstructor
@Data
public class Resource {
    private String url;
}

public class ResourceLoader {

    /**
     * 资源加载
     * @param url file:// http:// classpath://
     * @return 资源类
     */
    public Resource load(String url) {
        // 1.根据url获取前缀
        String prefix = getPreFix(url);

        Resource resource = null;

        // 2.根据前缀，处理不同的资源(有很多的分支逻辑)
        if ("http".equals(prefix)){
            // 发起http请求下载资源....(代码复杂)
            return new Resource(url);
        } else if ("file".equals(prefix)) {
            // 建立流，做异常...(代码复杂)
            return new Resource(url);
        } else if ("classpath".equals(prefix)) {
            // ......(代码复杂)
            return new Resource(url);
        }else {
            return new Resource("default");
        }
    }

    /**
     * 获取前缀
     * @param url
     * @return
     */
    private String getPreFix(String url) {
        if (url == null || url.equals("") || !url.contains("://")){
            throw new ResourceLoadException("传入的资源url不合法");
        }
        String[] split = url.split(":");
        return split[0];
    }
}

在上边的案例中，存在很多的if分支，如果分支数量不多，且不需要扩展，这样的编写方式当然没错，然而在实际的工作场景中，我们的业务代码可能会很多，分支逻辑也可能十分复杂，这个时候简单工厂设计模式就要发挥作用了。

只需要创建一个工厂类，将创建资源的能力交给工厂即可：

/**
 * 简单工厂
 */
public class ResourceFactory {

    public static Resource create(String type, String url) {
        if ("http".equals(type)){
            // 发起http请求下载资源....(代码复杂)
            return new Resource(url);
        } else if ("file".equals(type)) {
            // 建立流，做异常...(代码复杂)
            return new Resource(url);
        } else if ("classpath".equals(type)) {
            // ......(代码复杂)
            return new Resource(url);
        }else {
            return new Resource("default");
        }
    }
}

有了工厂之后，我们的主要逻辑就会简化：

public Resource load(String url) {
    // 1.根据url获取前缀
    String prefix = getPreFix(url);

    // 2.根据前缀，处理不同的资源(有很多的分支逻辑)
    return ResourceLoaderFactory.create(prefix, url);
}

1.a) 简单工厂的好处

这就是简单工厂设计模式，提取一个工厂类，工厂会根据传入的不同的类型，创建不同的产品，将创建对象的过程交给工厂类、其他业务需要某个产品时，直接使用create()创建，好处如下：

• 1.工厂将创建的过程进行封装，不需要关系创建的细节，更加符合面向对象思想
• 2.主要的业务逻辑不会被创建对象的代码干扰，代码更易阅读
• 3.产品的创建可以独立测试，更将容易测试
• 4.独立的工厂类只负责创建产品，更加符合单一原则

2) 工厂方法 Factory Method

对上面的代码进行重构。我们会为每一个 Resource 创建一个独立的工厂类，形成一个个小作坊，将每一个实例的创建过程交给工厂类完成。

2.a) 对工厂进行抽象化 (版本一)

回到的例子中，每一种url加载成不同的资源产品，那每一种资源都可以由一个独立的ResourceFactory生产，需要将生产资源的工厂类进行抽象：

public interface IResourceLoader {
    Resource load(String url);
}

为每一种资源创建与之匹配的实现：

// Http
public class HttpResourceLoader implements IResourceLoader {
    @Override
    public Resource load(String url) {
        // 省略复杂处理的创建过程
        return new Resource(url);
    }
}

// File
public class FileResourceLoader implements IResourceLoader {
    @Override
    public Resource load(String url) {
        // 省略复杂处理的创建过程
        return new Resource(url);
    }
}

// Classpath
public class ClasspathResourceLoader implements IResourceLoader {
    @Override
    public Resource load(String url) {
        // 省略复杂处理的创建过程
        return new Resource(url);
    }
}

// Default
public class DefaultResourceLoader implements IResourceLoader {
    @Override
    public Resource load(String url) {
        // 省略复杂处理的创建过程
        return new Resource(url);
    }
}

主要逻辑就会简化

private IResourceLoader resourceLoader;

public Resource load(String url) {
    // 1.根据url获取前缀
    String prefix = getPreFix(url);

    // 2.根据前缀选择不同的工厂，生产独自的产品
    if ("http".equals(prefix)){
        // 发起http请求下载资源....(代码复杂)
        resourceLoader = new HttpResourceLoader();
    } else if ("file".equals(prefix)) {
        // 建立流，做异常...(代码复杂)
        resourceLoader = new FileResourceLoader();
    } else if ("classpath".equals(prefix)) {
        // ......(代码复杂)
        resourceLoader = new ClasspathResourceLoader();
    }else {
        resourceLoader = new DefaultResourceLoader();
    }

    return resourceLoader.load(url);
}

当我们新增一种读取资源的方式时，只需要新增一个实现，并实现 IResourceLoader 接口即可。所以，工厂方法模式比起简单工厂模式更加符合开闭原则。

2.b) 对工厂进行缓存 (版本二)

们为每个产品引入了工厂，却发现需要为创建工厂这个行为付出代价，在创建工厂这件事上，仍然不符合开闭原则

为了解决上述的问题我们又不得不去创建一个工厂的缓存来统一管理工厂实例，以后使用工厂会更加的简单

主要业务逻辑优化为：使用静态代码块和Map进行缓存

// 略....
private static Map<String, IResourceLoader> resourceLoaderCache = new HashMap<>();

static {
    resourceLoaderCache.put("http", new HttpResourceLoader());
    resourceLoaderCache.put("file", new FileResourceLoader());
    resourceLoaderCache.put("classpath", new ClasspathResourceLoader());
    resourceLoaderCache.put("default", new DefaultResourceLoader());
}

/**
 * 资源加载
 * @param url file:// http:// classpath://
 * @return 资源类
 */
public Resource load(String url) {
    // 1.根据url获取前缀
    String prefix = getPreFix(url);

    // 2
    return resourceLoaderCache.get(prefix).load(url);
}
// 略....

2.c) 加载配置文件到缓存中 (版本三)

但是，当修改需求还是不够灵活，仍然需要修改static中的代码，将工厂类进行配置，加载配置文件到缓存中

创建resourceLoad.properties

http=com.dcy.factoryMethod.resourceFactory.impl.HttpResourceLoader
file=com.dcy.factoryMethod.resourceFactory.impl.FileResourceLoader
classpath=com.dcy.factoryMethod.resourceFactory.impl.ClasspathResourceLoader
default=com.dcy.factoryMethod.resourceFactory.impl.DefaultResourceLoader

主要业务逻辑优化为：

// 略...
private static Map<String, IResourceLoader> resourceLoaderCache = new HashMap<>();

static {
    InputStream inputStream = Thread.currentThread().getContextClassLoader().getResourceAsStream("resourceLoad.properties");
    Properties properties = new Properties();
    try {
        properties.load(inputStream);

        for (Map.Entry<Object, Object> entry : properties.entrySet()) {
            String key = entry.getKey().toString();
            Class<?> clazz = Class.forName(entry.getValue().toString());
            IResourceLoader loader = (IResourceLoader) clazz.getConstructor().newInstance();
            resourceLoaderCache.put(key, loader);
        }

    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

public Resource load(String url) {
    // 1.根据url获取前缀
    String prefix = getPreFix(url);

    // 2.
    return resourceLoaderCache.get(prefix).load(url);
}

// 略...

好处：

• 1.完成满足开闭原则。当需要扩充需求是，只需要新增实现和修改配置文件，不需要修改一行代码
• 2.完全解耦

c.1) 产品线

事实上，在工作中，我们的产品可能是及其复杂的，我们同样需要对整个产品线进行抽象

public abstract class AbstractResource {

    private String url;

    public AbstractResource() {
    }

    public AbstractResource(String url) {
        this.url = url;
    }

    protected void shared() {
        System.out.println("这是共享方法");
    }

    /**
     * 每个子类需要独自实现的方法
     * @return 字节流
     */
    public abstract InputStream getInputStream();

}

为每一种产品创建与之匹配的实现：

// classpath
public class ClasspathResource extends AbstractResource {
    public ClasspathResource() {
    }

    public ClasspathResource(String url) {
        super(url);
    }

    @Override
    public InputStream getInputStream() {
        return null;
    }
}

// Http
public class HttpResource extends AbstractResource {
    public HttpResource() {
    }

    public HttpResource(String url) {
        super(url);
    }

    @Override
    public InputStream getInputStream() {
        return null;
    }
}

// Default
public class DefaultResource extends AbstractResource {
    public DefaultResource() {
    }

    public DefaultResource(String url) {
        super(url);
    }

    @Override
    public InputStream getInputStream() {
        return null;
    }
}

修改IResourceLoader接口，将返回一个产品的资源

public interface IResourceLoader {
    AbstractResource load(String url);
}

修改实现工厂的方法

public class ClasspathResourceLoader implements IResourceLoader {
    @Override
    public AbstractResource load(String url) {
        // 省略复杂处理的创建过程
        return new ClasspathResource(url);
    }
}

主要 加载资源load()业务逻辑修改为

public AbstractResource load(String url) {
    // 1.根据url获取前缀
    String prefix = getPreFix(url);

    // 2.
    return resourceLoaderCache.get(prefix).load(url);
}

c.抽象工厂模式 (Abstract Factory)

重要性比不上简单工厂和工厂方法

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

多种类型的产品，即增加产品族。如：抽象多种产品类型

public interface Resource {
    InputStream getInputStream();
}

// 抽象文本类型
public abstract class AbstractTextResource implements Resource {
    // 略....
}

// 抽象图片类型
public abstract class AbstractPictureResource implements Resource {
	// 略....
}

// 抽象视频资源
public abstract class AbstractVideoResource implements Resource {
    // 略....
}

每一个工厂实例都可以生产一个产品族

/**
 * IResourceFactory，每一个工厂实例都可以生产一个产品族
 */
public interface IResourceLoader {
    /**
     * 加载图片资源的工厂方法
     * @param url 资源路径
     * @return 图片资源
     */
    AbstractPictureResource loadPicture(String url);

    /**
     * 加载视频资源的工厂方法
     * @param url 资源路径
     * @return 视频资源
     */
    AbstractVideoResource loadVideo(String url);

    /**
     * 加载文本资源的工厂方法
     * @param url 资源路径
     * @return 文本资源
     */
    AbstractTextResource loadText(String url);
}

每一个工厂都对应各自的产品生产线

// Classpath
public class ClasspathResourceLoader implements IResourceLoader {

    @Override
    public AbstractPictureResource loadPicture(String url) {
        return new ClasspathPictureResource(url);
    }

    @Override
    public AbstractVideoResource loadVideo(String url) {
        return new ClasspathVideoResource(url);
    }

    @Override
    public AbstractTextResource loadText(String url) {
        return new ClasspathTextResource(url);
    }
}
// Default
public class DefaultResourceLoader implements IResourceLoader {
    @Override
    public AbstractPictureResource loadPicture(String url) {
        return new DefaultPictureResource(url);
    }

    @Override
    public AbstractVideoResource loadVideo(String url) {
        return new DefaultVideoResource(url);
    }

    @Override
    public AbstractTextResource loadText(String url) {
        return new DefaultTextResource(url);
    }
}
// Http
public class HttpResourceLoader implements IResourceLoader {
    @Override
    public AbstractPictureResource loadPicture(String url) {
        return new HttpPictureResource(url);
    }

    @Override
    public AbstractVideoResource loadVideo(String url) {
        return new HttpVideoResource(url);
    }

    @Override
    public AbstractTextResource loadText(String url) {
        return new HttpTextResource(url);
    }
}

总结：3种工厂模式

简单工厂：一个工厂生产不同产品

静态资源工厂(工厂方法)：一个工厂生产一个产品

抽象工厂：一个工厂生产一个产品族，每一个产品族之间可能会有共享或交叉

当创建逻辑比较复杂，是一个“大工程”的时候，我们就应该考虑使用工厂模式，封装对象的创建过程，将对象的创建和使用相分离。

何为创建逻辑比较复杂呢？

• 类似规则配置解析的例子，代码中存在 if-else 分支判断。将这一大坨 if-else 创建对象的代码抽离出来，放到工厂类中。
• 单个对象本身的**创建过程比较复杂，**比如前面提到的要组合其他类对象，做各种初始化操作。在这种情况下，我们也可以考虑使用工厂模式，将对象的创建过程封装到工厂类中。

工厂模式的作用：

• 1.封装变化：创建逻辑有可能变化，封装成工厂类之后，创建逻辑的变更对调用者透明。
• 2.代码复用：创建代码抽离到独立的工厂类之后可以复用。
• 3.隔离复杂性：封装复杂的创建逻辑，调用者无需了解如何创建对象。
• 4.控制复杂度：将创建代码抽离出来，让原本的函数或类职责更单一，代码更简洁，测试更方便