【Java封神之路】设计模式学习-原型模式

原型模式简介

原型模式是创建型模式的一种，其特点在于通过“复制”一个已经存在的实例来返回新的实例,而不是新建实例。被复制的实例就是我们所称的“原型”，这个原型是可定制的。

原型模式多用于创建复杂的或者耗时的实例，因为这种情况下，复制一个已经存在的实例使程序运行更高效；或者创建值相等，只是命名不一样的同类数据。

代码实现

我们这里模拟一个多利羊的克隆问题，先来一个传统方式的做法

package com.company.prototypemode.tradition;


public class Dolly {


    private String name;
    private int age;
    private String color;


    public Dolly(String name, int age, String color) {
        super();
        this.name = name;
        this.age = age;
        this.color = color;
    }


    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 String getColor() {
        return color;
    }


    public void setColor(String color) {
        this.color = color;
    }


    @Override
    public String toString() {
        return "Dolly{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", color='" + color + '\'' +
                '}';
    }
}

package com.company.prototypemode.tradition;


public class DollyClient {
    public static void main(String[] args) {
        Dolly dolly = new Dolly("01",1,"1");
        Dolly dolly2 = new Dolly("02",1,"1");
        Dolly dolly3 = new Dolly("03",1,"1");
        Dolly dolly4 = new Dolly("04",1,"1");
        Dolly dolly5 = new Dolly("05",1,"1");
        Dolly dolly6 = new Dolly("06",1,"1");


        System.out.println(dolly);
        System.out.println(dolly2);
        System.out.println(dolly3);
        System.out.println(dolly4);
        System.out.println(dolly5);
        System.out.println(dolly6);
    }
}

上面的代码讲述的就是当我需要多个同样的养的时候我需要频繁的去创建新的，并把很多重复的属性重新注入内容，那我们有没有一种快速的方式能够将相同的属性内容直接通过复制的方式拿过来，只变动需要变动的部分呢，那么就自然而然的引出了我们的原型模式

package com.company.prototypemode.useclone;


public class Dolly implements Cloneable{


    private String name;
    private int age;
    private String color;


    public Dolly(String name, int age, String color) {
        super();
        this.name = name;
        this.age = age;
        this.color = color;
    }


    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 String getColor() {
        return color;
    }


    public void setColor(String color) {
        this.color = color;
    }


    @Override
    public String toString() {
        return "Dolly{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", color='" + color + '\'' +
                '}';
    }


    @Override
    protected Dolly clone() {
        Dolly dolly = null;
        try {
            dolly = (Dolly) super.clone();
        } catch (CloneNotSupportedException e) {
            System.out.println(e.getMessage());
        }
        return dolly;
    }
}

package com.company.prototypemode.useclone;


public class DollyClient {
    public static void main(String[] args) {
        Dolly dolly = new Dolly("01",1,"小红");
        Dolly dolly1 = dolly.clone();


        System.out.println(dolly);
        System.out.println(dolly1);
    }
}

相信很多小伙伴回担心的就是我们深拷贝和浅拷贝的问题其实这一块对于原型模式也有一个很好方案进行解决

package com.company.prototypemode.deepcopy;


import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;


/**
 * @author yangpeng
 */
public class Dolly implements Serializable,Cloneable{




    private static final long serialVersionUID = -64482404638622966L;
    private String name;
    private int age;
    private String color;
    private Dolly2 dolly2;


    public Dolly(String name, int age, String color) {
        super();
        this.name = name;
        this.age = age;
        this.color = color;
    }


    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 String getColor() {
        return color;
    }


    public void setColor(String color) {
        this.color = color;
    }


    public Dolly2 getDolly2() {
        return dolly2;
    }


    public void setDolly2(Dolly2 dolly2) {
        this.dolly2 = dolly2;
    }


    @Override
    public String toString() {
        return "Dolly{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", color='" + color + '\'' +
                '}';
    }


    @Override
    protected Object clone() {
        ByteArrayOutputStream bo = null;
        ObjectOutputStream oo = null;
        ByteArrayInputStream bi = null;
        ObjectInputStream oi = null;


        try {
            bo = new ByteArrayOutputStream();
            oo = new ObjectOutputStream(bo);
            oo.writeObject(this);


            bi = new ByteArrayInputStream(bo.toByteArray());
            oi = new ObjectInputStream(bi);
            Dolly dolly = (Dolly) oi.readObject();
            return dolly;
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }finally {
            try {
                bo.close();
                oo.close();
                bi.close();
                oi.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }
}

其实原型模式我们平常使用的还是比较频繁的一个模式，在我们实际工作中的Bean拷贝的时候也对深拷贝和浅拷贝有所涉及。

结束语

那么今天我们的设计模式-原型模式的笔记就到这里了，各位小伙伴也可以关注我的微信公众号 架构小知识 获取更多关于其他技术问题的内容