23种设计模式：（一）创建者模型

最新推荐文章于 2019-06-03 19:44:49 发布

以南_ttrg

最新推荐文章于 2019-06-03 19:44:49 发布

阅读量335

点赞数 1

分类专栏： Java基础

本文链接：https://blog.csdn.net/qq_41965731/article/details/90723957

版权

Java基础专栏收录该内容

23 篇文章 0 订阅

订阅专栏

根据北京尚学堂的课程学习

• 创建型模式：

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

• 结构型模式：

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

• 行为型模式：

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

创建者模型：

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

壹、单例模式

1、核心作用：

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

2、常见应用场景：

- Windows的Task Manager（任务管理器）就是很典型的单例模式

– windows的Recycle Bin（回收站）也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。

– 项目中，读取配置文件的类，一般也只有一个对象。没有必要每次使用配置文件数据，每次new一个对象去读取。

– 网站的计数器，一般也是采用单例模式实现，否则难以同步。

– 应用程序的日志应用，一般都何用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作

，否则内容不好追加。

– 数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。

– 操作系统的文件系统，也是大的单例模式实现的具体例子，一个操作系统只能有一个文件系统。

– Application 也是单例的典型应用（Servlet编程中会涉及到）

– 在Spring中，每个Bean默认就是单例的，这样做的优点是Spring容器可以管理

– 在servlet编程中，每个Servlet也是单例

– 在spring MVC框架/struts1框架中，控制器对象也是单例

3、单例模式的优点：

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

4、常见的五种单例模式

--主要：

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

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

– 其他：

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

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

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

1）饿汉式（单例对象立即加载）

package com.tk.one;

/**
 * 单例模式:饿汉式（单例对象立即加载）
 * @data :2019-5-31下午10:36:44
 * @author :田坤
 */
public class SingletonDemo0 {
	
	//类初始化时立即加载这个对象（没有延迟加载的优势），加载类时，天然是线程安全的
	private static SingletonDemo0 singletonDemo0 = new SingletonDemo0();

	//私有无参构造器 ——》外部无法创建该类的对象
	private SingletonDemo0(){
		
	}
	
	//方法没有同步效率高
	public static SingletonDemo0 getInstance(){
		return singletonDemo0;
	}
}

饿汉式单例模式代码中，static变量会在类装载时初始化，此时也不会涉及多个线程对象访问该对象的问题。虚拟机保证只会装载一次该类，肯定不会发生并发访问的问题。因此，可以省略synchronized关键字。
问题：
如果只是加载本类，而不是要调用getInstance()，甚至永远没有调用，则会造成资源浪费！

2）懒汉式（单例对象延迟加载）

package com.tk.one;

/**
 * 单例模式：懒汉式（单例对象延迟加载）
 * @data :2019-5-31下午10:46:12
 * @author :田坤
 */
public class SingletonDemo1 {

   //类初始化时类时，不初始化这个对象（延迟加载，真正用的时候在加载）
	private static SingletonDemo1 singletonDemo = null;

	//私有无参构造器 ——》外部无法创建该类的对象
	private SingletonDemo1(){
		
	}
	
	//方法同步  效率低
	public static synchronized SingletonDemo1 getInstance(){
		if(singletonDemo == null){
			singletonDemo = new SingletonDemo1();
		}
		return singletonDemo;
	}
}

• 要点：

– lazy load! 延迟加载，懒加载！真正用的时候才加载！

• 问题：

– 资源利用率高了。但是，每次调用getInstance()方法都要同步，并发效率较低。

3）双层检测锁

package com.tk.one;

/**
 * 单例模式：双重检测锁
 * @data :2019-6-1上午9:28:15
 * @author :田坤
 */
public class SingletonDemo2 {

     //延迟加载
	private static SingletonDemo2 singletonDemo2 = null;

     //私有无参构造器 ——》外部无法创建该类的对象
	private SingletonDemo2(){
		
	}
	
	public static SingletonDemo2 getInstance(){
		if(singletonDemo2 == null){
			SingletonDemo2 temp;
			synchronized (SingletonDemo2.class) {
				temp = singletonDemo2;
				if(temp == null){
					synchronized (SingletonDemo2.class) {
						if(temp == null){
							temp = new SingletonDemo2();
						}
					}
					return temp;
				}
			}
		}
		return singletonDemo2;
	}
	
}

