Java设计模式之Builder模式

前言

  之前写Android程序的时候，经常会用到Dialog（对话框）这个控件。我们在使用Dialog，比如AlertDialog的时候就用到了这里要说明的Builder模式。现在我们来看一下这样的一段代码：

Dialog alertDialog = new AlertDialog.Builder(this).   
                setTitle("确定删除？").   
                setMessage("您确定删除该条信息吗？").   
                setIcon(R.drawable.ic_launcher).   
                setPositiveButton("确定", new DialogInterface.OnClickListener() {   
                       
                    @Override   
                    public void onClick(DialogInterface dialog, int which) {   
                        // TODO Auto-generated method stub    
                    }   
                }).   
                setNegativeButton("取消", new DialogInterface.OnClickListener() {   
                       
                    @Override   
                    public void onClick(DialogInterface dialog, int which) {   
                        // TODO Auto-generated method stub    
                    }   
                }).   
                setNeutralButton("查看详情", new DialogInterface.OnClickListener() {   
                       
                    @Override   
                    public void onClick(DialogInterface dialog, int which) {   
                        // TODO Auto-generated method stub    
                    }   
                }).   
                create();   
        alertDialog.show();  

我们可以通过这种方式来显示一个系统自带的对话框。不知道大家有没有想过为什么Dialog要通过这种方式来构建呢？直接new出来不是更直接么？下面就通过Builder模式来详细说明一下这个问题。

定义

  builder模式的使用目的是为了将构建复杂对象的过程和它的部件解耦。将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

说明

  要怎么理解上面概述的这句话呢？《Java设计模式——工厂模式》中，我们知道了，如果一个类比较复杂，我们在new这个对象的时候就要多个心眼了。为什么？因为我们要考虑程序部件之间的耦合度。当然，我们也可以使用上篇的工厂模式来解决，不过这不属于我们本篇博客的范围。

  既然说到了对象的构建过程和部件需要解耦，那么势必会有两个不同的类，分别是构建过程类和部件类。我们可以从下面的图-2中看到这一点，分别是两个接口：HeroBuilder和Hero。下面就来列举一个实例加以说明。

实例及过程说明

背景

  因为博主是一个LOL Player，所以这里我就列举创建一个LOL英雄的过程吧。（真实游戏中英雄的创建并不是这样的，你可以理解这是一个外挂程序-_-!）。

  每一个英雄在被创建之前，他们都有一个抽象的统称——Hero。这里定义成一个接口。

  每一个英雄都有以下属性：玩家id、当前等级、当前学习技能点、当前装备。

创建过程

  这里我定义一个HeroBuilder的来抽象创建英雄，让具体的创建者TraxexBuilder去实现抽象创建者。所以，真实创建的时候，是通过具体创建者来实现的。我们把具体英雄的创建交给了一个创建者，这一点是不是跟工厂模式中的使用工厂来生产产品很类似？

创建者接口

  首先，我们定义一个接口来告诉具体的创建者要如何创建复杂对象的组件。

public interface HeroBuilder {  
  
    public HeroBuilder userName(String _name);  
      
    public HeroBuilder level(Level _level);  
      
    public HeroBuilder skills(List<Skill> _skills);  
      
    public HeroBuilder equipments(List<Equipment> _equipments);  
}  

具体创建者

  具体的创建者要实现创建者接口，然后提供一个能够返回对象的接口。

public class TraxexBuilder implements HeroBuilder {  
  
    private Traxex traxex;  
      
    public String userName; // 玩家id  
    public Level level; // 玩家等级  
    public List<Skill> skills; // 学习技能点  
    public List<Equipment> equipments; // 当前装备  
      
    @Override  
    public HeroBuilder userName(String _name) {  
        userName = _name;  
        return this;  
    }  
      
    ... ...  
  
    public Traxex build() {  
        if (traxex == null) {  
            traxex = new Traxex(this);  
        }  
          
        return traxex;  
    }  
}  

对象的接口

  这里我们为英雄统一定义一个接口，用于规定好英雄需要做哪些事情。这些事情到时候就交给创建者来完成。

public interface Hero {  
  
    public void setUserName(String name);  
  
    public void setLevel(Level level);  
      
    public void setSkill(List<Skill> skills);  
      
    public void setEquipment(List<Equipment> equipments);  
      
}  

具体的对象实例
  这里为了方便说明更理解，下面的具体对象中省略了很多内容。完整的代码可以在下面的GitHub链接中下载。

public class Traxex implements Hero {  
  
    private String userName; // 玩家id  
    private Level level; // 玩家等级  
    private List<Skill> skills; // 学习技能点  
    private List<Equipment> equipments; // 当前装备  
      
    // 省略从Hero接口中重写的方法  
      
    // 省略自定义方法  
      
    public Traxex(TraxexBuilder _builder) {  
        // 省略完成从创建者那里获得的属性信息  
    }  
  
    @Override  
    public String toString() {  
        ... ...  
          
        return something;  
    }  
}  

组装

  有了以上的这几个部分，事情大体完成了。说是大体完成的原因是因为还有最一步了，那就是组装（Director）。

  你是不是要问我，为什么之前有了一个Builder是具体创建者了，这里还要有一个Director，这是什么鬼？先别急，让我们来了解一下Builder和Director的区别，之后你就好理解了。
  从上面的代码和分析中，我知道了Builder是一个创建者，它负责的是创建复杂对象中的各个组件。比如例子中的英雄等级、学习技能、合成的装备等。那么我们创建好了这些单个组件之后，是不是应该把这些组件组装到具体的对象上呢？答案是肯定的。那么这里的Director就是干这个事情的啦。请看下面的代码：

public class Director {  
  
    private HeroBuilder builder = null;  
      
    public Director(HeroBuilder _builder) {  
        builder = _builder;  
    }  
      
    public void construct(String _playerName, Level _level, List<Skill> _skills, List<Equipment> _equipments) {  
        builder  
            .userName(_playerName)  
            .level(_level)  
            .skills(_skills)  
            .equipments(_equipments);  
    }  
}  

客户端测试

public class BuilderClient {  
  
    public static void main(String[] args) {  
        // 技能定义  
        List<Skill> skills = getSkills();  
          
        // 装备定义  
        List<Equipment> equipments = getEquipments();  
          
        // 构建对象  
        TraxexBuilder builder = new TraxexBuilder();  
        Director director = new Director(builder);  
        director.construct("Naga007", Level.Level_19, skills, equipments);  
        Traxex traxex = builder.build();  
          
        System.out.println(traxex);  
    }  
      
    ... ...  
}  

测试结果