java常用设计模式(建造者模式)

文章大部分转载自:点击打开链接


在阎宏博士的《JAVA与模式》一书中开头是这样描述建造（Builder）模式的：

　　建造模式是对象的创建模式。建造模式可以将一个产品的内部表象（internal representation）与产品的生产过程分割开来，从而可以使一个建造过程生成具有不同的内部表象的产品对象。我的理解就是为了解耦,根据客户端的具体情况创建不同的具体的build.

public class Product {
/**
* 定义一些关于产品的操作,也就具体的某款产品
*/
private String part1;
private String part2;
public String getPart1() {
return part1;
}
public void setPart1(String part1) {
this.part1 = part1;
}
public String getPart2() {
return part2;
}
public void setPart2(String part2) {
this.part2 = part2;
}
}
//创建抽象的builder,强大的多态
public interface Builder {
    public void buildPart1();
    public void buildPart2();
    public Product retrieveResult();
}

//具体的抽象者类,也就是根据情况选择具体的产品

public class ConcreteBuilder implements Builder {

    private Product product = new Product();
    /**
     * 产品零件建造方法1
     */
    @Override
    public void buildPart1() {
        //构建产品的第一个零件
 　　　　product.setPart1("编号：89757");
    }
    /**
     * 产品零件建造方法2
     */
    @Override
    public void buildPart2() {
        //构建产品的第二个零件
 　　　　product.setPart2("名称：林俊杰");
    }
    /**
     * 产品返还方法
     */
    @Override
    public Product retrieveResult() {
        return product;
    }

}

//导演者,封装抽象的构造者,也就是你给我什么样的剧本,我就照着剧本出剧情

public class Director {
    /**
     * 持有当前需要使用的建造器对象
     */
    private Builder builder;
    /**
     * 构造方法，传入建造器对象
     * @param builder 建造器对象
     */
    public Director(Builder builder){
        this.builder = builder;
    }
    /**
     * 产品构造方法，负责调用各个零件建造方法
     */
    public void construct(){
        builder.buildPart1();
        builder.buildPart2();
    }
}
//客户端类,也就是具体需求类
public class Client {
    public static void main(String[]args){
        Builder builder = new ConcreteBuilder();
        Director director = new Director(builder);
        director.construct();
        Product product = builder.retrieveResult();
        System.out.println(product.getPart1());//编号89757
        System.out.println(product.getPart2());//林俊杰
    }
}

分析上面的代码可以发现,当客户new ConcreteBuilder()时,产生的就是林俊杰,如果还有其它实现类,可能产生的就是谢霆锋,所以只需要给导演不同的构造者,我们就能创建不一样的剧情,实现了导演和构造者(剧本)的动态关联,降低了耦合性

使用场景

　　假设有一个电子杂志系统，定期地向用户的电子邮件信箱发送电子杂志。用户可以通过网页订阅电子杂志，也可以通过网页结束订阅。当客户开始订阅时，系统发送一个电子邮件表示欢迎，当客户结束订阅时，系统发送一个电子邮件表示欢送。本例子就是这个系统负责发送“欢迎”和“欢送”邮件的模块

4000

//分析思路:当用户订阅时,我们就发送欢迎消息邮件->也就是欢迎邮件builder,离开时,发送欢送消息邮件->也就是欢送邮件builder
,既然有都是发邮件,所以就可以抽象出一个抽象的builder.当客户订阅的时候,我们new 欢迎builder,反之欢送builder,
在将这些欢迎或者欢送信息builder交给导演,导演在进行加工(时间,日期等等)
//产品(邮件)
public abstract class AutoMessage {
//收件人地址
private String to;
//发件人地址
private String from;
//标题
private String subject;
//内容
private String body;
//发送日期
private Date sendDate;
public void send(){
System.out.println("收件人地址：" + to);
System.out.println("发件人地址：" + from);
System.out.println("标题：" + subject);
System.out.println("内容：" + body);
System.out.println("发送日期：" + sendDate);
}
public String getTo() {
return to;
}
public void setTo(String to) {
this.to = to;
}
public String getFrom() {
return from;
}
public void setFrom(String from) {
this.from = from;
}
public String getSubject() {
return subject;
}
public void setSubject(String subject) {
this.subject = subject;
}
public String getBody() {
return body;
}
public void setBody(String body) {
this.body = body;
}
public Date getSendDate() {
return sendDate;
}
public void setSendDate(Date sendDate) {
this.sendDate = sendDate;
}

}
//欢迎邮件
public class WelcomeMessage extends AutoMessage {
/**
* 构造子
*/
public WelcomeMessage(){
System.out.println("发送欢迎信息");
}
}
//欢送邮件

public class GoodbyeMessage extends AutoMessage{
/**
* 构造子
*/
public GoodbyeMessage(){
System.out.println("发送欢送信息");
}
}
//抽象构造者
public abstract class Builder {
protected AutoMessage msg;
//标题零件的建造方法
public abstract void buildSubject();
//内容零件的建造方法
public abstract void buildBody();
//收件人零件的建造方法
public void buildTo(String to){
msg.setTo(to);
}
//发件人零件的建造方法
public void buildFrom(String from){
msg.setFrom(from);
}
//发送时间零件的建造方法
public void buildSendDate(){
msg.setSendDate(new Date());
}
/**
* 邮件产品完成后，用此方法发送邮件
* 此方法相当于产品返还方法,可以返回具体的品,还可以返回产品属性和方法,灵活运用
*/
public void sendMessage(){
msg.send();
}
}
//具体构造者(欢迎)
public class WelcomeBuilder extends Builder {
public WelcomeBuilder(){
msg = new WelcomeMessage();
}
@Override
public void buildBody() {
// TODO Auto-generated method stub
　　　　msg.setBody("欢迎内容");
}

@Override
public void buildSubject() {
// TODO Auto-generated method stub
　　　　msg.setSubject("欢迎标题");
}

}
//具体的构造者(欢送)
public class GoodbyeBuilder extends Builder {

public GoodbyeBuilder(){
msg = new GoodbyeMessage();
}
@Override
public void buildBody() {
// TODO Auto-generated method stub
　　　　msg.setBody("欢送内容");
}

@Override
public void buildSubject() {
// TODO Auto-generated method stub
　　　　msg.setSubject("欢送标题");
}

}
//导演
public class Director {
Builder builder;
/**
* 构造子
*/
public Director(Builder builder){
this.builder = builder;
}
/**
* 产品构造方法，负责调用各零件的建造方法
*/
public void construct(String toAddress , String fromAddress){
this.builder.buildTo(toAddress);
this.builder.buildFrom(fromAddress);
this.builder.buildSubject();
this.builder.buildBody();
this.builder.buildSendDate();
this.builder.sendMessage();
}
}
//客户端
public class Client {

public static void main(String[] args) {
// TODO Auto-generated method stub
　　　 Builder builder = new WelcomeBuilder();
Director director = new Director(builder);
director.construct("toit_dao@aliyun.com", "fromit_dao@aliyun.com");

}

}
建造模式分成两个很重要的部分：
　　1. 一个部分是Builder接口，这里是定义了如何构建各个部件，也就是知道每个部件功能如何实现，以及如何装配这些部件到产品中去；

　　2. 另外一个部分是Director，Director是知道如何组合来构建产品，也就是说Director负责整体的构建算法，而且通常是分步骤地来执行。builder只是负责来欢迎,走欢送的模式,其余的有导演构建完成