Java与设计模式（6）：建造者模式

比眉伴天荒 2024-03-17 12:17 33阅读 0赞

## 一、定义 ##

建造者模式（Builder Pattern）是一种创建型设计模式，它允许你逐步构造复杂对象。该模式将对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示。

建造者模式的核心思想是将一个复杂对象的构建过程分解为多个简单的步骤，通过一系列的步骤来逐步构建对象，最终产生一个完整的对象。这种分步构建的方式使得对象的构建过程更加灵活，同时可以隐藏对象的创建细节。

建造者模式通常包含以下几个角色：

1.  产品（Product）：表示最终构建的复杂对象。它包含了多个部分或组件，这些部分或组件的构建过程由具体的建造者负责。
2.  抽象建造者（Builder）：定义了构建复杂对象的接口和步骤。它通常包含多个构建方法，用于构建不同部分或组件，并最终返回构建好的产品。
3.  具体建造者（Concrete Builder）：实现了抽象建造者的接口，负责具体的构建步骤和逻辑。它包含了构建过程中的具体实现，并最终返回构建好的产品。
4.  指导者（Director）：负责控制构建过程的顺序和步骤。它通过调用建造者的方法来构建产品，但并不直接与产品进行交互。

建造者模式提供了一种灵活的方式来构建复杂对象，使得构建过程更加可控和可扩展，同时也能隐藏对象的创建细节，提供了更好的封装性和抽象性。

## 二、Java示例 ##

以下是一个简单的Java示例，展示了如何使用建造者模式创建一个复杂对象：

// 产品类
    class Product {
        
        private String part1;
        private String part2;
        private String part3;
    
        public void setPart1(String part1) {
        
            this.part1 = part1;
        }
    
        public void setPart2(String part2) {
        
            this.part2 = part2;
        }
    
        public void setPart3(String part3) {
        
            this.part3 = part3;
        }
    
        public void show() {
        
            System.out.println("Part 1: " + part1);
            System.out.println("Part 2: " + part2);
            System.out.println("Part 3: " + part3);
        }
    }
    
    // 抽象建造者
    interface Builder {
        
        void buildPart1();
        void buildPart2();
        void buildPart3();
        Product getResult();
    }
    
    // 具体建造者
    class ConcreteBuilder implements Builder {
        
        private Product product;
    
        public ConcreteBuilder() {
        
            this.product = new Product();
        }
    
        public void buildPart1() {
        
            product.setPart1("Part 1");
        }
    
        public void buildPart2() {
        
            product.setPart2("Part 2");
        }
    
        public void buildPart3() {
        
            product.setPart3("Part 3");
        }
    
        public Product getResult() {
        
            return product;
        }
    }
    
    // 指导者
    class Director {
        
        private Builder builder;
    
        public Director(Builder builder) {
        
            this.builder = builder;
        }
    
        public void construct() {
        
            builder.buildPart1();
            builder.buildPart2();
            builder.buildPart3();
        }
    }
    
    // 客户端代码
    public class BuilderPatternExample {
        
        public static void main(String[] args) {
        
            Builder builder = new ConcreteBuilder();
            Director director = new Director(builder);
    
            director.construct();
    
            Product product = builder.getResult();
            product.show();
        }
    }

在上述示例中，我们定义了一个产品类`Product`，它包含了三个部分（part1、part2和part3）。然后，我们定义了抽象建造者`Builder`，具体建造者`ConcreteBuilder`和指导者`Director`。最后，在客户端代码中，我们使用建造者模式来构建一个复杂对象。

通过调用指导者的`construct()`方法，按照一定的步骤调用具体建造者的方法来构建产品。最后，通过建造者的`getResult()`方法获取构建好的产品，并调用其`show()`方法展示产品的组成部分。

运行以上示例，将输出如下结果：

Part 1: Part 1
    Part 2: Part 2
    Part 3: Part 3

这表明我们成功地使用建造者模式构建了一个复杂对象，并且可以根据需要灵活地控制构建过程。

## 三、优点 ##

建造者模式具有以下优点：