这个模式将同步内容下方到if内部，提高了执行的效率，不必每次获取对象时都进行同步，只有第一次才同步创建了以后就没必要了

• 问题：

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

4）静态内部类

package com.tk.one;

/**
 * 单例模式：内部静态类
 * 优点：线程安全、调用效率高，并且实现了延迟加载
 * @data :2019-6-1上午9:36:25
 * @author :田坤
 */
public class SingletonDemo2 {

	private static class SingletonDemo2Instance{
		private static final SingletonDemo2 instance= new SingletonDemo2();
	}
	
	private SingletonDemo2(){
		
	}
	
	public static SingletonDemo2 getInstance(){
		return SingletonDemo2Instance.instance;
	}
	
}

• 要点：

– 外部类没有static属性，则不会像饿汉式那样立即加载对象。

– 只有真正调用getInstance(),才会加载静态内部类。加载类时是线程安全的。 instance是static final 类型，保证了内存中只有这样一个实例存在，而且只能被赋值一次，从而保证了线程安全性.

– 兼备了并发高效调用和延迟加载的优势！

5）枚举

package com.tk.one;

/**
 * 单例模式：枚举（没有延迟加载）
 * @data :2019-6-1上午9:54:12
 * @author :田坤
 */
public enum SingletoDemo3 {

	/**
	 * 定义一个枚举元素,他就代表着singleton的一个实例
	 */
	INSTANCE;
	
	/**
	 * 单例模式可以有自己的操作
	 */
	public void Singleton(){
	}

}

优点：

– 实现简单

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

缺点：

– 无延迟加载

5、五种单例模式在多线程环境下的效率测试

在不同环境下测试的数据不一样

• CountDownLatch

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

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

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

package com.tk.one;

import java.util.concurrent.CountDownLatch;

public class Test0 {

	public static void main(String args[]) throws InterruptedException {
		final CountDownLatch cdl1 = new CountDownLatch(10);
		
		//饿汉式性能测试
		long start = System.currentTimeMillis();
		for(int i = 0; i < 10; i++){
			new Thread(new Runnable(){

				@Override
				public void run() {
					for(int i = 0 ; i < 1000000; i++){
						SingletonDemo0 instance = SingletonDemo0.getInstance();
					}
					cdl1.countDown();
					
				}
				
			}).start();
		}
		cdl1.await();
		long end = System.currentTimeMillis();
		System.out.println("饿汉式耗费的时间(ms):"+(end-start));
		
		
		//懒汉式性能测试
		final CountDownLatch cdl2 = new CountDownLatch(10);
		start = System.currentTimeMillis();
		for(int i = 0; i < 10; i++){
			new Thread(new Runnable(){

				@Override
				public void run() {
					for(int i = 0 ; i < 1000000; i++){
						SingletonDemo1 instance = SingletonDemo1.getInstance();
					}
					cdl2.countDown();
					
				}
				
			}).start();
		}
		cdl2.await();
		end = System.currentTimeMillis();
		System.out.println("懒汉式耗费的时间(ms):"+(end-start));
	
		
		//双重检测的性能
		final CountDownLatch cdl3 = new CountDownLatch(10);
		start = System.currentTimeMillis();
		for(int i = 0; i < 10; i++){
			new Thread(new Runnable(){
	
				@Override
				public void run() {
					for(int i = 0 ; i < 1000000; i++){
						SingletonDemo4 instance = SingletonDemo4.getInstance();
					}
					cdl3.countDown();
					
				}
				
			}).start();
		}
		cdl3.await();
		end = System.currentTimeMillis();
		System.out.println("懒汉式耗费的时间(ms):"+(end-start));
		
		//内部类的性能
		final CountDownLatch cdl4 = new CountDownLatch(10);
		start = System.currentTimeMillis();
		for(int i = 0; i < 10; i++){
			new Thread(new Runnable(){
	
				@Override
				public void run() {
					for(int i = 0 ; i < 1000000; i++){
						SingletonDemo2 instance = SingletonDemo2.getInstance();
					}
					cdl4.countDown();
					
				}
				
			}).start();
		}
		cdl4.await();
		end = System.currentTimeMillis();
		System.out.println("内部类耗费的时间(ms):"+(end-start));
		
		
		//内部类的性能
		final CountDownLatch cdl5 = new CountDownLatch(10);
		start = System.currentTimeMillis();
		for(int i = 0; i < 10; i++){
			new Thread(new Runnable(){
	
				@Override
				public void run() {
					for(int i = 0 ; i < 1000000; i++){
						SingletoDemo3 instance = SingletoDemo3.INSTANCE;
					}
					cdl5.countDown();
					
				}
				
			}).start();
		}
		cdl5.await();
		end = System.currentTimeMillis();
		System.out.println("枚举耗费的时间(ms):"+(end-start));
		
	}
}

