懒汉单例模式+抽象工厂模式

,1，基础类，接口

public interface SendServiceInterface {

    boolean send (String content);

    default void sendLog (String content, Boolean isSuccess) {
        System.out.println(String.format("content :: %s,isSuccess :: %s",content,isSuccess));
    }
}

@Data
public class EmailU  implements SendServiceInterface{


    @Override
    public boolean send(String content) {
        System.out.println("send Email ...");
        sendLog(content,false);
        return false;
    }
}

public class SmsU  implements SendServiceInterface{
    @Override
    public boolean send(String content) {
        System.out.println("send Sms ...");
        sendLog(content,true);
        return true;
    }
}

2，工厂类，接口：

public interface Provider {

    SendServiceInterface product ();

}

双重检查单例模式

public class SmsFactory implements Provider{

    //双重检查单例模式：线程安全，同步锁性能损耗，
    /**
     * volatile关键字 禁止new的时候重排序；
     * new 对象时，会有三条字节码指令：
     * 1，堆中创建对象；
     * 2，初始化堆中对象；
     * 3，将对象的地址赋值给变量。
     */
    private volatile static SmsFactory smsFactory;

    public static SmsFactory getInstance (){
        if (smsFactory == null){
            synchronized (SmsFactory.class){
                if (smsFactory == null){
                    smsFactory = new SmsFactory();
                }
            }
        }

        return smsFactory;
    }

    @Override
    public SendServiceInterface product() {
        return new SmsU();
    }
}

静态内部类实现单例模式

public class EmailFactory implements Provider{

    //静态内部类实现单例模式：利用类加载机制，线程安全，避免同步锁带来的性能损耗
    static class LazyHolder {
        private static final EmailFactory INSTANCE = new EmailFactory();
    }

    public static EmailFactory getInstance (){
        return LazyHolder.INSTANCE;
    }

    @Override
    public SendServiceInterface product() {
        return new EmailU();
    }
}