java 原型模式_五 Java设计模式解析(原型模式)

1️⃣概念

定义:指原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象;

特点:不需要知道任何的创建细节,并且不调用构造函数;

类型:创建型;

2️⃣适用场景

类初始化消耗太多资源;

new产生的一个对象需要非常繁琐的过程(数据准备 访问权限等);

构造函数比较复杂;

循环体中生产大量的对象时;

3️⃣优点

原型模式性能比直接new一个对象性能高;

简化创建过程

4️⃣缺点

必须配备克隆方法;

对克隆复杂对象或者对克隆出的对象进行复杂改造时,容易引入风险;

深拷贝和浅拷贝要运用得当;

5️⃣原型模式Coding

①创建一个发邮件的场景

public class Mail implements Cloneable{

private String name;

private String emailAddress;

private String content;

public Mail(){

System.out.println("Mail Class Constructor");

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public String getEmailAddress() {

return emailAddress;

}

public void setEmailAddress(String emailAddress) {

this.emailAddress = emailAddress;

}

public String getContent() {

return content;

}

public void setContent(String content) {

this.content = content;

}

@Override

public String toString() {

return "Mail{" +

"name='" + name + '\'' +

", emailAddress='" + emailAddress + '\'' +

", content='" + content + '\'' +

'}'+super.toString();

}

@Override

protected Object clone() throws CloneNotSupportedException {

System.out.println("clone mail object");

return super.clone();

}

}

②创建MailUtil工具类

public class MailUtil {

public static void sendMail(Mail mail){

String outputContent = "向{0}同学,邮件地址:{1},邮件内容:{2}发送邮件成功";

System.out.println(MessageFormat.format(outputContent,mail.getName(),mail.getEmailAddress(),mail.getContent()));

}

public static void saveOriginMailRecord(Mail mail){

System.out.println("存储originMail记录,originMail:"+mail.getContent());

}

}

③编写测试类

public class Test {

public static void main(String[] args) throws CloneNotSupportedException {

Mail mail = new Mail();

mail.setContent("初始化模板");

System.out.println("初始化mail:"+mail);

for(int i = 0;i < 10;i++){

Mail mailTemp = (Mail) mail.clone();

mailTemp.setName("姓名"+i);

mailTemp.setEmailAddress("姓名"+i+"@test.com");

mailTemp.setContent("恭喜您，此次活动中奖了");

MailUtil.sendMail(mailTemp);

System.out.println("克隆的mailTemp:"+mailTemp);

}

MailUtil.saveOriginMailRecord(mail);

}

}

6️⃣UML类图

7️⃣深克隆与浅克隆

(1)浅克隆

①创建pig类

public class Pig implements Cloneable{

private String name;

private Date birthday;

public Pig(String name, Date birthday) {

this.name = name;

this.birthday = birthday;

}

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;

}

@Override

protected Object clone() throws CloneNotSupportedException {

Pig pig = (Pig)super.clone();

}

@Override

public String toString() {

return "Pig{" +

"name='" + name + '\'' +

", birthday=" + birthday +

'}'+super.toString();

}

}

②编写测试类

public class Test {

public static void main(String[] args) throws CloneNotSupportedException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {

Date birthday = new Date(0L);

Pig pig1 = new Pig("佩奇",birthday);

Pig pig2 = (Pig) pig1.clone();

System.out.println(pig1);

System.out.println(pig2);

pig1.getBirthday().setTime(666666666666L);

System.out.println(pig1);

System.out.println(pig2);

}

}

从结果中可以看出,先打印的pig1与pig2的内容是一致的,在设置完生日以后打印的一组结果内容也是一致的,但是我们发现在我们设置完pig1的生日以后,后打印的一组内容的生日都发生了变化,这又是为什么呢?我们通过debug找到了答案;

通过分析我们找到了原因,pig1与pig2对象所使用的生日属性都是一个对象的,所以我们在修改完生日以后两个对象的内容都发生了变化(也就是说我们引用的克隆对象都是同一个对象,当我们修改被克隆对象的属性的时候,克隆出来的对象属性也会跟着发生变化);这就是浅克隆,同时默认的也是浅克隆;

(2)深克隆

从上边的结论中我们可以得出,默认的克隆方式是浅克隆,那么怎么实现深克隆呢?其实也简单,只要我们对对象的引用类型也添加克隆实现就可以解决了;

@Override

protected Object clone() throws CloneNotSupportedException {

Pig pig = (Pig)super.clone();

//深克隆

pig.birthday = (Date) pig.birthday.clone();

return pig;

}

通过上图我们可以看出在我们进行了引用属性的深克隆以后,最后一组对象的内容已经发生了变化,同时debug的时候内存中引用的对象也发生了变化,效果已经达到了我们的预期;

注意:在使用原型模式的时候一定要进行深克隆,否则可能会出现Bug

8️⃣原型模式破坏单例

①使用HungrySingleton

public class HungrySingleton implements Serializable,Cloneable{

private final static HungrySingleton hungrySingleton;

static{

hungrySingleton = new HungrySingleton();

}

private HungrySingleton(){

if(hungrySingleton != null){

throw new RuntimeException("单例构造器禁止反射调用");

}

}

public static HungrySingleton getInstance(){

return hungrySingleton;

}

private Object readResolve(){

return hungrySingleton;

}

@Override

protected Object clone() throws CloneNotSupportedException {

return super.clone();

}

}

②编写测试类

public class Test {

public static void main(String[] args) throws CloneNotSupportedException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {

HungrySingleton hungrySingleton = HungrySingleton.getInstance();

Method method = hungrySingleton.getClass().getDeclaredMethod("clone");

method.setAccessible(true);

HungrySingleton cloneHungrySingleton = (HungrySingleton) method.invoke(hungrySingleton);

System.out.println(hungrySingleton);

System.out.println(cloneHungrySingleton);

}

}

可以看到通过使用clone我们依旧破坏了单例,那要如何才能解决这个问题呢?

①单例类不实现Cloneable接口;

②单例类在重写clone方法时不使用默认的实现,将其修改为

@Override

protected Object clone() throws CloneNotSupportedException {

return getInstance();

}

可以看到通过以上的修改,再次运行测试类的时候两个对象就完全是一致的了;

9️⃣原型模式的实际应用

①JDK中原型模式的使用

public class ArrayList extends AbstractList

implements List, RandomAccess, Cloneable, java.io.Serializable

/**

* Returns a shallow copy of this ArrayList instance. (The

* elements themselves are not copied.)

*

* @return a clone of this ArrayList instance

*/

public Object clone() {

try {

ArrayList> v = (ArrayList>) super.clone();

v.elementData = Arrays.copyOf(elementData, size);

v.modCount = 0;

return v;

} catch (CloneNotSupportedException e) {

// this shouldn't happen, since we are Cloneable

throw new InternalError(e);

}

}

同理hashMap也实现了克隆接口也重写了克隆方法,也就是说HashMap也应用了原型模式;