创建型模式、结构型模式和行为型模式

设计模式GOF23（Group of Four）

设计模式可分为三种类型：

创建型模式：单例模式，工厂模式，抽象工厂模式，建造者模式，原型模式。

结构型模式：适配器模式，桥接模式，装饰模式，组合模式，外观模式，享元模式，代理模式。

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

一、单例模式

1 核心作用：

保证一个类只有一个实例，并提供一个访问该实例的全局访问点。

2 常见应用场景：

Windows的Task Manager（任务管理器）就是很典型的单例模式；
Windows的Recycle Bin（回收站）也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例；
网站的计数器，一般也是采用单例模式实现，否则难以同步；
应用程序的日志应用，一般都何用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加；
操作系统的文件系统，也是大的单例模式实现的具体例子，一个操作系统只能有一个文件系统；
项目中，读取配置文件的类，一般也只有一个对象。没有必要每次使用配置文件数据，每次new一个对象去读取；
数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源；
Application 也是单例的典型应用（Servlet编程中会涉及到）；
在Spring中，每个Bean默认就是单例的，这样做的优点是Spring容器可以管理；
在servlet编程中，每个Servlet也是单例；
在spring MVC框架/struts1框架中，控制器对象也是单例。

3 单例模式的优点：

由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式来解决。
单例模式可以在系统设置全局的访问点，优化环共享资源访问，例如可以设计一个单例类，负责所有数据表的映射处理。

对于资源共享，或者初始化资源慢的处理可以使用单例模式。

4 常见的五种单例模式实现方式：

主要：

• 饿汉式（线程安全，调用效率高。但是，不能延时加载。）

• 懒汉式（线程安全，调用效率不高。但是，可以延时加载。）

其他：

• 双重检测锁式（由于JVM底层内部模型原因，偶尔会出问题。不建议使用）

• 静态内部类式(线程安全，调用效率高。可以延时加载)

• 枚举单例(线程安全，调用效率高，不能延时加载)

4.1 饿汉式实现（单例对象立即加载）

public class singletonDemo1{//类初始化时立即加载（不能延时加载，可能造成资源浪费）。线程安全。private static SingletonDemo1 instance = new SingletonDemo1();//私有构造器private SingletonDemo1(){};//提供一个可以访问该实例的全局访问点，方法不用同步锁（synchronized），调用效率高。public static SingletonDemo1 getInstance(){return instance;}
}

饿汉式单例模式代码中，static变量会在类装载时初始化，此时也不会涉及多个线程对象访问该对象的问题。虚拟机保证只会装载一次该类，肯定不会发生并发访问的问题。因此，可以省略synchronized关键字。

问题：如果只是加载本类，而不是要调用getInstance()，甚至永远没有调用，则会造成资源浪费！

4.2懒汉式实现（单例对象延迟加载）

public class singletonDemo2{//类初始化时不初始化对象，用的时候才加载（延时加载）private static SingletonDemo2 instance;//私有构造器private SingletonDemo2(){};//需要同步锁，为了避免并发量高时，产生多个对象。public static synchronized SingletonDemo2 getInstance(){//方法被调用才加载，if(instance == null){instance = new SingletonDemo2();}return instance;}
}

要点：

lazy load 延迟加载，懒加载。真正用时才加载。

问题：

资源利用率高了，但是并发量高时，因为调用方法有同步锁，并发效率低。

懒汉和饿汉的应用：

如果创建一个对象的成本高，建议用懒汉（延迟加载）；
如果调用频率高，建议用饿汉。

4.3双重检测锁实现

将同步内容放到下方的if内部，提高了执行效率，只有第一次获取对象时同步。

但是由于编译器优化原因和JVM底层内部模型原因，偶尔会出现问题，不建议使用。

4.4静态内部类实现方式（懒加载）

public class SingletonDemo3 {//静态内部类，类初始化时不加载静态内部类，被调用时才加载private static class SingletonClassInstance {private static final SingletonDemo3 instance = new SingletonDemo3();}//私有构造器private  SingletonDemo3（）{}//public static SingletonDemo3 getInstance(){return SingletonClassInstance.instace;}
}

要点：

外部类没有static属性，不会像饿汉式那样在类初始化时立即加载对象；
只有真正调用了getInstance时，才会加载静态内部类。加载类时，线程安全。instance是static final 类型，保证了内存中只有这样一个实例存在，而且只能被赋值一次，从而保证了线程安全。
兼并了并发高效调用和延迟加载的优势。

4.5使用枚举实现单例模式

public enum SingletonDemo4{//定义一个枚举的元素，它代表了Singleton的一个实例INSTANCE;//单例可以有自己的操作public void singletonOperation(){//功能处理}
}

