模式说法之——建造者

简介: 在软件系统中,有时候面临一个“复杂对象”的创建工作,其通常由各个部分的子对象用一定算法构成;由于需求的变化,这个复杂对象的各个部分经常面临着剧烈的变化,但是将它们组合到一起的算法却相对稳定。 如何应对种变化呢?如何提供一种“封装机制”来隔离出“复杂对象的各个部分”的变化,从而保持系统中的“稳定构建算法”不随需求的改变而改变?   将一个复杂对象的构建与其表示相分离,使得同样的构建过程可以创建不同的表示。

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

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

 

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

 

 

 

·抽象建造者(Builder):给出一个抽象接口,以规范产品对象的各个组成成分的建造。这个接口规定要实现复杂对象的哪些部分的创建,并不涉及具体的对象部件的创建。

·具体建造者(Concrete Builder):实现Builder接口,针对不同的商业逻辑,具体化复杂对象的各部分的创建。 在建造过程完成后,提供产品的实例。

·指导者(Director):调用具体建造者来创建复杂对象的各个部分,在指导者中不涉及具体产品的信息,只负责保证对象各部分完整创建或按某种顺序创建。

产品(Product):要创建的复杂对象。

 

(一)代码

//复杂的对象

    //各个部分的子对象用一定算法构成

    //各个部分经常面临着剧烈的变化

    public class Product

    {

        List<string> _list = new List<string>();

 

        public void Add(string strPart)

        {

            _list.Add(strPart);

        }

 

        public void Show()

        {

            foreach(string s in _list)

                Console.WriteLine(s);

        }

    }

 

    //建造者

    public interface IBuilder

    {

        //产品的各个部分

        void BuildPart1();

        void BuildPart2();

        void BuildPartn();

 

        Product GetProduct();

    }

 

    //实现建造者

    public class BuilderA : IBuilder

    {

        private Product _product = new Product();

 

        public void BuildPart1()

        {

            _product.Add("Part 1");

        }

 

        public void BuildPart2()

        {

            _product.Add("Part 2");

        }

 

        public void BuildPartn()

        {

            _product.Add("Part n");

        }

 

        public Product GetProduct()

        {

            return _product;

        }

 

    }

 

    //指导者

    public class Director

    {

        public void CreateProduct(IBuilder builder)

        {

            builder.BuildPart1();

            builder.BuildPart2();

            builder.BuildPartn();

        }

    }

(二)测试

[Test]

        public void TestBuilder()

        {

            //建造者

            IBuilder builder = new BuilderA();

 

            //指导者

            Director director = new Director();

 

            //指导

            director.CreateProduct(builder);

 

            //产品

            Product pro = builder.GetProduct();

 

            //产品内容

            pro.Show();

        }

 

结果:

 

Part 1

Part 2

Part n

 

 

再举一个比较容易理解的例子

(一) 产品类

public class Product

    {

        public delegate void DeleDo();

        public List<DeleDo> _list = new List<DeleDo>();

 

        public void Add(DeleDo i)

        {

            _list.Add(i);

        }

 

        public void Show()

        {

            foreach (DeleDo dd in _list)

            {

                dd();

            }

        }

}

这里一个完整的产品,它由几部分构成,因为它的构建相对稳定,但每个部分却可能发生剧烈变化。因为这个构成如果用别的方法来理解不太好理解,比如:产品类有个字符串的List。这里用委托实现。可以助于理解:构建部分1,……

(二)建造者接口

public interface IBuilder

    {

        void Part1();

        void Part2();

        void Part3();

        void Part4();

 

        Product GetProduct();

}

产品构建是相对稳定的,但包括的4部分却可能发生剧烈变化。

(三)实现构造者1

public class Builder : IBuilder

    {

        Product pro=new Product();

 

        public void p1() { Console.WriteLine("part 1"); }

        public void p2() { Console.WriteLine("part 2"); }

        public void p3() { Console.WriteLine("part 3"); }

        public void p4() { Console.WriteLine("part 4"); }

 

        public void Part1()

        {

            pro.Add(p1);

        }

 

        public void Part2()

        {

            pro.Add(p2);

        }

 

        public void Part3()

        {

            pro.Add(p3);

        }

 

        public void Part4()

        {

            pro.Add(p4);

        }

 

        public Product GetProduct()

        {           

            return pro;

        }

}

这里实现了建造者。每实现一部分的的构建,就代表了整个产品构造完成了一部分。这由产品的Add方法实现。

(四)指挥者

此部分用于构建相对稳定的产品

public class Director

    {

        public void CreateProduct(IBuilder builder)

        {

            builder.Part1();

            builder.Part2();

            builder.Part3();

            builder.Part4();

        }

    }

(五)测试

public void TestBuilder()

        {

            IBuilder builder = new Builder();

 

            Director d = new Director();

            d.CreateProduct(builder);

 

            Product pro = builder.GetProduct();

 

            pro.Show();

        }

 其中,建造者用于应对产品各部分剧烈的变化;而指挥者是稳定的。

 

