After reviewing the example that Chris provided I wanted to take things s step further and integrate Hibernate and MySQL into the project. I wrestled with the JAR’s, the classpath, the Spring and Hibernate XML markup, and the Hibernate Annotations for a while and then realized that I needed to get a firm understanding of some Spring fundamentals. Manning’s Spring in Action was recommended by a colleague and so far has been really shedding some light.

I was able to create a simple Spring project (no Flex, no BlazeDS, no Hibernate… yet) to help me understand some of the core Spring concepts. The IoC Container and AOP are two very important pieces of the Spring framework. This very simple project only utilizes the IoC Container. Aspect Oriented Programming is very cool and I also recommend checking it out. AOP is not covered in this example. (Check out cross cutting concerns.)

There is a simple Ant task to compile, jar and run the application. You’ll also need the latest version of the JDK for this application.

You can download the project using a Subversion client using the following URL:

http://seantheflexguy.com/applicationcontextex/

You can also download a zipped version of the project here:

http://seantheflexguy.com/java/ApplicationContextExample.zip

To run the project navigate to the directory where you downloaded the project, and extracted if you grabbed the zip. Then from the project root using a Terminal or Command Prompt issue the command: ant to compile and: ant run to run the application.

The first version of the application used a BeanFactory. This second version uses the ApplicationContext class instead. BeanFactory is in Spring’s core module, it’s the main Spring container that provides DI. The ApplicationContext module builds on BeanFactory providing additional capabilities such as: internationalization and validation support and access to the application event lifecycle.

The Simple Spring Example Project should help you understand the most basic level Spring mechanics. The only JARs required by the project are spring.jar and the commons-logging-1.1.1.jar, both are included with the project. The Ant build file will set the CLASSPATH for these JARs, if you bypass Ant make sure to set these on the CLASSPATH prior to compiling the application.

So far Spring really looks like a powerful way to organize and manage Java application development. You should take a moment to check it out. Also be sure to check out the Spring BlazeDS Integration.

Some items we’ve covered in the Java class so far are: SDK installation and command line compilation, data types, control flow, variables/operators, numbers, arrays, objects and classes, static classes and methods, method overloading, object construction, constructor overloading, OOP basics, packages, commenting, generating JavaDoc, inheritance, abstract classes, polymorphism, sub/superclasses, reflection, inner classes, graphics programming, event handling, Swing and Collections including Maps, Lists, Sets and the Comparator interface. We’re compiling all of our homework using the command line. It’s pretty cool. The class also demands a pretty rigorous reading schedule. The three-pronged-learning-approach is working well for me: lectures, reading, coding (homework and labs.) The ins and outs of the language are really sinking in.

A few immediate benefits to learning more about Java are: Flex and BlazeDS / LCDS integration, strengthen fundamental OOP understanding and comprehension and also gain knowledge of OOP concepts not available in Flex/AS3. Learning Java also provides the opportunity to get exposure to Swing (Flex’s distant relative). Also, since the Flex compiler and other aspects of the Flex SDK are written in Java this opens up the door to greater understanding of the Flex SDK and even bug contributions. Java makes extensive use of design patterns and there is a plethora of existing Java code to look at, use and learn from. (Cairngorm was born from J2EE design patterns.)

There are several differences that I noticed in Java. Some items available in Java and not in AS3: static classes, abstract classes, private constructors, constructor overloading, method overloading and Collections. Working with Arrays is a LOT different, working with numbers is different, working with Strings is different and String comparison is different. There are no Hashmaps and no hashcodes in ActionScript. No equals() method. Another difference is that you have to implement your own design patterns more often in Java. Not a bad thing, and good to know how to do, but Flex takes care of a lot of things behind the scenes: events, data binding etc. I noticed that when coding Java the developer is expected to implement interfaces more often than in Flex/AS3. This is pretty cool; it involves more work but provides more power.

It’s been a cool experience and I wanted to share some of these thoughts and observations. I think more developers come into the Flex world from Java vs. the other way around. For some reason Java sort of reminds me of AS2… I may try to post some Java source code soon if time permits…