@Target(value={TYPE,METHOD,CONSTRUCTOR})
@Retention(value=SOURCE)
public @interface Builder
@Builder
.
If a member is annotated, it must be either a constructor or a static method. If a class is annotated,
then a private constructor is generated with all fields as arguments
(as if @AllArgsConstructor(AccessLevel.PRIVATE)
is present
on the class), and it is as if this constructor has been annotated with @Builder
instead.
The effect of @Builder
is that an inner class is generated named TBuilder
,
with a private constructor. Instances of TBuilder
are made with the static
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 / static 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 static method that was annotated with @Builder
. The return type of this method will be the same
as the relevant class, unless a static 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 { private int 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); } } }
Modifier and Type | Optional Element and Description |
---|---|
java.lang.String |
builderClassName
Name of the builder class.
|
java.lang.String |
builderMethodName
Name of the static method that creates a new builder instance.
|
java.lang.String |
buildMethodName
Name of the instance method in the builder class that creates an instance of your
@Builder -annotated class. |
boolean |
toBuilder
If true, generate an instance method to obtain a builder that is initialized with the values of this instance.
|
public abstract java.lang.String builderMethodName
builder
.public abstract java.lang.String buildMethodName
@Builder
-annotated class.public abstract java.lang.String builderClassName
@Builder
on types and constructors: (TypeName)Builder
.
Default for @Builder
on static methods: (ReturnTypeName)Builder
.
public abstract boolean toBuilder
@Builder
is used on a constructor, on the type itself, or on a static method that returns
an instance of the declaring type.Copyright © 2009-2015 The Project Lombok Authors, licensed under the MIT licence.