设计模式-工厂模式

在讲述之前先通过一个生活中的例子感受一下工厂模式的作用。

```
工厂流水线在生产的时候，不可避免的一个问题，类的实现用 new关键字实现，如 new 1()来实现。
如果有一天，我们想用new 2()来实现，那我们只能打开代码，把代码改了，改成new 2()实现。

问题在于，我们的应用都是web开发，都是部署到服务器上的，如果每次修改都需要改源码的话，
带来的问题就是我们每次在用的时候都会重新编译，重新部署，重新启动服务器，这显然不是
一个很好的解决办法。

所以我们把new关键字给屏蔽了，而是使用工厂为我们去生产一个sqlsession对象，
这样就解决了类之间的依赖关系。
```
而我们常说的工厂模式其实细分为三类，即：简单工厂模式、工厂模式、抽象工厂模式。下面我们通过概念以及例子理解下工厂模式。

**简单工厂模式**
专门定义一个类用来负责创建其他类的实例，被创建的实例通常都具有共同的父类。

举一个例子：
郝某人喜欢吃面条(emm……可能是假的，就当真喜欢吃面吧！)
那么我们可以定义一个接口。(注意此处的接口是广义的，即可以是类也可以是接口)，此处我们用接口。(面向接口编程好一点嘛)好的，进入正题！定义一个面条接口。诺，如下。

```java
public interface INoodles {
void desc();
}
```

 

接着干啥呢？当然是定义一些面条接口的具体实现类了呀！兰州拉面、老坛酸菜泡面、武汉热干面？这几种面还可以吧！可以可以还是可以的吧。来。我们看代码。

 

```java
/*
兰州拉面呀
*/
public class Lzlm implements INoodles {
@Override
public void desc() {
System.out.println("兰州拉面，当然兰州才卖有。哈哈，开个玩笑。");
}
}
```

```java
/*
泡面呀
*/
public class PaoNoodles implements INoodles {
@Override
public void desc() {
System.out.println("泡面当然不可少了呀，但是要少吃呀……");
}
}
```

```java
/*
武汉热干面
*/
public class WuhanNoodles implements INoodles {
@Override
public void desc() {
System.out.println("正义也需会晚到，但武汉热干面绝不缺席。呀，嘴瓢了。");
}
}
```

 

具体产品做完了，接下来我们做点什么呢？来，我们去“郝氏面馆”(简单工厂类)看看都有什么饭吧。

 

```java
/*
面馆(简单工厂类)
*/
public class HaoSyFactory {
public static final int ID_LZLM = 1;//兰州拉面
public static final int ID_PM = 2;//泡面
public static final int ID_WHRGM = 3;//武汉热干面

public static INoodles createNoodles(int ID) {
switch (ID) {
case ID_LZLM:
return new Lzlm();
case ID_PM:
return new PaoNoodles();
case ID_WHRGM:
default:
return new WuhanNoodles();
}
}
}

```

 

呼，别急，我们测试一下，简单工厂就完结撒花了呀。

```java
/*
测试测试呀(简单工厂模式)
*/
public class Test {
public static void main(String[] args) {
INoodles noodles= HaoSyFactory.createNoodles(HaoSyFactory.ID_WHRGM);
noodles.desc();
}

}
```

 

贴一张结果哇。

总结一下呀：
简单工厂：
**特点**
它是一个具体的类，非接口 抽象类。有一个重要的create()方法，利用if或者 switch创建产品并返回。
create()方法通常是静态的，所以也称之为静态工厂。
**缺点**
扩展性差（我想增加一种面条，除了新增一个面条产品类，还需要修改工厂类方法）
不同的产品需要不同额外参数的时候 不支持。

俗话说嘛，你不完美，那就有比你厉害完美点的呀。接下来我们看下工厂方法模式。

