Prototype (patron de conception)
En programmation informatique, le patron de conception prototype est utilisé lorsque la création d'une instance est complexe ou consommatrice en temps. Plutôt que créer plusieurs instances de la classe, on copie la première instance et on modifie la copie de façon appropriée.
Pour implémenter ce patron il faut déclarer une classe abstraite spécifiant une méthode virtuelle pure appelée clone(). Toute classe nécessitant un constructeur polymorphique dérivera de cette classe abstraite et implémentera la méthode clone().
Le client de cette classe, au lieu d'écrire du code invoquant directement l'opérateur "new" sur une classe explicitement connue, appellera la méthode clone() sur le prototype ou passera par un mécanisme fourni par un autre patron de conception (par exemple une méthode de fabrique avec un paramètre désignant la classe concrète à instancier).
Structure
Le diagramme de classes est le suivant :
La classe Prototype sert de modèle principal pour la création de nouvelles copies. Les classes ConcretePrototype1 et ConcretePrototype2 viennent spécialiser la classe Prototype en venant par exemple modifier certains attributs. La méthode clone() doit retourner une copie de l'objet concerné. Les sous-classes peuvent hériter ou surcharger la méthode clone(). La classe Client va se charger d'appeler les méthodes de clonage via sa méthode operation().
Exemple de code en C#
public enum RecordType
{
Car,
Person
}
/// <summary>
/// Record is the Prototype
/// </summary>
public abstract class Record : ICloneable
{
#region ICloneable Membres
object ICloneable.Clone() { return this.Clone(); }
#endregion
public abstract Record Clone();
}
/// <summary>
/// PersonRecord is the Concrete Prototype
/// </summary>
public class PersonRecord : Record
{
string name;
int age;
public override Record Clone()
{
return (Record)this.MemberwiseClone(); // default shallow copy
}
}
/// <summary>
/// CarRecord is another Concrete Prototype
/// </summary>
public class CarRecord : Record
{
string carname;
Guid id;
public override Record Clone()
{
CarRecord clone = (CarRecord)this.MemberwiseClone(); // default shallow copy
clone.id = Guid.NewGuid(); // always generate new id
return clone;
}
}
/// <summary>
/// RecordFactory is the client
/// </summary>
public class RecordFactory
{
private static Dictionary<RecordType, Record> _prototypes =
new Dictionary<RecordType, Record>();
/// <summary>
/// Constructor
/// </summary>
public RecordFactory()
{
_prototypes.Add(RecordType.Car, new CarRecord());
_prototypes.Add(RecordType.Person, new PersonRecord());
}
/// <summary>
/// The Factory method
/// </summary>
public Record CreateRecord(RecordType type)
{
return _prototypes[type].Clone();
}
}
Exemple de code en JAVA
/* Prototype Class */
public class Cookie implements Cloneable
{
@Override
public Cookie clone()
{
try
{
Cookie copy = (Cookie)super.clone();
// Dans une implémentation réelle de ce patron de conception, il faudrait
// créer la copie en dupliquant les objets contenus et en attribuant des
// valeurs valides (exemple : un nouvel identificateur unique pour la copie).
return copy;
}
catch (CloneNotSupportedException e)
{
return null;
}
}
}
/* Concrete Prototypes to clone */
public class CoconutCookie extends Cookie { }
/* Client Class */
public class CookieMachine
{
private Cookie cookie; // aurait pu ĂŞtre "private Cloneable cookie;"
public CookieMachine(Cookie cookie)
{
this.cookie = cookie;
}
public Cookie makeCookie()
{
return cookie.clone();
}
public static void main(String args[])
{
Cookie tempCookie = null;
Cookie prot = new CoconutCookie();
CookieMachine cm = new CookieMachine(prot);
for (int i=0; i<100; i++)
{
tempCookie = cm.makeCookie();
}
}
}
Exemples
Exemple où prototype s'applique : supposons une classe pour interroger une base de données. À l'instanciation de cette classe on se connecte et on récupère les données de la base avant d'effectuer tous types de manipulation. Par la suite il sera plus performant pour les futures instances de cette classe de continuer à manipuler ces données que de réinterroger la base. Le premier objet de connexion à la base de données aura été créé directement puis initialisé. Les objets suivants seront une copie de celui-ci et donc ne nécessiteront pas de phase d'initialisation.