lombok

Annotation Type Builder

@Target(value={TYPE,METHOD,CONSTRUCTOR})
 @Retention(value=SOURCE)
public @interface Builder

The builder annotation creates a so-called 'builder' aspect to the class that is annotated or the class that contains a member which is annotated with @Builder.

If a member is annotated, it must be either a constructor or a method. If a class is annotated, then a package-private constructor is generated with all fields as arguments (as if @AllArgsConstructor(access = AccessLevel.PACKAGE) is present on the class), and it is as if this constructor has been annotated with @Builder instead. Note that this constructor is only generated if you haven't written any constructors and also haven't added any explicit @XArgsConstructor annotations. In those cases, lombok will assume an all-args constructor is present and generate code that uses it; this means you'd get a compiler error if this constructor is not present.

The effect of @Builder is that an inner class is generated named TBuilder, with a private constructor. Instances of TBuilder are made with the method named builder() which is also generated for you in the class itself (not in the builder class).

The TBuilder class contains 1 method for each parameter of the annotated constructor / method (each field, when annotating a class), which returns the builder itself. The builder also has a build() method which returns a completed instance of the original type, created by passing all parameters as set via the various other methods in the builder to the constructor or method that was annotated with @Builder. The return type of this method will be the same as the relevant class, unless a method has been annotated, in which case it'll be equal to the return type of that method.

Complete documentation is found at the project lombok features page for @Builder.

Before:

 @Builder
 class Example<T> {
        private T foo;
        private final String bar;
 }
 

After:

 class Example<T> {
        private T foo;
        private final String bar;
        
        private Example(T foo, String bar) {
                this.foo = foo;
                this.bar = bar;
        }
        
        public static <T> ExampleBuilder<T> builder() {
                return new ExampleBuilder<T>();
        }
        
        public static class ExampleBuilder<T> {
                private T foo;
                private String bar;
                
                private ExampleBuilder() {}
                
                public ExampleBuilder foo(T foo) {
                        this.foo = foo;
                        return this;
                }
                
                public ExampleBuilder bar(String bar) {
                        this.bar = bar;
                        return this;
                }
                
                @java.lang.Override public String toString() {
                        return "ExampleBuilder(foo = " + foo + ", bar = " + bar + ")";
                }
                
                public Example build() {
                        return new Example(foo, bar);
                }
        }
 }
 

See Also:

Singular

Optional Element Summary

Optional Elements

Modifier and Type	Optional Element and Description
AccessLevel	access Sets the access level of the generated builder class.
String	builderClassName Name of the builder class.
String	builderMethodName
String	buildMethodName
String	setterPrefix Prefix to prepend to 'set' methods in the generated builder class.
boolean	toBuilder If true, generate an instance method to obtain a builder that is initialized with the values of this instance.

Element Detail

builderMethodName

public abstract String builderMethodName

Returns:

Name of the method that creates a new builder instance. Default: builder. If the empty string, suppress generating the builder method.

Default:

"builder"

buildMethodName

public abstract String buildMethodName

Returns:

Name of the method in the builder class that creates an instance of your @Builder-annotated class.

Default:

"build"

builderClassName

public abstract String builderClassName

Name of the builder class. Default for @Builder on types and constructors: see the configkey lombok.builder.className, which if not set defaults to (TypeName)Builder.

Default for @Builder on methods: see the configkey lombok.builder.className, which if not set defaults to (ReturnTypeName)Builder.

Returns:

Name of the builder class that will be generated (or if it already exists, will be filled with builder elements).

Default:

""

toBuilder

public abstract boolean toBuilder

If true, generate an instance method to obtain a builder that is initialized with the values of this instance. Legal only if @Builder is used on a constructor, on the type itself, or on a static method that returns an instance of the declaring type.

Returns:

Whether to generate a toBuilder() method.

Default:

false

access

public abstract AccessLevel access

Sets the access level of the generated builder class. By default, generated builder classes are public. Note: This does nothing if you write your own builder class (we won't change its access level).

Returns:

The builder class will be generated with this access modifier.

Default:

lombok.AccessLevel.PUBLIC

setterPrefix

public abstract String setterPrefix

Prefix to prepend to 'set' methods in the generated builder class. By default, generated methods do not include a prefix. For example, a method normally generated as someField(String someField) would instead be generated as withSomeField(String someField) if using @Builder(setterPrefix = "with"). Note that using "with" to prefix builder setter methods is strongly discouraged as as "with" normally suggests immutable data structures, and builders by definition are mutable objects. For @Singular fields, the generated methods are called withName, withNames, and clearNames, instead of the default name, names, and clearNames.

Returns:

The prefix to prepend to generated method names.

Default:

""