Java设计模式之建造者模式（精髓版）

╰半夏微凉° 2024-03-23 11:35 44阅读 0赞

**目录**

1、建造者模式阐述

2、使用Java代码实现建造者模式

3、为什么需要使用建造者模式？

4、建造者模式与工厂方法模式有什么区别？

--------------------

#### 1、建造者模式阐述 ####

Java 建造者模式是一种创建型设计模式，其主要目的是将一个复杂对象的构建过程与其表示分离，从而使得同样的构建过程可以创建不同的表示。

在 Java 中，建造者模式通常由以下几个角色组成：

1.  产品（Product）：表示被构建的复杂对象，通常由多个部件组成。
2.  抽象建造者（Builder）：定义创建产品对象各个部件的接口，通常由多个方法组成。
3.  具体建造者（Concrete Builder）：实现抽象建造者接口，实现创建产品对象各个部件的具体方法，同时定义返回组装好的产品对象的方法。
4.  指挥者（Director）：负责调用建造者来创建产品对象，同时指定建造过程的顺序。

在 Java 中，建造者模式的应用非常广泛，例如，Java 标准库中的 StringBuilder 类就是一个建造者模式的实现。StringBuilder 类允许用户通过 append() 方法添加字符串，最终构建出一个复杂的字符串对象。StringBuilder 类本身就是一个具体建造者，而用户通过调用 append() 方法来添加不同的字符串部件，由 StringBuilder 类来负责组装最终的字符串对象。

另外，在一些框架和项目中也经常使用建造者模式来构建复杂的对象，例如，在 Spring 框架中，我们可以使用建造者模式来创建 ApplicationContext 对象。Spring 中的 ApplicationContext 对象可以看作是一个复杂的对象，它由多个不同的部件（如 bean 定义、环境配置、AOP 配置等）组成。而 Spring 框架为我们提供了多种方式来创建 ApplicationContext 对象，其中就包括了建造者模式。通过调用不同的建造者方法，我们可以创建出不同的 ApplicationContext 对象。

#### 2、使用Java代码实现建造者模式 ####

下面是一个简单的 Java 建造者模式的示例代码：// 该示例严格遵循了模式所需要的角色，请仔细看

产品类：

public class Car {
        private String engine;
        private String wheels;
        private String body;
    
        public void setEngine(String engine) {
            this.engine = engine;
        }
    
        public void setWheels(String wheels) {
            this.wheels = wheels;
        }
    
        public void setBody(String body) {
            this.body = body;
        }
    
        @Override
        public String toString() {
            return "Car{" +
                    "engine='" + engine + '\'' +
                    ", wheels='" + wheels + '\'' +
                    ", body='" + body + '\'' +
                    '}';
        }
    }

抽象建造者类：

public abstract class CarBuilder {
        protected Car car = new Car();
    
        public abstract void buildEngine();
    
        public abstract void buildWheels();
    
        public abstract void buildBody();
    
        public Car getCar() {
            return car;
        }
    }

具体建造者类：

public class SportsCarBuilder extends CarBuilder {
        @Override
        public void buildEngine() {
            car.setEngine("V8 engine");
        }
    
        @Override
        public void buildWheels() {
            car.setWheels("20-inch wheels");
        }
    
        @Override
        public void buildBody() {
            car.setBody("Carbon fiber body");
        }
    }
    
    public class FamilyCarBuilder extends CarBuilder {
        @Override
        public void buildEngine() {
            car.setEngine("4-cylinder engine");
        }
    
        @Override
        public void buildWheels() {
            car.setWheels("16-inch wheels");
        }
    
        @Override
        public void buildBody() {
            car.setBody("Steel body");
        }
    }

指挥者类：

public class CarDirector {
        private CarBuilder carBuilder;
    
        public CarDirector(CarBuilder carBuilder) {
            this.carBuilder = carBuilder;
        }
    
        public void buildCar() {
            carBuilder.buildEngine();
            carBuilder.buildWheels();
            carBuilder.buildBody();
        }
    
        public Car getCar() {
            return carBuilder.getCar();
        }
    }

客户端代码：

