Java设计模式-创建型设计模式-建造者模式

从这一专栏开始将学习设计模式，上课学习和自己总结归纳的笔记将总结出来供大家参考。
参考书籍：《设计模式就该这样学》

其他文章：

一、创建型设计模式

创建型模式对类的实例化过程进行了抽象，能够将软件模块中对象的创建和对象的使用分离，对客户端代码需要调用对象的时候隐藏了类的实例化的创建细节。

其中包括：简单工厂模式（不在GoF23种设计模式中）、工厂方法模式、抽象工厂模式、建造者模式、原型模式、单例模式。

二、建造者模式

1.建造者模式定义

建造者模式（Builder Pattern）：又叫生成器模式，是一种对象构建模式。将一个复杂对象的构建和它的表示分离，使得同样的构建过程可以创建不同的表示。

建造者模式可以将部件本身和他们的组装过程分开，关注如何一步步创建一个包含多个组成部分的复杂对象，用户只需要指定复杂对象的类型即可得到该对象，而无需知道其内部的具体构造细节。

复杂对象就是指那些包含多个成员变量的对象，这些成员变量也叫部件或者零件，例如汽车包括方向盘，发动机，轮胎等 ， 汽车就是复杂对象，方向盘，发动机以及轮胎就是汽车的部件

在GoF23种设计模式中属于创建型设计模式：

​ 其中包括：简单工厂模式（不在GoF23种设计模式中）、工厂方法模式、抽象工厂模式、建造者模式、原型模式、单例模式。

2.建造者模式的角色

产品角色（Product）：它是包含多个组成部件的复杂对象，由具体建造者来创建其各个零部件。

抽象建造者（Builder）：它是一个包含创建产品各个子部件的抽象方法的接口，通常还包含一个返回复杂产品的方法 getResult()。

具体建造者(Concrete Builder）：实现 Builder 接口，完成复杂产品的各个部件的具体创建方法。

指挥者（Director）：它调用建造者对象中的部件构造与装配方法完成复杂对象的创建，在指挥者中不涉及具体产品的信息。

3.建造者模式的特点

优点 :

1. 封装性好，构建和表示分离。
2. 扩展性好，各个具体的建造者相互独立，有利于系统的解耦。
3. 客户端不必知道产品内部组成的细节，建造者可以对创建过程逐步细化，而不对其它模块产生任何影响，便于控制细节风险。

缺点 :

1. 产品的组成部分必须相同，这限制了其使用范围。
2. 如果产品的内部变化复杂，如果产品内部发生变化，则建造者也要同步修改，后期维护成本较大。

建造者模式与工厂模式区别:

1.注重点不同 :

建造者模式更注重于方法的调用顺序 ;

工厂模式注重于创建产品 , 不关心方法调用的顺序 。
2.创建对象力度不同 :

创建对象的力度不同 , 建造者模式可以创建复杂的产品 , 由各种复杂的部件组成 ；

工厂模式创建出来的都是相同的实例对象 。

4.建造者模式的类图

5.建造者模式的代码实现

案例：

产品角色（Product）： 游戏角色类（Actor）
抽象建造者（Builder）： 游戏角色建造者（ActorBuilder）
具体建造者 （Concretebuilder）：天使角色建造者（AngelBuilder）、恶魔角色建造者（DevilBuilder）
指挥者（Director） ： 角色控制器（ActorController）

类图如下：

具体代码实现：

1.产品角色（product）：游戏角色类（Actor）

/**
 * 产品角色（product）：游戏角色类（Actor）
 * @author WxrStart
 * @create 2022-04-12 14:28
 */
public class Actor {
    private String type;
    private String sex;
    private String face;
    private String costume;
    private String hairstyle;

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getFace() {
        return face;
    }

    public void setFace(String face) {
        this.face = face;
    }

    public String getCostume() {
        return costume;
    }

    public void setCostume(String costume) {
        this.costume = costume;
    }

    public String getHairstyle() {
        return hairstyle;
    }

    public void setHairstyle(String hairstyle) {
        this.hairstyle = hairstyle;
    }

    @Override
    public String toString() {
        return "Actor{" +
                "type='" + type + '\'' +
                ", sex='" + sex + '\'' +
                ", face='" + face + '\'' +
                ", costume='" + costume + '\'' +
                ", hairstyle='" + hairstyle + '\'' +
                '}';
    }
}

2.抽象建造者（builder）： 游戏角色建造者（ActorBuilder）

/**
 * 抽象建造者（builder）： 游戏角色建造者（ActorBuilder）
 * @author WxrStart
 * @create 2022-04-12 14:28
 */
public abstract class ActorBuilder {
    protected Actor actor=new Actor();

    public abstract void buildType();

    public abstract void buildSex();

    public abstract void buildFace();

    public abstract void buildCostume();

    public abstract void buildHairstyle();


    public Actor createActor(ActorBuilder ab) {
        ab.buildType();
        ab.buildSex();
        ab.buildFace();
        ab.buildCostume();
        ab.buildHairstyle();
        return actor;
    }
}

3.具体建造者 （concretebuilder）：恶魔角色建造者（DevilBuilder）

/**
 * 具体建造者 （concretebuilder）：恶魔角色建造者（DevilBuilder）
 * @author WxrStart
 * @create 2022-04-12 14:29
 */
public class DevilBuilder extends ActorBuilder {
    public void buildType() {
        actor.setType("恶魔");
    }

    public void buildSex() {
        actor.setSex("妖");
    }

    public void buildFace() {
        actor.setFace("丑陋");
    }

    public void buildCostume() {
        actor.setCostume("黑衣");
    }

    public void buildHairstyle() {
        actor.setHairstyle("光头");
    }
}

4.指挥者（director） ： 角色控制器（ActorController）

/**
 * 指挥者（director） ： 角色控制器（ActorController）
 * @author WxrStart
 * @create 2022-04-12 14:29
 */
public class ActorController {
    public Actor construct(ActorBuilder ab){
        Actor actor = ab.createActor(ab);
        return actor;
    }
}

5.ConfigUtils（读取配置文件工具类）

/**
 * ConfigUtils（读取配置文件工具类）
 * @author WxrStart
 * @create 2022-04-07 10:46
 */
public class ConfigUtils {
    /**
     * 从properties文件中创建Bean对象
     * @param fileName properties文件名
     * @param key 包含的Bean对象的类名的配置项
     * @return Bean实例
     */
    public static <T>T getBeanFromProp(String fileName,String key) {
        try {
            Properties pros = new Properties();
            InputStream is =ConfigUtils.class.getClassLoader().getResourceAsStream(fileName);
            //加载配置文件
            pros.load(is);
            //通过反射创建Bean实例
            Class clazz = Class.forName(pros.getProperty(key));
            T bean=(T)clazz.newInstance();
            return bean;

        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

}

6.bulider.properties配置文件

FactoryClassName=com.builder.DevilBuilder

7.Client（客户端测试类）

/**
 * 客户端类
 * @author WxrStart
 * @create 2022-04-07 10:45
 */
public class Client {
    public static void main(String[] args) {
        ActorBuilder actorBuilder = ConfigUtils.getBeanFromProp("builder.properties", "FactoryClassName");
        ActorController actorController=new ActorController();
        System.out.println(actorController.construct(actorBuilder));
    }
}