Builder pattern code generation in IntelliJ

Question

Is there any way to automate writing Builder patterns in IntelliJ?

For example, given this simple class:

class Film {
   private String title;
   private int length;

   public void setTitle(String title) {
       this.title = title;
   }

   public String getTitle() {
       return this.title;
   }

   public void setLength(int length) {
       this.length = length;
   }

   public int getLength() {
       return this.length;
   }
}

is there a way that I could get the IDE to generate this, or similar:

public class FilmBuilder {

    Film film;

    public FilmBuilder() {
        film = new Film();
    }

    public FilmBuilder withTitle(String title) {
        film.setTitle(title);
        return this;
    }

    public FilmBuilder withLength(int length) {
        film.setLength(length);
        return this;
    }

    public Film build() {
        return film;
    }
}

Answer 1

Use the Replace Constructor with Builder refactoring.

To use this function, click on the constructor's signature in your code, then right click and select the "Refactor" menu, then click "Replace Constructor with Builder..." to bring up the dialog box to generate the code.

Answer 2

I found the built-in builder pattern generation in IntelliJ to be a bit clunky for a few reasons:

1. It needs to use an existing constructor as reference.
2. It's not quickly accessible via the "Generate" menu (command+N on OS X).
3. It only generates external Builder classes. As others have mentioned, it's very common to use static inner classes when implementing the builder pattern.

The InnerBuilder plugin addresses all of these shortcomings, and requires no setup or configuration. Here's a sample Builder generated by the plugin:

public class Person {
    private String firstName;
    private String lastName;
    private int age;

    private Person(Builder builder) {
        firstName = builder.firstName;
        lastName = builder.lastName;
        age = builder.age;
    }

    public static final class Builder {
        private String firstName;
        private String lastName;
        private int age;

        public Builder() {
        }

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

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

        public Builder age(int age) {
            this.age = age;
            return this;
        }

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

Answer 3

Here's how to overcome the shortcomings mentioned by Mansoor Siddiqui:

1) It needs to use an existing constructor as reference.

Which is very easy to generate. Just hit Alt + Ins on Windows to invoke Generate menu and choose Constructor.

2) It's not quickly accessible via the "Generate" menu (command+N on OS X)

Just go to Settings -> Keymap, search for Builder and assign it a shortcut of your choice (if you use this functionality very often, which is rarely the case). You can assign Alt + B for example.

Another alternative is Ctrl + Shift + A (Find Action). Start typing Builder and you'll immediately get access to the command:

You could use this shortcut for quickly getting access to any IntelliJ IDEA feature (this helps a lot when you don't remember exactly what the command is called and where to find it).

3) It only generates external Builder classes. As others have mentioned, it's very common to use static inner classes when implementing the builder pattern.

I also prefer my builders as static inner classes. Unfortunately, there is no straightforward way to do it, but it's still feasible. You just have to define the nested inner class yourself (leave it empty), and when you invoke Replace Constructor with Builder dialog, choose Use existing option and select your inner class. Works like a charm! Although, it would've been easier to make this option configurable.

Answer 4

If you are wondering if this can be used to create a class with an inner builder class as described by Joshua Block - you just have to define an empty inner class first, then check "Use existing" and search for your newly created (inner class) and hit "Refactor".

PS! Cursor must reside inside constructor (pre-written) in order to use the "Replace Constructor with Builder" refactoring function.

Answer 5

The IntelliJ way to to this is, IMHO, is convoluted. There are out there two plugins (I prefer this one: https://plugins.jetbrains.com/plugin/7354) that serve the purpose much much better.

For example, I prefer having the Builder class as an inner class of the PoJo. To achieve that with IntelliJ you need few extra strokes.

Another plus for the plugin is the location of the functionality (in the Generate... context menu).

Answer 6

Lombok is the easiest way to do it! (It has a Intellij plugin for syntax support https://plugins.jetbrains.com/plugin/6317-lombok-plugin)

Just add a @Builder annotation, and behind the walls it will add a builder implementation inside the object.

With Lombok:

import lombok.Builder;
import lombok.Singular;
import java.util.Set;

@Builder
public class BuilderExample {
  @Builder.Default private long created = System.currentTimeMillis();
  private String name;
  private int age;
  @Singular private Set<String> occupations;
}

Without Lombok:

import java.util.Set;

public class BuilderExample {
  private long created;
  private String name;
  private int age;
  private Set<String> occupations;
  
  BuilderExample(String name, int age, Set<String> occupations) {
    this.name = name;
    this.age = age;
    this.occupations = occupations;
  }
  
  private static long $default$created() {
    return System.currentTimeMillis();
  }
  
  public static BuilderExampleBuilder builder() {
    return new BuilderExampleBuilder();
  }
  
  public static class BuilderExampleBuilder {
    private long created;
    private boolean created$set;
    private String name;
    private int age;
    private java.util.ArrayList<String> occupations;
    
    BuilderExampleBuilder() {
    }
    
    public BuilderExampleBuilder created(long created) {
      this.created = created;
      this.created$set = true;
      return this;
    }
    
    public BuilderExampleBuilder name(String name) {
      this.name = name;
      return this;
    }
    
    public BuilderExampleBuilder age(int age) {
      this.age = age;
      return this;
    }
    
    public BuilderExampleBuilder occupation(String occupation) {
      if (this.occupations == null) {
        this.occupations = new java.util.ArrayList<String>();
      }
      
      this.occupations.add(occupation);
      return this;
    }
    
    public BuilderExampleBuilder occupations(Collection<? extends String> occupations) {
      if (this.occupations == null) {
        this.occupations = new java.util.ArrayList<String>();
      }

      this.occupations.addAll(occupations);
      return this;
    }
    
    public BuilderExampleBuilder clearOccupations() {
      if (this.occupations != null) {
        this.occupations.clear();
      }
      
      return this;
    }

    public BuilderExample build() {
      // complicated switch statement to produce a compact properly sized immutable set omitted.
      Set<String> occupations = ...;
      return new BuilderExample(created$set ? created : BuilderExample.$default$created(), name, age, occupations);
    }
    
    @java.lang.Override
    public String toString() {
      return "BuilderExample.BuilderExampleBuilder(created = " + this.created + ", name = " + this.name + ", age = " + this.age + ", occupations = " + this.occupations + ")";
    }
  }
}

Source: https://projectlombok.org/features/Builder

Answer 7

In my opinion, the simplest way to get the inner static class instead of a separate are:

1. If you don't have a constructor yet, generate one using Generate a constructor dialog
2. Then, use Replace Constructor with Builder
3. Move the newly created class back to the initial one using Move refactoring (Hotkey: F6)

Answer 8

As a complement to @CrazyCoder's answer, I think it's very useful to know that in the upper-right side of Replace Constructor with Builder dialog there is a configuration button that you can use to rename setters' prefix.

Answer 9

For those wanting to replace "too many parameters" with a builder pattern, do "extract parameter object" and then the convert constructor to builder mentioned in other answers here.

Answer 10

Generate constructor of the class by right clicking on class Generate>Constructor. Then, on Windows, press is Ctrl+Shift+A to find action and type "builder", select "Replace constructor with builder.."

Answer 11

I have found the Effective Inner Builder to be the best option as it adds null checks and can start with just the members defined.

Answer 12

In addition to CrazyCoder's answer and Chris B's comment . There's a huge advantage using the refactor of Intellij compared to the usage of InnerBuilder plugin mentioned by Mansoor Siddiqui, that if the constructor is already used in code it will be refactored to the new created builder which is not the case with InnerBuilder.