优点：

实现简单

枚举本身就是单例模式，由JVM从根本上保障，避免通过反射和反序列化的漏洞。

缺点：

无延迟加载。

4.6测试单例

public static void main (String[] args){SingletonDemo1 s1 = SingletonDemo1.getInstance();SingletonDemo1 s2 = SingletonDemo1.getInstance();System.out.println(s1);System.out.println(s1);//枚举System.out.println(SingletonDemo4.INSTANCE == SingletonDemo4.INSTANCE);
}

4.7常见的五种单例模式在多线程环境下的效率测试：

– 大家只要关注相对值即可。在不同的环境下不同的程序测得值完全不一样

• CountDownLatch

– 同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。

• countDown() 当前线程调此方法，则计数减一(建议放在 finally里执行)

• await()，调用此方法会一直阻塞当前线程，直到计时器的值为0

4.8 单例模式的问题

反射可以破解上面几种(不包含枚举式)实现方式！可以在构造方法中手动抛出异常控
反序列化可以破解上面几种((不包含枚举式))实现方式！反序列化时，如果对象所在类定义了readResolve()，（实际是一种回调），定义返回哪个对象。

懒汉式解决方案：

public class SingletonDemo01 implements Serializable { private static SingletonDemo01 s;private int count = 0;//私有化构造器private SingletonDemo01() throws Exception{ if(count>0){ //通过手动抛出异常，避免通过反射创建多个单例对象！ throw new Exception("只能创建一个对象"); }}public static synchronized SingletonDemo01 getInstance() throws Exception{  if( s == null){ s = new SingletonDemo01(); }return s;} //反序列化时，如果对象所在类定义了readResolve()，（实际是一种回调），定义返回哪个对象。 private Object readResolve() throws ObjectStreamException {return s; }
}

饿汉式解决方案

public class singletonDemo1{//类初始化时立即加载（不能延时加载，可能造成资源浪费）。线程安全。private static SingletonDemo1 instance = new SingletonDemo1();//私有构造器private SingletonDemo1(){if(s != null){//通过手动抛出异常，避免通过反射创建多个单例对象！ throw new RuntimeException()}};//提供一个可以访问该实例的全局访问点，方法不用同步锁（synchronized），调用效率高。public static SingletonDemo1 getInstance(){return instance;}
}

4.9 常见的五种单例模式实现方式和选用

主要：

• 饿汉式（线程安全，调用效率高。但是，不能延时加载。）

• 懒汉式（线程安全，调用效率不高。但是，可以延时加载。）

其他：

• 双重检测锁式（由于JVM底层内部模型原因，偶尔会出问题。不建议使用）

• 静态内部类式(线程安全，调用效率高。可以延时加载)

• 枚举式(线程安全，调用效率高，不能延时加载。并且可以天然的防止反射和反序列化漏洞！)

• 如何选用?

单例对象占用资源少，不需要延时加载：枚举式好于饿汉式
单例对象占用资源大，需要延时加载：静态内部类式好于懒汉式

二、工厂模式

2.1 作用：

实现了创建者和调用者的分离。

2.2 详细分类：

1 简单工厂模式

• 用来生产同一等级结构中的任意产品。（对于增加新的产品，需要修改已有代码）

2 工厂方法模式

• 用来生产同一等级结构中的固定产品。（支持增加任意产品）

3 抽象工厂模式

• 用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族）

2.3 面向对象设计的基本原则：

OCP（开闭原则，Open-Closed Principle）：一个软件的实体应当对扩展开放，对修改关闭。
DIP（依赖倒转原则，Dependence Inversion Principle）：要针对接口编程，不要针对实现编程。
LoD（迪米特法则，Law of Demeter）：只与你直接的朋友通信，而避免和陌生人通信。

2.4 核心本质：

实例化对象，用工厂方法代替new操作。
将选择实现类、创建对象统一管理和控制。从而将调用者跟我们的实现类解耦。

2.5不使用工厂模式的情况：

public class Client01 { //调用者 public static void main(String[] args) { Car c1 = new Audi();Car c2 = new Byd(); c1.run(); c2.run(); }
}

问题：

使用者不仅要知道接口，还需要知道实现类。

2.6 简单工厂模式

要点：

简单工厂模式也叫静态工厂模式，就是工厂类一般是使用静态方法，通过接收的参数的不同来返回不同的对象实例。

缺点：

对于增加新产品无能为力！不修改代码的话，是无法扩展的。违反了OCP原则。

工厂类：

方式一：

public class CarFactory1 {public static Car createCar(String type) {Car c = null;if ("奥迪".equals(type)) {c = new Audi();} else if ("奔驰".equals(type)) {c = new Benz();}return c;}
}

方式二：

