详解23种设计模式（基于Java）—— 创建者模式（二 / 五）

本文章笔记整理来自黑马视频https://www.bilibili.com/video/BV1Np4y1z7BU，相关资料可在评论区获取。

详解23种设计模式（基于Java）—— 设计模式相关内容介绍（一 / 五） 详解23种设计模式（基于Java）—— 结构型模式（三 / 五） 详解23种设计模式（基于Java）—— 行为型模式（四 / 五） 详解23种设计模式（基于Java）—— 综合练习之自定义Spring IoC（五 / 五）

2.创建者模式（5 种）

创建型模式的主要关注点在于“怎样创建对象？”，它的主要特点是“将对象的创建与使用分离”。 这样可以降低系统的耦合度，使用者不需要关注对象的创建细节。创建型模式分为：单例模式、工厂方法模式、抽象工厂模式、原型模式、建造者模式这 5 种。

2.1.单例模式

有关单例模式的具体知识可以参考 Java 设计模式——单例模式这篇文章。

2.2.工厂方法模式

有关工厂方法模式的具体知识可以参考 Java 设计模式——工厂方法模式这篇文章。

2.3.抽象工厂模式

前面介绍的工厂方法模式中考虑的是一类产品的生产，如畜牧场只养动物、电视机厂只生产电视机等。这些工厂只生产同种类产品，同种类产品称为同等级产品，也就是说：工厂方法模式只考虑生产同等级的产品，但是在现实生活中许多工厂是综合型的工厂，能生产多等级（种类） 的产品，如电器厂既生产电视机又生产洗衣机或空调，大学既有软件专业又有生物专业等。 本节要介绍的抽象工厂模式将考虑多等级产品的生产，将同一个具体工厂所生产的位于不同等级的一组产品称为一个产品族，下图所示横轴是产品等级，也就是同一类产品；纵轴是产品族，也就是同一品牌的产品，同一品牌的产品产自同一个工厂。

2.3.1.概念

抽象工厂模式是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品。

2.3.2.结构

抽象工厂模式的主要角色如下： ① 抽象工厂 (Abstract Factory)：提供了创建产品的接口，它包含多个创建产品的方法，可以创建多个不同等级的产品。 ② 具体工厂 (Concrete Factory)：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。 ③ 抽象产品 (Product)：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。 ④ 具体产品 (ConcreteProduct)：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。

2.3.3.实现

现咖啡店业务发生改变，不仅要生产咖啡还要生产甜点，如提拉米苏、抹茶慕斯等，要是按照工厂方法模式，需要定义提拉米苏类、抹茶慕斯类、提拉米苏工厂、抹茶慕斯工厂、甜点工厂类，很容易发生类爆炸情况。其中拿铁咖啡、美式咖啡是一个产品等级，都是咖啡；提拉米苏、抹茶慕斯也是一个产品等级；拿铁咖啡和提拉米苏是同一产品族（也就是都属于意大利风味），美式咖啡和抹茶慕斯是同一产品族（也就是都属于美式风味）。所以这个案例可以使用抽象工厂模式实现。类图如下： 部分核心代码如下： DessertFactory.java

package com.itheima.patterns.factory.abstract_factory;

//抽象工厂类
public interface DessertFactory {
    //生产咖啡的功能
    Coffee createCoffee();
    
    //生产甜品的功能
    Dessert createDessert();
}

AmericanDessertFactory.java

package com.itheima.patterns.factory.abstract_factory;

//美式风味的甜品工厂，可以生产美式咖啡和抹茶慕斯
public class AmericanDessertFactory implements DessertFactory{
    @Override
    public Coffee createCoffee() {
        return new AmericanCoffee();
    }
    
    @Override
    public Dessert createDessert() {
        return new Matchamousse();
    }
}

ItalyDessertFactory.java

package com.itheima.patterns.factory.abstract_factory;

//意大利风味甜品工厂，可以生产拿铁咖啡和提拉米苏甜品
public class ItalyDessertFactory implements DessertFactory{
    @Override
    public Coffee createCoffee() {
        return new LatteCoffee();
    }
    
    @Override
    public Dessert createDessert() {
        return new Trimisu();
    }
}

Client.java

package com.itheima.patterns.factory.abstract_factory;

public class Client {
    public static void main(String[] args) {
        //创建的是意大利风味甜品工厂对象
        ItalyDessertFactory factory = new ItalyDessertFactory();
        //获取拿铁咖啡和提拉米苏甜品
        Coffee coffee = factory.createCoffee();
        Dessert dessert = factory.createDessert();
    
        System.out.println(coffee.getName());
        dessert.show();
    }
}