测试结果

饿汉式耗费的时间(ms):83
懒汉式耗费的时间(ms):312
懒汉式耗费的时间(ms):871
内部类耗费的时间(ms):85
枚举耗费的时间(ms):51

饿汉式	22ms
懒汉式	636ms
静态内部类式	28ms
枚举式	32ms
双重检查锁式	65ms

如何选用?

– 单例对象占用资源少，不需要延时加载：

• 枚举式好于饿汉式

– 单例对象占用资源大，需要延时加载：

• 静态内部类式好于懒汉式

6、问题（反射、反序列化）

以懒汉式单例模式为例

1）反射

package com.tk.one;

import java.lang.reflect.Constructor;

public class Test {

	public static void main(String args[]) throws Exception {
		SingletonDemo1 demo1 = SingletonDemo1.getInstance();
		SingletonDemo1 demo2 = SingletonDemo1.getInstance();
		
		System.out.println(demo1);
		System.out.println(demo2);

		//通过反射方式直接调用私有构造器
		
		Class<SingletonDemo1> clazz = (Class<SingletonDemo1>) Class.forName("com.tk.one.SingletonDemo1");
		//获取无参构造器
		Constructor<SingletonDemo1> c = clazz.getDeclaredConstructor(null);
		//跳过权限检测
		c.setAccessible(true);
		
		SingletonDemo1 instance1 = c.newInstance();
		SingletonDemo1 instance2 = c.newInstance();
		
		System.out.println(instance1);
		System.out.println(instance2);
		
		
	}
}

com.tk.one.SingletonDemo1@15db9742
com.tk.one.SingletonDemo1@15db9742
com.tk.one.SingletonDemo1@6d06d69c
com.tk.one.SingletonDemo1@7852e922

可以从结构看出来通过反射创建了俩个对象

解决方法：将单例模式中的私有构造器改写为下面的代码

   //私有无参构造器 ——》外部无法创建该类的对象
   private SingletonDemo1(){
//解决反射的问题
if(singletonDemo != null){
throw new RuntimeException();
}
   }

在此执行刚才的代码：

2）反序列化

package com.tk.one;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class Test implements Serializable {

	public static void main(String args[]) throws Exception {
		SingletonDemo1 demo1 = SingletonDemo1.getInstance();
		SingletonDemo1 demo2 = SingletonDemo1.getInstance();
		
		System.out.println(demo1);
		System.out.println(demo2);
		
		//通过反序列化的方法创建多个对象
		FileOutputStream fos = new FileOutputStream("C:/Users/84741/Desktop/rejava/01. JAVA初级阶段【北京尚学堂·百战程序员】/a.txt");
		ObjectOutputStream oos = new ObjectOutputStream(fos);
		oos.writeObject(demo1);
		oos.close();
		fos.close();
		
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("C:/Users/84741/Desktop/rejava/01. JAVA初级阶段【北京尚学堂·百战程序员】/a.txt"));
		SingletonDemo1 instance = (SingletonDemo1) ois.readObject();
		System.out.println(instance);
		
	}
}

com.tk.one.SingletonDemo1@15db9742
com.tk.one.SingletonDemo1@15db9742
com.tk.one.SingletonDemo1@4c873330

可以从结果看出来反序列化出来的对象和我们的序列化的对象不同

