Design Patterns : Builder

what is Builder

Builder is a creational design pattern. It helps you construct complex objects step by step and the final step will return the object. The process of constructing an object should be generic so that it can be used to create different representations of the same object.

Example

Suppose we want to make a Lunch Order. It has a bunch of items such as bread, condiments, dressing, and meat, in reality, even more complex objects. if we use tradition way, that would require a bunch of and complex constructors to achieve that. Check out below example to understand the Builder Patter.

java

public class LunchOrder {
    private final String bread;
    private final String condiments;
    private final String dressing;
    private final String meat;

    /*
    * 1. making constructor as private, ensure LunchOrder can't be instanted outside this class
    * 2. constructor only accept Builder, so this is the bridge how we use builder to create LunchOderBean object
    * 3. In order to wire the two object up, you observe that redundancy fields between Builder and LunchOrder
    * */
    private LunchOrder(Builder builder){
        this.bread = builder.bread;
        this.condiments = builder.condiments;
        this.dressing = builder.dressing;
        this.meat = builder.meat;
    }


    /*
    * you can only see the getters but no setters, that ensures the object immucontratable
    * */
    public String getBread() {
        return bread;
    }
    public String getCondiments() {
        return condiments;
    }
    public String getDressing() {
        return dressing;
    }
    public String getMeat() {
        return meat;
    }


    /*
    * 1.this inner must be static, otherwise it requires an instance of outer calss(LunchOrder) to access Builder
    *
    * */
    public static class Builder{
        private String bread;
        private String condiments;
        private String dressing;
        private String meat;

        public Builder(){}

        public LunchOrder build(){
            return new LunchOrder(this);
        }

        public Builder buildBread(String bread){
            this.bread = bread;
            return this;
        }
        public Builder buildDressing(String dressing){
            this.dressing = dressing;
            return this;
        }
        public Builder buildCondiments(String condiments){
            this.condiments = condiments;
            return this;
        }
        public Builder buildMeat(String meat){
            this.meat = meat;
            return this;
        }
    }

}

Below shows how to use builder to build our object:

java

public class TestApp {
    public static void main(String[] args) {

        LunchOrder.Builder builder = new LunchOrder.Builder();
		/*
		* it not necessary to invoke all buildXXX() method, but only follow your needs. 
		*/
        LunchOrder lunchOrder = builder.buildBread("bread")
                                .buildCondiments("condiments")
                                .buildDressing("dressing")
                                .buildMeat("meat")
                                .build();

        System.out.println(lunchOrder.getBread());
        System.out.println(lunchOrder.getCondiments());
        System.out.println(lunchOrder.getDressing());
        System.out.println(lunchOrder.getMeat());
    }
}

Advantages

• Use the builder pattern to get rid of a “telescopic constructor”.

  say you have a bunch of parameters, to fulfill various requirements, you have to create different constructors.

  java

  class Bread{
      Bread(){...}
      Bread(String p1,String p2){...}
      Bread(String p1,String p2,String p3){...}
      //...
  }

  The builder pattern lets you build objects step by step, with only those steps/ parameters that you really need.

• Builder Pattern can help to create different representtations of some product.

  This requires you to build base builder interface defines all possible construction steps. And concrete builders implement these steps to consturst particular representations of the product.

• Use the Builder to construct Composite trees or other comple objects.

  The Builder pattern lets you construct products step-by-step. You could defer execution of some steps without breaking the final product. You can even call steps recursively, which comes in handy when you need to build an object tree.

  A builder doesn’t expose the unfinished product while running construction steps. This prevents the client code from fetching an incomplete result.