Docs

Documentation versions (currently viewingVaadin 14)
You are viewing documentation for an older Vaadin version. View latest documentation

Starting a Project

Once you have installed a development toolchain, as described in the previous chapter, you are ready to create a Vaadin project.

You have a number of choices for creating a project:

Download a starter project from vaadin.com/hello-world-starters

There you will find starter projects for Spring Boot, plain Java, and CDI stacks.

Create a project from a Maven archetype

You can create a project from a Maven archetype either on command-line or with IDEs that support Maven. This way does not support any customization, except for project IDs and names.

Create a project with the Vaadin Plugin for Eclipse

The Eclipse plugin new-project wizard lets you create a Vaadin application. Using the plugin, you avoid the small effort with downloading and importing the application package.

Technology Stacks

The tools allow creating a project with three different technology stacks. All of them follow the same application architecture, where you have the UI layer as an application view, with a service-layer back-end.

Spring Boot

Spring Boot is a Java framework for creating web services that you can deploy and run easily. It enables using Spring Framework, the popular enterprise application framework for Java EE, with minimal configuration.

The application has a main view, which gets access to the business model service by autowiring.

public class MainView extends VerticalLayout {
    public MainView(@Autowired GreetService service) {
        ...
    }
}

The service is a simple Spring service:

@Service
public class GreetService implements Serializable {
    public String greet(String name) {
        if (name == null || name.isEmpty()) {
            return "Hello anonymous user";
        } else {
            return "Hello " + name;
        }
    }
}

CDI and Java EE

The Java Enterprise Edition (EE) includes many features for creating enterprise applications. CDI or context dependency injection is the Java EE way to manage service objects and inject them into applications, in our case Vaadin UIs. CDI requires a Java EE -enabled web container; the starter projects use Apache TomEE.

The starter project includes an example service that handles business data and logic. It is injected in the main view, and can be injected in similar way to other views or elsewhere.

public class MainView extends VerticalLayout {
    @Inject
    private GreetService greetService;

    ...
}

The service is scoped to the Vaadin session, so each user session has its own service instance.

@VaadinSessionScoped
public class GreetService {
    public String greet(String name) {
        if (name == null || name.isEmpty()) {
            return "Hello anonymous user";
        } else {
            return "Hello " + name;
        }
    }
}

Plain Java Servlet

You can also choose to develop the application as a plain Java servlet, which you can deploy to any Java web container, which does not need to support Java EE or its features.

In a similar way to the Spring and CDI starters, the plain Java application also has a service to handle business data and logic, but you need to manage access to it by your own.

public class MainView extends VerticalLayout {

    public MainView() {
        // Use TextField for standard text input
        TextField textField = new TextField("Your name");

        // Button click listeners can be defined as lambda expressions
        GreetService greetService = new GreetService();
        Button button = new Button("Say hello",
            e -> Notification.show(greetService.greet(textField.getValue())));
        ...
    }
}

In the plain Java servlet, the service is an ordinary object:

public class GreetService {
    public String greet(String name) {
        if (name == null || name.isEmpty()) {
            return "Hello anonymous user";
        } else {
            return "Hello " + name;
        }
    }
}

If you use the web tools to create a project, you then need to import it in your IDE as a Maven project. We will go through that with each major IDE: IntelliJ IDEA, Eclipse IDE, and NetBeans IDE. You can also create, compile, and run the projects on the command-line.