Java设计模式——原型模式【ProtoType Pattern】

川长思鸟来 2021-12-01 15:36 269阅读 0赞

## 一、引言 ##

23种设计模式大概分为三大类：

5种（创建型模式）：工厂方法模式、抽象工厂模式、单例模式、原型模式、建造者模式。

7种（结构型模式）：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

11种（行为型模式）：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

行为型又可以通过类与类之间的关系进行划分 :  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70]

原型模式基本介绍：

*  原型模式（Prototype模式）是指：用原型实例指定创建对象的种类，并且通过拷贝这些原型，创建新的对象
 *  原型模式：是一种创建型设计模式，允许一个对象再创建另外一个可定制的对象， 无需知道如何创建的细节
 *  工作原理：是通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建，即 对象.clone()

## 二、案列分析 ##

### 1. 克隆羊问题 ###

现在有一只羊Tom，姓名为：tom，年龄为：1，颜色为：白色。请编写程序创建和tom羊属性完全相同的5只羊。

### 2. 传统方式解决克隆羊问题 ###

public class Sheep { 
    	private String name;
    	private int age;
    	private String color;
    	public Sheep(String name, int age, String color) { 
    		super();
    		this.name = name;
    		this.age = age;
    		this.color = color;
    	}
        
    	// get/set方法略
        
    	@Override
    	public String toString() { 
    		return "Sheep [name=" + name + ", age=" + age + ", color=" + color + "]";
    	}
    }
    
    public class Client { 
    
    	public static void main(String[] args) { 
    		// 创建一只羊
    		Sheep sheep = new Sheep("tom", 1, "白色");
    		// 分别创建五只羊
    		Sheep sheep2 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
    		Sheep sheep3 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
    		Sheep sheep4 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
    		Sheep sheep5 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
    				
    		System.out.println(sheep);
    		System.out.println(sheep2);
    		System.out.println(sheep3);
    		System.out.println(sheep4);
    		System.out.println(sheep5);
    	}
    }
    
    // 运行结果
    Sheep [name=tom, age=1, color=白色]
    Sheep [name=tom, age=1, color=白色]
    Sheep [name=tom, age=1, color=白色]
    Sheep [name=tom, age=1, color=白色]
    Sheep [name=tom, age=1, color=白色]

上面的代码，应该没人看不懂吧~~~~~

### 3. 传统方式解决克隆羊问题的优缺点 ###

*  优点是比较好理解，简单易操作
 *  在创建新的对象时，总是需要重新获取原始对象的属性，如果创建的对象比较复杂时，效率较低（想象一下，如果这只羊有20几个属性，难道每个属性，都要调用get方法吗？）
 *  总是需要重新初始化对象，而不是动态地获得对象运行时的状态, 不够灵活

### 4. 改进的思路 ###

Java中Object类是所有类的根类，Object类提供了一个clone()方法，该方法可以将一个Java对象复制一份，但是需要实现clone的Java类必须要实现一个接口Cloneable，该接口表示该类能够复制且具有复制的能力，即原型模式

## 三、使用原型模式解决克隆羊问题 ##

原型模式解决克隆羊问题，让程序具有更高的效率和扩展性。在使用原型模式之前，先介绍一下浅拷贝和深拷贝

### 1.浅拷贝的介绍 ###

*  对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性值复制一份给新的对象
 *  对于数据类型是引用数据类型的成员变量，比如说成员变量是某个数组、某个类的对象等，那么浅拷贝会进行引用传递，也就是只是将该成员变量的引用值（内存地址）复制一份给新的对象。因为实际上两个对象的该成员变量都指向同一个实例。在这种情况下，在一个对象中修改该成员变量会影响到另一个对象的该成员变量值。
 *  浅拷贝是使用默认的 clone()方法来实现。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70 1]

public class Sheep implements Cloneable { 
    	private String name;
    	private int age;
    	private String color;
    	private String address = "内蒙古";
    	public Sheep friend;	// 有个朋友，引用类型
    
    	public Sheep(String name, int age, String color) { 
    		super();
    		this.name = name;
    		this.age = age;
    		this.color = color;
    	}
    
    	// set、get、tostring方法忽略
    	
    	// 实现Cloneable接口，并重写其中的clone方法
    	@Override
    	protected Object clone() { 
    		Sheep sheep = null;
    		try { 
    			sheep = (Sheep) super.clone();
    		} catch (Exception e) { 
    			System.out.println(e.getMessage());
    		}
    		return sheep;
    	}
    }
    
    public class Client { 
    
    	public static void main(String[] args) { 
    		Sheep sheep = new Sheep("tom", 1, "白色");
    
    		sheep.friend = new Sheep("jack", 2, "黄色");
    
    		// 直接调用clone方法，就可以创建出一个新对象，这个要注意引用类型
    		Sheep sheep2 = (Sheep) sheep.clone(); 
    		Sheep sheep3 = (Sheep) sheep.clone(); 
    		Sheep sheep4 = (Sheep) sheep.clone(); 
    		Sheep sheep5 = (Sheep) sheep.clone(); 
    
    		System.out.println("sheep2 =" + sheep2 + "，sheep2.friend=" + sheep2.friend.hashCode());
    		System.out.println("sheep3 =" + sheep3 + "，sheep3.friend=" + sheep3.friend.hashCode());
    		System.out.println("sheep4 =" + sheep4 + "，sheep4.friend=" + sheep4.friend.hashCode());
    		System.out.println("sheep5 =" + sheep5 + "，sheep5.friend=" + sheep5.friend.hashCode());
    	}
    
    }
    
    // 运行结果
    sheep2 =Sheep [name=tom, age=1, color=白色, address=内蒙古]，sheep2.friend=1632905274
    sheep3 =Sheep [name=tom, age=1, color=白色, address=内蒙古]，sheep3.friend=1632905274
    sheep4 =Sheep [name=tom, age=1, color=白色, address=内蒙古]，sheep4.friend=1632905274
    sheep5 =Sheep [name=tom, age=1, color=白色, address=内蒙古]，sheep5.friend=1632905274

