The Builder pattern is a creative design pattern used to build complex objects in steps. It separates the object's construction process from its representation, making the code clearer and easier to expand. 1. Applicable to scenarios where the class has multiple optional fields, too many constructor parameters, and requires flexible control of the construction process; 2. It can be manually implemented by defining internal static classes, setting parameters using chain calls and calling build() method to generate objects; 3. Lombok provides @Builder annotation to automatically generate Builder code to improve development efficiency; 4. It is recommended to use it when there are more than 4 parameters, default values ??or verification logic, and hope to improve readability, but simple objects do not need to be used.

Using the Builder pattern in Java is mainly to simplify the creation process of complex objects. Especially when a class has many optional parameters, it becomes difficult to maintain by passing directly with a constructor. The Builder pattern allows you to build objects step by step through chain calls, making the code clearer and easier to expand.

What is Builder mode?

The Builder pattern is a creative design pattern used to separate the construction of a complex object from its representation. Simply put, it allows you to create an object in steps instead of passing in all parameters at once.
This mode is especially suitable for the following scenarios:

• The class has multiple optional fields
• Too many constructor parameters lead to poor readability
• Need to flexibly control the construction process of objects

Common examples include: creating configuration objects, building request bodies, generating reports, etc.

How to manually implement a Builder?

You can implement the Builder pattern by defining an internal static class. Here is a simple example:

 public class Pizza {
    private final String dough;
    private final String sauce;
    private final boolean cheese;
    private final String topping;

    private Pizza(Builder builder) {
        this.dough = builder.dough;
        this.sauce = builder.sauce;
        this.cheese = builder.cheese;
        this.topping = builder.topping;
    }

    public static class Builder {
        private String dough = "regular";
        private String sauce = "tomato";
        private boolean cheese = true;
        private String topping;

        public Builder setDough(String dough) {
            this.dough = dough;
            return this;
        }

        public Builder setSauce(String sauce) {
            this.sauce = sauce;
            return this;
        }

        public Builder addCheese(boolean cheese) {
            this.cheese = cheese;
            return this;
        }

        public Builder setTopping(String topping) {
            this.topping = topping;
            return this;
        }

        public Pizza build() {
            return new Pizza(this);
        }
    }
}

How to use it is as follows:

 Pizza pizza = new Pizza.Builder()
    .setDough("thin")
    .setSauce("pesto")
    .addCheese(false)
    .setTopping("mushrooms")
    .build();

The benefits of writing this way are obvious: clear parameters, easy to read, and easy to expand.

Simplify Builder implementation with Lombok

If you don't want to hand-written Builder, Lombok provides a very convenient annotation @Builder , which automatically generates Builder classes and related methods.

Just add:

 import lombok.Builder;

@Builder
public class Pizza {
    private String dough;
    private String sauce;
    private boolean cheese;
    private String topping;
}

Then you can use it like before:

 Pizza pizza = Pizza.builder()
    .dough("thin")
    .sauce("pesto")
    .cheese(false)
    .topping("mushrooms")
    .build();

Note: Lombok will generate Builder-related code at compile time, so there will be no performance issues at runtime, but you need to make sure that the Lombok plugin is correctly configured in the project.

In what circumstances is Builder suitable?

• There are more than 4 constructor parameters , especially when some are optional.
• I hope to improve the readability of the code , such as chain calls are easier to understand than long parameter lists.
• Properties may be expanded in the future , and Builder can easily add new fields without affecting existing code.
• Default value or verification logic is required , and judgment logic can be added to the Builder method.

However, it should also be noted that if the object is simple and only has one or two parameters, there is no need to use Builder, which will increase the complexity of the code.

Basically that's it. Builder mode is not necessary, but when used when appropriate, it can make the code more elegant and easier to maintain.

The above is the detailed content of How to use the Builder Pattern in Java.. For more information, please follow other related articles on the PHP Chinese website!