Happy 设计模式之工厂模式（Java）

闲暇之余学习设计模式。只是把我理解的整理成笔记，如果有不对的地方，请各位大牛指出。

工厂模式
1、简单工厂模式、
2、工厂方法模式、
3、抽象工厂模式、

下面首先介绍简单工厂模式：
先看代码：

import java.util.Map;

/**
 * 发送服务
 * @author lenovo
 *
 */
public interface SendService {

    /**
     * 发送服务
     * @param messageBody
     * @return
     */
    public String sendMessage(Map<String, String> messageBody);

}

import java.util.HashMap;
import java.util.Map;

import com.alibaba.fastjson.JSONObject;

/**
 * 邮件服务
 * 
 * @author lenovo
 *
 */
public class EmailSendService implements SendService{

    @Override
    public String sendMessage(Map<String, String> messageBody) {
        //messageBody处理message业务，map可以应用里面传参数
        System.out.println("email-requst-messsage->" + JSONObject.toJSONString(messageBody));

        //返回的具体信息
        Map<String, String> response = new HashMap<String, String>();
        response.put("code", "5000");
        response.put("data", "成功发送邮件服务");

        //返回的json字符串
        String json = JSONObject.toJSONString(response);
        return json;
    }

}

import java.util.HashMap;
import java.util.Map;

import com.alibaba.fastjson.JSONObject;

/**
 * 短信服务
 * 
 * @author lenovo
 *
 */
public class SmsService implements SendService{

    @Override
    public String sendMessage(Map<String, String> messageBody) {
        //messageBody处理message业务，map可以应用里面传参数
    System.out.println("sms-requst-messsage->" + JSONObject.toJSONString(messageBody));

        //返回的具体信息
        Map<String, String> response = new HashMap<String, String>();
        response.put("code", "5000");
        response.put("data", "成功发送短信服务");

        //返回的json字符串
        String json = JSONObject.toJSONString(response);
        return json;
    }

}

/**
 * 工厂类
 * 
 * @author lenovo
 *
 */
public class SendServiceFactory {

    /**
     * 创建发送服务模式
     * 
     * @param sendType
     * @return
     * @throws Exception
     */
    public static SendService createSendServiceFactory(String sendType) throws Exception {
        if(sendType == null)
            throw new Exception();
        if(sendType.equals("sms")) {
            return new SmsService();
        }
        else if(sendType.equals("email")) {
            return new EmailSendService();
        }
        else {
            throw new Exception();
        }
    }

}

import java.util.HashMap;
import java.util.Map;

public class SendClient {

    public static void main(String[] args) throws Exception {
        SendService smservice = SendServiceFactory.createSendServiceFactory("sms");
        Map<String, String> request = new HashMap<String, String>();
        request.put("body", "您好，请在三分钟内完成验证!");
        request.put("code", "2121");

        String response = smservice.sendMessage(request);
        System.out.println("response:" + response);
    }

}

输出
自己打印

到此简单工厂模式已经开发完毕，说下具体的细节。
简单工厂模式角色：
抽象产品角色-》SendService（发送服务）
具体产品角色-》EmailSendService和SmsService
工厂类角色-》SendServiceFactory
解释：建立一个工厂，来创建产品即可。客户端可以免除创建产品，以往的经验，用什么产品我直接在客户端new了，还需要产品的具体角色，这种模式，一看就是不太好，每当增加一个产品服务，都需要更改工厂类再添加一个具体产品服务。

工厂方法模式：
代码：
EmailSendService和SmsService和SendService没有变，还是原来的那套。
额外增加了邮件服务和短信服务的各自的工厂类。

/**
 * 抽象工厂角色
 * @author lenovo
 *
 */
public interface SendFactory {

    public SendService factory();

}

/**
 * 短信工厂
 * @author lenovo
 *
 */
public class SmsServiceFactory implements SendFactory{

    @Override
    public SendService factory() {
        // TODO Auto-generated method stub
        return new SmsService();
    }

}

