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 private constructor is generated with all fields as arguments (as if @AllArgsConstructor(access = AccessLevel.PRIVATE) 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 Description
      AccessLevel access
      Sets the access level of the generated builder class.
      java.lang.String builderClassName
      Name of the builder class.
      java.lang.String builderMethodName  
      java.lang.String buildMethodName  
      boolean toBuilder
      If true, generate an instance method to obtain a builder that is initialized with the values of this instance.
    • Element Detail

      • builderMethodName

        java.lang.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

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

        java.lang.String builderClassName
        Name of the builder class. Default for @Builder on types and constructors: (TypeName)Builder.

        Default for @Builder on methods: (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:
        lombok.AccessLevel.PUBLIC