Imagine a bacon-wrapped Ferrari. Still not better than our free technical reports.

The Ultimate Java Web Frameworks Comparison: Spring MVC, Grails, Vaadin, GWT, Wicket, Play, Struts and JSF

3. Ease of Use

This section is all about how easy it is to pick up a framework for the first time and play with it, learn and get results. Think of it this way: if you gave one of these frameworks to a colleague, how many questions would you have to answer for them? The quality of documentation is always useful, but if you have to refer to the docs, have you already lost the battle?

Spring MVC

Spring is extensive to say the least and, as a result of that, is not particularly easy to just pick up one day and use. In order to take advantage, you need to know how Spring as a whole works, which is its biggest caveat. There are a lot of online tutorials and documentation pages as well as the Petclinic sample application that you could strip down and use as a base, but, overall, Spring is for building serious applications with solid foundations, rich user interfaces and a RESTful API, which makes it completely unnecessary for anything significantly simpler than that.

Score: 3/5 — Spring knowledge needed. Plain JSP & Controllers do not provide usable, out-of -the-box components and widgets.


Grails

Grails is designed to be a rapid development framework and rapid is a direct consequence of ease of use. It is advocating convention over configuration and doing it right. Extensibility is very simple when using plugins (there is a lot of them). One command in the console – and all the dependencies and configurations are managed for you.

One downside is that you need to get familiar with Groovy when you learn how to use Grails. But it shouldn’t be a big problem since Groovy is so Java-like anyway.

Score: 4.5/5 — Designed to be easy to use without any complex configuration, and Groovy should be more or less easy for Java devs.


Vaadin

Vaadin takes away the bulk of the GWT boilerplate code away from the developer, so that the code looks a lot neater. A great feature for ‘ease of use’ is the design mode. The design view allows us to drag and drop components onto a canvas and provide the logic code behind each component. The code which creates and sets up the UI for each component is created for us, magically, which we can see back in the source view. There are also many videos and documentation pages set up for new users to ease the new user learning curve. These really do take you by the hand and get you up and running. If you’re not using the design mode, the code can get a little hairy but not too bad. Also visualising your changes in the runtime can often be a bit slow.

Score: 4.5/5 — Super easy to use, particularly from the design mode. The Vaadin directory also helps. If you run into problems, you have plenty of support around to help out.


GWT

Whether you’re a coder or a designer, GWT has a good, fairly straightforward structure. The component structure for the coders out there are easy to work with and the widget options are numerous. The code is easy to read, modify and reuse, and if you are already familiar with client-side storage that is easy to work with as well, the only problem is, there’s so much of it. The code is incredibly similar to JavaScript (it does translate it to JavaScript at compile time after all) so if you’d need to be familiar with it to develop quickly.

GWT Designer, while not for everyone, is a powerful bi-directional Java GUI designer that lets you create user interfaces with tools for intelligent layout assist, drag-and-drop, and automatic code generation.

Score: 4/5 — Code is easy to read and write and there’s a Design mode is there for the non-coders.  Client side storage is a little hard to grasp if you haven’t used it before.

What if you no longer had to redeploy your Java code to see changes? The choice is yours. In just a few clicks you can Say Goodbye to Java Redeploys forever.

Wicket

Wicket keeps things simple – it lets Java developers do what Java developers do best: Java. There is a clear separation of markup (HTML/XML) and logic (Java code) which lets your Java devs worry about the Java and your web designers make changes to the markup templates of an application without worrying about breaking everything (and a huge sigh of relief just sounded from the design corner).

Wicket is also designed to do a lot of the heavy lifting for you, so boilerplate and repetitive code is kept to a bare minimum. View Components can be easily generated from metadata such as annotated “bean” classes and there are built-in utilities in extension modules that allow the developer to bind these components to back-ends.

Score: 3.5/5 — HTML and Java code focused, no need for silly configuration files.  Model inheritance can be a little hard to grasp initially.


Play

Play is really simple to get started with, however it’s very complex for a developer to take full advantage. One of the best things about Play is the ability to go from zero knowledge of the framework to leveraging some of the more basic capabilities in less than 10 minutes. Features like scaffolding and native JSON processing are immediately available to even the most eager developer, while features like asynchronous calls through Akka Actors may require a bit more research into the documentation.

There are a few knocks against Play in the Ease of Use department; the most obvious learning curve issue with Play is integrating it with your existing build tools and environment. Play tries to provide an entire ecosystem by itself, which can make it very non-trivial to swap items for your existing pieces of infrastructure and tooling, using SBT instead of Maven or Ant for example. The other potential issues with Play in terms of usability are backwards compatibility with existing code bases built on previous versions of Play and Akka Actors. The Play migration guide is very comprehensive for migrating 2.0.x applications to 2.1.x versions of the framework, however migrating a version 1.x application to 2.x is not for the faint of heart.

Score: 3.5/5 — While simple to get started, the two things that really keep Play from being really easy to use are the complete backward incompatibility between versions and the requiring Scala to use templates.


Struts

Struts is definitely not the easiest to use. Let’s say you need to implement a new business spec with simple CRUD operation over an entity. You need to create actions with probably different action results, URL mapping/page navigation configurations in XML, form beans classes with their validation configurations in XML and finally, the view templates. Good luck with all that. Don’t forget that you need to make sure that all of the names match in classes/configurational files/views. Compiler won’t do that for you.

Score: 3/5 — Lots of classes/configuration files needs to be written for a single component.


JSF

JSF tries to provide an easy to use framework for creating reusable web components in your Java applications without a large learning curve. JSF 2.2 was recently ratified and released as part of the Java EE 7 specification. JSF is very easy to get up and running and often does not require extra downloads or configuration as the necessary code is bundled in any Java EE compliant application server. Assuming it’s not enabled already, getting JSF support in your application server can be as simple as enabling a checkbox. There are several great tutorials for JSF, some written by Oracle and others by third parties (MyFaces and others).

JSF can be a little confusing at times however, Java EE can be overwhelming and incredibly useful features can seem obtuse or obfuscated by poor documentation or easy to miss in the corpus that is the body of Java EE features. Documentation for JSF is often incredibly specific to certain tailored environments, and straying from the happy path often leads to frustration and woe for hopeful and aspiring Java EE developers.

Score: 4/5 — JSF’s tooling makes it easy to use and there are no external dependencies as long as you stay within the Java EE ecosystem, which JSF leverages well. There are also several built in components that provide tremendous benefit and some third party component libraries that look great.

 

web-frameworks-ease-of-use

Framework Score

Grails

4.5

Vaadin

4.5

GWT

4

JSF

4

Wicket

3.5

Play

3.5

Spring MVC

3

Struts

3



DOWNLOAD THE PDF