如果要加同一个产品族的话，只需要再加一个对应的工厂类即可，不需要修改其他的类。

2.3.4.优缺点

优点：当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。 缺点：当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。

2.3.5.使用场景

① 当需要创建的对象是一系列相互关联或相互依赖的产品族时，如电器工厂中的电视机、洗衣机、空调等。 ② 系统中有多个产品族，但每次只使用其中的某一族产品。如有人只喜欢穿某一个品牌的衣服和鞋。 ③ 系统中提供了产品的类库，且所有产品的接口相同，客户端不依赖产品实例的创建细节和内部结构。

2.3.6.模式扩展

（1）可以通过工厂模式 + 配置文件的方式解除工厂对象和产品对象的耦合。在工厂类中加载配置文件中的全 类名，并创建对象进行存储，客户端如果需要对象，直接进行获取即可。 （2）具体步骤如下： ① 定义配置文件 bean.properties

american=com.itheima.patterns.factory.config_factory.AmericanCoffee
latte=com.itheima.patterns.factory.config_factory.LatteCoffee

② 改进工厂类

package com.itheima.patterns.factory.config_factory;

import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Properties;
import java.util.Set;

public class CoffeeFactory {
    
    //加载配置文件，获取配置文件中配置的全类名，并创建该类的对象进行存储
    //1.定义容器对象来存储咖啡对象
    private static HashMap map = new HashMap();
    
