Java web frameworks

Having used struts, wicket, rails & Tapestry, I recommend you look into [Tapestry 5][1].

It supports

- in container class reloading (so you dont have to restart your webapp each time you make a change)
- fast development time & increased productivity - it uses a component based model, with declarative wiring
- minimal configuration, which is mostly in code anyway, convention over config - etc..
- No base classes to extend
- An expression language for use in template files
- good ajax support
- excellent debugging support, both client and server side
- good data access integration
- an active community
- written from the ground up with [performance][2] in mind. e.g. page pooling (to minimise resource usage), page compression, whitespace elimination, all dynamic code is compiled to native.
- good bean and form support - making common tasks simple. A sortable database backed drid can be coded with just one line of template code, and a minimal skeleton server backend.

the only downside is the documentation, which, is good, but a little terse, although the user groups/mailing lists are very active and most questions are answered well & eagerly.

(Also, be sure to only look at T5 - and not T4,3,2,1..... as these are very different to the current version)

More on why [here][3].


[1]:

[To see links please register here]

[2]:

[To see links please register here]

[3]:

[To see links please register here]

[4]:

[To see links please register here]

I discovered Grails about a year ago, and haven't looked back. It takes a lot of ideas from Ruby on Rails (original it was named Groovy on Rails), and has a rich ecosystems of plugins / extensions. Grails, and underlying Grails language (superset of Java) make it a joy to program - you can really focus on the essentials. Its GORM functionality (a layer on top of hibernate) is also very powerful, and in addition to the plugin system, is one of two huge reasons to check it out (you can use it in your java apps as well).

With version 1.2 about to come out, I feel it's feature-rich and mature enough to be something that any developer should have in their toolbelt.

As far as performance, it's definitely less than that of pure Java, but you have everything from spring / hibernate / J2EE available to you to optimize, and you can always drop into pure java for some critical pieces of code. There have been some recent experiments with allowing to run part of the Groovy code using static method resolution, which, coupled with invokedynamic support, should provide huge performance boosts.

Other ones to check out in Java are Spring Roo, and AribaWeb.

**Update Based on Additional Qualifications**

> Scalability, Productivity,
> Documentation, and decent Resources
> consumption

- Scalability - you get the proven Java / Spring / Hibernate stack, though I can't say Grails provides much itself.
- Productivity - this is the main reason to use Grails. You do have a performance overhead, but Grails is what you use when development time / productivity is more important.
- Documentation - the grails docs are great, and there are at least three good books written on Grails alone. The community is thriving and very helpful.
- Resources Consumption - that is the one tradeoff. Grails (partially because of the underlying java stack) is resource-intensive. If I was building something like Google, Grails would not be the choice. However, in any web app of any sophistication, you'd do well for a caching solution, so same applies here.

<a href="http://www.springsource.org/roo">Spring Roo</a> claims to be a solution.

Consider trying [Lift Framework][1]. It`s really great.


[1]:

[To see links please register here]

AribaWeb also supports Groovy. Check out our other features at [

[To see links please register here]

][1] and find out our approach to making web development productive.


[1]:

[To see links please register here]

"AribaWeb"

Anytime you are contemplating an application stack (language, framework, etc...) you also need to consider what are you trying to solve for and what kind of programming skills do you have at your disposal. I've found that more experienced Java programmers have been very productive with the Groovy and Grails stack when compared to more junior programmers.

You mention the following as areas of concern:

- Scalability: in terms of what exactly? (page views/second, # transactions/second, etc...) In general, Groovy & Grails will scale when it comes to rendering pages, however as with any application stack using ORM (in the case of Grails you have GORM) there is some overhead to consider.
- Productivity: one of the primary advantages here - quick prototyping, rapid development is a breeze with Groovy & Grails, though it helps to have folks on staff that have developed in Java or Ruby to understand what the Grails framework is actually doing "under the hood". There are tons of plug-ins for the UI that help with creating web 2.0-like pages very quickly.
- Documentation: there is an increasing number of quality reference books being written for Groovy & Grails. Both are maturing very nicely over the last 2 years. Things are certainly not very well documented with respect to much of the inner working of the Grails framework when errors/issues are encountered (much of the output from the framework is obscure or non-existent at best when an error is faced). If you are willing to roll up your sleeves and be resourceful in walking through the inner workings, then you won't be disappointed with this stack. Again, experienced programmers will find this as second nature while more junior folks may throw up their hands in frustration at times.
- Resource Consumption: there is overhead, however with most of the hardware found today (local or in a cloud) I wouldn't worry too much about physical resource consumption for a given application instance.

Hope this helps.

We use Stripes framework extensively and it works really great. It's really lightweight and it directs you towards a clean design of your applications. It basically just hides the boring parts of development from you, so you can focus on the fun stuff (One such example are the [indexed properties][1]).


[1]:

[To see links please register here]

I've done a project with grails and i've found it really fast for some tasks, but it does many "magic" behind the scenes that makes it difficult when debugging.

Also I found myself reading over and over the documentation because I didn't feel it natural. A simple example is the controller where the action's are defined as fields (It's natural for me to think of an action as a method...). I can say something about GORM where you need to know some special words that when put in static fields does some magic like making a field transient... No annotations, no autocompletition... only the manual.

As for Play! I found it amazingly simple and fast for developing, easy to learn and to remember. The community seems smaller than Grail's but it's more active and faster to answer. The only disadvantage is that it does not rely on servlet's api so some 3rd party filters or other stuff is difficult to integrate but not impossible. It's important to note that you can deploy a Play application in any traditional web server packagin it as a war.

In my opinion Grails is great but you need to have a lot of experience with it to be productive, otherwise you'll lose a lot of time with the manuals. So if that is not your case I should recommend Play! Specially if you are not familiar with Groovy

I have been using

[To see links please register here]

for micro-services and it is very close to most mvc paradigms,if you used rails, asp.net mvc, or nancyfx, you are good to go. It is very close to that philosophy and really awesome and easy to test. Only down-side there isn't much documentation, but it follows mvc pattern pretty closely. It uses nothing proprietary in the framework so it is a pure java based solution. So this makes up for the lack of documentation.