工厂模式之简单工厂、工厂方法、抽象工厂分析对比

工厂模式有三种分类，简单工厂（也叫静态工厂）、工厂方法模式、抽象工厂

 

一、简单工厂

简单工厂通俗的说就是提供一个类，这个类中的某个方法根据入参的不同来创建并返回实现了同一个接口的不同具体子类(产品)。

java实现如下：

1.首先定义一个接口（抽象产品）并定义核心方法

public interface Message {
    void  sendMessage();
}

 

2.编写基于该接口的不同实现类（具体产品）

class  Sms implements  Message  {
    @Override
    public void sendMessage() {
        System.out.println("send Sms msg");
    }
}
class  Email implements  Message {
    @Override
    public void sendMessage() {
        System.out.println("send Email msg");
    }
}

3.编写工厂类，工厂类一般有公用静态方法，根据入参创建不同的实现类

public class SimpleFactory {
    public  static   Message createMsg(String  msgType){
        Message msg=null;
        if ("sms".equals(msgType)){
            msg=new Sms();
        }
        else{
            msg=new Email();
        }
        return  msg;
    }

}

4.简单工厂测试

public static void main(String[] args) {
    SimpleFactory.createMsg("sms").sendMessage();
}

 

 

二、工厂方法模式

工厂方法模式去掉了简单工厂的静态属性，分化为抽象工厂和具体工厂。抽象工厂与最后创建的具体实现类（具体产品）无关，应用程序不直接调用。具体工厂是抽象工厂的具体类或实现类，根据业务逻辑创建不同的实现类（具体产品），一般一个具体产品对应一个具体工厂。还是以消息发送为例，工厂方法模式如下:

 

1.创建抽象产品和具体产品，同简单工厂模式第1、2步

 

--------------------------------------------------------略-----------------------------------------------

2.创建抽象工厂

public interface FactoryMessage {
    Message  createMessage();
}

3.实现抽象工厂，对没一个具体产品创建一个具体产品的工厂

//短信工厂类

public class FactorySms  implements  FactoryMessage{
    @Override
    public Message createMessage() {
        return new Sms();
    }
}

//邮件工厂类

public class FactoryEmail implements  FactoryMessage {
    @Override
    public Message createMessage() {
        return new Email();
    }
}

4.应用程序测试

public static void main(String[] args) {
    //短信工厂类 生产 短信产品
    FactoryMessage smsMessageFactory=new FactorySms();
    Message smsMessage=smsMessageFactory.createMessage();
    smsMessage.sendMessage();
    //邮件工厂类 生产 邮件产品
    FactoryMessage mailMessageFactory=new FactoryEmail();
    Message mailMessage=mailMessageFactory.createMessage();
    mailMessage.sendMessage();
}

三、抽象工厂模式

抽象工厂模式是工厂方法模式的升级版，一般用来创建一组相关或相互依赖的对象（产品），相对工厂方法抽象工厂的诞生是对象（产品）复杂度提升，产品本身包含多个相互关联的对象（组件产品）。

为了说明抽象工厂，此模式以笔记本电脑为例，假设笔记本有两个组件构成：显示器和CPU，戴尔笔记本有两款产品DellA(显示屏Sharpu和CPU Amdx)、DellB(显示屏Sharpv和CPU Intelx),这样由于笔记本产品包含显示器和处理器两个相互关联的组件产品，所以需要两个抽象产品角色显示器和CPU，而目前两个最终产品DellA和DellB为两个具体生产笔记本的工厂，抽象工厂模式如下:

1.创建抽象产品和具体产品

//显示器及其具体型号

public interface Monitor {
}

 

public class Sharpu implements  Monitor {

    public Sharpu(){
        System.out.println("制造-->Sharpu");
    }
}

 

public class Sharpv implements Monitor {
    public Sharpv(){
        System.out.println("制造-->Sharpv");
    }
}

 

//CPU及其具体型号

public interface CPU {
}

public class Amdx implements  CPU {
    public Amdx(){
        System.out.println("制造-->Amdx");
    }
}

public class Amdx implements  CPU {
    public Amdx(){
        System.out.println("制造-->Amdx");
    }
}

2.抽象工厂

//创建抽象工厂
public interface AbstractFactory {
     Monitor createMonitor();
     CPU createCPU();
}

3.具体工厂类

//为DellA笔记本生产配件
public class FactoryDellA implements  AbstractFactory {
    @Override
    public MonitorcreateMonitor() {
        return new Sharpu();
    }
    @Override
    public CPUcreateCPU() {
        return new Amdx();
    }
}

 

//为DellB笔记本生产配件
public class FactoryDellB implements  AbstractFactory {
    @Override
    public MonitorcreateMonitor() {
        return new Sharpv();
    }
    @Override
    public CPUcreateCPU() {
        return new Intelx();
    }

 

}

 

4.测试

public static void main(String[] args) {
    //生产dellA的配件
    AbstractFactory dellAFactory=new FactoryDellA();
    dellAFactory.createCPU();
    dellAFactory.createMonitor();
    //生产dellB的配件
    AbstractFactory dellBFactory=new FactoryDellB();
    dellBFactory.createCPU();
    dellBFactory.createMonitor();

}

 

 

总结：三种工厂模式，简单工厂当有新产品或者新业务出现时需要修改工厂的核心主逻辑，不利于业务扩展；工厂方法模式扩展新业务时只需要增加新的具体工厂类即可，但是当业务复杂时会出现大量的具体工厂，造成系统臃肿;抽象工厂更利于调用双方解耦，一般应用于复杂系统业务