Tutorials : The Anatomy Of A Groovy Builder :

The Anatomy Of A Groovy Builder

Groovy is a fairly recent language for the JVM, possessing a strong focus on developer productivity and literate programming (making code easier to read). In particular, the Groovy feature that enables this focus is it's builder support.

What Is a Builder?

Imagine you have a complex object graph to construct as part of your program. Suppose, for example, you wanted to model elements of a user interface as widgets that could be rendered in many different ways. You would probably want a screen object that could contain a title, a navigation (or menu) widget, and a footer (or status bar), while the main content of the screen would be able to have panels, lists, and tables. Even at this high level of definition, you are looking at some fairly complex code to build up the widget object graph.

The builder design pattern is intended to make construction of complex object graphs simpler. It does this by allowing developers to construct an object graph consistently, while providing validation that the graph is complete and structured correctly. This means, to use the screen widget example, that a screen cannot be constructed without a title, menu, or status bar, while the main content should not contain a footer element.

Builders in Java

Your set of builders in Java for the above scenario, implemented using method chaining, might allow you to construct screens in the following manner:

        Navigation nav = new NavigationBuilder()
                .withItem( "Home", true, false )
                .withItem( "Admin", false, true )
                .withItem( "Logout", false, false )
                .build();

        Content content = new ContentBuilder()
                .withTable( new Table() )
                .build();

        Screen screen = new ScreenBuilder()
                .withTitle( "My Page" )
                .withNavigation( nav )
                .withContent( content )
                .withFooter(new Footer( "Our Footer text" ) )
                .build();

The code above is quite readable and is certainly a big improvement over a lot of setter method calls to construct your object graph. The other advantage is the build() method, which provides a natural place to validate the structure of the object graph. However, this approach can start to break down as the model gets more complicated. The sign of trouble is when you add navigation items on the NavigationBuilder. What exactly do all those boolean values mean? They happen to determine both whether the navigation item has focus and whether it is visible to the user, for example, non-administrative users will not want to see the "Admin" navigation item, but you wouldn't know to look at the code. The alternative is to create a builder for your navigation items. This allows you to replace the cryptic booleans with meaningful method calls that determine the state of the constructed object. Taking this approach, you will end up with the code shown in Listing 1.

You can see clearly that the "Home" navigation item has focus, while the "Admin" navigation item is hidden. Unfortunately, the lines of code have almost doubled.

Home / Articles / The Anatomy Of A Groovy Builder / 1

Applet Index
(sorted alphabetically)
A B C D E F G H I J K
L M N O P Q R S T U
V W X Y Z #s

The Java Source
(applets w/source code)
A B C D E F G H I J K
L M N O P Q R S T U
V W X Y Z

How to Add Java Applets to Your Site

New on the Java Boutique:

New Review:

Time Management Made Easy with the Quartz Enterprise Job Scheduler
Why not just use the Java timer API? This open source scheduling API boasts simplicity, ease-of-integration, a well-rounded feature set, and it's free!

New Applet:

Reverse Complement
Reverse Complement is a simple applet that converts DNA or RNA sequences into three useful formats.