还得来一个例子,这个例子比较真实,能更好的说明这个建造者模式:

 

  /*

         * 要创建的对象是个复杂的对象,它由各部分组成.其中每个部分存在变化,而把部分组成整体的算法不变,即可用建造者

         *

         * 建造者抽象

         * 各个建造者

         * 指导者,把部分按固定的算法组成复杂对象,并返回这个对象

        */

//产品,car

 

    public class Car

    {

        public void Head(string str)

        {

            Console.WriteLine("head:"+str);

        }

        public void Body(string str)

        {

            Console.WriteLine("body:" + str);

        }

        public void Tail(string str)

        {

            Console.WriteLine("tail:" + str);

        }

    }

 

    public interface IBuilder

    {

        void CreateHead();

        void CreateBody();

        void CreateTail();

 

        Car GetCar();

    }

 

    //jeep builder(jeep factory)

    public class JeepBuilder : IBuilder

    {

        Car car = new Car();

        public void CreateHead()

        {

            car.Head("Jeep");

        }

 

        public void CreateBody()

        {

            car.Body("Jeep");

        }

 

        public void CreateTail()

        {

            car.Tail("Jeep");

        }

 

        public Car GetCar()

        {

            return car;

        }

 

    }

 

    //指挥者,监督者

    public class Director

    {

        public void CreateCar(IBuilder builder)

        {

            builder.CreateTail();

            builder.CreateBody();

            builder.CreateTail();

        }

    }

 

    // 部分发生变化,例如现在是truck

    public class TruckBuilder : IBuilder

    {

        Car car = new Car();

        public void CreateHead()

        {

            car.Head("Truck");

            Console.WriteLine("creating truck head.");

        }

 

        public void CreateBody()

        {

            car.Body("Truck");

            Console.WriteLine("creating truck body.");

        }

 

        public void CreateTail()

        {

            car.Tail("Truck");

            Console.WriteLine("creating truck tail.");

        }

 

        public Car GetCar()

        {

            return car;

        }

    }

 

 

[Test]

public void Test_4_Builder()

{

    IBuilder builder = new JeepBuilder();

    Director director = new Director();

 

    director.CreateCar(builder);

    Car car=builder.GetCar();

 

    builder = new TruckBuilder();

    director.CreateCar(builder);

    car = builder.GetCar();

    //维持顺序,复杂对象组成算法稳定,部分发生变化.

}

 

博客园大道至简

http://www.cnblogs.com/jams742003/

转载请注明:博客园

目录
相关文章
|
3月前
|
设计模式
抽象工厂和原型设计模式之间的区别
【8月更文挑战第22天】
33 0
|
6月前
|
设计模式 Java 数据库连接
Java设计模式--简单工厂、工厂方法和抽象工厂之间的区别
设计模式中的工厂模式(Factory Design pattern)是一个比较常用的创建型设计模式,其中可以细分为三种:简单工厂(Simple Factory)、工厂方法(Factory Method)和抽象工厂(Abstract Factory)。那么三者有什么区别呢?
163 1
Java设计模式--简单工厂、工厂方法和抽象工厂之间的区别
|
设计模式 算法 前端开发
【大话设计模式】-简单工厂-工厂方法-自动化实现工厂工厂方法!
【大话设计模式】-简单工厂-工厂方法-自动化实现工厂工厂方法!
106 0
|
6月前
创建型 简单工厂(工厂方法)模式
创建型 简单工厂(工厂方法)模式
58 1
|
6月前
|
设计模式 SQL 数据库连接
设计模式之抽象工厂模式--创建一系列相关对象的艺术(简单工厂、工厂方法、到抽象工厂的进化过程,类图NS图)
设计模式之抽象工厂模式--创建一系列相关对象的艺术(简单工厂、工厂方法、到抽象工厂的进化过程,类图NS图)
|
存储 设计模式 API
设计模式 | 工厂(方法)模式
工厂模式是简单工厂模式的延伸,它继承了简单工厂模式的优点,同时还弥补了简单工厂模式的不足。工厂方法模式是使用频率最高的设计模式之一,是很多开源框架和 API 类库的核心模式。
105 1
设计模式 | 工厂(方法)模式
|
设计模式
大话设计模式-三种工厂模式(简单工厂、工厂方法、抽象工厂)
大话设计模式-三种工厂模式(简单工厂、工厂方法、抽象工厂)
简单工厂、工厂、抽象工厂总结
简单工厂、工厂、抽象工厂总结
46 0
|
设计模式 uml
设计模式中工厂方法与抽象工厂之间的区别联系
设计模式中工厂方法与抽象工厂之间的区别联系
78 0
|
设计模式 Java
23种设计模式-创建模式-抽象工厂模式(2)
23种设计模式-创建模式-抽象工厂模式(2)