Bonjour à tous, je suis Lao Tian, ????Aujourd'hui, je vais partager avec vous 原型模式 des modèles de conception. Utilisez des histoires de vie appropriées et des scénarios de projet réels pour parler du modèle de conception, et enfin résumez le modèle de conception en une phrase.

Histoire

Je me souviens encore que lorsque je cherchais un emploi au cours de ma dernière année, j'ai accidentellement trouvé un modèle de CV de programmeur relativement beau sur Internet, puis toute la classe a commencé à le copier leurs CV comme des fous (disque U). Dans le même temps, il y a eu aussi une blague. Plusieurs étudiants ont copié leurs curriculum vitae sans changer le contenu ni leur nom. Ils les ont soumis à l'intervieweur (intervieweur de recrutement sur le campus) comme date limite. Plus tard, tout le monde devrait pouvoir deviner le résultat. Tout le monde est parti en stage, et certains d'entre eux étaient encore à la recherche d'un emploi. Retour de l'intervieweur de l'entreprise et d'autres camarades de classe plus tard?: j'ai re?u plusieurs CV qui étaient exactement les mêmes. à mon retour, tout le monde savait quel était le problème après en avoir parlé. J'ai admis que je l'avais copié et soumis. sans le changer du tout. Quel dommage.

Divisez les copies de CV en deux types?:

• La première consiste à copier le CV puis à modifier les informations selon les v?tres
• L'autre consiste à copier le CV sans changer le contenu.

Définition du modèle de prototype

Spécifiez les types d'objets à créer à l'aide d'une instance de prototype et créez de nouveaux objets en faisant face à ce prototype

signifiant grosso modo?: Spécifiez la création d'objets avec un type d'instance de prototype et créez de nouveaux objets en copiant ces prototypes.

Mode Prototype : Prototype Pattern, un mode créatif.

L'appelant n'a pas besoin de conna?tre les détails de la création, ni d'appeler le constructeur pour créer l'objet.

Scénarios d'utilisation

Le mode prototype propose les scénarios d'utilisation suivants?:

• L'initialisation de la classe consomme plus de ressources
• Un objet généré par new nécessite un processus très fastidieux (préparation des données, autorisations d'accès, etc.)
• Le constructeur est plus compliqué
• Quand un grand nombre de les objets sont générés dans le corps de la boucle
• Au Spring, le modèle prototype est largement utilisé, par exemple?: scope='prototype'scope='prototype'

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

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

new、反射、克隆、序列化

實(shí)際案例

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

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

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

Nous pouvons encapsuler certains getters et setters dans une méthode d'usine, puis pour l'utilisateur, il suffit d'appeler la méthode, pas besoin de savoir comment les getters et les setters à l'intérieur sont gérés. Nous pouvons également utiliser Implémentation fournie par JDKCloneable pour obtenir une copie rapide.

Quatre fa?ons de créer des objets?:

nouveau, réflexion, Clone, sérialiser??

Cas réel

以下是代碼的實(shí)現(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

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

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

關(guān)系如下：

深克隆

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

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

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

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

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

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

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;

//孫悟空有七十二變,拔猴毛生成一個(gè)金箍棒
//使用JDK的克隆機(jī)制，
//實(shí)現(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);

            //完成一個(gè)新的對象,底層是使用new創(chuàng)建的一個(gè)對象
            //詳情可以了解readObject方法
            QiTianDaSheng qiTianDaSheng = (QiTianDaSheng) bis.readObject();
            //每個(gè)猴子的生日不一樣，所以每次拷貝的時(shí)候，把生日改一下
            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é)論

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

總結(jié)

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

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

• Copie approfondie?: copiez un CV, puis modifiez les informations du CV pour le personnaliser
• Copie superficielle?: copiez un CV et le contenu du CV reste complètement inchangé

Avantages?:

• Le mode prototype Java est basé sur la copie de flux binaire en mémoire, qui offre de meilleures performances que le nouveau direct.
• Vous pouvez utiliser le clonage profond pour enregistrer l'état de l'objet, enregistrer une ancienne copie (la cloner) et lors de sa modification, il peut agir comme une fonction d'annulation.

Inconvénients?:

• nécessite de configurer la méthode de clonage. Lors de la transformation, les classes existantes doivent être modifiées, ce qui viole le "principe d'ouverture et de fermeture".
• S'il existe plusieurs références imbriquées entre les objets, chaque calque doit être cloné.

Nous avons donné une explication complète du modèle de prototype à partir de sa définition, des scénarios d'utilisation, des cas réels, du clonage superficiel, du clonage profond, des avantages et des inconvénients, etc.