解决方法：将单例模式中的编写readResolve()方法

   //反序列化时，如果定义了readResolve()则直接返回此方法指定的对象，而不需要单独在创建新对象
   private Object readResolve() {
       return singletonDemo;
   }

在此运行查看结果

com.tk.one.SingletonDemo1@15db9742
com.tk.one.SingletonDemo1@15db9742
com.tk.one.SingletonDemo1@15db9742

贰、工厂模式

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

– 详细分类：

• 简单工厂模式

• 工厂方法模式

• 抽象工厂模式

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

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

核心本质：

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

工厂模式：

– 简单工厂模式

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

– 工厂方法模式

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

– 抽象工厂模式

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

创建Car的接口，Ferrari类和Lamborghini类，并且实现Car方法

package com.tk.gongchang;

public interface Car {
	void run();
}

package com.tk.gongchang;

public class Ferrari implements Car{

	@Override
	public void run() {
		System.out.println("法拉利");
	}

}

package com.tk.gongchang;

public class Lamborghini implements Car{

	@Override
	public void run() {
		System.out.println("兰博基尼");
	}
}

1、不使用简单工厂的情况

package com.tk.gongchang;

/**
 * 不使用简单工厂
 * @data :2019-6-1上午11:52:26
 * @author :田坤
 */
public class Test {

	public static void main(String args[]) {
		Car f = new Ferrari();
		Car l = new Lamborghini();
		
		f.run();
		l.run();
	}
}

2、简单的工厂模式

要点：

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

– 对于增加新产品无能为力！不修改代码的话，是无法扩展的。

创建工厂类

package com.tk.gongchang;

/**
 * 汽车的工厂类
 * @data :2019-6-1上午11:59:39
 * @author :田坤
 */
public class CarFactory {

	//方法一
	public static Car createCar(String type){
		Car car = null;
		if("Ferrari".equals(type)){
			car = new  Ferrari();
		}else if("Lamborghini".equals(type)){
			car = new Lamborghini();
		}
		
		return car;
	}
	
	//方法二
	
	public static Car createFerrari(){
		return new Ferrari();
	}
	
	public static Car createLamborghini(){
		return new Lamborghini();
	}
}

package com.tk.gongchang;

/**
 * 使用简单工厂模式
 * @data :2019-6-1下午12:09:48
 * @author :田坤
 */
public class Test0 {

	public static void main(String args[]) {
		//方法一
		Car f =  CarFactory.createCar("Ferrari");
		Car l =  CarFactory.createCar("Lamborghini");
		
		if(f!=null)
			f.run();
		if(l!=null)
			l.run();
		
		//方法二
		Car f1 =  CarFactory.createFerrari();
		Car l1 =  CarFactory.createLamborghini();
		f1.run();
		l1.run();
	}
}

3、工厂方法模式

要点：

– 为了避免简单工厂模式的缺点，不完全满足OCP。

– 工厂方法模式和简单工厂模式最大的不同在于，简单工厂模式只有一个（对于一个项或者一个独立模块而言）工厂类，而工厂方法模式有一组实现了相同接口的工厂类。

1、创建一个汽车的工厂接口

public interface CarFactory {
	Car createCar();
}

2、为每辆车创建一个每辆车的工厂类并实现 CarFactory

public class FerrariFactory implements CarFactory{

	@Override
	public Car createCar() {
		return new Ferrari();
	}

}

public class LamborghiniFactory implements CarFactory{

	@Override
	public Car createCar() {
		return new Lamborghini();
	}
}

3、测试

/**
 * 使用工厂方法模式
 * @data :2019-6-1下午12:26:57
 * @author :田坤
 */
public class Test0 {

	public static void main(String args[]) {
		Car f =  new FerrariFactory().createCar();
		Car l =  new LamborghiniFactory().createCar();
	
		f.run();
		l.run();
		
	}
}

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

– 结构复杂度

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

– 代码复杂度

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

– 客户端编程难度

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

– 管理上的难度

这是个关键的问题。

我们先谈扩展。众所周知，工厂方法模式完全满足OCP，即它有非常良好的扩展性。那是否就说明了简单工厂模式就

没有扩展性呢？答案是否定的。简单工厂模式同样具备良好的扩展性——扩展的时候仅需要修改少量的代码（修改工