public class Client {
        public static void main(String[] args) {
            CarBuilder sportsCarBuilder = new SportsCarBuilder();
            CarBuilder familyCarBuilder = new FamilyCarBuilder();
    
            CarDirector sportsCarDirector = new CarDirector(sportsCarBuilder);
            CarDirector familyCarDirector = new CarDirector(familyCarBuilder);
    
            sportsCarDirector.buildCar();
            familyCarDirector.buildCar();
    
            Car sportsCar = sportsCarDirector.getCar();
            Car familyCar = familyCarDirector.getCar();
    
            System.out.println(sportsCar.toString());
            System.out.println(familyCar.toString());
        }
    }

在这个示例代码中，我们定义了一个产品类 `Car`，其中包含了三个部件（发动机、车轮和车身）。然后，我们定义了一个抽象建造者类 `CarBuilder`，其中定义了创建产品对象各个部件的接口，同时包含了一个返回组装好的产品对象的方法。接着，我们定义了两个具体建造者类 `SportsCarBuilder` 和 `FamilyCarBuilder`，分别实现了抽象建造者接口中的方法，从而实现了创建不同类型的 `Car` 对象的具体方法。最后，我们定义了一个指挥者类 CarDirector，它包含一个建造者对象，并定义了一个构建方法来组装不同类型的 Car 对象。

在客户端代码中，我们创建了两个具体建造者对象（`SportsCarBuilder` 和 `FamilyCarBuilder`），并将它们分别传递给 `CarDirector` 对象中。然后，我们通过 `CarDirector` 中定义的构建方法来组装不同类型的 `Car` 对象，并通过 `getCar()` 方法获取到组装好的对象。最后，我们输出这些对象的属性信息。

这个示例代码中使用了建造者模式来创建不同类型的汽车对象，通过将创建过程分离到不同的建造者对象中，从而简化了创建过程，并且可以通过不同的建造者对象来创建不同类型的对象。

#### 3、为什么需要使用建造者模式？ ####

需要使用建造者模式有以下几个原因：// 创建复杂对象

1.  简化复杂对象的创建过程：有些对象的创建过程非常复杂，需要多个步骤和复杂的逻辑才能完成。使用建造者模式可以将对象的创建过程分解为多个简单的步骤，使得代码更加可读和易于维护。
2.  提高代码的可扩展性：使用建造者模式可以方便地扩展对象的创建过程，可以在不影响其他代码的情况下添加新的建造者对象和创建步骤。
3.  降低耦合性：使用建造者模式可以将对象的创建过程和表示分离开来，降低对象的表示和创建之间的耦合性。
4.  使代码更加灵活：使用建造者模式可以动态地改变对象的创建过程，可以根据需要动态地选择建造者对象和创建步骤。

#### 4、建造者模式与工厂方法模式有什么区别？ ####

建造者模式和工厂方法模式都是用于创建对象，但它们的目的和应用场景略有不同。

1.  目的不同：建造者模式的主要目的是将一个复杂对象的创建过程分解为多个简单的步骤，使得代码更加可读和易于维护。而工厂方法模式的主要目的是定义一个用于创建对象的接口，让子类决定实例化哪一个类，使得代码更加灵活。
2.  返回值不同：建造者模式返回一个组装好的完整对象，而工厂方法模式则返回一个具体类型的对象。
3.  适用场景不同：建造者模式适用于需要创建复杂对象，对象的创建过程比较复杂，需要多个步骤和复杂的逻辑才能完成的情况。而工厂方法模式适用于需要创建多种类型的对象，对象的创建过程比较简单的情况。

举个例子，比如我们要创建一辆汽车，如果汽车的创建过程非常复杂，需要多个步骤和复杂的逻辑才能完成，那么我们可以使用建造者模式。如果我们只需要创建几种不同类型的汽车，而且每种汽车的创建过程比较简单，那么我们可以使用工厂方法模式。

什么是工厂方法模式？点击这里《[工厂方法模式][Link 1]》。

// 总的来说，就是建造者模式用来创建复杂的对象，工厂模式用来创建简单对象

[Link 1]: https://blog.csdn.net/swadian2008/article/details/127124421