Hello everyone, I am Lao Tian, ??Today I will share with you the Prototype pattern## in the design pattern. #. Use appropriate life stories and real project scenarios to talk about the design pattern, and finally summarize the design pattern in one sentence.

##Story I still remember looking for At work, I accidentally found a relatively beautiful programmer resume template from the Internet, and then the whole class started copying the resume (U disk) like crazy. At the same time, there was also a joke. Several students copied their past resumes without changing the contents or their names. They submitted them to the interviewer (campus recruitment interviewer) as the deadline. Later, everyone should be able to guess the result. Everyone went for internships, and some of them were still looking for jobs.

There are two types of resume copies:

• One is to copy the resume and then modify the information to your own
• The other is to copy the resume without changing the content.

Prototype pattern definition

Specify the kinds of objects to create using a prototype instance, and create new objects by coping with this prototype

roughly meaning: Specify the types of objects to create using prototype instances, and create new objects by copying these prototypes.

Prototype pattern: Prototype Pattern, which is a creational pattern.

The caller does not need to know any creation details, nor does it need to call the constructor to create the object.

Usage scenarios

The prototype mode has the following usage scenarios:

• Class initialization consumes more resources
• An object generated by new requires a very cumbersome process (data preparation, access permissions, etc.)
• The constructor is more complex
• When a large number of objects are generated in the loop body
• In Spring, the prototype pattern is very much used Widely, for example: scope='prototype'

We can encapsulate some getters and setters into a factory method, and then for those who use it, Just call the method, you don't need to know how the getters and setters inside are handled. We can also use the Cloneable interface provided by JDK to achieve fast copying.

Four ways to create objects:

new, reflection, cloning, serialization

Actual case

Have you ever encountered this common situation? It is stipulated in the project that the entity class mapped with the database table cannot be returned to the front end, so the following are usually returned to the front end: Various O, such as: XxxVO, XxxBO, XxxDTO...

The following scene will appear at this time, and everyone may have guessed it.

The following is the UserEntity entity class mapped to the database table.

public class UserEntity {
    private Long id;
    private String name;
    private Integer age;
    //....可能還有很多屬性
    //省略getter setter
}

The UserVO entity class returned to the front end or caller.

public class UserVO {
    private Long id;
    private String name;
    private Integer age;
    //....可能還有很多屬性
    //省略getter setter
}

At this time, the UserEntity found from the database needs to be converted into UserVO and then returned to the front end (or caller).

public class ObjectConvertUtil {

    public static UserVo convertUserEntityToUserVO(UserEntity userEntity) {
        if (userEntity == null) {
            return null;
        }
        UserVo userVo = new UserVo();

        userVo.setId(userEntity.getId());
        userVo.setName(userEntity.getName());
        userVo.setAge(userEntity.getAge());
         //如果還有更多屬性呢？
        return userVo;
    }
}

從這個util類中，我們可以看出，如果一個類的屬性有幾十個，上百個的，這代碼量是不是有點恐怖？

于是，我們通常都會使用一些工具類來處理，比如常見有以下：

BeanUtils.copy();
JSON.parseObject()
Guava工具類
.....

這些工具類就用到了原型模式。

通過一個對象，創(chuàng)建一個新的對象。

也把原型模式稱之為對象的拷貝、克隆。

其實對象的克隆分淺克隆和深克隆，下面我們就來聊聊淺克隆和深克隆。

• 淺克?。簞?chuàng)建一個新對象，新對象的屬性和原來對象完全相同，對于非基本類型屬性，仍指向原來對象的屬性所指向的對象的內(nèi)存地址。
• 深克?。簞?chuàng)建一個新對象，屬性中引用的其他對象也會被克隆，不再指向原有對象地址。

我們先來聊聊淺克隆，都喜歡由淺入深。

淺克隆

比如，我現(xiàn)在相對用戶信息User進行克隆，但是User中有用戶地址信息UserAddress屬性。

以下是代碼的實現(xiàn)：

//用戶地址信息
public class UserAddress  implements Serializable{
    private String province;
    private String cityCode;

    public UserAddress(String province, String cityCode) {
        this.province = province;
        this.cityCode = cityCode;
    }
}
//用戶信息
public class User implements Cloneable {
    private int age;
    private String name;
    //用戶地址信息
    private UserAddress userAddress;

    //getter setter 省略

    @Override
    protected Object clone() throws CloneNotSupportedException { 
        return super.clone();
    }
}
//測試
public class UserTest {
    public static void main(String[] args) throws Exception {
        User user = new User();
        user.setAge(20);
        user.setName("田維常");
        UserAddress userAddress = new UserAddress("貴州", "梵凈山");
        user.setUserAddress(userAddress);

        User clone = (User) user.clone();

        System.out.println("克隆前后UserAddress比較：" + (user.getUserAddress() == clone.getUserAddress()));
    }
}

輸出結(jié)果