厂类的代码）就可以满足扩展性的要求了。尽管这没有完全满足OCP，但我们不需要太拘泥于设计理论，要知道，

sun提供的java官方工具包中也有想到多没有满足OCP的例子啊。

然后我们从维护性的角度分析下。假如某个具体产品类需要进行一定的修改，很可能需要修改对应的工厂类。当同时

需要修改多个产品类的时候，对工厂类的修改会变得相当麻烦（对号入座已经是个问题了）。反而简单工厂没有这些

麻烦，当多个产品类需要修改是，简单工厂模式仍然仅仅需要修改唯一的工厂类（无论怎样都能改到满足要求吧？大

不了把这个类重写）。

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

4、抽象工厂模式

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

– 抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。

类图

工厂模式要点：

– 简单工厂模式(静态工厂模式)

• 虽然某种程度不符合设计原则，但实际使用最多。

– 工厂方法模式

• 不修改已有类的前提下，通过增加新的工厂类实现扩展。

– 抽象工厂模式

• 不可以增加产品，可以增加产品族！

应用场景

– JDK中Calendar的getInstance方法

– JDBC中Connection对象的获取

– Hibernate中SessionFactory创建Session

– spring中IOC容器创建管理bean对象

– XML解析时的DocumentBuilderFactory创建解析器对象

– 反射中Class对象的newInstance()

叁、构建者模式

场景：

– 我们要建造一个复杂的产品。比如：神州飞船,Iphone。这个复杂的产品的创建。有这样一个问题需要处理：

• 装配这些子组件是不是有个步骤问题?

– 实际开发中，我们所需要的对象构建时，也非常复杂，有很多步骤需要处理时。

建造模式的本质：

– 分离了对象子组件的单独构造(由Builder来负责)和装配(由Director负责)。从而可以构造出复杂的对象。这个模式适用于：某个对象的构建过程复杂的情况下使用。

– 由于实现了构建和装配的解耦。不同的构建器，相同的装配，也可以做出不同的对象；相同的构建器，不同的装配顺序也可以做出不同的对象。也就是实现了构建算法、装配算法的解耦，实现了更好的复用。

例：构建“尚学堂牌”神舟飞船的示例

package com.tk.jianzaozhe;

/**
 * 宇宙飞船实体类
 * @data :2019-6-1下午3:07:44
 * @author :田坤
 */
public class AirShip {
	
	private OrbitalModule orbitalModule;	//轨道仓
	private Engine engine;					//发动机
	private EscapeTower escapeTower;		//逃逸塔
	
	public void launch(){
		System.out.println("发射！");
	}
	
	public AirShip(OrbitalModule orbitalModule, Engine engine,
			EscapeTower escapeTower) {
		this.orbitalModule = orbitalModule;
		this.engine = engine;
		this.escapeTower = escapeTower;
	}

	public OrbitalModule getOrbitalModule() {
		return orbitalModule;
	}

	public void setOrbitalModule(OrbitalModule orbitalModule) {
		this.orbitalModule = orbitalModule;
	}

	public Engine getEngine() {
		return engine;
	}

	public void setEngine(Engine engine) {
		this.engine = engine;
	}

	public EscapeTower getEscapeTower() {
		return escapeTower;
	}

	public void setEscapeTower(EscapeTower escapeTower) {
		this.escapeTower = escapeTower;
	}
	
}

class OrbitalModule{
	private String name;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public OrbitalModule(String name) {
		this.name = name;
	}

	public OrbitalModule() {
	}

}

class Engine{
	private String name;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Engine(String name) {
		this.name = name;
	}

	public Engine() {
	}
}

class EscapeTower{
	private String name;
	
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public EscapeTower(String name) {
		this.name = name;
	}

	public EscapeTower() {
		
	}
}

package com.tk.jianzaozhe;

/**
 * 构建宇宙飞船接口
 * @data :2019-6-1下午3:08:01
 * @author :田坤
 */
public interface AirShipBuilder {
	Engine builderEngine();
	OrbitalModule builderOrbitalModule();
	EscapeTower builderEscapeTower();
}

package com.tk.jianzaozhe;

/**
 * Tk宇宙飞船的创造
 * @data :2019-6-1下午3:08:19
 * @author :田坤
 */