**工厂方法模式**
**概念:**
定义一个用于创建对象的接口，让子类觉得实例化哪一个类，使一个类的实例化延迟到其子类。
**作用：**
可以一定程度上**解耦**，消费者和产品实现类隔离开，只依赖产品接口(抽象产品)，产品实现类如何改动与消费者完全无关。
可以一定程度增加扩展性，若增加一个产品实现，只需要实现产品接口，修改工厂创建产品的方法，消费者可以无感知（若消费者不关心具体产品是什么的情况）。
可以一定程度增加代码的封装性、可读性。清楚的代码结构，对于消费者来说很少的代码量就可以完成很多工作。
等等。
另外，**抽象工厂才是实际意义的工厂模式**，工厂方法只是抽象工厂的一个比较常见的情况。
**适用场景：**
消费者不关心它所要创建对象的类(产品类)的时候。
消费者知道它所要创建对象的类(产品类)，但不关心如何创建的时候。
等等。
例如：hibernate里通过sessionFactory创建session、通过代理方式生成ws客户端时，通过工厂构建报文中格式化数据的对象。
**模式要素**
提供一个产品类的接口。产品类均要实现这个接口(也可以是abstract类，即抽象产品)。

提供一个工厂类的接口。工厂类均要实现这个接口(即抽象工厂)。

由工厂实现类创建产品类的实例。工厂实现类应有一个方法，用来实例化产品类。

概念终于过去了，来来来，我们看例子呀。

先定义一个工厂接口呀。

```java
/*
工厂方法模式(工厂模式)
*/
public interface IMyMessageFactory {
IMyMessage createMessage(String messageType);
}
```

 

然后，我们实现这个接口哇。

```java
/*
工厂实现类
*/
public class MyMessageFactory implements IMyMessageFactory {
@Override
public IMyMessage createMessage(String messageType) {
IMyMessage myMessage;
Map<String, Object> messageParam = new HashMap<String, Object>();
// 根据某些条件去选择究竟创建哪一个具体的实现对象，条件可以传入的，也可以从其它途径获取。
// sms
if ("SMS".equals(messageType)) {
myMessage = new MyMessageSms();
messageParam.put("PHONENUM", "123456789");
} else
// OA待办
if ("OA".equals(messageType)) {
myMessage = new MyMessageOaTodo();
messageParam.put("OAUSERNAME", "testUser");
} else
// email
if ("EMAIL".equals(messageType)) {
myMessage = new MyMessageEmail();
messageParam.put("EMAIL", "test@test.com");
} else
// 默认生产email这个产品
{
myMessage = new MyMessageEmail();
messageParam.put("EMAIL", "test@test.com");
}
myMessage.setMessageParam(messageParam);
return myMessage;
}
}
```

 

工厂有了，我们定义一下产品呀，先定义产品接口。

 

```java
/*
产品接口
*/
public interface IMyMessage {
Map<String, Object> getMessageParam();
void setMessageParam(Map<String, Object> messageParam);
void sendMesage() throws Exception;// 发送通知/消息
}

```

 

然后，我们定义几个产品的实现类呀。
一口气定义3个好不好，好的好的啊。

 

```java
public class MyAbstractMessage implements IMyMessage {
private Map<String, Object> messageParam;// 这里可以理解为生产产品所需要的原材料库。最好是个自定义的对象，这里为了不引起误解使用Map。

@Override
public Map<String, Object> getMessageParam() {
return messageParam;
}

@Override
public void setMessageParam(Map<String, Object> messageParam) {
this.messageParam = messageParam;
}

@Override
public void sendMesage() throws Exception {

}
}
```

 

上面是实现了接口，我们下面3个产品用继承类的方式来展示展示。

 

```java
public class MyMessageEmail extends MyAbstractMessage{
@Override
public void sendMesage() throws Exception {
// TODO Auto-generated method stub
if (null == getMessageParam() || null == getMessageParam().get("EMAIL")
|| "".equals(getMessageParam().get("EMAIL"))) {
throw new Exception("发送短信,需要传入EMAIL参数");// 为了简单起见异常也不自定义了
}// 另外邮件内容，以及其他各种协议参数等等都要处理

System.out.println("我是邮件，发送通知给" + getMessageParam().get("EMAIL"));
}
}

```

```java
public class MyMessageOaTodo extends MyAbstractMessage {

@Override
public void sendMesage() throws Exception {
// TODO Auto-generated method stub
if (null == getMessageParam()
|| null == getMessageParam().get("OAUSERNAME")
|| "".equals(getMessageParam().get("OAUSERNAME"))) {
throw new Exception("发送OA待办,需要传入OAUSERNAME参数");// 为了简单起见异常也不自定义了
}// 这里的参数需求就比较多了不一一处理了

System.out
.println("我是OA待办，发送通知给" + getMessageParam().get("OAUSERNAME"));
}

}
```