克隆前后 UserAddress 比較：true

兩個對象屬性 UserAddress 指向的是同一個地址。

這就是所謂的淺克隆，只是克隆了對象，對于該對象的非基本類型屬性，仍指向原來對象的屬性所指向的對象的內(nèi)存地址。

關(guān)系如下：

深克隆

關(guān)于深克隆，我們來用一個很經(jīng)典的案例，西游記里的孫悟空。一個孫悟空能變成n多個孫悟空，手里都會拿著一個金箍棒。

按照前面的淺克隆，結(jié)果就是：孫悟空倒是變成很多孫悟空，但是金箍棒用的是同一根。

深克隆的結(jié)果是：孫悟空變成了很多個，金箍棒也變成很多個根。

下面我們用代碼來實現(xiàn)：

//猴子，有身高體重和生日
public class Monkey {
    public int height;
    public int weight;
    public Date birthday;
}

孫悟空也是猴子，兵器 孫悟空有個金箍棒：

import java.io.Serializable;
//孫悟空的金箍棒
public class JinGuBang implements Serializable{
    public float  h=100;
    public float  d=10;
    //金箍棒變大
    public void big(){
        this.h *=10;
        this.d *=10;
    }
    //金箍棒變小
    public void small(){
        this.h /=10;
        this.d /=10;
    }
}

齊天大圣孫悟空：

import java.io.*;
import java.util.Date;

//孫悟空有七十二變,拔猴毛生成一個金箍棒
//使用JDK的克隆機制，
//實現(xiàn)Cloneable并重寫clone方法
public class QiTianDaSheng extends Monkey implements Cloneable, Serializable {

    public JinGuBang jinGuBang;

    public QiTianDaSheng() {
        this.birthday = new Date();
        this.jinGuBang = new JinGuBang();
    }

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

    //深克隆
    public QiTianDaSheng deepClone() {
        try {
            //內(nèi)存中操作完成、對象讀寫，是通過字節(jié)碼直接操作
            //與序列化操作類似
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            oos.writeObject(this);

            ByteArrayInputStream bais = new ByteArrayInputStream(bos.toByteArray());
            ObjectInputStream bis = new ObjectInputStream(bais);

            //完成一個新的對象,底層是使用new創(chuàng)建的一個對象
            //詳情可以了解readObject方法
            QiTianDaSheng qiTianDaSheng = (QiTianDaSheng) bis.readObject();
            //每個猴子的生日不一樣，所以每次拷貝的時候，把生日改一下
            qiTianDaSheng.birthday = new Date();
            return qiTianDaSheng;
        } catch (Exception ex) {
            ex.printStackTrace();
            return null;
        }
    }

    //淺克隆，就是簡單的賦值
    public QiTianDaSheng shalllowClone(QiTianDaSheng target) {
        QiTianDaSheng qiTianDaSheng = new QiTianDaSheng();
        qiTianDaSheng.height = target.height;
        qiTianDaSheng.weight = target.weight;

        qiTianDaSheng.jinGuBang = target.jinGuBang;
        qiTianDaSheng.birthday = new Date();
        return qiTianDaSheng;

    }
}

接著我們就來測試一下：

public class DeepCloneTest {
    public static void main(String[] args) {
        QiTianDaSheng qiTianDaSheng = new QiTianDaSheng();
        try {
            QiTianDaSheng newObject = (QiTianDaSheng) qiTianDaSheng.clone();
            System.out.print("深克隆后 ");
            System.out.println("金箍棒是否一直：" + (qiTianDaSheng.jinGuBang == newObject.jinGuBang));
            
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        
        QiTianDaSheng newObject=qiTianDaSheng.shalllowClone(qiTianDaSheng);
        System.out.print("淺克隆后 ");
        System.out.println("金箍棒是否一直：" + (qiTianDaSheng.jinGuBang == newObject.jinGuBang));
    }
}

輸出結(jié)果為：

深克隆后 金箍棒是否一直：false
淺克隆后 金箍棒是否一直：true

結(jié)論

深克隆后每個孫悟空都有自己的金箍棒，而淺克隆后每個孫悟空用的金箍棒實質(zhì)上還是同一根。

總結(jié)

切記：深和淺，指的是克隆對象里的屬性（引用類型）是否指向同一個內(nèi)存地址。

為了更深刻的理解深克隆和淺克隆，我們回答文中的簡歷拷貝的故事。

• Deep copy: Copy a resume, and then modify the information in the resume into your own
• ##Shallow copy: Copy a resume, resume content Completely unchanged

Advantages:

• Java prototype mode is based on memory binary stream copy, which has better performance than direct new Better.
• You can use deep cloning to save the object state, save an old copy (clone it), and then modify it, which can serve as an undo function.

Disadvantages:

• needs to configure the clone method, and needs to modify existing classes during transformation, which violates the "open" principle of closure”.
• If there are multiple nested references between objects, each layer needs to be cloned.