常用Java设计模式系列（2）- 原型模式

梦里梦外; 2022-06-16 00:53 171阅读 0赞

在上篇文章中，我们讲述了最常见也是最简单的单例设计模式<[常用Java设计模式系列（1）- 单例模式][Java_1_-]>，在这篇文章中，我们继续设计模式之旅，来讲第二个比较常见的设计模式，那就是原型模式。

什么是原型模式呢？

原型模式属于对象的创建模式，通过一个原型对象，我们可以创建出更多同类型的对象，避免每次创建同一类型的对象时都是使用new关键字进行创建。

简单原型模式的框架大致如下所示：

![Center][]

从上图可以看出，整个模式中设计及三种角色，分别如下：

（1）客户角色：（提出创建对象的客户类）

（2）抽象原型角色：这是一个抽象角色，一般由一个接口或者抽象类来进行实现

（3）具体原型角色：能被复制的对象，需要实现抽象原型角色中定义的复制自身能力的接口

下面我们简单的通过Java示例代码来进行说明。

package com.majing.test.designpattern.prototype; import java.io.Serializable; import java.util.List; public abstract class Prototype implements Cloneable,Serializable{ private static final long serialVersionUID = 6373322365181226285L; private String name; private int age; private List<String> interests; public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public List<String> getInterests() { return interests; } public void setInterests(List<String> interests) { this.interests = interests; } @Override public String toString() { return "Prototype [name=" + name + ", age=" + age + ", interests=" + interests + "]"; } }

下面是具体原型类定义：

package com.majing.test.designpattern.prototype; public class ConcretePrototype1 extends Prototype { private static final long serialVersionUID = 1060689305923602305L; @Override protected Prototype clone() throws CloneNotSupportedException { return (Prototype)super.clone(); } }

下面给出客户角色（也就是使用原型模式提出创建对象请求的类）：

package com.majing.test.designpattern.prototype; import java.util.ArrayList; import java.util.List; public class Client { public static void main(String[] args) throws CloneNotSupportedException { shallowCopy(); } public static void shallowCopy() throws CloneNotSupportedException{ ConcretePrototype1 concretePrototype1 = new ConcretePrototype1(); concretePrototype1.setName("majing"); concretePrototype1.setAge(29); List<String> interests = new ArrayList<String>(); interests.add("军事"); interests.add("上网"); concretePrototype1.setInterests(interests); ConcretePrototype1 copyPrototype = (ConcretePrototype1)concretePrototype1.clone(); System.out.println("通过原型模式拷贝（浅拷贝）："); System.out.println(copyPrototype.getName()); System.out.println(copyPrototype.getAge()); System.out.println(copyPrototype.getInterests()); System.out.println("修改原型实例的内容："); concretePrototype1.getInterests().remove("上网"); System.out.println("修改后："); System.out.println(copyPrototype.getName()); System.out.println(copyPrototype.getAge()); System.out.println(copyPrototype.getInterests()); } }

运行上面的代码后，我们贴出运行的结果：

![Center 1][]

从上面的运行结果看，我们可以看到，通过原型对象拷贝出来的对象其实和原对象还是有关联的，对原型对象的修改会影响到通过他复制出来的对象（反之亦然）。这是为什么呢？

其实，还是因为我们这里的实现其实实现的是浅拷贝。

什么是浅拷贝呢？浅拷贝是和深拷贝而言的。对于浅拷贝，Java基础类型会和原型对象保持独立，但是对于引用类型，被拷贝者其实是和拷贝者共同指向同一个引用，其实指向的是同一块堆地址。而对于深拷贝，则会给拷贝者的引用类型重新分配内存空间，被拷贝者其实是和拷贝者中的引用类型指向的是不同的堆空间地址。下面我们给出深拷贝的一种实现，看看效果如何：

package com.majing.test.designpattern.prototype; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; public class ConcretePrototype2 extends Prototype { private static final long serialVersionUID = -5479395220936927123L; @Override protected Object clone() throws CloneNotSupportedException { try { //将对象写到流里 ByteArrayOutputStream bos = new ByteArrayOutputStream(); ObjectOutputStream oos = new ObjectOutputStream(bos); oos.writeObject(this); //从流里读回来 ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray()); ObjectInputStream ois = new ObjectInputStream(bis); return ois.readObject(); } catch (ClassNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } return null; } }

这里通过序列化的方式将对象状态先保存，再进行反序列化从而完成新对象的创建。我们稍微修改下之前的客户角色代码：

package com.majing.test.designpattern.prototype; import java.util.ArrayList; import java.util.List; public class Client { public static void main(String[] args) throws CloneNotSupportedException { deepCopy(); } public static void deepCopy() throws CloneNotSupportedException{ ConcretePrototype2 concretePrototype2 = new ConcretePrototype2(); concretePrototype2.setName("majing"); concretePrototype2.setAge(29); List<String> interests = new ArrayList<String>(); interests.add("军事"); interests.add("上网"); concretePrototype2.setInterests(interests); ConcretePrototype2 copyPrototype = (ConcretePrototype2)concretePrototype2.clone(); System.out.println("通过原型模式拷贝（深拷贝）："); System.out.println(copyPrototype.getName()); System.out.println(copyPrototype.getAge()); System.out.println(copyPrototype.getInterests()); System.out.println("修改原型实例的内容："); concretePrototype2.getInterests().remove("上网"); System.out.println("修改后："); System.out.println(copyPrototype.getName()); System.out.println(copyPrototype.getAge()); System.out.println(copyPrototype.getInterests()); } }

运行后我们得到如下的结果：

![Center 2][]

从这里我们可以看到，通过深拷贝，被拷贝者和拷贝者两者之间已经完全独立了，不会相互影响。当然这里只是给出一个简单的示例说明，实际使用过程中还要根据实际情况进行适当的调整。

至此，关于原型模式的相关说明已经全部讲述完毕，如果想了解我最新的博文，请关注我的博客，谢谢。如果您愿意打赏我，可扫描下方二维码，对您的打赏我表示感谢。![吐舌头][tongue.gif]

![20170430151631454][]![20170430151912379][]

[Java_1_-]: http://blog.csdn.net/majinggogogo/article/details/71012133
[Center]: /images/20220616/4c5c056684ab4ddea290b6c7d0c5fc10.png
[Center 1]: /images/20220616/6402502937f441dfb10d49ef886196a5.png
[Center 2]: /images/20220616/65753c1805f94558a8284ba808767454.png
[tongue.gif]: /images/20220616/ef7b62da385742b98ccdee1518305ab4.png
[20170430151631454]: https://img-blog.csdn.net/20170430151631454
[20170430151912379]: /images/20220616/60ea912d08a44bafb2775de96503d0d8.png