introduction
Dans le développement logiciel, il existe un grand nombre d'objets complexes, qui ont une série d'attributs membres, dont certains sont des objets membres de type référence. Et dans ces objets complexes, il peut y avoir des restrictions. Par exemple, si certains attributs ne sont pas affectés, l'objet complexe ne peut pas être utilisé comme un produit complet; l'attribution de certains attributs doit être dans un certain ordre. Avant qu'un attribut ne soit attribué, un autre attribut Il peut être impossible d'attribuer des valeurs, etc.
Le processus d'assemblage de pièces étant très compliqué, le processus d'assemblage de ces pièces est souvent "externalisé" en un objet appelé générateur. Ce que le constructeur renvoie au client est un objet produit complet qui a été construit et l'utilisateur n'a pas besoin de Se soucier des attributs contenus dans l'objet et de la manière dont ils sont assemblés est la motivation du motif du constructeur.
Le modèle de générateur utilise plusieurs objets simples pour créer un objet complexe étape par étape. Ce type de modèle de conception est un modèle de création, qui constitue le meilleur moyen de créer des objets.
Exemple
Le mode générateur comprend les rôles suivants:
Builder: Constructeur abstraitConcreteBuilder: Constructeur de bétonDirector: Le commandantProduct:produit
Un ordinateur est une configuration standard pour chaque programmeur, et les principaux accessoires sont: le processeur, la carte mère, la mémoire, la carte graphique et l'alimentation. Il existe actuellement deux plates-formes principales: AMDet Intel, mais certaines parties des deux plates-formes sont différentes. Par conséquent, les accessoires sélectionnés par Fei Zhai lors de l'assemblage des deux plateformes sont également différents.
Produit (ordinateur):
public class Computer {
/**
* cpu
*/
private String cpu;
/**
* 主板
*/
private String motherboar;
/**
* 内存
*/
private String ram;
/**
* 显卡
*/
private String graphicsCard;
/**
* 电源
*/
private String power;
//setter and getter
// toString
}
Usine abstraite:
abstract class AbstractComputerBuilder {
/**
* 选择CPU
*/
abstract void buildCPU();
/**
* 选择主板
*/
abstract void buildMotherboar();
/**
* 选择内存
*/
abstract void buildRam();
/**
* 选择显卡
*/
abstract void buildGraphicsCard();
/**
* 选择电源
*/
abstract void buildPower();
/**
* 获取电脑
*/
abstract Computer getComputer();
}
Constructeur spécifique:
// AMD电脑 建造者
public class AmdComputerBuilder extends AbstractComputerBuilder {
private Computer computer = new Computer();
@Override
void buildCPU() {
computer.setCpu("2700x");
}
@Override
void buildMotherboar() {
computer.setMotherboar("华硕 ROG X470");
}
@Override
void buildRam() {
computer.setRam("芝奇 DDR4 8G");
}
@Override
void buildGraphicsCard() {
computer.setGraphicsCard("vega 56");
}
@Override
void buildPower() {
computer.setPower("EVGA 750W");
}
@Override
Computer getComputer() {
return computer;
}
}
// Intel 电脑建造者
public class IntelComputerBuilder extends AbstractComputerBuilder {
private Computer computer = new Computer();
@Override
void buildCPU() {
computer.setCpu("i7 8700");
}
@Override
void buildMotherboar() {
computer.setMotherboar("微星 Z370");
}
@Override
void buildRam() {
computer.setRam("金士顿 DDR4 8G");
}
@Override
void buildGraphicsCard() {
computer.setGraphicsCard("GTX 1080Ti");
}
@Override
void buildPower() {
computer.setPower("海韵 750W");
}
@Override
Computer getComputer() {
return computer;
}
}
Le commandant:
public class ComputerDirector {
public void construct(AbstractComputerBuilder builder) {
builder.buildCPU();
builder.buildMotherboar();
builder.buildRam();
builder.buildGraphicsCard();
builder.buildPower();
}
}
tester:
public class Fz {
@Test
public void build() {
ComputerDirector director = new ComputerDirector();
AmdComputerBuilder amdComputerBuilder = new AmdComputerBuilder();
director.construct(amdComputerBuilder);
Computer amdComputer = amdComputerBuilder.getComputer();
System.out.println("选择AMD平台配件：" + amdComputer);
IntelComputerBuilder intelComputerBuilder = new IntelComputerBuilder();
director.construct(intelComputerBuilder);
Computer intelComputer = intelComputerBuilder.getComputer();
System.out.println("选择Intel平台配件：" + intelComputer);
}
}
Diagramme de classe
avantage
- L'encapsulation du mode constructeur est très bonne. L'utilisation du mode générateur peut encapsuler efficacement les modifications. Dans le scénario d'utilisation du mode générateur, la catégorie de produit générale et la catégorie de générateur sont relativement stables. Par conséquent, l'encapsulation de la logique métier principale dans la catégorie directeur peut être comparée dans son ensemble. Bonne stabilité.
- En mode constructeur, le client n'a pas besoin de connaître les détails de la composition interne du produit et dissocie le produit lui-même du processus de création de produit, de sorte que le même processus de création puisse créer différents objets de produit.
- Le processus de création de produit peut être contrôlé plus finement. Décomposer les étapes de création d'un produit complexe en différentes méthodes rend le processus de création plus clair et plus pratique à utiliser des programmes pour contrôler le processus de création.
- Le mode constructeur est facile à développer. S'il y a une nouvelle exigence, elle peut être complétée en implémentant une nouvelle classe de générateur. Fondamentalement, il n'est pas nécessaire de modifier le code qui a été testé auparavant, donc il n'introduira pas de risques pour la fonction d'origine. Respectez le principe d'ouverture et de fermeture.
Désavantage
- Les produits créés par le mode constructeur ont généralement plus en commun, et leurs composants sont similaires. Si les produits sont très différents, il n'est pas approprié d'utiliser le mode constructeur, donc l'étendue de leur utilisation est soumise à certaines restrictions.
- Si les changements internes du produit sont complexes, cela peut conduire à la nécessité de définir un grand nombre de classes de constructeurs concrets pour réaliser ce changement, ce qui rend le système très volumineux.
Scène applicable
Le mode constructeur peut être utilisé dans les situations suivantes:
- Les objets produit qui doivent être générés ont une structure interne complexe et ces objets produit contiennent généralement plusieurs attributs membres.
- Les attributs des objets produit à générer dépendent les uns des autres et l'ordre de leur génération doit être spécifié.
- Le processus de création d'un objet est indépendant de la classe qui a créé l'objet. En mode générateur, la classe leader est introduite et le processus de création est encapsulé dans la classe leader, pas dans la classe constructeur.
- Isolez la création et l'utilisation d'objets complexes et activez le même processus de création pour créer différents produits.
Pour résumer
Le mode constructeur est similaire au mode usine et les scénarios applicables sont également très similaires. Le mode constructeur n'a qu'un seul rôle de "commandant" de plus que le mode usine. Dans le diagramme de classes du modèle de générateur, si la classe Director est considérée comme le client finalement appelé, le reste de l'image peut être considéré comme un simple modèle d'usine.
Le mode générateur est généralement utilisé pour créer des objets plus complexes, car le processus de création d'objet est plus compliqué, de sorte que le processus de création d'objet est séparé en une nouvelle classe de directeur de classe. En d'autres termes, le modèle d'usine encapsule l'ensemble du processus de création de l'objet dans la classe d'usine, et la classe d'usine fournit le produit final au client; en mode constructeur, la classe constructeur ne fournit généralement que la construction de chaque composant de la classe de produit. Le processus de construction spécifique est livré à la classe des directeurs. La classe des directeurs est responsable de l'organisation de chaque composant en un produit selon des règles spécifiques, puis de la livraison du produit assemblé au client. Le mode constructeur accorde plus d'attention à la séquence d'assemblage des pièces.
De manière générale, si la construction du produit est complexe, veuillez utiliser le modèle d'usine; si la construction du produit est plus complexe, veuillez utiliser le modèle constructeur.