/**
 * email服务工厂
 * @author lenovo
 *
 */
public class EmailSendServiceFactory implements SendFactory{

    @Override
    public SendService factory() {
        // TODO Auto-generated method stub
        return new EmailSendService();
    }

}

public class SendClient {

    public static void main(String[] args) throws Exception {
//      SendService smservice = SendServiceFactory.createSendServiceFactory("sms");
        Map<String, String> request = new HashMap<String, String>();
        request.put("body", "您好，请在三分钟内完成验证!");
        request.put("code", "2121");
//      
//      String response = smservice.sendMessage(request);
//      System.out.println("response:" + response);

        SendFactory emailservice = new EmailSendServiceFactory();
        String emailResponse = emailservice.factory().sendMessage(request);
        System.out.println("emailResponse:" + emailResponse);

        SendFactory smsFactory = new SmsServiceFactory();
        String smsResponse = smsFactory.factory().sendMessage(request);
        System.out.println("smsResponse:" + smsResponse);
    }

}

输出：
email-requst-messsage->{"code":"2121","body":"您好，请在三分钟内完成验证!"}
emailResponse:{"code":"5000","data":"成功发送邮件服务"}
sms-requst-messsage->{"code":"2121","body":"您好，请在三分钟内完成验证!"}
smsResponse:{"code":"5000","data":"成功发送短信服务"}

到此工厂方法模式完事：
角色：
1、抽象产品
2、具体的产品角色
3、抽象工厂
4、具体的产品对应的工厂
相比较简单工厂模式，区别在于，每个服务都有自己的工厂，工厂方法模式不在需要简单工厂的工厂类（SendServiceFactory），工厂方法每个都有自己的工厂，可以自己生产自己的服务，并且，再新添加服务的时候，原来的服务一点不需要动，直接可以平滑的添加，不影响其它业务代码。

抽象工厂模式：
代码:

/**
 * 手机
 * @author sdc
 *
 */
public interface Phone {

    public void createPhone();

}

/**
 * oppo手机生产线
 * @author sdc
 *
 */
public class OppoPhone implements Phone{

    @Override
    public void createPhone() {
        // TODO Auto-generated method stub
        System.out.println("生产oppo手机");
    }

}

/**
 * vivo生产线
 * @author sdc
 *
 */
public class VivoPhone implements Phone{

    @Override
    public void createPhone() {
        // TODO Auto-generated method stub
        System.out.println("生产vivo手机");
    }

}

/**
 * 手机工厂
 * @author sdc
 *
 */
public abstract class PhoneFactory {

    public abstract Phone createOppoPhone();

    public abstract Phone createVivoPhone();
}

/**
 * 工厂1，来生产oppo和vivo
 * @author sdc
 *
 */
public class PhoneFactory1 extends PhoneFactory{

    @Override
    public Phone createOppoPhone() {
        // TODO Auto-generated method stub
        return new OppoPhone();
    }

    @Override
    public Phone createVivoPhone() {
        // TODO Auto-generated method stub
        return new VivoPhone();
    }

}

/**
 * 客户端类
 * @author sdc
 *
 */
public class Client {

    public static void main(String[] args) {
        PhoneFactory pf1 = new PhoneFactory1();
        Phone oppoPhone = pf1.createOppoPhone();
        Phone vivoPhone = pf1.createVivoPhone();

        oppoPhone.createPhone();

        vivoPhone.createPhone();
    }

}

代码完结；

从代码可以看出一个生产线上的vivo手机和oppo手机被一个工厂生产出来，如果某个公司想再开一个分厂同样生产这个vivo和oppo手机，就是单纯呢实现那个抽象工厂模式或者甚至可以用那个厂的实现类即可，可以看出非常方便。
但是，如果再加一个产品：华为呢？是不是要更改抽象工厂，原来实现此抽象工厂的类都要重写，其实这就是抽象工厂和工厂方法的模式的区别。

本文转自 豆芽菜橙 51CTO博客，原文链接:http://blog.51cto.com/shangdc/2052728