Patrones de diseño detallados: patrones de constructor

Echemos un vistazo al quinto modo de crear nuevos modos hoy: el modo constructor. Todavía queda mirar primero las dos imágenes, revisar el tipo de modo y profundizar en la memoria.

 

definición:

Patrón de construcción: separa la construcción de un objeto complejo de su representación para que el mismo proceso de construcción pueda crear diferentes representaciones. Builder Pattern: Separa la construcción de un objeto complejo de su representación para que el mismo proceso de construcción pueda crear diferentes representaciones.

Separe al cliente del proceso de creación de objetos complejos que contienen múltiples partes. El cliente no necesita conocer los componentes internos y los métodos de ensamblaje de los objetos complejos. Solo necesita saber el tipo de constructor requerido para enfocarse en cómo crear un objeto complejo. paso a paso Diferentes constructores definen diferentes procesos de creación

estructura:

El modo constructor incluye los siguientes 4 roles:

Constructor (constructor abstracto)

ConcreteBuilder (constructor de hormigón)

Producto

Director

analizar:

El patrón de construcción puede separar los componentes de su proceso de ensamblaje y centrarse en cómo crear un objeto complejo con múltiples componentes paso a paso.Los usuarios solo necesitan especificar el tipo de objeto complejo para obtener el objeto sin conocer sus detalles internos. detalles.

Diagrama de clase:

 

aplicabilidad:

Los objetos de producto que deben generarse tienen estructuras internas complejas , y estos objetos de producto suelen contener varias variables miembro.

Los atributos de los objetos del producto que deben generarse dependen unos de otros , y es necesario especificar el orden de su generación.

Un objeto se crea independientemente de la clase que lo creó . En el modo de constructor, al introducir la clase de conductor, el proceso de creación se encapsula en la clase de conductor, no en la clase de constructor y la clase de cliente.

Aísle la creación y el uso de objetos complejos y habilite el mismo proceso de creación para crear diferentes productos

ventaja:

El cliente no necesita conocer los detalles de la composición interna del producto, desvinculando el propio producto del proceso de creación del producto, de manera que un mismo proceso de creación puede crear diferentes objetos de producto

Cada constructor específico es relativamente independiente y no tiene nada que ver con otros constructores específicos. Por lo tanto, es fácil reemplazar constructores específicos o agregar nuevos constructores específicos. Es fácil de expandir y se ajusta al principio de apertura y cierre.

Control más detallado sobre el proceso de creación de productos.

defecto:

Los productos creados por el modo constructor generalmente tienen más en común y sus componentes son similares. Si los productos son muy diferentes, no es adecuado utilizar el modo constructor, por lo que su alcance de uso es limitado.

Si los cambios internos del producto son complicados, puede ser necesario definir muchas clases de constructores específicas para lograr este cambio, lo que da como resultado un sistema muy grande, lo que aumenta la dificultad de comprensión del sistema y el costo operativo.

---

Caso 1: (código .NET)

Una empresa de software de juegos decidió desarrollar un juego multijugador en línea basado en el juego de roles. Los jugadores pueden desempeñar un papel específico en el mundo virtual del juego. Con diferentes habilidades, los personajes también tendrán habilidades más poderosas a medida que continúen mejorando. Como parte importante del juego, los personajes del juego deben diseñarse y se agregarán nuevos personajes continuamente a medida que se actualice el juego. A través del análisis, se encuentra que el personaje del juego es un objeto complejo, que incluye múltiples componentes como el género y la cara. Los diferentes tipos de personajes del juego tienen diferentes características externas como el género, la cara, la ropa y el peinado. Por ejemplo, " Los ángeles" tienen la cara hermosa y el pelo largo como un chal, y visten un vestido blanco; mientras que el "demonio" es extremadamente feo, con la cabeza calva y viste un deslumbrante color negro. No importa qué tipo de personaje de juego sea, sus pasos de creación son similares y sus componentes deben crearse paso a paso y luego ensamblarse en un personaje de juego completo. Ahora use el modo constructor para realizar la creación de personajes del juego.

Lista de funciones de código:

(1) Actor: clase de rol de juego, que actúa como un objeto de producto complejo

(2) ActorBuilder: creador de personajes del juego, que actúa como un constructor abstracto

(3) HeroBuilder: constructor de roles de héroe, que actúa como un constructor específico

(4) AngelBuilder: ángel constructor de roles, actuando como un constructor concreto

(5) DevilBuilder: constructor de personajes diabólicos, que actúa como constructor de hormigón

(6) ActorController: rol de controlador, actuando como comandante

(7) Archivo de configuración App.config

(8) Programa: clase de prueba de cliente

 

Actor.cs

namespace BuilderSample
{
    class Actor
    {
        private string type; //角色类型
        private string sex; //性别
        private string face; //面容
        private string costume; //服装
        private string hairstyle; //发型

        public string Type
        {
            get { return type; }
            set { type = value; }
        }

        public string Sex
        {
            get { return sex; }
            set { sex = value; }
        }

        public string Face
        {
            get { return face; }
            set { face = value; }
        }

        public string Costume
        {
            get { return costume; }
            set { costume = value; }
        }

        public string Hairstyle
        {
            get { return hairstyle; }
            set { hairstyle = value; }
        }
    }
}

