Builder生成器模式学习笔记整理

Builder模式的缘起:

    假设创建游戏中的一个房屋House设施,该房屋的构建由几个部分构成，且各个部分要富于变化。

    如果使用最直观的设计方法，每一个房屋部分的变化，都将导致房屋构建的重新修正......

动机(Motivation)

    在软件系统中，有时候面临着一个"复杂对象"的创建工作，其通常由各个部分的子对象按照一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将他们组合在一起的算法却相对稳定。

    如何应对这种变化？如何提供一种"封装机制"来隔离出"复杂对象各个部分"的变化，从而保持系统中的"稳定构建算法"不随着需求的变化而改变？

意图(Intent)

    将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示

结构(Struction)

 

 

 

 

 

 

 

代码演示

using System;

namespace BuilderDemo
{
    public abstract class House
    { 
    }
    public abstract class Wall
    { 
    }
    public abstract class Windows
    { 
    }
    public abstract class Floor
    { 
    }
    public abstract class HouseCeiling
    { 
    }

    /// <summary>
    /// 对应结构图中的Builder
    /// </summary>
    public abstract class Builder
    {
        public abstract void BuildDoor();
        public abstract void BuildWall();
        public abstract void BuildWindows();
        public abstract void BuildFloor();
        public abstract void BuildHouseCeiling();

        public abstract House GetHouse(); 
    }
}

 

using System;

namespace BuilderDemo
{
    public class GameManager
    {
        //此为构建算法，为系统当中相对稳定的部分
        /// <summary>
        /// 对应结构图中的Director
        /// </summary>
        /// <param name="builder"></param>
        /// <returns></returns>
        public static House CreateHouse(Builder builder)
        {
            
            builder.BuildDoor();
            builder.BuildDoor();

            builder.BuildWall();
            builder.BuildWall();

            builder.BuildWindows();
            builder.BuildWindows();

            builder.BuildFloor();
            builder.BuildHouseCeiling();

            return builder.GetHouse();
        }
    }
}

 

using System;

namespace BuilderDemo
{
    //以下是系统当中变化剧烈的地方
    public class RomanHouse : House
    {
    }
    public class RomanWall : Wall
    {
    }
    public class RomanWindows : Windows
    {
    }
    public class RomanFloor : Floor
    {
    }
    public class RomanHouseCeiling : HouseCeiling
    {
    }
    /// <summary>
    /// 对应结构图中的ConcretBuilder
    /// </summary>
    public class RomanBuilder : Builder
    {
        public override void BuildDoor()
        { 
        }
        public override void BuildWall()
        { 
        }
        public override void BuildWindows()
        { 
        }
        public override void BuildFloor()
        { 
        }
        public override void BuildHouseCeiling()
        { 
        }
        public override House GetHouse()
        {
            //对上面的Build进行组合，具体怎么组合，视具体实现而定
        }
    }
    
}

 

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

namespace BuilderDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            //此种实现仍有缺点，每次改变Builder也要重新编译
            //House house = GameManager.CreateHouse(new RomanBuilder());

            //推荐如下方法，使用反射机制
            string assemblyName = ConfigurationManager.AppSettings["BuilderAssembly"];
            string builderName = ConfigurationManager.AppSettings["BuilderClass"];

            Assembly assembly = Assembly.Load(assemblyName);
            Type t = assembly.GetType(builderName);

            Builder builder = Activator.CreateInstance(t) as Builder;

            House house = GameManager.CreateHouse(builder);
        }
    }
}

Builder模式的几个要点:

    Builder模式主要用于"分步骤构建一个复杂的对象"。这其中的"分步骤"是一个稳定的算法，而复杂对象的各个部分却经常变化。

    变化点在哪里，封装哪里—Builder模式主要在于应对"复杂对象各个部分"的频繁需求变动。其缺点在于难以应付"分步骤构建算法"的需求变动

    抽象工厂模式解决"系列对象"的需求变化，Builder模式解决"对象部分"的需求变化。Builder模式通常和Composite模式组合使用。