public class TkAirShipBuilder implements AirShipBuilder {

	@Override
	public Engine builderEngine() {
		System.out.println("建造发送机");
		return new Engine("发动机");
	}

	@Override
	public OrbitalModule builderOrbitalModule() {
		System.out.println("建造轨道舱");
		return new OrbitalModule("轨道舱");
	}

	@Override
	public EscapeTower builderEscapeTower() {
		System.out.println("建造逃逸塔");
		return new EscapeTower("逃逸塔");
	}

}

package com.tk.jianzaozhe;

/**
 * 装配宇宙飞船的接口
 * @data :2019-6-1下午3:08:43
 * @author :田坤
 */
public interface AirShipDirector {
	AirShip directAirShip();
}

package com.tk.jianzaozhe;

/**
 * 装配Tk宇宙飞船
 * @data :2019-6-1下午3:29:33
 * @author :田坤
 */
public class TkAirShipDirector implements AirShipDirector {
	
	private AirShipBuilder airShipBuilder;
	
	public TkAirShipDirector(AirShipBuilder airShipBuilder) {
		this.airShipBuilder = airShipBuilder;
	}

       @Override
	public AirShip directAirShip() {
    	Engine engine = airShipBuilder.builderEngine();
    	OrbitalModule orbitalModule = airShipBuilder.builderOrbitalModule();
    	EscapeTower escapeTower = airShipBuilder.builderEscapeTower();
    	
    	AirShip airShip = new AirShip(orbitalModule, engine, escapeTower);
    	return airShip;
	}

}

测试

public class Test {
	public static void main(String args[]) {
		AirShipDirector airShipDirector = new TkAirShipDirector(new TkAirShipBuilder());
		AirShip airShip = airShipDirector.directAirShip();
		
		System.out.println(airShip.getEngine().getName());
		System.out.println(airShip.getOrbitalModule().getName());
		System.out.println(airShip.getEscapeTower().getName());
		
		airShip.launch();
	}
}

类图

开发中应用场景：

– StringBuilder类的append方法

– SQL中的PreparedStatement

– JDOM中，DomBuilder、SAXBuilder

肆、原型模式

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

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

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

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

原型模式实现：

– Cloneable接口和clone方法

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

1、浅克隆

package com.tk.prototype;

import java.util.Date;

/**
 * 羊的实体类
 * 类需要继承Cloneable
 * @data :2019-6-1下午3:56:35
 * @author :田坤
 */
public class Sheep implements Cloneable{

	private String name;
	private Date birthday;
	
	
	@Override
	protected Object clone() throws CloneNotSupportedException {
		Object clone = super.clone();	//直接调用Object对象的clone方法
		return clone;
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Date getBirthday() {
		return birthday;
	}
	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}
}

package com.tk.prototype;

import java.util.Date;

/**
 * 浅克隆
 * @data :2019-6-1下午4:08:44
 * @author :田坤
 */
public class Test1 {

	public static void main(String args[]) throws CloneNotSupportedException {
		Sheep sheep = new Sheep();
		sheep.setName("多利");
		Date date = new Date(6565687875L);
		sheep.setBirthday(date);
		System.out.println(sheep.getBirthday());
		//克隆已有的对象sheep
		Sheep sheep2 = (Sheep) sheep.clone();
		System.out.println(sheep);
		
		//修改sheep中的birthday属性
		date.setTime(6564425484848L);
		System.out.println(sheep.getBirthday());
		
		System.out.println(sheep2);
		System.out.println(sheep2.getBirthday());
		
	}
}

Wed Mar 18 07:48:07 CST 1970
com.tk.prototype.Sheep@70dea4e
Wed Jan 07 11:31:24 CST 2178
com.tk.prototype.Sheep@5c647e05
Wed Jan 07 11:31:24 CST 2178

由上面的结果可知，在我们对原型属性（date）进行修改的时候，复制原型的对象中的属性也发生了修改

浅克隆存在的问题

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

2、深克隆

深克隆如何实现?

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

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

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

