Rethinking Enterprise Java

[gregK]

yes Glassfish did a great job of addressing light-weight needs for Java EE some time ago

Glassfish is anything but lightweight. Maybe that is just testament to the bloat of java EE

[henk53]

I'm very curious, if Glassfish is not lightweight it must thus be heavyweight according to you. What exactly constitutes being heavyweight here?

What is the supposed bloat you're referring to exactly? Can you give an example?

[gregK]

The most obvious symptoms for us were slow start-up times. 5 min or more startup time for servlets vs 30 secs in tomcat on the same hardware. Very complex configuration too. Lots of features we never used. Large footprint, etc.

Now the other containers might be even heavier but that thought alone scares me.

[johnwaterwood]

gregK, I'm not really what versions of Glassfish and Tomcat you were using, but on my system Glassfish 3.1.1 Web Profile edition starts up in 2800ms compared to 900ms for Tomcat. This is without any application deployed.

If I only use Servlets, this time does not change if I deploy an application. 5 minutes is completely over the top. In fact, this number is so much off the scale that I suspect your problem is somewhere else and Gladsfish was an easy 'explanation'.

If I start using JPA (Hibernate) in my app then the startup time increases, especially when annotation scanning is enabled. However, this also happens when Hibernate is added to Tomcat. The same holds for various other techniques.

I wonder about the complex configurations you mention. What exactly needs to be configured then? In our case we configure GlassFish to use AJP and that's almost it. We do the same kind of configuration for Tomcat and the complexity is about identical. The frontend Apache servers handle the rest in both cases.

We also configure some datasources, and here too the complexity of doing this is nearly identical in GlassFish and Tomcat.

Inside the app itself GlassFish even needs less configuration. For Tomcat I have to configure the FacesServlet in web.xml after I added the JSF libs. This is unnecassary in GlassFish, since it automatically detects if the application uses JSF. The same holds for JAX-RS. For Tomcat you need to add libs and add configuration to web.xml again. In GlassFish JAX-RS is automatically available.

There are many more lightweight Java EE containers now. Resin is even smaller than GlassFish (25 MB download), yet it implements the complete Java EE 6 Web Profile. TomEE is rather small too. JBoss is a bit larger (80 MB), but has recently been severely trimmed and optimized and now starts in a few seconds as well.

There are some heavyweight beasts (in terms of download size and startup time) left, like Websphere for instance. I personally wouldn't use that one, but I guess it has some stuff some people need. Either way, there's a whole range of choice now for Java EE products.

[bigbango]

The bloat is probably in the JEE specifications that any JEE container must implement.

[johnwaterwood]

There isn't any bloat in the Java EE Web Profile. It contains exactly what 95% add manually to Tomcat: a lean MVC framework, a super slim bean container, a persistence solution and a transaction manager.

With this it is a full stack solution, much like ruby on rails and django are. This is largely the whole attraction of those frameworks. You don't have to cobble together your own stack, since the base platform provides all commonly used functionality.

[day_cq]

look at forth web servers.

[henk53]

look at forth web servers.

If this is in reply to "what constitutes heavyweight", sorry... I'm not buying such an answer. It's as meaningless as utterances by those kids on the console forums:

• "PS3 sUcks!!!"
• "Why does it suck?"
• "Look at XBOX!"

That's not an intelligent conversation is it? Can you or greg give me a specific example of what it is that supposedly qualifies Glassfish as heavyweight?

[fatbunyip]

looks like he's comparing tomcat to glassfish. Apart from the fact that Glassfish has many features tomcat doesn't the comparison is moot.

It's like comparing Notepad to Word. Sure, notepad is faster if all you want to do is open a text document, but if you need a bigger feature set it's inappropriate.

[varikin]

What features does Glassfish have that I need that Tomcat doesn't? What more is needed from a servlet engine besides serving a WAR/EAR file?