ActorBuilder.cs

namespace BuilderSample
{
    //角色建造者：抽象建造者
    abstract class ActorBuilder
    {
        protected Actor actor = new Actor();

        public abstract void BuildType();
        public abstract void BuildSex();
        public abstract void BuildFace();
        public abstract void BuildCostume();
        public abstract void BuildHairstyle();

        //工厂方法，返回一个完整的游戏角色对象
        public Actor CreateActor()
        {
            return actor;
        }
    }
}

HeroBuilder.cs

namespace BuilderSample
{
    class HeroBuilder : ActorBuilder
    {
        public override void BuildType()
        {
            actor.Type = "英雄";
        }

        public override void BuildSex()
        {
            actor.Sex = "男";
        }

        public override void BuildFace()
        {
            actor.Face = "英俊";
        }

        public override void BuildCostume()
        {
            actor.Costume = "盔甲";
        }

        public override void BuildHairstyle()
        {
            actor.Hairstyle = "飘逸";
        }	
    }
}

AngelBuilder.cs

namespace BuilderSample
{
    class AngelBuilder : ActorBuilder
    {
        public override void BuildType()
        {
            actor.Type = "天使";
        }

        public override void BuildSex()
        {
            actor.Sex = "女";
        }

        public override void BuildFace()
        {
            actor.Face = "漂亮";
        }

        public override void BuildCostume()
        {
            actor.Costume = "白裙";
        }

        public override void BuildHairstyle()
        {
            actor.Hairstyle = "披肩长发";
        }	
    }
}

DevilBuilder.cs

namespace BuilderSample
{
    class DevilBuilder : ActorBuilder
    {
        public override void BuildType()
        {
            actor.Type = "恶魔";
        }

        public override void BuildSex()
        {
            actor.Sex = "妖";
        }

        public override void BuildFace()
        {
            actor.Face = "丑陋";
        }

        public override void BuildCostume()
        {
            actor.Costume = "黑衣";
        }

        public override void BuildHairstyle()
        {
            actor.Hairstyle = "光头";
        }	
    }
}

ActorController.cs

namespace BuilderSample
{
    class ActorController
    {
        //逐步构建复杂产品对象
        public Actor Construct(ActorBuilder ab)
        {
            Actor actor;
            ab.BuildType();
            ab.BuildSex();
            ab.BuildFace();
            ab.BuildCostume();
            ab.BuildHairstyle();
            actor = ab.CreateActor();
            return actor;
        }
    }
}

Aplicación.config

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <appSettings>
    <add key="builder" value="BuilderSample.HeroBuilder"/>
  </appSettings>
</configuration>

Programa.cs

using System;
using System.Configuration;
using System.Reflection;

namespace BuilderSample
{
    class Program
    {
        static void Main(string[] args)
        {

		    ActorBuilder ab; //针对抽象建造者编程
            //读取配置文件
            string builderType = ConfigurationManager.AppSettings["builder"]; 
            //反射生成对象
            ab = (ActorBuilder)Assembly.Load("BuilderSample").CreateInstance(builderType); 

            ActorController ac = new ActorController();
		    Actor actor;
		    actor = ac.Construct(ab); //通过指挥者创建完整的建造者对象
            
            Console.WriteLine("{0}的外观：",actor.Type);
            Console.WriteLine("性别：{0}",actor.Sex);
            Console.WriteLine("面容：{0}",actor.Face);
            Console.WriteLine("服装：{0}",actor.Costume);
            Console.WriteLine("发型：{0}",actor.Hairstyle);
            Console.Read();
        }
    }
}

Caso 2: (código JAVA)

 

Constructor

public interface PersonBuilder {

    void buildHead();
    
    void buildBody();
    
    void buildFoot();

    Person buildPerson();
}

ConcretoConstructor

public class ManBuilder implements PersonBuilder {

    Person person;
    
    public ManBuilder() {
        person = new Man();
    }
    
    public void buildbody() {
        person.setBody("建造男人的身体");
    }

    public void buildFoot() {
        person.setFoot("建造男人的脚");
    }

    public void buildHead() {
        person.setHead("建造男人的头");
    }

    public Person buildPerson() {
        return person;
    }
}

Director

public class PersonDirector {

    public Person constructPerson(PersonBuilder pb) {
        pb.buildHead();
        pb.buildBody();
        pb.buildFoot();
        return pb.buildPerson();
    }
}

Producto

public class Person {

    private String head;
    
    private String body;
    
    private String foot;

    public String getHead() {
        return head;
    }

    public void setHead(String head) {
        this.head = head;
    }

    public String getBody() {
        return body;
    }

    public void setBody(String body) {
        this.body = body;
    }

    public String getFoot() {
        return foot;
    }

    public void setFoot(String foot) {
        this.foot = foot;
    }
}

Hombre

public class Man extends Person {

}

Prueba

public class Test{
    
    public static void main(String[] args) {
        PersonDirector pd = new PersonDirector();
        Person person = pd.constructPerson(new ManBuilder());
        System.out.println(person.getBody());
        System.out.println(person.getFoot());
        System.out.println(person.getHead());
    }
}

Resultado de salida:

construyendo el cuerpo de un hombre

construyendo los pies del hombre

construyendo la cabeza del hombre