```java
public class MyMessageSms extends MyAbstractMessage {

@Override
public void sendMesage() throws Exception {
// TODO Auto-generated method stub
if (null == getMessageParam()
|| null == getMessageParam().get("PHONENUM")
|| "".equals(getMessageParam().get("PHONENUM"))) {
throw new Exception("发送短信,需要传入PHONENUM参数");// 为了简单起见异常也不自定义了
}// 另外短信信息，以及其他各种协议参数等等都要处理

System.out.println("我是短信，发送通知给" + getMessageParam().get("PHONENUM"));
}

}
```

 

快，再定义一个测试类，工厂方法模式就完结撒花了哦。

 

```java
public class MyFactoryMethodMain {
public static void main(String[] args) {
IMyMessageFactory myMessageFactory = new MyMessageFactory();
IMyMessage myMessage;
// 对于这个消费者来说，不用知道如何生产message这个产品，耦合度降低
try {
// 先来一个短信通知
myMessage = myMessageFactory.createMessage("SMS");
myMessage.sendMesage();

// 来一个oa待办
myMessage = myMessageFactory.createMessage("OA");
myMessage.sendMesage();

// 来一个邮件通知
myMessage = myMessageFactory.createMessage("EMAIL");
myMessage.sendMesage();
} catch (Exception e) {
e.printStackTrace();
}
}
}
```

 

呼，可真是复杂，来看下运行结果把。

快，再有一个抽象工厂模式（真正的工厂模式）我们就GET到它了哇。

**抽象工厂模式**
概念：
提供一个创建一系列相关或者相互依赖对象的接口，而无需指定他们具体的类。

抽象模式我们暴力一点哦，直接上全部代码。你看。

```java
interface IProduct1 { 
public void show(); 
} 
interface IProduct2 { 
public void show(); 
} 

class Product1 implements IProduct1 { 
public void show() { 
System.out.println("这是1型产品"); 
} 
} 
class Product2 implements IProduct2 { 
public void show() { 
System.out.println("这是2型产品"); 
} 
} 

interface IFactory { 
public IProduct1 createProduct1(); 
public IProduct2 createProduct2(); 
} 
class Factory implements IFactory{ 
public IProduct1 createProduct1() { 
return new Product1(); 
} 
public IProduct2 createProduct2() { 
return new Product2(); 
} 
} 

public class Client { 
public static void main(String[] args){ 
IFactory factory = new Factory(); 
factory.createProduct1().show(); 
factory.createProduct2().show(); 
} 
}
```

 

其实简单的看一下就可以看明白。
下面我们说下抽象工厂的优缺点啊。

**抽象工厂模式的优点**
抽象工厂模式除了具有工厂方法模式的优点外，最主要的优点就是可以在类的内部对产品族进行约束。所谓的产品族，一般或多或少的都存在一定的关联，抽象工厂模式就可以在类内部对产品族的关联关系进行定义和描述，而不必专门引入一个新的类来进行管理。

**抽象工厂模式的缺点**
产品族的扩展将是一件十分费力的事情，假如产品族中需要增加一个新的产品，则几乎所有的工厂类都需要进行修改。所以使用抽象工厂模式时，对产品等级结构的划分是非常重要的。

**适用场景**
当需要创建的对象是一系列相互关联或相互依赖的产品族时，便可以使用抽象工厂模式。说的更明白一点，就是一个继承体系中，如果存在着多个等级结构（即存在着多个抽象类），并且分属各个等级结构中的实现类之间存在着一定的关联或者约束，就可以使用抽象工厂模式。假如各个等级结构中的实现类之间不存在关联或约束，则使用多个独立的工厂来对产品进行创建，则更合适一点。

呀，上面3段话，是别出摘录的，其实说的简单一点，利用工厂模式的目的是什么呢？是解耦呀。对的，**在使用工厂模式时，只需要关心降低耦合度的目的是否达到了就OK。**

最后的最后，总结一下工厂方法模式和抽象工厂模式的核心区别：

工厂方法模式利用继承，抽象工厂模式利用组合
工厂方法模式产生一个对象，抽象工厂模式产生一族对象
工厂方法模式利用子类创造对象，抽象工厂模式利用接口的实现创造对象

终于码完了，所以，小伙伴，今天你Get到工厂模式了吗？