工厂模式

2) 工厂方法 Factory Method

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

总结：3种工厂模式

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()创建，好处如下：

2) 工厂方法 Factory Method

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

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

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

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

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

// Http
 public class HttpResourceLoader implements IResourceLoader {@Overridepublic Resource load(String url) {// 省略复杂处理的创建过程return new Resource(url);}
 }// File
 public class FileResourceLoader implements IResourceLoader {@Overridepublic Resource load(String url) {// 省略复杂处理的创建过程return new Resource(url);}
 }// Classpath
 public class ClasspathResourceLoader implements IResourceLoader {@Overridepublic Resource load(String url) {// 省略复杂处理的创建过程return new Resource(url);}
 }// Default
 public class DefaultResourceLoader implements IResourceLoader {@Overridepublic 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 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);// 2return 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 resourceLoaderCache = new HashMap<>();static {InputStream inputStream = Thread.currentThread().getContextClassLoader().getResourceAsStream("resourceLoad.properties");Properties properties = new Properties();try {properties.load(inputStream);for (Map.Entry 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);
 }// 略...
 

好处：

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);}@Overridepublic InputStream getInputStream() {return null;}
 }// Http
 public class HttpResource extends AbstractResource {public HttpResource() {}public HttpResource(String url) {super(url);}@Overridepublic InputStream getInputStream() {return null;}
 }// Default
 public class DefaultResource extends AbstractResource {public DefaultResource() {}public DefaultResource(String url) {super(url);}@Overridepublic InputStream getInputStream() {return null;}
 }
 

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

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

修改实现工厂的方法

public class ClasspathResourceLoader implements IResourceLoader {@Overridepublic 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 {@Overridepublic AbstractPictureResource loadPicture(String url) {return new ClasspathPictureResource(url);}@Overridepublic AbstractVideoResource loadVideo(String url) {return new ClasspathVideoResource(url);}@Overridepublic AbstractTextResource loadText(String url) {return new ClasspathTextResource(url);}
 }
 // Default
 public class DefaultResourceLoader implements IResourceLoader {@Overridepublic AbstractPictureResource loadPicture(String url) {return new DefaultPictureResource(url);}@Overridepublic AbstractVideoResource loadVideo(String url) {return new DefaultVideoResource(url);}@Overridepublic AbstractTextResource loadText(String url) {return new DefaultTextResource(url);}
 }
 // Http
 public class HttpResourceLoader implements IResourceLoader {@Overridepublic AbstractPictureResource loadPicture(String url) {return new HttpPictureResource(url);}@Overridepublic AbstractVideoResource loadVideo(String url) {return new HttpVideoResource(url);}@Overridepublic AbstractTextResource loadText(String url) {return new HttpTextResource(url);}
 }
 

总结：3种工厂模式

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

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

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

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

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

工厂模式的作用：