    //2.加载配置文件，只需要加载一次
    static {
        //2.1.创建Properties对象
        Properties properties = new Properties();
        //2.2.调用properties对象中的load方法来加载配置文件
        InputStream is = CoffeeFactory.class.getClassLoader().getResourceAsStream("bean.properties");
        try {
            properties.load(is);
            //从properties集合中获取全类名并创建对象
            Set keys = properties.keySet();
            for (Object key : keys) {
                String className = properties.getProperty((String) key);
                //通过反射技术创建对象
                Class clazz = Class.forName(className);
                Coffee coffee = (Coffee) clazz.newInstance();
                //将名称和对象存储到容器中
                map.put((String) key, coffee);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    //根据名称获取对象
    public static Coffee createCoffee(String name) {
        return map.get(name);
    }
}

③ 测试

package com.itheima.patterns.factory.config_factory;

public class Client {
    public static void main(String[] args) {
        Coffee coffee1 = CoffeeFactory.createCoffee("american");
        System.out.println(coffee1.getName());    //美式咖啡
        Coffee coffee2 = CoffeeFactory.createCoffee("latte");
        System.out.println(coffee2.getName());    //拿铁咖啡
    }
}

静态成员变量用来存储创建的对象（键存储的是名称，值存储的是对应的对象），而读取配置文件以及创建对象写在静态代码块中，目的就是只需要执行一次。

有关 Properties 类的具体知识可以参考Java 基础——Properties 类这篇文章。

2.3.7.JDK源码解析——Collection.iterator方法

（1）首先来看一下这一段代码

package com.itheima.patterns.factory.iteratordemo;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class IteratorDemo {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("Tom");
        list.add("Mike");
        list.add("Marry");
    
        //获取迭代器对象
        Iterator iterator = list.iterator();
        //使用迭代器遍历
        while(iterator.hasNext()){
            String element = iterator.next();
            System.out.println(element);
        }
    }
}

大家应该很熟悉上面的代码，它使用迭代器遍历集合，获取集合中的元素。而单列集合获取迭代器的方法就使用到了工厂方法模式。现在通过类图来看其中的结构： Collection 接口是抽象工厂类，ArrayList 是具体的工厂类；Iterator 接口是抽象商品类，ArrayList 类中的 Iter 内部类是具体的商品类。在具体的工厂类中 iterator() 方法创建具体的商品类的对象。 Iterator.java Collection.java ArrayList.java 注：DateForamt 类中的 getInstance() 方法、Calendar 类中的 getInstance() 方法使用的也都是工厂模式。

2.4.原型模式

有关原型模式的具体知识可以参考 Java 设计模式——原型模式这篇文章。

2.5.建造者模式 2.5.1.概述

建造者模式：将一个复杂对象的构建与表示分离，使得同样的构建过程可以创建不同的表示。 （1）分离了部件的构造（由 Builder 来负责）和装配（由 Director 负责）。 从而可以构造出复杂的对象。这个模式适用于某个对象的构建过程复杂的情况。 （2）由于实现了构建和装配的解耦。不同的构建器，相同的装配，也可以做出不同的对象；相同的构建器，不同的装配顺序也可以做出不同的对象。也就是实现了构建算法、装配算法的解耦，实现了更好的复用。 （3）建造者模式可以将部件和其组装过程分开，一步一步创建一个复杂的对象。用户只需要指定复杂对象的类型就可以得到该对象，而无须知道其内部的具体构造细节。

2.5.2.结构

建造者模式包含如下角色： （1）抽象建造者类 (Builder)：这个接口规定要实现复杂对象的那些部分的创建，并不涉及具体的部件对象的创建。 （2）具体建造者类 (ConcreteBuilder)：实现 Builder 接口，完成复杂产品的各个部件的具体创建方法。在构造过程完成后，提供产品的实例。 （3）产品类 (Product)：要创建的复杂对象。 （4）指挥者类 (Director)：调用具体建造者来创建复杂对象的各个部分，在指导者中不涉及具体产品的信息，只负责保证对象各部分完整创建或按某种顺序创建。类图如下：

2.5.3.实例

【例】创建共享单车 生产自行车是一个复杂的过程，它包含了车架，车座等组件的生产。而车架又有碳纤维，铝合金等材质的，车座有橡胶，真皮等材质。对于自行车的生产就可以使用建造者模式。这里 Bike 是产品，包含车架，车座等组件；Builder 是抽象建造者，MobikeBuilder 和 OfoBuilder 是具体的建造者；Director 是指挥者。类图如下： 具体代码如下： Bike.java

package com.itheima.patterns.builder.demo1;

public class Bike {
    private String frame;//车架
    
    private String seat;//车座
    
    public String getFrame() {
        return frame;
    }
    
    public void setFrame(String frame) {
        this.frame = frame;
    }
    
    public String getSeat() {
        return seat;
    }
    
    public void setSeat(String seat) {
        this.seat = seat;
    }
}

Builder.java

package com.itheima.patterns.builder.demo1;

public abstract class Builder {
    //声明Bike类型的变量，并进行赋值
    protected Bike bike = new Bike();
    
    public abstract void buildFrame();
    
    public abstract void buildSeat();
    
    //构建自行车的方法
    public abstract Bike createBike();
}

MobileBuilder.java

package com.itheima.patterns.builder.demo1;

//具体的构建者，用来构建摩拜单车对象
public class MobileBuilder extends Builder{
    public void buildFrame() {
        bike.setFrame("碳纤维车架");
    }
    
    public void buildSeat() {
        bike.setSeat("真皮车座");
    }
    
    public Bike createBike() {
        return bike;
    }
}

OfoBuilder.java

package com.itheima.patterns.builder.demo1;

public class OfoBuilder extends Builder{
    public void buildFrame() {
        bike.setFrame("铝合金车架");
    }
    
    public void buildSeat() {
        bike.setSeat("橡胶车座");
    }
    
    public Bike createBike() {
        return bike;
    }
}

Director.java

package com.itheima.patterns.builder.demo1;

public class Director {
    //声明builder类型的变量
    private Builder builder;
    
    public Director(Builder builder) {
        this.builder = builder;
    }
    
    //组装自行车的功能
    public Bike construct() {
        builder.buildFrame();
        builder.buildSeat();
        return builder.createBike();
    }
}

Client.java

package com.itheima.patterns.builder.demo1;

public class Client {
    public static void main(String[] args) {
        //创建指挥者对象
        Director director = new Director(new MobileBuilder());
        //让指挥者只会组装自行车
        Bike bike = director.construct();
        
        System.out.println(bike.getFrame());
        System.out.println(bike.getSeat());
    }
}

注意：上面示例是 Builder 模式的常规用法，指挥者类 Director 在建造者模式中具有很重要的作用，它用于指导具体构建者如何构建产品，控制调用先后次序，并向调用者返回完整的产品类，但是有些情况下需要简化系统结构，可以把指挥者类和抽象建造者进行结合。

// 抽象 builder 类
public abstract class Builder {
	protected Bike mBike = new Bike();
	
	public abstract void buildFrame();
	public abstract void buildSeat();
	public abstract Bike createBike();
	
	public Bike construct() {
		this.buildFrame();
		this.BuildSeat();
		return this.createBike();
	}
}

2.5.4.优缺点

（1）优点： ① 建造者模式的封装性很好。使用建造者模式可以有效的封装变化，在使用建造者模式的场景中，一般产品类和建造者类是比较稳定的，因此，将主要的业务逻辑封装在指挥者类中对整体而言可以取得比较好的稳定性。 ② 在建造者模式中，客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象。 ③ 可以更加精细地控制产品的创建过程 。将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，也更方便使用程序来控制创建过程。 ④ 建造者模式很容易进行扩展。如果有新的需求，通过实现一个新的建造者类就可以完成，基本上不用修改之前已经测试通过的代码，因此也就不会对原有功能引入风险。符合开闭原则。 （2）缺点： 造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制。

2.5.5.使用场景

建造者 (Builder) 模式创建的是复杂对象，其产品的各个部分经常面临着剧烈的变化，但将它们组合在一起的算法却相对稳定，所以它通常在以下场合使用： ① 创建的对象较复杂，由多个部件构成，各部件面临着复杂的变化，但构件间的建造顺序是稳定的。 ② 创建复杂对象的算法独立于该对象的组成部分以及它们的装配方式，即产品的构建过程和最终的表示是独立的。

2.5.6.模式扩展

建造者模式除了上面的用途外，在开发中还有一个常用的使用方式，就是当一个类构造器需要传入很多参数时，如果创建这个类的实例，代码可读性会非常差，而且很容易引入错误，此时就可以利用建造者模式进行重构。 （1）重构前代码如下： Phone.java

package com.itheima.patterns.builder.demo2;

public class Phone {
    private String cpu;
    private String screen;
    private String memory;
    private String mainboard;
    
    public Phone(String cpu, String screen, String memory, String mainboard) {
        this.cpu = cpu;
        this.screen = screen;
        this.memory = memory;
        this.mainboard = mainboard;
    }
    
    @Override
    public String toString() {
        return "Phone{" +
                "cpu='" + cpu + '\'' +
                ", screen='" + screen + '\'' +
                ", memory='" + memory + '\'' +
                ", mainboard='" + mainboard + '\'' +
                '}';
    }
}

Client.java

package com.itheima.patterns.builder.demo2;

public class Client {
    public static void main(String[] args) {
        //构建Phone对象
        Phone phone = new Phone("麒麟","三星屏幕","金士顿","华硕主板");
        System.out.println(phone);
    }
}

上面在客户端代码中构建Phone对象，传递了四个参数，如果参数更多，那么代码的可读性会变差，以及使用的成本会变高。 （2）重构后代码如下： Phone.java

package com.itheima.patterns.builder.demo3;

public class Phone {
    private String cpu;
    private String screen;
    private String memory;
    private String mainboard;
    
    private Phone(Builder builder) {
        cpu = builder.cpu;
        screen = builder.screen;
        memory = builder.memory;
        mainboard = builder.mainboard;
    }
    
    public static final class Builder{
        private String cpu;
        private String screen;
        private String memory;
        private String mainboard;
        
        public Builder(){}
        
        public Builder cpu(String val){
            cpu = val;
            return this;
        }
    
        public Builder screen(String val){
            screen = val;
            return this;
        }
    
        public Builder memory(String val){
            memory = val;
            return this;
        }
    
        public Builder mainboard(String val){
            mainboard = val;
            return this;
        }
        
        public Phone build(){
            return new Phone(this);
        }
    }
    
    @Override
    public String toString() {
        return "Phone{" +
                "cpu='" + cpu + '\'' +
                ", screen='" + screen + '\'' +
                ", memory='" + memory + '\'' +
                ", mainboard='" + mainboard + '\'' +
                '}';
    }
}

Client.java

package com.itheima.patterns.builder.demo3;

public class Client {
    public static void main(String[] args) {
        //构建Phone对象
        Phone phone = new Phone.Builder()
                .cpu("麒麟")
                .memory("金士顿")
                .screen("三星屏幕")
                .mainboard("华硕")
                .build();
        System.out.println(phone);
    }
}

重构后的代码在使用起来更方便，某种程度上也可以提高开发效率。从软件设计上，对程序员的要求比较高。

2.5.7.创建者模式对比

（1）工厂方法模式VS建造者模式 工厂方法模式注重的是整体对象的创建方式；而建造者模式注重的是部件构建的过程，意在通过一步一步地精确构造创建出一个复杂的对象。 （2）抽象工厂模式VS建造者模式 ① 抽象工厂模式实现对产品家族的创建，一个产品家族是这样的一系列产品：具有不同分类维度的产品组合，采用抽象工厂模式则是不需要关心构建过程，只关心什么产品由什么工厂生产即可。 ② 建造者模式则是要求按照指定的蓝图建造产品，它的主要目的是通过组装零配件而产生一个新产品。 如果将抽象工厂模式看成汽车配件生产工厂，生产一个产品族的产品，那么建造者模式就是一个汽车组装工厂，通过对部件的组装可以返回一辆完整的汽车。