public class CarFactory2 {public static Car createAudi() {return new Audi();}public static Car createBenz() {return new Benz();}}

2.7 工厂方法模式

工厂方法模式要点：

为了避免简单工厂模式的缺点，不完全满足OCP。
工厂方法模式和简单工厂模式最大的不同在于，简单工厂模式只有一个（对于一个项目或者一个独立模块而言）工厂类，而工厂方法模式有一组实现了相同接口的工厂类。

简单工厂模式和工厂方法模式PK:

结构复杂度：

从这个角度比较，显然简单工厂模式要占优。简单工厂模式只需一个工厂类，而工厂方法模式的工厂类随着产品类个数增加而增加，这无疑会使类的个数越来越多，从而增加了结构的复杂程度。

代码复杂度：

代码复杂度和结构复杂度是一对矛盾，既然简单工厂模式在结构方面相对简洁，那么它在代码方面肯定是比工厂方法模式复杂的了。简单工厂模式的工厂类随着产品类的增加需要增加很多方法（或代码），而工厂方法模式每个具体工厂类只完成单一任务，代码简洁。

客户端编程难度：

工厂方法模式虽然在工厂类结构中引入了接口从而满足了OCP，但是在客户端编码中需要对工厂类进行实例化。而简单工厂模式的工厂类是个静态类，在客户端无需实例化，这无疑是个吸引人的优点。

管理上的难度：这是个关键的问题。

我们先谈扩展。众所周知，工厂方法模式完全满足OCP，即它有非常良好的扩展性。那是否就说明了简单工厂模式就没有扩展性呢？答案是否定的。简单工厂模式同样具备良好的扩展性——扩展的时候仅需要修改少量的代码（修改工厂类的代码）就可以满足扩展性的要求了。尽管这没有完全满足OCP，但我们不需要太拘泥于设计理论，要知道，sun提供的java官方工具包中也有相当多没有满足OCP的例子。

然后我们从维护性的角度分析下。假如某个具体产品类需要进行一定的修改，很可能需要修改对应的工厂类。当同时需要修改多个产品类的时候，对工厂类的修改会变得相当麻烦（对号入座已经是个问题了）。反而简单工厂没有这些麻烦，当多个产品类需要修改时，简单工厂模式仍然仅仅需要修改唯一的工厂类（无论怎样都能改到满足要求吧？大不了把这个类重写）。

根据设计理论建议：工厂方法模式。但是实际上，我们一般使用简单工厂模式。

2.8 抽象工厂模式

用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族）
抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。

类图：

工厂模式要点：

简单工厂模式(静态工厂模式) ：虽然某种程度不符合设计原则，但实际使用最多。
工厂方法模式：不修改已有类的前提下，通过增加新的工厂类实现扩展。
抽象工厂模式：不可以增加产品，可以增加产品族！

应用场景

JDK中Calendar的getInstance方法
JDBC中Connection对象的获取
Hibernate中SessionFactory创建Session
spring中IOC容器创建管理bean对象
XML解析时的DocumentBuilderFactory创建解析器对象
反射中Class对象的newInstance()

三、原型模式

场景：

javascript语言中的，继承怎么实现?那里面也有prototype，大家还记得吗?

原型模式： 通过new产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式。

就是java中的克隆技术，以某个对象为原型，复制出新的对象。显然，新的对象具备原型对象的特点。

优势有：效率高(直接克隆，避免了重新执行构造过程步骤) 。

克隆类似于new，但是不同于new。new创建新的对象属性采用的是默认值。克隆出的对象的属性值完全和原型对象相同。并且克隆出的新对象改变不会影响原型对象。然后，再修改克隆对象的值。

原型模式实现：

浅克隆：

Cloneable接口和clone方法；

Prototype模式中实现起来最困难的地方就是内存复制操作，所幸在Java中提供了clone()方法替我们做了绝大部分事情。

注意用词：克隆和拷贝一回事！

