Builder Pattern

Concepts

• Handles complex constructors
• Large number of parameters
• Immutability
• Examples: StringBuilder, DocumentBuilder, Locale.Builder

-----------------------------------------
Design

• Flexibility over telescoping constructors
• Static inner class
• Calls appropriate constructor
• Negates the need for exposed setters
• Java 1.5+ can take advantage of Generics
  

--------------------------------------

Everyday Example - StringBuilder

StringBuilder builder = new StringBuilder();
builder.append("This is an example ");
builder.append("of the builder pattern. ");
builder.append("It has methods to append ");
builder.append("almost anything we want to a String. ");
builder.append(42);

----------------------------------------

Exercise Builder

• Demonstrate Exposed Setters
• Demonstrate Telescoping Constructors
• Create Builder
• Build Out Example
  

1. Demo: JavaBean Setters

2. Demo: Telescoping

***3. Demo Builder

package com.pattern.builder;

public class LunchOrder {

	public static class Builder {
		
		private String bread;
		private String condiments;
		
		public Builder() {
			
		}
		
		public LunchOrder build() {
			return new LunchOrder(this);
		}
		
		public Builder bread(String bread) {
			this.bread = bread;
			return this;
		}
		
		public Builder condiments(String condiments) {
			this.condiments = condiments;
			return this;
		}
		
	}
	
	private final String bread;
	private final String condiments;
	
	private LunchOrder(Builder builder) {
		this.bread = builder.bread;
		this.condiments = builder.condiments;
	}
	
	public String getBread() {
		return bread;
	}
	/*public void setBread(String bread) {
		this.bread = bread;
	}*/
	public String getCondiments() {
		return condiments;
	}
	/*public void setCondiments(String condiments) {
		this.condiments = condiments;
	}*/
	
}

package com.pattern.builder;

public class BuilderLunchOrderDemo {

	public static void main(String[] args) {

		LunchOrder.Builder builder = new LunchOrder.Builder();
		builder.bread("Wheat").condiments("Lettuce");
		
		LunchOrder lunchOrder = builder.build();
		
		System.out.println(lunchOrder.getBread());
		System.out.println(lunchOrder.getCondiments());
		
	}
}

--------------------------------------------

Pitfalls

• Immutable
• Inner static class
• Designed first
• Complexity

---------------------------------------------------

Contrast
Builder

• Handles complex constructors
• No interface required
• Can be a separate class
• Works with legacy code

Prototype

• Implemented around a clone
• Avoids calling complex construcorts
• Difficult to implement in legacy code

----------------------------------------------------------

Builder Summary

• Creative way to deal with complexity
• Easy to implement
• Few drawbacks
• Can refactor in with separate class

---------------------------------------------------------------
Prototype Pattern
http://blog.csdn.net/u012596785/article/details/79509697