设计模式基础之单例模式和工厂模式

设计模式

概念

• 软件设计模式（Design pattern），又称设计模式，是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。
• Java中有23种设计模式，本质是对面向对象设计原则的实际应用，是对类的封装、继承性和多态性，以及类的关联关系和组合关系的充分理解。

1. 对于简单的程序，可能一个简单的算法要比某种设计模式更加容易
2. 但是对于大型项目开发或者框架设计，用设计模式来组织代码显然更好
3. 根据用途，这些设计模式可以分为三大类：创建型模式、结构型模式和行为型模式

1、单例模式

1.1、单例设计模式的概念

  单例模式可以说是大多数开发人员在实际中使用最多的，常见的Spring默认创建的bean就是单例模式的。
  单例模式有很多好处，比如可以节约系统内存空间，控制资源的使用。
  单例模式最重要的是确保对象只有一个，也就是保证一个类在内存中的对象只有一个

1.2 饿汉式

• 目的：控制外键创建对象的个数，只能创建一个对象
• 开发步骤：

1. 私有化构造方法
2. 在类的内部创建好对象
3. 对外界提供一个公共的get()，返回一个已经准备好的对象
   优点：没有线程安全问题，简单（因为类加载的时候就已将创建类对象，不会再次创建对象，因此线程安全）
   缺点：提前初始化会演唱类加载器加载类的时间，如果不使用会浪费内存，不能传递参数

public class Singleton {
    //1私有化构造方法,不让外界new
    private Singleton(){
    }
    //在类的内部，创建好对象
    private static final Singleton instance = new Singleton();
    //对外界提供一个公共的get(),返回一个已经准备好的对象
    public static Singleton getInstance(){
        return instance;
    }
}

1.2.1 饿汉式解决资源浪费的问题

优点：解决线程安全，延迟初始化
缺点：暂时没有

public class Singleton {
    //1私有化构造方法,不让外界new
    private Singleton(){
    }
    //对外界提供一个公共的get(),返回一个已经准备好的对象
    public static Singleton getInstance(){
       return Holder.instance;
    }
    //加载外部内的时候才会加载静态类部类，实现了异步加载
    public static class Holder{
        //定义一个静态的变量instance
        private static Singleton instance=new Singleton();
    }
}

1.3 懒汉式

优点：易于使用，延迟初始化，节约资源。
缺点：当有多个线程同时调用getInstance()会出现线程安全问题，创建出两个instance对象

public class Singleton {
    //1私有化构造方法,不让外界new
    private Singleton(){
    }
    //定义一个静态的变量instance
    private static Singleton instance=null;
    //对外界提供一个公共的get(),返回一个已经准备好的对象
    public static Singleton getInstance(){
        //进行判断，如果对象为空就会创建一个对象
        if(instance==null){
            instance=new Singleton();
        }
        return instance;
    }
}

1.3.1 解决懒汉式线程安全问题

双重检查加锁：
  所谓的双重检查加锁机制，指的是：并不是每次进入getInstance()方法都需要同步，而是先不同步，进入方法后，先检查实例是否存在，如果不存在才进入下面的同步块，这是第一重检查。进入同步块后，再次检查实例是否存在，如果不存在，就在同步的情况下创建实例，这是第二重检查，这样依赖就只需要同步一次，从而减少了多次在同步情况下进行判断所浪费的时间。
  双重检查加锁机制的实现会使用一个关键字volatile，它的意思是：被volatile修饰的变量的值，将不会被本地线程缓存，所有对该变量的读写都是直接操作共享内存,从而确保多个线程能正确的处理该变量。

public class Singleton {  
      
    private volatile static Singleton instance = null;  
    private Singleton(){  
    }  
    public static  Singleton getInstance(){  
        //先检查实例是否存在，如果不存在才进入下面的同步块  
        if(instance == null){  
            //同步块，线程安全地创建实例  
            synchronized(Singleton.class){  
                //再次检查实例是否存在，如果不存在才真正地创建实例  
                if(instance == null){  
                    instance = new Singleton();  
                }  
            }  
        }  
        return instance;  
    }  
} 

这种实现方式可以实现既线程安全地创建实例，而又不会对性能造成太大的影响。它只是在第一次创建实例的时候同步，以后就不需要同步了，从而加快了运行速度。

1.4 单例模式参考连接

链接1
链接2

2 工厂模式-Factory Pattern

2.1 概念

• 工厂模式（Factory Pattern）是Java中最常用的设计模式之一。这种类型设计模式属于创建型模式，它提供了一种创建对象的最佳方式
• 在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象
• 意图：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂使其创建过程延迟到子类进行
• 主要解决：主要解决接口选择问题
• 何时使用：我们明确地计划不同条件下创建不同实例时
• 如何解决：让其子类实现工厂接口，返回的也是一个抽象的产品
• 关键代码：创建过程在其子类执行
• 应用实例：

1. 你需要一辆车，可以直接从工厂里面提货，而不用去管这辆车是怎么做出来的，
2. Hibernate 换数据库只需换方言和驱动就可以。

• 优点：

1. 一个调用者想创建一个对象，只要知道其名称就可以了。
2. 扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以
3. 屏蔽产品的具体实现，调用者只关心产品的接口。

• 缺点：每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。
• 使用场景：
  1、日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方。
  2、数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。
  3、设计一个连接服务器的框架，需要三个协议，“POP3”、“IMAP”、“HTTP”，可以把这三个作为产品类，共同实现一个接口。
• 注意事项：
  作为一种创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要通过 new 就可以完成创建的对象，无需使用工厂模式。如果使用工厂模式，就需要引入一个工厂类，会增加系统的复杂度。

2.2 工厂模式详情

2.2.1 工厂模式分为三种

1. 简单工作模式
2. 工厂方法模式(Factory Method)
3. 抽象工厂模式(Abstract Factory)
   关于三种工厂模式的详解链接

2.1 工厂模式的体会

1. 工厂可以隐藏创建产品的细节，且不一定每次都会真正创建产品，完全可以返回缓存的产品，从而提升速度并减少内存消耗。