1.  将复杂对象的构建过程与其表示分离：建造者模式将对象的构建过程封装在具体的建造者类中，与产品的表示分离。这样可以使构建过程更加灵活，可以按需构建不同的表示，而不影响最终产品的使用。
2.  隐藏了对象的创建细节：客户端只需关注最终产品的获取，而不需要了解具体的构建细节。具体的构建过程由建造者类负责，客户端无需知道每个部分的构建细节，提高了代码的封装性和抽象性。
3.  可以通过改变具体的建造者来创建不同的产品表示：通过定义不同的具体建造者类，可以创建不同的产品表示。客户端可以根据需要选择不同的建造者来构建不同的产品，增加了系统的灵活性和可扩展性。
4.  可以更加精细地控制对象的构建过程：由于建造者模式将对象的构建过程分解为多个步骤，可以逐步构建复杂对象，并在每个步骤中进行必要的验证和处理。这样可以更加精细地控制对象的构建过程，确保最终构建出的对象是符合要求的。
5.  提供了更好的封装性和代码复用性：建造者模式将对象的构建过程封装在具体的建造者类中，使得每个建造者只需要关注自己负责的部分。这样可以提高代码的封装性，降低了各个部分之间的耦合度。同时，由于具体的建造者类可以复用，可以在不同的场景中重复使用。

建造者模式通过将复杂对象的构建过程分解为多个简单的步骤，提供了一种灵活的方式来构建对象。它隐藏了对象的创建细节，提供了更好的封装性和抽象性，同时也能够根据需要灵活地控制构建过程。这使得建造者模式成为一种常用的创建型设计模式。

## 四、缺点 ##

建造者模式的一些缺点包括：

1.  增加了代码量：建造者模式需要定义多个类，包括产品类、抽象建造者类、具体建造者类和指导者类。这样会增加代码量，特别是在构建较为复杂的对象时，需要定义更多的类和方法。
2.  建造者模式的使用需要结合指导者类：在使用建造者模式时，需要通过指导者类来调用具体建造者的方法来构建产品。这会增加一定的复杂性，特别是在构建过程需要灵活变化时，可能需要修改指导者类的代码。
3.  不适用于构建简单对象：建造者模式主要用于构建复杂对象，如果需要构建的对象比较简单，使用建造者模式可能会显得繁琐和冗余。
4.  可能会产生多余的对象：在建造者模式中，产品对象的构建过程是逐步进行的，每个步骤都会产生一个中间对象。这些中间对象可能会占用额外的内存空间，特别是在构建较大的对象时，可能会产生较多的中间对象。
5.  需要全面了解产品的构建过程：使用建造者模式需要对产品的构建过程有全面的了解，包括每个部分的构建细节和顺序。这对于开发人员来说可能需要花费一定的时间和精力来理解和设计构建过程。

需要注意的是，上述缺点并不是建造者模式固有的问题，而是在特定的情况下可能会出现的一些问题。在设计和使用建造者模式时，需要根据具体的需求和场景来权衡利弊，选择合适的设计模式。

## 五、使用场景 ##

建造者模式适用于以下场景：

1.  需要创建复杂对象：如果需要创建的对象具有复杂的内部结构，包含多个部分，并且这些部分的组合方式可能会变化，可以考虑使用建造者模式。通过将对象的构建过程分解为多个步骤，可以更加灵活地构建复杂对象。
2.  需要精细控制对象的构建过程：如果需要对对象的构建过程进行精细的控制，例如需要在每个构建步骤中进行验证、处理或记录操作，可以使用建造者模式。通过将构建过程分解为多个步骤，可以在每个步骤中添加必要的逻辑，以满足特定的需求。
3.  需要创建不同表示的对象：如果需要根据不同的需求创建不同表示的对象，可以使用建造者模式。通过定义不同的具体建造者类，可以构建不同的产品表示，而客户端代码无需关心具体的构建过程。
4.  需要重复使用相同的构建过程：如果需要在不同的场景中重复使用相同的构建过程，可以考虑使用建造者模式。通过复用具体建造者类，可以在不同的场景中重复使用已定义好的构建过程，提高代码的复用性和可维护性。