public class sheep implement Cloneable{privata String name ;private Date birthday//get方法和set方法...//从写克隆方法@Overrideprotected Object clone () throws CloneNotSuppertedException {//直接调用Object对象的clon方法Object obj = super.clone();return obj;     }
}//测试选型模式
public class Client {public Static void main (String[] args){Date date = new Date(123123321331L);//原型Sheep s1 = new Sheep("多利",date);System.out.println(s1);System.out.println(s1.getName());System.out.println(s1.getBirthday());//克隆Sheep s2 = (Sheep)s1.clone();System.out.println(s2);System.out.println(s2.getName());System.out.println(s2.getBirthday());}
}

结果两个对象的值一样。

浅克隆存在的问题：

被复制的对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用都仍然指向原来的对象。

深克隆如何实现?

深克隆把引用的变量指向复制过的新对象，而不是原有的被引用的对象。

深克隆：让已实现Clonable接口的类中的属性也实现Clonable接口，

基本数据类型和String能够自动实现深度克隆（值的复制）

//深克隆
public class sheep implement Cloneable{privata String name ;private Date birthday//get方法和set方法...//从写克隆方法@Overrideprotected Object clone () throws CloneNotSuppertedException {//直接调用Object对象的clon方法Object obj = super.clone();//添加下边代码实现深克隆Sheep s = (Sheep) obj;//把属性也克隆s.birthday =  (Date) this.birthday.clone();return obj;        }
//测试
public class Client {public Static void main (String[] args){Date date = new Date(123123321331L);//原型Sheep s1 = new Sheep("多利",date);//实现深克隆，里边的属性不会随原型的改表而改变。Sheep s2 = (Sheep)s1.clone();System.out.println(s1);System.out.println(s1.getName());System.out.println(s1.getBirthday());//修改属性date.setTime(234234325122L);System.out.println(s1.getBirthday());s2.setName("多利的克隆");System.out.println(s2);System.out.println(s2.getName());System.out.println(s2.getBirthday());}
}

利用序列化和反序列化技术实现深克隆

//使用浅克隆的Sheep类，利用序列化和反序列化技术实现深克隆,需要实现序列化
public class sheep implement Cloneable,serializable{privata String name ;private Date birthday//get方法和set方法...//从写克隆方法@Overrideprotected Object clone () throws CloneNotSuppertedException {//直接调用Object对象的clon方法Object obj = super.clone();return obj;       }
}//测试
public class Client {public Static void main (String[] args) throws Exception{ Date date = new Date(12312321331L);Sheep s1 = new Sheep("少利",date);System.out.println(s1); System.out.println(s1.getSname());System.out.println(s1.getBirthday()); //使用序列化和反序列化实现深复制//序列化为字节数组ByteArrayOutputStream bos = new ByteArrayOutputStream();ObjectOutputStream    oos = new ObjectOutputStream(bos); oos.writeObject(s1);byte[] bytes = bos.toByteArray(); //反序列化ByteArrayInputStream bis = new ByteArrayInputStream(bytes); ObjectInputStream ois = new ObjectInputStream(bis); //克隆好的对象！     Sheep s2 = (Sheep) ois.readObject();  System.out.println("修改原型对象的属性值"); date.setTime(23432432423L); System.out.println(s1.getBirthday());s2.setSname("多利"); System.out.println(s2);System.out.println(s2.getSname()); System.out.println(s2.getBirthday());}
}

短时间大量创建对象时，原型模式和普通new方式效率测试

/*** 测试普通new方式创建对象和clone方式创建对象的效率差异！* 如果需要短时间创建大量对象，并且new的过程比较耗时。则可以考虑使用原型模式！* @author 尚学堂高淇 www.sxt.cn**/
public class Client4 {public static void testNew(int size){long start = System.currentTimeMillis();for(int i=0;i<size;i++){Laptop t = new Laptop();}long end = System.currentTimeMillis();System.out.println("new的方式创建耗时："+(end-start));}public static void testClone(int size) throws CloneNotSupportedException{long start = System.currentTimeMillis();Laptop t = new Laptop();for(int i=0;i<size;i++){Laptop temp = (Laptop) t.clone();}long end = System.currentTimeMillis();System.out.println("clone的方式创建耗时："+(end-start));}public static void main(String[] args) throws Exception { testNew(1000);testClone(1000);}
}class Laptop implements Cloneable {  //笔记本电脑public Laptop() {try {Thread.sleep(10);  //模拟创建对象耗时的过程!} catch (InterruptedException e) {e.printStackTrace();}}@Overrideprotected Object clone() throws CloneNotSupportedException {Object obj = super.clone();  //直接调用object对象的clone()方法！return obj;}}

耗时时间比例：clone：new约等于 1：对象个数。

开发中的应用场景

原型模式很少单独出现，一般是和工厂方法模式一起出现，通过clone 的方法创建一个对象，然后由工厂方法提供给调用者。
spring中bean的创建实际就是两种：单例模式和原型模式。（当然，原型模式需要和工厂模式搭配起来）

四、创建型模式总结：都是用来帮助我们创建对象的

单例模式

• 保证一个类只有一个实例，并且提供一个访问该实例的全局访问点。

工厂模式

• 简单工厂模式

用来生产同一等级结构中的任意产品。（对于增加新的产品，需要修改已有代码）

• 工厂方法模式

用来生产同一等级结构中的固定产品。（支持增加任意产品）

• 抽象工厂模式

用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族）

原型模式

通过new产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式。