You will be required to have Java SE Development Kit and Java EE SDK version 8 or later. You also need Maven version 3 or later. A Java IDE with Maven support, such as IntelliJ IDEA, Eclipse, or NetBeans is recommended. Finally, to use the Git repository of this book, you need to install Git.

The code files of this chapter can be found on GitHub:
https://github.com/PacktPublishing/Data-centric-Applications-with-Vaadin-8/tree/master/chapter-02

Check out the following video to see the code in action:
https://goo.gl/VnLouE

A multi-module Maven project aggregates several Maven projects into a single one. In this chapter, we will create three modules that form the whole application:

• webapp: A Vaadin web application packaged as a WAR file that includes everything needed to deploy it to a server such as Tomcat, Wildfly, Jetty, or any other Java server
• api: A Java API packaged as a JAR used by the webapp and any functional module
• example-module: An example functional module that uses the api JAR to add functionality to the application

All these modules are aggregated into a single Maven project with the name chapter-02. Let's start by creating this aggregator project by using the pom-root Maven archetype. Run the following in a terminal:

mvn archetype:generate \
-DarchetypeGroupId=org.codehaus.mojo.archetypes \
-DarchetypeArtifactId=pom-root \
-DarchetypeVersion...

Let's start by implementing a concrete component: A main screen, something every web application needs. Please keep in mind that there's not only one way of implementing main screens. The example presented here may be good for your own application, or it might inspire you to develop even more sophisticated implementations.

The main screen in this example consists of a header, a menu, and a working area where other components are shown when the user selects an option from the main menu. To the external world, this component should include the following functionality:

• Adding components to the header
• Adding components to the working area
• Adding options to the main menu
• Adding listeners to respond to menu actions
• Getting components from the working area and the header

In this book, we use the term module to refer to a software component that can be independently developed and deployed. In that sense, a modularized application can be customized and extended without distributing or modifying the source code of the original application. For our purposes, when a new module is deployed, it must register with the application. The functionality of the module is incorporated into the application at runtime.

There are several mechanisms and ways of implementing modularized applications in Java. For example, you can use OSGi if you need to provide hot deployment—that is, the capability of deploying and un-deploying modules at runtime. Another option is Service Provider Interface (SPI), a set of standard interfaces and classes included in Java SE that help with the development of extensible applications. You can even use Contexts and Dependency Injection (CDI) or an inversion of control framework such as the one provided by the Spring Framework to develop a custom module system based on the injection mechanism. Moreover, you could go down to the Java Reflection API to create instances of classes not known at compile time.

Because explaining all these alternatives is out of the scope of this book, we'll use the simplest alternative...

In this chapter, we developed a self-packaged UI component (a main screen component), created a multi-module Maven project, and learned how to implement application-specific modules that are discovered and registered with a Vaadin application at run-time. While explaining these concepts, we also saw some Java 8 and Vaadin 8 snippets of code that highlighted good practices such as making your code more maintainable and extensible.

In the next chapter, you will learn how to implement a login form with multi-language capabilities.