需要注意的是，建造者模式并不适用于所有情况。如果需要构建的对象比较简单，没有复杂的内部结构或构建过程，使用建造者模式可能会显得繁琐和冗余。在设计和使用建造者模式时，需要根据具体的需求和场景来判断是否适合使用。

## 六、注意事项 ##

在使用建造者模式时，需要注意以下几点：

1.  确定是否需要使用建造者模式：建造者模式适用于需要创建复杂对象、需要精细控制构建过程、需要创建不同表示的对象或需要重复使用相同构建过程的情况。在设计之前，需要仔细评估需求，确定是否真正需要使用建造者模式。
2.  明确对象的构建过程：在使用建造者模式时，需要明确对象的构建过程，包括每个部分的构建细节和顺序。这对于开发人员来说可能需要花费一定的时间和精力来理解和设计构建过程。
3.  定义合适的抽象和具体建造者类：根据对象的构建过程，需要定义合适的抽象建造者类和具体建造者类。抽象建造者类定义了构建过程的接口，具体建造者类实现了具体的构建逻辑。需要根据实际情况进行设计和抽象，确保建造者类的层次结构合理且易于扩展。
4.  使用指导者类进行构建过程的调用：在建造者模式中，通常会使用指导者类来调用具体建造者的方法来构建产品。指导者类负责控制构建过程的顺序和逻辑。需要根据实际情况确定是否需要使用指导者类，以及如何组织和调用构建过程。
5.  考虑使用生成器模式替代：在某些情况下，生成器模式可以作为建造者模式的替代方案。生成器模式将对象的构建过程封装在一个生成器类中，并提供一种链式调用的方式来构建对象。在设计和选择时，可以根据具体需求和场景来选择合适的模式。

## 七、在spring 中的应用 ##

建造者模式在Spring框架的源码中有多个应用场景，以下是其中一些例子：

1.  Spring MVC中的请求构建器（RequestBuilder）：在Spring MVC中，可以使用请求构建器来构建HTTP请求。请求构建器提供了一系列方法来设置请求的URL、请求方法、请求头、请求体等信息，最后通过build方法返回构建好的请求对象。

MockHttpServletRequestBuilder requestBuilder = MockMvcRequestBuilders.get("/api/users")
            .param("page", "1")
            .param("size", "10")
            .header("Authorization", "Bearer token")
            .contentType(MediaType.APPLICATION_JSON)
            .content("{ \"name\": \"John\" }");
    
    // 使用请求构建器构建请求对象
    MockHttpServletRequest request = requestBuilder.buildRequest(mockMvc);

1.  Spring Data中的查询构建器（Querydsl）：在Spring Data中，可以使用查询构建器来构建复杂的查询条件。查询构建器提供了一系列方法来设置查询的条件、排序方式、分页等信息，最后通过build方法返回构建好的查询对象。

QUser user = QUser.user;
    Predicate predicate = new BooleanBuilder()
            .and(user.name.eq("John"))
            .and(user.age.goe(18))
            .and(user.gender.eq(Gender.MALE))
            .build();
    
    // 使用查询构建器构建查询对象
    JPAQuery<User> query = new JPAQuery<>(entityManager);
    List<User> userList = query.from(user).where(predicate).fetch();

1.  Spring Security中的认证构建器（AuthenticationBuilder）：在Spring Security中，可以使用认证构建器来构建认证对象。认证构建器提供了一系列方法来设置认证的用户名、密码、角色等信息，最后通过build方法返回构建好的认证对象。

AuthenticationBuilder authenticationBuilder = new AuthenticationBuilder()
            .setName("user")
            .setPassword("password")
            .setRoles("ROLE_USER");
    
    // 使用认证构建器构建认证对象
    Authentication authentication = authenticationBuilder.build();

这些是Spring框架中一些使用建造者模式的例子，它们通过建造者模式将对象的构建和配置过程解耦，使得代码更加清晰、可读性更高，并且方便扩展和维护。这些应用场景都是在Spring框架内部实现的，开发人员可以直接使用这些构建器来构建相应的对象。