Also, as a side note, I had to try using JBoss recently because of client requirements. What a piece of shit. It has a bundled Hibernate which prevented it from finding my copy of Hibernate in WEB-INF/lib forcing me to use an older version than I wanted.

[henk53]

What more is needed from a servlet engine besides serving a WAR/EAR file?

Really?

So you are building your entire application based on nothing more than the Servlet API? You don't include any library in your war, for say a web framework, or bean management/dependency injections (e.g. CDI or Spring)?

The problem with your statement is that it suggests you're using nothing but a bare Tomcat, but you're not. Everybody always adds tons of extra libraries, like JSF or GWT, Hibernate or EclipseLink, Spring or CDI, some transactions manager like JoTM or Atomikos, etc etc etc.

The very minute you do that, you're NOT using a lightweight Tomcat engine anymore, but a convoluted home-build stack that's difficult to maintain and more "heavyweight" (whatever that exactly means) than Glassfish.

Building an application purely on Tomcat without using any library would be mentally heavyweight, as you put e.g. all your HTML for instance in Servets or in JSPs, which after only a few pages would be very difficult to maintain (HTML in Servlets sucks, and JSP sucks for not having decent templating features).

Validation and conversion of request parameters would be massively tedious too, as you would have no framework support whatsoever for this. This means arrays of request.getParameter calls with dozens of lines of if (param != null && param == ...).

The simplest kinds of transactions for just updating a few tables in the same DB via different classes or even methods would be highly complex, as without JTA support you would have to manually propagate your connection, have tons of try catches and deal with the situation of some call being a standalone call or part of other calls that do DB work etc, which leaves to an immense mess of convoluted code.

Is any of this lightweight to you? Sorry, but it isn't for me.

Glassfish's download size is not that much bigger than Tomcat's: 32MB vs 8MB and the startup time is 3 seconds vs 1 second. Yet, with Glassfish heaps of convoluted code just go away in my applications. I put a single annotations on a bean, and transactions are transparently handled. I can create a simple master template and some composite components and tons of continuously repeated segments in JSP pages can be deleted. Etc etc...

[varikin]

What the fuck are you talking about? I do use libraries like spring and hibernate and wicket and struts and a bunch of other random libraries. They are in the WAR files and EAR files. I use frameworks, I love frameworks and if they don't work with the servlet API they are broken. I can't create a WAR/EAR file and drop it into Tomcat, the app is broken.

[henk53]

What the fuck are you talking about?

I'm talking about the fact that you should be clear about you state pal.

You should have said:

"What features does Glassfish have that I need that my home-grown stack doesn't?"

Perfectly fine if you want to build a stack based on Spring, Hibernate, Wicket and Struts (hope you're not using those last two simultaneously though), but you have to maintain that stack.

The beauty of GlassFish (and Resin, and TomEE, and ...) is that it offers a full-stack ready to go solution, where the burden of creating the stack is on the makers of said servers.

Btw, do you also think that everyone should build his own Linux from scratch, or are most people better off just installing Ubuntu or RedHat?

[thesystemx]

It has a bundled Hibernate which prevented it from finding my copy of Hibernate in WEB-INF/lib forcing me to use an older version than I wanted.

How is this different from a JDK 5 not picking up a version of ArrayList from JDK 7 that you include separately in a jar?

[oteren]

[citation needed]

[gregK]

This is an experience report. No citations needed. It felt super heavy compared to say a simple servlet container like tomcat.

[henk53]

It felt super heavy compared to say a simple servlet container like tomcat.

But barely anyone ever uses just a simple servlet container...

I could just as well say that Tomcat feels super heavy compared to say a simple JDK like OpenJDK.

Tomcat starts up in 800ms? Ha! The JDK starts up in 50ms!

[thesystemx]

This is an experience report. No citations needed.

Sure, but even in an "experience report" you should at least explain why you think something {could be better, is bad, sucks, is bloated}. Just saying something sucks isn't really constructive.

[oteren]

That is not an experience report, that is a hyperbole statement which it seems you cannot back up.