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()时,产生的就是林俊杰,如果还有其它实现类,可能产生的就是谢霆锋,所以只需要给导演不同的构造者,我们就能创建不一样的剧情,实现了导演和构造者(剧本)的动态关联,降低了耦合性

使用场景

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

//分析思路:当用户订阅时,我们就发送欢迎消息邮件->也就是欢迎邮件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只是负责来欢迎,走欢送的模式,其余的有导演构建完成