Group items tagged

The discussion whether or not to use Spring vs. Java EE for new enterprise Java applications is a no-brainer

Why migrate?

since then fallen a prey to the hungry minds of Venture Capitalists and finally into the hands of a virtualization company called VMware

While the different companies and individuals behind the Spring framework have been doing some work in the JCP their voting behavior on important JSRs is peculiar to say the least

outdated ORM solution like JDBC templates

some developers completely stopped looking at new developments in the Java EE space and might have lost track of the current state of technology

size of the deployment archive

fairly standard Java EE 6 application will take up about 100 kilobytes

comparable Spring application weighs in at a whopping 30 Megabytes!

Lightweight

Firing up the latest JBoss AS 7 Application Server from scratch and deploying a full blown Java EE 6 application into the server takes somewhere between two and five seconds on a standard machine. This is in the same league as a Tomcat / Spring combo

Dependency injection

Java EE 6, the Context and Dependency Injection (CDI) specification was introduced to the Java platform, which has a very powerful contextual DI model adding extensibility of injectable enterprise services

Aspect Oriented Programming

“AOP Light” and this is exactly what Java EE Interceptors do

common pitfall when taking AOP too far is that your code might end up all asymmetric and unreadable. This is due to the fact that the aspect and its implementation are not in the same place. Determining what a piece of code will do at runtime at a glance will be really hard

Testing

With Arquillian we can get rid of mocking frameworks and test Java EE components in their natural environment

Tooling

capabilities comparison matrix below to map Spring’s technology to that of Java EE

Capability Spring JavaEE Dependency Injection Spring Container CDI Transactions AOP / annotations EJB Web framework Spring Web MVC JSF AOP AspectJ (limited to Spring beans) Interceptors Messaging JMS JMS / CDI Data Access JDBC templates / other ORM / JPA JPA RESTful Web Services Spring Web MVC (3.0) JAX-RS Integration testing Spring Test framework Arquillian *

William Drai

Honestly I don't see any value in switching to CDI if it is

please not this Dao/Template mess

Gavin King

to reproduce the same awful patterns

please not this Dao/Template mess

Because, of course, there are no other well-known patterns for dealing with boiler-plate cleanup code and connection leaks.

This is exactly the kind of

It gives people a

and somehow shuts down their brains so they

It's a very impressive magic trick, and I wish I knew how to do it myself. But then, I'm just not like that. I'm always trying to poke holes in things - whether they were Invented Here or Not.

but that might be too high-level for your taste. Their are other, less-abstract options.

exception handling, this is one area where Spring does a good job: "The Spring Framework's handling of SQLException is one of its most useful features in terms of enabling easier JDBC development and maintenance. The Spring Framework provides JDBC support that abstracts SQLException and provides a DAO-friendly, unchecked exception hierarchy."

Automatic connection closing (and other boiler-plate code) is obviously a hard requirement to be handled by the fwk.

Gavin King

there are a bunch of people

They don't understand, or see the value of, using managed objects to represent their persistent data.

Um. Why? Why would that be a bad thing? I imagine that any app with 1000 queries has tens of thousands of classes already. What's the problem? Why is defining a class worse than writing a method?

GraniteDS does not support the standard Consumer and Producer Flex messaging API

its own client implementations of these classes org.granite.gravity.Consumer and org.granite.gravity.Producer that provide very similar functionality

most advanced features and greatly simplifies asynchronous handling and client data management

preferred for new projects

Server Options

two options

RemoteObject API,

GraniteDS support for externalization of lazily loaded JPA entities/collections, and support for scalable messaging though Gravity

Tide API

full feature set of Tide data management and further integration with data push through Gravity

complete support for Spring and Seam security or integration with CDI events

Tide/CDI/JPA2/Java EE 6 on JBoss 6/7 or GlassFish 3

If you are on a Java EE 6 compliant application server, it is definitely the best option

All managed entity instances are unique in a Tide context

Tide keeps the classic three layers web architecture, when LCDS removes the service layer, and is some kind of remote JPA provider for Flex applications

Tide approach is to minimize the amount of code needed to make things work between the client and the server

principles are very similar to the ones of JBoss Seam, which is the main reason why the first integration of Tide has been done with this framework. Integrations with Spring, EJB 3 and CDI are also available

need to compile your MXML/AS sources with the granite-essentials.swc and granite.swc libraries

3 separate projects: a Java project, a Flex project and a Webapp project.

GraniteDS archetypes

archetypeGroupId: org.graniteds.archetypes archetypeVersion: 1.1.0.GA archetypeArtifactId:

Maven 3.x required

mvn archetype:generate    -DarchetypeGroupId=org.graniteds.archetypes    -DarchetypeArtifactId=graniteds-tide-spring-jpa-hibernate    -DarchetypeVersion=1.1.0.GA    -DgroupId=org.example    -DartifactId=springgds    -Dversion=1.0-SNAPSHOT

cd springgdsmvn clean package

build the project

CDI archetype requires a Java EE 6 server and uses an embedded GlassFish

cd webappmvn embedded-glassfish:run

With the Eclipse Maven integration (the M2E plugin), you can simply choose one of the archetypes when doing New Maven Project.

mvn war:war

two very easy ways to quickly create a new GraniteDS project

@RunWith(Arquillian.class)

JDBC Templates hardly give any abstraction on top of the database and you’re on your own for Object Relational Mapping. We strongly advise to use JPA wherever possible; it gives portability by abstracting most of the database specific SQL that you would need, and it does all the hard and painful work of object mapping

small part of your application