1. Introduction
The Builder design pattern is one of the most widely used creational patterns. It helps us to construct complex objects.
Writing builders by hand is cumbersome and error-prone. Therefore, we should use dedicated tools to auto-generate them whenever possible.
In this tutorial, we’ll explore different ways to automatically create builder classes in the IntelliJ IDE. We’ll take a look at the built-in features IntelliJ provides out of the box, as well as at the third-party plugins.
2. Initial Setup
Throughout this article, we’ll be using version 2019.1.3 of IntelliJ IDEA Community edition, which is the most recent release at the time of writing. However, all the techniques presented in the examples should work fine with any other version of IDEA as well.
Let’s begin with defining the Book class for which we’ll generate a builder:
public class Book {
private String title;
private Author author;
private LocalDate publishDate;
private int pageCount;
// standard constructor(s), getters and setters
}
3. Using IntelliJ’s Built-in Functionality
To generate a builder for the Book class using IntelliJ’s built-in tools, we need an appropriate constructor.
Let’s create one:
public Book(String title, Author author, LocalDate publishDate, int pageCount) {
this.title = title;
this.author = author;
this.publishDate = publishDate;
this.pageCount = pageCount;
}
Now, we’re ready to create a builder. Therefore, let’s place the cursor on the created constructor and open the Refactor This popup by pressing Ctrl+Alt+Shift+T (on PC) and select Replace Constructor with Builder refactoring:
We can further adjust some of the options for the builder class, like its name and target package:
As a result, we’ve generated the BookBuilder class:
public class BookBuilder {
private String title;
private Author author;
private LocalDate publishDate;
private int pageCount;
public BookBuilder setTitle(String title) {
this.title = title;
return this;
}
public BookBuilder setAuthor(Author author) {
this.author = author;
return this;
}
public BookBuilder setPublishDate(LocalDate publishDate) {
this.publishDate = publishDate;
return this;
}
public BookBuilder setPageCount(int pageCount) {
this.pageCount = pageCount;
return this;
}
public Book createBook() {
return new Book(title, author, publishDate, pageCount);
}
}
3.1. Custom Setters Prefix
It’s a common practice to use a with prefix for setter methods in builder classes.
To change the default prefix, we need to choose the Rename Setters Prefix icon in the upper right corner of the options window:
3.2. Static Inner Builder
Some of us may prefer to implement builders as static inner classes as described by Joshua Bloch in Effective Java.
If this is the case, we need to take a few extra steps to achieve this using IntelliJ’s Replace Constructor with Builder feature.
First of all, we need to manually create an empty inner class and make the constructor private:
public class Book {
private String title;
private Author author;
private LocalDate publishDate;
private int pageCount;
public static class Builder {
}
private Book(String title, Author author, LocalDate publishDate, int pageCount) {
this.title = title;
this.author = author;
this.publishDate = publishDate;
this.pageCount = pageCount;
}
// standard getters and setters
}
Furthermore, we have to choose Use existing in the options window and point to our newly created class:
4. Using InnerBuilder Plugin
Let’s now see how we can generate a builder for the Book class using InnerBuilder plugin.
Once we’ve installed the plugin, we can open the Generate pop-up by pressing Alt+Insert (on PC) and choosing the Builder… option:
Alternatively, we can call the InnerBuilder plugin directly by pressing Alt+Shift+B (on PC):
As we see, there are a few options we can choose from to customize the generated builder.
Let’s see the builder generated when all the options are unchecked:
public static final class Builder {
private String title;
private Author author;
private LocalDate publishDate;
private int pageCount;
public Builder() {
}
public Builder title(String val) {
title = val;
return this;
}
public Builder author(Author val) {
author = val;
return this;
}
public Builder publishDate(LocalDate val) {
publishDate = val;
return this;
}
public Builder pageCount(int val) {
pageCount = val;
return this;
}
public Book build() {
return new Book(this);
}
}
The InnerBuilder plugin implements builders as static inner classes by default.
5. Using Builder Generator Plugin
Finally, let’s see how Builder Generator works.
Similarly, as for InnerBuilder, we can either press Alt+Insert (on PC) and choose Builder option or use Alt+Shift+B shortcut.
As we can see, we have three options to choose from for customizing the BookBuilder:
Let’s leave all the options unchecked and see the generated builder class:
public final class BookBuilder {
private String title;
private Author author;
private LocalDate publishDate;
private int pageCount;
private BookBuilder() {
}
public static BookBuilder aBook() {
return new BookBuilder();
}
public BookBuilder withTitle(String title) {
this.title = title;
return this;
}
public BookBuilder withAuthor(Author author) {
this.author = author;
return this;
}
public BookBuilder withPublishDate(LocalDate publishDate) {
this.publishDate = publishDate;
return this;
}
public BookBuilder withPageCount(int pageCount) {
this.pageCount = pageCount;
return this;
}
public Book build() {
Book book = new Book();
book.setTitle(title);
book.setAuthor(author);
book.setPublishDate(publishDate);
book.setPageCount(pageCount);
return book;
}
}
The first option that Builder Generator plugin provides to customize the created builder class – Inner builder – is rather self-explanatory.
Two others, however, are more interesting, and we’ll explore them in the following sections.
5.1. ‘but’ method Option
If we choose this option, the plugin will add a but() method to the BookBuilder class:
public BookBuilder but() {
return aBook().withTitle(title).withAuthor(author)
.withPublishDate(publishDate).withPageCount(pageCount);
}
Now, let’s imagine we want to create three books with the same author and the same number of pages but with different titles and publish dates. We may create a base builder with common properties already set and then use the but() method to create new BookBuilders (and Books later on) out of it.
Let’s take a look at an example:
BookBuilder commonBuilder = BookBuilder.aBook().withAuthor(johnDoe).withPageCount(123);
Book my_first_book = commonBuilder.but()
.withPublishDate(LocalDate.of(2017, 12, 1))
.withTitle("My First Book").build();
Book my_second_book = commonBuilder.but()
.withPublishDate(LocalDate.of(2018, 12, 1))
.withTitle("My Second Book").build();
Book my_last_book = commonBuilder.but()
.withPublishDate(LocalDate.of(2019, 12, 1))
.withTitle("My Last Book").build();
5.2. Use a single field Option
If we choose this option, the generated builder will hold a reference to the created Book object instead of all the book’s properties:
public final class BookBuilder {
private Book book;
private BookBuilder() {
book = new Book();
}
public static BookBuilder aBook() {
return new BookBuilder();
}
public BookBuilder withTitle(String title) {
book.setTitle(title);
return this;
}
public BookBuilder withAuthor(Author author) {
book.setAuthor(author);
return this;
}
public BookBuilder withPublishDate(LocalDate publishDate) {
book.setPublishDate(publishDate);
return this;
}
public BookBuilder withPageCount(int pageCount) {
book.setPageCount(pageCount);
return this;
}
public Book build() {
return book;
}
}
This is a bit different approach to create a builder class that might come in handy in certain situations.
6. Conclusion
In this tutorial, we’ve explored different ways to generate builder classes in IntelliJ.
It’s usually better to use these kinds of tools to automatically generate our builders. Each of the options we’ve presented has its pros and cons. Which approach we actually choose is rather a matter of taste and individual preferences.