Package lombok

Annotation Type Builder


@Target({TYPE,METHOD,CONSTRUCTOR}) @Retention(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:
  • Nested Class Summary

    Nested Classes
    Modifier and Type
    Class
    Description
    static @interface 
    The field annotated with @Default must have an initializing expression; that expression is taken as the default to be used if not explicitly set during building.
    static @interface 
    Put on a field (in case of @Builder on a type) or a parameter (for @Builder on a constructor or static method) to indicate how lombok should obtain a value for this field or parameter given an instance; this is only relevant if toBuilder is true.
  • Optional Element Summary

    Optional Elements
    Modifier and Type
    Optional Element
    Description
    Sets the access level of the generated builder class.
    Name of the builder class.
     
     
    Prefix to prepend to 'set' methods in the generated builder class.
    boolean
    If true, generate an instance method to obtain a builder that is initialized with the values of this instance.
  • Element Details

    • builderMethodName

      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

      String buildMethodName
      Returns:
      Name of the method in the builder class that creates an instance of your @Builder-annotated class.
      Default:
      "build"
    • builderClassName

      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

      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

      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:
      PUBLIC
    • setterPrefix

      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 "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:
      ""