设计模式之建造者模式

本文还是以汽车为例，一辆汽车包含许许多多的零件，而汽车制造商在生产汽车时，都是先由对应供应商将零件生产好，然后再将这些零件组装成汽车。在现实生活中，经常会要生产十分复杂的东西，而这些东西基本上都是先生产出零件，然后再组装成成品。而在我们Java程序设计中，也会遇到这种情况，当一个对象十分复杂的时候，我们就可以利用建造者模式来解决。

建造者模式主要有为四个重要组件：

①：Builder(建造者)，通常是一个接口，定义了生产复杂对象所需要的各个小对象的方法（例如汽车对象的各个零件对象）；

②：ConcreteBuilder（真实的建造者），实现了Builder接口，具体实现了接口中的方法（真正的生产零件）；

③：Director(组装者)，将ConcreteBuilder创建的各个零件组装起来

④：Product（需要生产的复杂对象），该对象的零件由ConcreteBuilder创建，然后由Director组装成真实需要的对象。

建造者模式的UML图：

图中的接口Builder为建造者（Builder），CarBuilder类为真实的建造者（即ConcreteBuilder）,Director类为组装者（即Director），Car类为复杂对象（即Product,其零件分别对应类Tyre、Engine、Seat），Client类为测试类，为了得到Car对象，在Clint类中只需要拥有组装者的对象即可，然后调用相应的方法即可得到。

具体的代码如下：

package com.tiantang.builder;

/**
* 汽车对象car
* @author LiuJinkun
*
*/
public class Car {
private Engine engine;
private Tyre tyre;
private Seat seat;

public Car(Engine engine, Tyre tyre, Seat seat) {
this.engine = engine;
this.tyre = tyre;
this.seat = seat;
}

public Engine getEngine() {
return engine;
}

public void setEngine(Engine engine) {
this.engine = engine;
}

public Tyre getTyre() {
return tyre;
}

public void setTyre(Tyre tyre) {
this.tyre = tyre;
}

public Seat getSeat() {
return seat;
}

public void setSeat(Seat seat) {
this.seat = seat;
}

}

/**
* 汽车引擎
* @author LiuJinkun
*
*/
class Engine {
public void start() {
System.out.println("引擎启动");
}
}

/**
* 汽车轮胎
* @author LiuJinkun
*
*/
class Tyre {
public void run() {
System.out.println("轮胎使汽车跑动");
}
}

/**
* 汽车座椅
* @author LiuJinkun
*
*/
class Seat {
public void sit() {
System.out.println("供乘客及司机坐");
}
}

package com.tiantang.builder;

/**
* 建造者
* @author LiuJinkun
*
*/
public interface Builder {
Engine createEngine();
Tyre createTyre();
Seat createSeat();

}

package com.tiantang.builder;

public class CarBuilder implements Builder{

@Override
public Engine createEngine() {
return new Engine();
}

@Override
public Tyre createTyre() {
return new Tyre();
}

@Override
public Seat createSeat() {
return new Seat();
}

}

package com.tiantang.builder;

/**
* 组装者
* @author LiuJinkun
*
*/
public class Director {

//持有对建造者的引用
private Builder builder;

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

/**
* 组装汽车
* @return
*/
public Car directeCar(){
Engine engine=builder.createEngine();
Tyre tyre=builder.createTyre();
Seat seat=builder.createSeat();
return new Car(engine,tyre,seat);
}
}

package com.tiantang.builder;

public class Client {

public static void main(String[] args) {
Builder builder=new CarBuilder();//创建建造者
Director director=new Director(builder);//创建组装者
Car car=director.directeCar();//组装者组装汽车
car.getEngine().start();
car.getTyre().run();
car.getSeat().sit();

}

}

这样就实现了建造者模式，看到这里，读者可能就会发现，这里可以和工厂模式相结合起来使用，利用工厂模式来生产汽车的各个零件，这里由于笔者只是测试建造者模式，就没有写那么复杂。同时读者可能会有疑惑，为什么不直接new一个Car对象就完了吗，为什么非得使用建造者模式呢？反而弄得那么复杂。但如果我们考虑到程序的扩展性，如果同样再生产一辆汽车，这辆汽车的零件与之前那辆车的零件一样，只是具体的生产 方式不一样，然后零件组装成汽车的流程也一样，这时我们就可以直接使用我们的Builder和Director了，只需要再增加一个Builder的实现类，具体的零件生产方式由接口的实现类去具体实现，这样我们就生产了另一种汽车，而不要再根据新汽车的特点去设计新的类了。同时也增加了我们代码的重用性。

最后总结一下，建造者模式一般用在创建复杂对象的情景，可与工厂模式结合使用。