Hallo zusammen, ich bin Lao Tian, ????Heute werde ich Designmuster 原型模式 mit euch teilen. Verwenden Sie geeignete Lebensgeschichten und reale Projektszenarien, um über das Entwurfsmuster zu sprechen, und fassen Sie das Entwurfsmuster schlie?lich in einem Satz zusammen.

Geschichte

Ich erinnere mich noch daran, als ich in meinem Abschlussjahr auf Jobsuche war, zuf?llig eine relativ sch?ne Lebenslaufvorlage für Programmierer aus dem Internet gefunden habe und dann die ganze Klasse angefangen hat zu kopieren ihre Lebensl?ufe wie verrückt (U-Disk). Gleichzeitig gab es auch einen Witz, als mehrere Studenten ihre früheren Lebensl?ufe kopierten, ohne den Inhalt oder ihren Namen zu ?ndern. Sp?ter sollte jeder das Ergebnis erraten k?nnen. Alle machten ein Praktikum, und einige von ihnen waren noch auf der Suche nach einem Job. Feedback vom Interviewer im Unternehmen und anderen Klassenkameraden sp?ter: Ich habe mehrere Lebensl?ufe erhalten, die genau gleich waren. Als ich zurückkam, wussten alle, wo das Problem lag, nachdem wir darüber gesprochen hatten. Ich gab zu, dass ich es kopiert und eingereicht hatte ohne es überhaupt zu ?ndern. Schade.

Unterteilen Sie Lebenslaufkopien in zwei Arten:

• Eine besteht darin, den Lebenslauf zu kopieren und dann die Informationen an Ihre eigenen anzupassen.
• Die andere besteht darin, den Lebenslauf zu kopieren, ohne den Inhalt zu ?ndern. ?Definition von Prototypmustern“ mit Prototyp-Instanztypen und erstellen Sie neue Objekte durch Kopieren dieser Prototypen. Prototyp-Modus:
  , ein kreativer Modus.

Nutzungsszenarien

Der Prototyp-Modus verfügt über die folgenden Nutzungsszenarien:

• Die Klasseninitialisierung verbraucht mehr Ressourcen
• Ein von new generiertes Objekt erfordert einen sehr langwierigen Prozess (Datenvorbereitung, Zugriffsberechtigungen usw.)
• Der Konstruktor ist komplizierter
• Wenn eine gro?e Anzahl von Objekte werden innerhalb des Schleifenk?rpers generiert
• Im Frühjahr wird h?ufig das Prototypmuster verwendet, zum Beispiel: scope='prototype'scope='prototype'

我們可以將一些getter和setter之類封裝成一個工廠方法，然后對于使用的人來說，調(diào)用方法就可以了，不需要知道里面的getter和setter是怎么處理的。我們也可以使用JDK提供的實現(xiàn)Cloneable接口，實現(xiàn)快速復制。

創(chuàng)建對象的四種方式：

new、反射、克隆、序列化

實際案例

大家是否有遇到過這種常見，就是項目中規(guī)定，不能把與數(shù)據(jù)庫表映射的entity類返回給前端，所以通常返回給前端的有各種O，比如：XxxVO、XxxBO、XxxDTO...

這時候就會出現(xiàn)下面的場景，大家也想已經(jīng)猜到了。

下面是與數(shù)據(jù)庫表映射的UserEntity

Wir k?nnen einige Getter und Setter in eine Factory-Methode kapseln und dann für den Benutzer einfach die Methode aufrufen, Es ist nicht erforderlich, zu wissen, wie die darin enthaltenen Getter und Setter gehandhabt werden. Wir k?nnen auch Implementierung bereitgestellt durch JDK

Vier M?glichkeiten zum Erstellen von Objekten:

new,flection, Clone, serialize??

Tats?chlicher Fall

??Jemand ist mir darauf begegnet H?ufiges Problem. Im Projekt ist festgelegt, dass die der Datenbanktabelle zugeordnete Entit?tsklasse nicht an das Frontend zurückgegeben werden kann. Daher werden normalerweise verschiedene O an das Frontend zurückgegeben, z. B.: XxxVO, XxxBO, XxxDTO ... ?? ??Zu diesem Zeitpunkt erscheint die folgende Szene, und jeder hat es vielleicht erraten. ????Das Folgende ist die Zuordnung zur Datenbanktabelle以下是代碼的實現(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

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