设计模式-建造者模式(Bulider)

设计模式-建造者模式(Bulider)

定义

”将一个复杂对象的构建流程与它的对象表现分离出来，让相同的构建流程可以产生不同的对象行为表现。”

实现

建造者模式可以分成两个步骤来实施:

1. 将复杂的构建流程独立出来，并将整个流程分成几个步骤，其中的每一个步骤可以是一个功能组件的设置，也可以是参数的指定，并且在一个构建方法中，将这些步骤串接起来；
2. 定义一个专门实现这些步骤（提供这些功能）的实现者，这些实现者知道每一部分该如何完成，并且能接受参数来决定要产出的功能，但不知道整个组装流程是什么；

基本上，实现时只要把握这两个原则："流程分析安排"和“功能分开实现”，就能将建造者模式应用于复杂的对象构建流程上。

类图

说明

• Director(建造指示者)
  负责对象构建是的“流程分析安排”；
  在Construct()方法中会明确定义对象的组装流程，即调用Builder接口方法的顺序；
• Builder(构建者接口类)
  定义不同的方法将“功能分开实现”
  其中的每一个方法都是用来提供给某复杂对象的一部分功能，或是提供设置规则；
• ConcreteBuilder(具体构建者)
  Builder的具体实现
  不同的COncreteBuilder可以产出不同的功能，用来实现不同对象的行为表现和功能；
• Procuct(产品)
  代表最终完成的复杂对象，其必须提供方法可以让Builder类可以将各部分功能设置给它；

代码

以下代码在unity环境下编写运行

using UnityEngine;

namespace ZhhDesignPattern_Builder
{

    public class Builder_UnitTest : MonoBehaviour
    {
        Director m_director;//构建指示者
        public Product m_product_1;
        public Product m_product_2;

        void Awake()
        {
            m_director = new Director();
        }

        void Start()
        {
            //构建类型A的对象
            m_director.Construct(new ConcreteBuilder_A());
            m_product_1 = m_director.GetResult();
            m_product_1.ShowProduct();

            //构建类型B的对象
            m_director.Construct(new ConcreteBuilder_B());
            m_product_2 = m_director.GetResult();
            m_product_2.ShowProduct();
        }
    }

    //具体产品类，需要提供方法可以让Builder类可以将各部分功能设置给它
    public class Product
    {
        public ProductType m_type;//类型
        public string m_describe;//描述
        public string m_position;//位置

        public void SetType(ProductType type)//设置类型
        {
            m_type = type;
        }

        public void SetMemberNumber(string describe, string position)//设置成员属性
        {
            m_describe = describe;
            m_position = position;
        }

        public void ShowProduct()
        {
            switch (m_type)
            {
                case ProductType.Type_A:
                    Debug.Log("产生的A类对象");
                    break;
                case ProductType.Type_B:
                    Debug.Log("产生的B类对象");
                    break;
                default:
                    break;
            }
            Debug.Log(string.Format("描述：{0}，位置：{1}", m_describe, m_position));
        }
    }

    public enum ProductType
    {
        Type_A,
        Type_B,
    }


    //建造指示者
    public class Director
    {
        private Product m_product;

        //构建-明确定义对象的组装流程，即调用Builder接口方法的顺序
        public void Construct(Builder builder)
        {
            m_product = new Product();

            builder.BuilderPart_1(m_product);
            builder.BuilderPart_2(m_product);

        }

        //返回具体产品
        public Product GetResult()
        {
            return m_product;
        }
    }

    //构建者接口类
    public abstract class Builder
    {
        public abstract void BuilderPart_1(Product product);
        public abstract void BuilderPart_2(Product product);
    }

    //具体的构建者A，代表不同的构建流程
    public class ConcreteBuilder_A : Builder
    {
        public override void BuilderPart_1(Product product)
        {
            product.SetType(ProductType.Type_A);
        }

        public override void BuilderPart_2(Product product)
        {
            product.SetMemberNumber("A类对象的描述", "A类对象的位置");
        }
    }

    //具体的构建者B，代表不同的构建流程
    public class ConcreteBuilder_B : Builder
    {
        public override void BuilderPart_1(Product product)
        {
            product.SetType(ProductType.Type_B);
        }

        public override void BuilderPart_2(Product product)
        {
            product.SetMemberNumber("B类对象的描述", "B类对象的位置");
        }
    }
}

小结

将构建与功能分开实现，只在具体的产品对象中提供工具方法，而在Builder中调用这些工具方法来达到产生具体所需要的对象；
将复杂对象的”产生流程“与”功能实现“拆分后，让系统的调整和维护变得更容易；此外在不更新实现者的情况下，调整产生流程的顺序就能完成装备线的更改；