10-Builder

The goal of builder is to separate the construction from the “representation,” to allow multiple different representations . The construction process stays the same, but the resulting object has different possible representations.GoF points out that the main difference with Abstract Factory is that a Builder creates the object step-by-step, so the fact that the creation process is spread out in time seems to be important. In addition, it seems that the “director” gets a stream of pieces that it passes to the Builder, and each piece is used to perform one of the steps in the build process.

......

Here’s an example that may be a little more compelling, or at least give more of an idea of what Builder is trying to do. Media may be constructed into different representations, in this case books, magazines and web sites. The example argues that the steps involved are the same, and so can be abstracted into the director class.

//: builder:BuildMedia.java

// Example of the Builder pattern

package builder;

import java.util.*;

import junit.framework.*;

 

// Different "representations" of media:

class Media extends ArrayList {}

class Book extends Media {}

class Magazine extends Media {}

class WebSite extends Media {}

 

// ... contain different kinds of media items:

class MediaItem {

  private String s;

  public MediaItem(String s) { this.s = s; }

  public String toString() { return s; }

}

class Chapter extends MediaItem {

  public Chapter(String s) { super(s); }

}

class Article extends MediaItem {

  public Article(String s) { super(s); }

}

class WebItem extends MediaItem {

  public WebItem(String s) { super(s); }

}

 

// ... but use the same basic construction steps:

class MediaBuilder {

  public void buildBase() {}

  public void addMediaItem(MediaItem item) {}

  public Media getFinishedMedia() { return null; }

}

 

class BookBuilder extends MediaBuilder {

  private Book b;

  public void buildBase() {

    System.out.println("Building book framework");

    b = new Book();

  }

  public void addMediaItem(MediaItem chapter) {

    System.out.println("Adding chapter " + chapter);

    b.add(chapter);

  }

  public Media getFinishedMedia() { return b; }

} 

 

class MagazineBuilder extends MediaBuilder {

  private Magazine m;

  public void buildBase() {

    System.out.println("Building magazine framework");

    m = new Magazine();

  }

  public void addMediaItem(MediaItem article) {

    System.out.println("Adding article " + article);

    m.add(article);

  }

  public Media getFinishedMedia() { return m; }

} 

 

class WebSiteBuilder extends MediaBuilder {

  private WebSite w;

  public void buildBase() {

    System.out.println("Building web site framework");

    w = new WebSite();

  }

  public void addMediaItem(MediaItem webItem) {

    System.out.println("Adding web item " + webItem);

    w.add(webItem);

  }

  public Media getFinishedMedia() { return w; }

} 

 

class MediaDirector { // a.k.a. "Context"

  private MediaBuilder mb;

  public MediaDirector(MediaBuilder mb) {

    this.mb = mb; // Strategy-ish

  }

  public Media produceMedia(List input) {

    mb.buildBase();

    for(Iterator it = input.iterator(); it.hasNext();)

      mb.addMediaItem((MediaItem)it.next());

    return mb.getFinishedMedia();

  }

};

 

public class BuildMedia extends TestCase {

  private List input = Arrays.asList(new MediaItem[] {

    new MediaItem("item1"), new MediaItem("item2"),

    new MediaItem("item3"), new MediaItem("item4"),

  });

  public void testBook() {

    MediaDirector buildBook =

      new MediaDirector(new BookBuilder());

    Media book = buildBook.produceMedia(input);

    String result = "book: " + book;

    System.out.println(result);

    assertEquals(result,

      "book: [item1, item2, item3, item4]");

  }

  public void testMagazine() {

    MediaDirector buildMagazine =

      new MediaDirector(new MagazineBuilder());

    Media magazine = buildMagazine.produceMedia(input);

    String result = "magazine: " + magazine;

    System.out.println(result);

    assertEquals(result,

      "magazine: [item1, item2, item3, item4]");

  }

  public void testWebSite() {

    MediaDirector buildWebSite =

      new MediaDirector(new WebSiteBuilder());

    Media webSite = buildWebSite.produceMedia(input);

    String result = "web site: " + webSite;

    System.out.println(result);

    assertEquals(result,

      "web site: [item1, item2, item3, item4]");

  }

  public static void main(String[] args) {

    junit.textui.TestRunner.run(BuildMedia.class);

  }

} ///:~

 

Note that in some ways this could be seen as a more complicated State pattern, since the behavior of the director depends on what type of builder you use. Instead of simply forwarding the requests through to the underlying State object, however, the director has a sequence of operations to perform, and it uses the State object as a Policy to fulfill its job. Thus, Builder could be described as using a Policy to create objects.

 

//示例代码是比较简单的，能够很好地读懂，但是没有具体的应用实例，不是很好理解。看来具体的项目时间还是比较重要啊！整体的感觉是：Builder模式是按照自己的喜好组装好自己的目标对象，Abstract Factory模式则是一步到位得到自己的目标对象 。找了一个很有意思的讲解：builder 与abstract factory 之间的区别

实际的样例，等以后有了实际的项目经验就好了，到时再整理咯！