设计模式之建造者模式

4. 建造者模式

• 结构
  抽象建造者Builder + 具体建造者ConcreteBuilder + 产品Product + 指挥者Director
• 适用环境
  需要生成的产品对象有复杂的内部结构，这些产品对象通常包含多个成员对象。
  需要生成的产品对象的属性相互依赖，需要指定其生成顺序。
  对象的创建过程独立于创建该对象的类。
  隔离复杂对象的创建和使用，并使得相同的创建过程可以创建不同的产品。
• 实现

public class Computer {
   //主机
   private Master master;
   //显示器
   private Display display;
   //键盘
   private KeyBoard keyBoard;

   public Master getMaster() {
       return master;
   }

   public void setMaster(Master master) {
       this.master = master;
   }

   public Display getDisplay() {
       return display;
   }

   public void setDisplay(Display display) {
       this.display = display;
   }

   public KeyBoard getKeyBoard() {
       return keyBoard;
   }

   public void setKeyBoard(KeyBoard keyBoard) {
       this.keyBoard = keyBoard;
   }
}

public class Master {
    private String cpu;
    private String name;

    public Master(String cpu, String name) {
        this.cpu = cpu;
        this.name = name;
    }
}

public class Display {
    private Integer size;
    private String name;

    public Display(Integer size, String name) {
        this.size = size;
        this.name = name;
    }
}

public class KeyBoard {
    private String color;
    private String name;

    public KeyBoard(String color, String name) {
        this.color = color;
        this.name = name;
    }
}

public abstract class Builder{
    protected Computer computer = new Computer();

    //构建主机
    public abstract void buildMaster();
    //构建显示器
    public abstract void buildDisplay();
    //构建键盘
    public abstract void buildKeyBoard();

    public Computer getResult(){
        return computer;
     };
}

public class ComputerBuilder extends Builder {
    @Override
    public void buildMaster() {
        System.out.println("构建主机");
        computer.setMaster(new Master("Intel 酷睿i9 9900K","主机"));
    }

    @Override
    public void buildDisplay() {
        System.out.println("构建显示器");
        computer.setDisplay(new Display(16,"防辐射显示器"));
    }

    @Override
    public void buildKeyBoard() {
        System.out.println("构建键盘");
        computer.setKeyBoard(new KeyBoard("黑色","静音键盘"));
    }
}

public class Director {
    private Builder builder;

    public Director(Builder builder){
        this.builder = builder;
    }

    public Computer construct(){
        builder.buildMaster();
        builder.buildDisplay();
        builder.buildKeyBoard();
        return builder.getResult();
    }
}

public class Client {
    public static void main(String[] args) {
        Builder builder = (Builder) XMLUtils.getBean();
        Director director = new Director(builder);
        director.construct();
    }
}

public class XMLUtils {
	public static Object getBean(){
	        try {
	            DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();
	            DocumentBuilder builder = dFactory.newDocumentBuilder();
	            Document doc;
	            doc = builder.parse(new File("resources//createPattern//factoryMethod//config.xml"));
	
	            NodeList nodeList = doc.getElementsByTagName("className");
	            Node firstChild = nodeList.item(0).getFirstChild();
	            String className = firstChild.getNodeValue().trim();
	
	            Class c = Class.forName(className);
	            Object object = c.newInstance();
	            return object;
	        }catch (Exception e){
	            e.printStackTrace();
	            return null;
	        }
	    }
}

<?xml version="1.0" encoding="UTF-8"?>
<config>
    <className>createPattern.builderPattern.ComputerBuilder</className>
</config>