> 说明:  
> 可以发现应用类型为同一个对象，即引用类型并没有重写创建  
> 使用原型模式的浅拷贝之后，即使Sheep类的属性发生改变，对Client的调用依旧没有影响

### 2.深拷贝基本介绍 ###

*  复制对象的所有基本数据类型的成员变量值
 *  为所有引用数据类型的成员变量申请存储空间，并复制每个引用数据类型成员变量所引用的对象，直到该对象可达的所有对象。也就是说，对象进行深拷贝要对整个对象进行拷贝
 *  深拷贝实现方式：
    
     *  第一种：重写clone方法来实现深拷贝
     *  第二种：通过对象序列化实现深拷贝(推荐)

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70 2]

// 要拷贝的目标对象，实现Serializable、Cloneable接口
    public class DeepCloneableTarget implements Serializable, Cloneable { 
    
    	private static final long serialVersionUID = 1L;
    
    	private String cloneName;
    
    	private String cloneClass;
    
    	public DeepCloneableTarget(String cloneName, String cloneClass) { 
    		this.cloneName = cloneName;
    		this.cloneClass = cloneClass;
    	}
    
    	@Override
    	protected Object clone() throws CloneNotSupportedException { 
    		return super.clone();
    	}
    }
    
    // 要实现深拷贝的原型
    public class DeepProtoType implements Serializable, Cloneable { 
    
    	public String name;
    	public DeepCloneableTarget deepCloneableTarget;
    
    	public DeepProtoType() { 
    		super();
    	}
    
    	// 方式一： clone方式实现深拷贝
    	@Override
    	protected Object clone() throws CloneNotSupportedException { 
    		Object deep = null;
    		deep = super.clone();
    		DeepProtoType deepProtoType = (DeepProtoType) deep;
    		deepProtoType.deepCloneableTarget = (DeepCloneableTarget) deepCloneableTarget.clone();
    		return deepProtoType;
    	}
    
    	// 方式二：序列化方式实现深拷贝
    	public Object deepClone() { 
    		ByteArrayOutputStream bos = null;
    		ObjectOutputStream oos = null;
    		ByteArrayInputStream bis = null;
    		ObjectInputStream ois = null;
    
    		try { 
    			bos = new ByteArrayOutputStream();
    			oos = new ObjectOutputStream(bos);
    			oos.writeObject(this);
    
    			bis = new ByteArrayInputStream(bos.toByteArray());
    			ois = new ObjectInputStream(bis);
    			DeepProtoType copyObj = (DeepProtoType) ois.readObject();
    			return copyObj;
    		} catch (Exception e) { 
    			e.printStackTrace();
    			return null;
    		} finally { 
    			try { 
    				bos.close();
    				oos.close();
    				bis.close();
    				ois.close();
    			} catch (Exception e2) { 
    				// TODO: handle exception
    				System.out.println(e2.getMessage());
    			}
    		}
    	}
    }
    
    public class Client { 
    
    	public static void main(String[] args) throws Exception { 
    		DeepProtoType p = new DeepProtoType();
    		p.name = "Tom";
    		p.deepCloneableTarget = new DeepCloneableTarget("friend", "深拷贝");
    
    		// 方式一
    		DeepProtoType p2 = (DeepProtoType) p.clone();
    		System.out.println("p.name=" + p.name + ",p.deepCloneableTarget=" + p.deepCloneableTarget.hashCode());
    		System.out.println("p2.name=" + p.name + ",p2.deepCloneableTarget=" + p2.deepCloneableTarget.hashCode());
    		System.out.println("------------------------------");
    
    		// 方式二
    		DeepProtoType p3 = (DeepProtoType) p.deepClone();
    		System.out.println("p.name=" + p.name + ",p.deepCloneableTarget=" + p.deepCloneableTarget.hashCode());
    		System.out.println("p3.name=" + p.name + ",p3.deepCloneableTarget=" + p3.deepCloneableTarget.hashCode());
    
    	}
    }
    
    // 运行结果
    p.name=Tom,p.deepCloneableTarget=1088333500
    p2.name=Tom,p2.deepCloneableTarget=1502913001
    ------------------------------
    p.name=Tom,p.deepCloneableTarget=1088333500
    p3.name=Tom,p3.deepCloneableTarget=1659213513

> 说明：可以看出，深拷贝之后得到对象的hashcode都不一样，说明引用对象都不一样。

## 四、小结 ##

原型模式优点：

*  创建新的对象比较复杂时，可以利用原型模式简化对象的创建过程，同时也能够提高效率
 *  不用重新初始化对象，而是动态地获得对象运行时的状态
 *  如果原始对象发生变化(增加或者减少属性)，其它克隆对象的也会发生相应的变化，无需修改代码
 *  在实现深克隆的时候可能需要比较复杂的代码

原型模式缺点：

*  需要为每一个类配备一个克隆方法，这对全新的类来说不是很难，但对已有的类进行改造时，需要修改其源代码，违背了ocp原则。

## 五、原型模式在Spring框架中源码分析 ##

Spring中原型bean的创建，就是原型模式的应用。在Spring的配置文件中，下面的代码，应该不陌生：

上面的代码是创建一个Bean，指定scope为prototype，表示以原型模式来创建该Bean。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70]: /images/20211201/a652eb1da20d4992b7465bf94f428315.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70 1]: /images/20211201/6d19695fb890456bae384a8b0617a843.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70 2]: /images/20211201/913c38d6c6854cda8667c40d90cffc21.png