设计模式--工厂模式

普通工厂模式

就是建立一个工厂类，对实现了同一接口的一些类进行实例的创建。

抽象接口

public interface Sender {
    void send();
}

 抽象接口的不同具体实现

import lombok.extern.slf4j.Slf4j;
@Slf4j
public class MailSender implements Sender {
    public void send(){
        log.info("发送邮件！！！");
    }
}

 

import lombok.extern.slf4j.Slf4j;
@Slf4j
public class SmsSender implements Sender {
    public void send(){
        log.info("发送短信！！！");
    }
}

 定义工厂类

@Slf4j
public class SenderFactory {
    public Sender produce(String type) {
        if ("mail".equals(type)) {
            return new MailSender();
        } else if ("sms".equals(type)) {
            return new SmsSender();
        } else {
            log.error("请输入正确的类型!");
            return null;
        }
    }
}

 

工厂方法模式

抽象接口和抽象接口的不同具体实现同上，差别在于工厂类：

public class SenderFactory {
    public Sender produceMail(){
        return new MailSender();
    }
    public Sender produceSms(){
        return new SmsSender();
    }
}

静态工厂方法模式（推荐）

抽象接口和抽象接口的不同具体实现同普通工厂，差别在于工厂类的方法为静态方法：

public class SenderFactory {
    public static Sender produceMail(){
        return new MailSender();
    }
    public static Sender produceSms(){
        return new SmsSender();
    }
}

抽象工厂模式（推荐）

工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则，所以，从设计角度考虑，有一定的问题，如何解决？就用到抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。

1、对发送行为抽象及具体实现；

2、对创建实施对象抽象及具体实现；

3、提供对外暴露接口及具体实现

/** 对生产实施对象的创建行为进行抽象**/
public interface SenderFactory {
    Sender getSender();
}

/***对生产实施对象的创建行为进行具体实现**/
public class MailSenderFactory implements SenderFactory{
    public Sender getSender(){
        return new MailSender();
    }
}

/** 对生产实施对象的创建行为进行具体实现**/
public class SmsSenderFactory implements SenderFactory{
    @Override
    public Sender getSender(){
        return new SmsSender();
    }
}

/** 对客户端暴露抽象接口**/
public abstract class AbstractSendFactory {
    public abstract void sendMail();
    public abstract void sendMsSms();
}

/** 对外暴露接口工厂的具体实现**/
public class SendFactory extends AbstractSendFactory {
    @Override
    public void sendMail() {
        new MailSenderFactory().getSender().send();
    }
    @Override
    public void sendMsSms() {
        new SmsSenderFactory().getSender().send();
    }
}

测试 

/**测试类**/
public class Test {
    public static void main(String[] args) {
        SendFactory factory=new SendFactory();
        factory.sendMail();
        System.out.println("=======================================================");
        factory.sendMsSms();
    }
}

其实这个模式的好处就是，如果你现在想增加一个功能：发即时信息，则只需做一个实现类，实现Sender接口，同时做一个工厂类，实现Provider接口，就OK了，无需去改动现成的代码。这样做，拓展性较好！