再战设计模式(一)之单例模式

关于设计模式,之前已经看过很多很多了.但是每次到过了很久之后,在此回忆总是感觉有模糊的感觉.这次我要重新学习一下设计模式.并在这里做一个博客记录,以作为以后的备忘吧.大家看过如果有问题或者更好的方式,可以在评论留言

这篇文章也是我写设计模式的开章.主要方式是看视频和看书,设计模式被人称为GOF23 主要就是国外有4个编程牛人编写的这23中设计模式.大家主要理解人家的思想.而不是死记硬背,这句话也是对我自己说的.

设计模式的分类

1.创建型模式:5种

单例模式工厂模式抽象工厂模式建造者模式原型模式

2.结构型模式 7种

适配模式桥接模式装饰模式组合模式外观模式享元模式代理模式

3.行为模式:11 种

模板方法模式命令模式迭代器模式观察者模式中介者模式备忘录模式解释器模式状态模式策略模式职责链模式访问者模式

分类主要是为了方便记忆突然想到了jdk 8 有 9个函数式接口想回忆下

单例模式的实现

单例模式-饿汗模式

　　饿汉模式顾名思义就是非常饿,直接吃.其实关于单例模式的总结就一句话,私有构造方法,提供外部获取实例的方法

　　所以在类加载的时候对象已经创建好了.方法没有锁,调用效率高!

/**
 * @Created by xiaodao
 */
public class Sington01 {

    //类初始化时立即加载对象(没有延迟加载的优势)，天然的线程安全
    private static Sington01 instance = new Sington01();


    private Sington01() {
    }

    public static Sington01 getInstance(){
        return instance;
    }
}

延时加载模式

public class Sington02 {

    /***
     * 延时加载模式,在调用的时候,才会获取对像
     */
    private static Sington02 sington ;

    private Sington02() {
    }

    /**
     * 同步调用效率低
     * @return
     */
    public static Sington02 getInstance(){
        synchronized (Sington02.class){
            if(null == sington){
                sington= new Sington02();
            }
            return sington;
        }
    }
}

双重检查 double-check单例模式

/**
 * @Created by xiaodao
 * 双重检索模式
 */
public class Sington03 {

    /***
     *
     */
    private static volatile  Sington03 sington ;

    private Sington03() {
    }

    /**
     *
     * @return
     */
    public static Sington03 getInstance(){
        if(sington !=null ){

        }else{
            synchronized (Sington03.class){
                if(sington== null){
                    sington = new Sington03();
                }
            }
        }
        return sington;

    }

    public static void main(String[] args) {
        Sington03 sington03 = getInstance();
        Sington03 sington04 = getInstance();
        System.out.println(sington03);
        System.out.println(sington04);
    }
}

静态内部类延时加载模式

/**
 * @Created by xiaodao
 * 
 */
public class Sington04 {

    /***
     *
     */
    private static class Sington04Interior {
        private static Sington04 instance= new Sington04();
    };

    private Sington04() {
    }

    /**
     *
     * @return
     */
    public static Sington04 getInstance(){
        return Sington04Interior.instance;
    }

    public static void main(String[] args) {
        Sington04 sington03 = getInstance();
        Sington04 sington04 = getInstance();
        System.out.println(sington03);
        System.out.println(sington04);
    }
}

View Code

加载类的时候外部没有static属性不会像恶汉模式一样立即加载对象

只有getInstance才会加载静态内部类.是线程安全的

兼备了并发高效和延迟加载的优势

枚举方式实现单例模式

/**
 * @Created by xiaodao
 *
 */
public enum  Sington05 {

    /***
     * 定义一个枚举.代表singleton的一个实例
     */
    INSTANCE;
    public void singletonOperator(){
        //这个单例的功能处理
    }

    public static void main(String[] args) {
        Sington05 sington05 = Sington05.INSTANCE;
    }

}

枚举的单例,可以避免反射和反序列来破解,实现比较简单

反射跳过单例

 public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {

        //第一次调用.
//        Sington06 instance = Sington06.getInstance();
//        System.out.println(instance);
        Class<Sington06> aClass = (Class<Sington06>) Class.forName("com.xiaodao.jdk8.disign.sington.Sington06");
        //获取构造器
        //第二次调用.
        Constructor<Sington06> declaredConstructor = aClass.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        Sington06 s2 = declaredConstructor.newInstance();
        Sington06 s1 = declaredConstructor.newInstance();
        System.out.println(s1);
        System.out.println(s2);
        //第三次.
        Sington06 instance = Sington06.getInstance();
        System.out.println(instance);
        Sington06 s3 = declaredConstructor.newInstance();
    }

这种方式可以跳过单例模式,需要在单例模式里加一个判断.

private Sington06() {
    if(sington !=null){
       throw  new RuntimeException();
    }
}

平时我们写项目不需要这样的判断.但是如果是写个框架的话,可能需要严谨一点,但是这也是有漏洞的,如果你没有创建过一次单例,那么通过反射就是无数次调用,如果你创建了.那么就不能通过反射就创建了.

反序列化破解与防止反序列破解

 Sington06 instance = Sington06.getInstance();
        System.out.println(instance);

        FileOutputStream out = new FileOutputStream("/Users/xuyuanfang/study/java视频/disgin/a.txt");
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(out);
        objectOutputStream.writeObject(instance);
        out.close();
        objectOutputStream.close();

        //反序列化

        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("/Users/xuyuanfang/study/java视频/disgin/a.txt"));
        Sington06 s3 = (Sington06) objectInputStream.readObject();
        System.out.println(s3);

防止破解:

    /**
     * 反序列化 如果定义了readResolve方法 直接调用这个方法返回对象,不需要重新创建对象
     * @return
     */
    public Object readResolve() throws ObjectStreamException {
        return  sington;
    }

效率对比

恶汉模式,比懒汉方式在多线程环境下效率好点

如何选用呢?

如果对象占用资源少,不需要延时加载

枚举比恶汉式比较好

如果对象资源占用比较大的话.需要延时加载

静态内部类好于懒汉式