1）改变clone方法

	protected Object clone() throws CloneNotSupportedException {
		Object obj = super.clone();	//直接调用Object对象的clone方法
		
		//添加如下代码进行深克隆
		Sheep sheep = (Sheep) obj;
		sheep.birthday = (Date) this.birthday.clone();  //将birthday属性也进行克隆
		return obj;
	}

2）利用序列化和反序列化



/**
 * 深克隆——序列化和反序列化
 * @data :2019-6-1下午4:17:43
 * @author :田坤
 */
public class Test1 {

	public static void main(String args[]) throws CloneNotSupportedException, IOException, ClassNotFoundException {
		Sheep sheep = new Sheep();
		sheep.setName("多利");
		Date date = new Date(6565687875L);
		sheep.setBirthday(date);
		System.out.println(sheep.getBirthday());
		//克隆已有的对象sheep
		System.out.println(sheep);
		
		//利用序列化和反序列化实现深克隆（赋值）
		ByteArrayOutputStream bos = new ByteArrayOutputStream();
		ObjectOutputStream oos = new ObjectOutputStream(bos);
		oos.writeObject(sheep);
		byte[] bytes = bos.toByteArray();
		ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
		ObjectInputStream ois = new ObjectInputStream(bis);
		Sheep sheep2 = (Sheep) ois.readObject(); //克隆好的对象！
		
		//修改sheep中的birthday属性
		date.setTime(6564425484848L);
		System.out.println(sheep.getBirthday());
		
		System.out.println(sheep2);
		System.out.println(sheep2.getBirthday());
		
	}
}

Wed Mar 18 07:48:07 CST 1970
com.tk.prototype.Sheep@70dea4e
Wed Jan 07 11:31:24 CST 2178
com.tk.prototype.Sheep@7cca494b
Wed Mar 18 07:48:07 CST 1970

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

package com.tk.prototype;

/**
 * 测试普通new方法创建对象和clone方法创建对象 效率差异
 * 如果需要短时间内创建大量对象，并且new的过程中比较耗时，则可以考虑使用原型模式
 * @data :2019-6-1下午4:30:05
 * @author :田坤
 */
public class Test {

	//检测使用new方法创建对象所耗费的时间
	public static void Testnew(int size){
		long start = System.currentTimeMillis();
		for(int i = 0;i < size; i++){
			Person person = new Person();
		}
		long end = System.currentTimeMillis();
		System.out.println("使用new方法耗费的时间（	ms）:"+(end-start));
	} 
	
	//检测使用Clone方法创建对象所耗费的时间
	public static void TestClone(int size) throws CloneNotSupportedException{
		Person person = new Person();
		long start = System.currentTimeMillis();
		for(int i = 0;i < size; i++){
			Person tt = (Person) person.clone();
		}
		long end = System.currentTimeMillis();
		System.out.println("使用clone方法耗费的时间（ms）:"+(end-start));
	} 
	
	public static void main(String args[]) throws Exception {
		Testnew(1000);
		TestClone(1000);
	}
	
}

class Person implements Cloneable{
	
	private String name;
	
	public Person() {
		try {
			Thread.sleep(10);  //模拟创建对象所花费的时间
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

	@Override
	protected Object clone() throws CloneNotSupportedException {
		return super.clone();
	}
}

使用new方法耗费的时间(ms）:10688
使用clone方法耗费的时间（ms）:1

开发中的应用场景

– 原型模式很少单独出现，一般是和工厂方法模式一起出现，通过clone 的方法创建一个对象，然后由工厂方法提供给调用者。

• spring中bean的创建实际就是两种：单例模式和原型模式。（当然，原型模式需要和工厂模式搭配起来）

伍、创建型模式的总结

创建型模式：都是用来帮助我们创建对象的！

– 单例模式

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

– 工厂模式

• 简单工厂模式

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

• 工厂方法模式

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

• 抽象工厂模式

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

– 建造者模式

• 分离了对象子组件的单独构造(由Builder来负责)和装配(由Director负责)。从而可以构造出复杂的对象。

– 原型模式

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

以南_ttrg

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
23种设计模式：（一）创建者模型

根据北京尚学堂的课程学习• 创建型模式： – 单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式。 • 结构型模式： – 适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。 • 行为型模式： – 模版方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式、访问者模式。...
复制链接

扫一扫