An introduction to the AppFuse project, which provides an almost-turnkey web application environment, based on popular open source tools.
AppFuse is a web application to accelerate developing J2EE web applications. It's based on open source tools such as Hibernate, Spring, and Struts. It also provides many out-of-the-box features such as security and user management. Creator Matt Raible provides an overview
of its history and features.
One of the hardest parts about J2EE development is getting started. There is an
immense amount of open source tools for web app development. Making a decision
on which technologies to use can be tough -- actually beginning to use them
can be even more difficult. Once you've decided to use Struts and Hibernate, how
do you go about implementing them? If you look on the
Hibernate site or the Struts site, you'll
probably have a hard time finding any information on integrating the two. What if
you want to throw Spring into the mix? As a developer, the best way for me to learn is
by viewing sample apps and tutorials that explain how to extend those applications.
In order for me to learn (and remember) how to integrate open source technologies
such as Hibernate, Spring, Struts, and Ant/XDoclet, I created AppFuse. The beauty
of AppFuse is you can actually get started with Hibernate, Spring, and Struts without
even knowing much about them. Using test-driven development, AppFuse and its tutorials
will show you how to develop a J2EE web application quickly and efficiently.
The Birth of AppFuse
In early 2002, I managed to land a contract where I was the lone developer. I
was responsible for everything, from gathering requirements to database creation
to DHTML on the web front end.
While I'd done a lot of front-end work (Struts, HTML, etc.) over the years,
the business layer and persistence layer were mostly new to me. So I searched
and searched for J2EE patterns to do things the "right way" for my new client.
I ended up implementing Business Delegates, DAOs, and ServiceLocators -- many
of them modeled after J2EE Blueprints. Towards the end of that contract,
contracted to help write a book on JSP 2.0. The publisher was Wrox Press
and the book was Professional JSP 2.0. I
to write two chapters -- one on Struts and one on web security. Note:
in March 2003, Wrox went out of business and this book eventually became
JSP, Third Edition , published by Apress .
When you write a technical book, it's helpful to use a sample app to demonstrate
concepts. I was tired of reading books that had a throwaway sample app,
so I wanted to develop something meaningful; something I could use after
I was done writing. My initial thoughts were to write an application that
would help you get started with Struts, and would use XDoclet to do a lot
of the heavy lifting. It also had to have a lot of security features so I could
use it for my chapter on web application security. I came up with the name
developing my application .
After a couple of weeks, I decided that "
struts-xdoclet" was too hard to
renamed the project AppFuse . I developed the sample app for my Struts
chapter using AppFuse and
released it as Struts Resume . After publishing Struts Resume, I needed to
extract the resume-specific stuff out of it to revert back to the generic "jumpstart" application
I wanted AppFuse to be. It took me almost three months, but I finally
released the first official version of AppFuse in April 2003.
Since its initial release, AppFuse has gone through many changes and improvements.
Most of the technology decisions were made from experience. It was a pain
to keep my ValueObjects (VOs) and ActionForms in sync, so ActionsForms
are generated using XDoclet. I found it tedious to write JDBC and more tedious
to update SQL and VOs when adding new table columns. To solve this, I chose
to use Hibernate for persistence and use Ant/XDoclet to dynamically create
my database tables. Rather than lose my tables' data each time, I integrated
DBUnit, which also came in handy when running unit tests. I decided to use
Tomcat/MySQL as the default server/database setup because I was most familiar
with them. I integrated a plethora of unit/integration tests so I could make
sweeping changes and verify that everything still worked (including the JSPs)
In March of 2004, I moved the AppFuse project from the
Struts project on SourceForge to java.net .
I had a
couple of reasons for doing this. First of all, it was a sub-project on
SourceForge, and its user base was growing quickly. It needed dedicated mailing lists
and forums. Secondly, java.net seemed to do a better job of marketing projects and
I'd heard their CVS system was much more stable. My experience at java.net has
been quite nice: it's a very stable system, and the administrators are very supportive
of the project and have even helped with marketing it.
What is AppFuse?
So after all that history, what is AppFuse?
At its very core, AppFuse is a web application that you can package into a
.war and deploy to a J2EE 1.3-compliant app server. It's designed to help you
create new web applications using a
new target in its build.xml file.
new target allows you to specify a name for your project and
a name for the database it will talk to. Once you've created a project, you
can instantly create a MySQL database and deploy it to Tomcat using
. Furthermore, you can verify that the basic functionality
of your new application works by running
At this point, you might sneer and say, "What's the big deal? Anyone
can create a .war file and deploy it to Tomcat." I agree, but do you
target that will configure Tomcat with JNDI
resources for connections pooling and mail services? Most of what AppFuse
does is not rocket science. In reality, it's nothing more than a directory
structure, a build file, and a bunch of base classes -- with a few features
thrown in. However, it has vastly accelerated my ability to start projects
and develop high-quality, well-tested web applications.
AppFuse tries to make it as simple as possible to build, test, and deploy your
application. It virtually eliminates setup
and configuration, which are often the hard parts.
Tools like Ant, JUnit, XDoclet, Hibernate, and Spring can
be difficult to get started with. Furthermore, features like authentication,
password hints, "remember me," user registration, and user management are things
that most web apps need. AppFuse ships with
developing DAOs, business delegates, Struts actions (or Spring controllers),
integrating tiles and validation, and uses an Ant-based XDoclet task
(written by Erik Hatcher) to generate master/detail JSPs from model objects.
It uses slick open source tag libraries like Struts
Menu (for navigation) and the Display
Tag (for paging and sorting lists).
One of the best parts, in my opinion,
is that it embraces the Java community's ideas and suggestions. The directory
structure and build file are largely based on Erik Hatcher and Steve Loughran's
excellent Java Development with
Ant book. In this book, Erik built a
application that inspired me to learn more about Ant and XDoclet -- and
use it in my Struts development.
When I first started learning and using Hibernate in
AppFuse, I made many mistakes -- and the community let me know. At first,
I opened and closed its Session object for each DAO method. When Gavin told
me this was a bad idea, I made modifications to use an OpenSessionInView
pattern, with my own ServletFilter to do the work. I passed the session
object into each method signature, for which the community repeatedly questioned
my logic. My answer was, "I wanted to get it working more than anything
-- do you have a better idea?" The better idea turned out to
be using the Session as a constructor argument, which worked pretty well.
Then, late last year, I discovered the
Spring framework and found the beautiful solution I'd been looking for.
Using its ORM support, I was able to eliminate any Session handling in
AppFuse; now Spring elegantly handles it all. AppFuse now uses Spring's
OpenSessionInViewFilter. All I needed to do was configure it in web.xml
and it manages opening and closing the session for me. When I integrated
Spring in AppFuse's persistence layer, I deleted two or three classes and reduced
my LOC count by around 75 percent. All of the Hibernate issues I'd had before
disappeared! In addition, I was quickly able to add a DAO implementation
using iBATIS, which I worked with on a project last year. On that project,
I discovered that iBATIS was easy to use and worked very well for interacting
with complex database schemas.
AppFuse is not only a jumpstart kit for your web apps; it's also a showcase
for integrating technologies like Hibernate, Spring, and Struts. Tutorials
exist for integrating these different open source components, but rarely
do they give you an application you can walk away with and use to develop
your next application. In a sense, AppFuse is a glue that binds open source
projects together. When I found Spring, it was a perfect fit, since it was
the glue to configure components and loosely couple the different layers
of an application. Erik's book might have been the match that lit AppFuse,
but Spring is the gasoline that really got it roaring. Spring has vastly
simplified how I develop with AppFuse and forced me to follow best practices
in J2EE. In short, it's the best tool I've ever used with J2EE. I realize
Spring is not the be-all-end-all for J2EE applications -- AppFuse worked fine
before I integrated it. However, it helped answer all of my "How should
I do ..." questions -- which was a nice relief.
What Does the Future Hold?
AppFuse 1.5 was released at the end of May. Its major feature is the option
to use Spring MVC instead of Struts. All of the tutorials have been updated
to educate users how to use Spring (or Struts) for their web layers. For AppFuse
1.6, I plan to add support for using WebWork and SiteMesh, as well as make
it easier to run unit tests from Eclipse and IDEA. By the end of the year,
I hope to add Tapestry and JSF as MVC options. The middle tier and back end
(Spring plus Hibernate) probably won't change much. It's a well-oiled machine
at this point. This isn't to say that I think AppFuse is perfect. I hope
I continue to receive valuable feedback and suggestions. After all, this
is the driving force behind improving its quality.
When I find innovative and easier ways to develop web apps, it ends up in AppFuse.
People ask me why AppFuse doesn't support
The reason is simple: I've never used or needed Middlegen on a project,
so I don't see any reason to add it. If I end up on a project where I use
Middlegen, you can bet I'll end up adding support for it. Recently, I started
using Spring's MVC framework instead of Struts. At first, I found it a bit
difficult to understand, so I implemented the web layer with Spring MVC.
Since the web layer contains many features that I use in web apps (i.e., templating,
validation, file upload, and exception handling), I learned the ins and outs
of Spring MVC by integrating it.
Using and learning AppFuse is a good way to keep up to date with the latest
releases of its dependent projects. I try to keep as up to date as possible
with new releases -- and due to AppFuse's unit test coverage, I can easily test
new releases by dropping them in and running
This even works for dependent resources such as Tomcat and MySQL, in which I've
found bugs via AppFuse. For me, it acts as a testing tool to verify the
functionality of new open source releases.
Equinox is a lightweight version
of AppFuse; hence its pseudonym "AppFuse Light." I was inspired to create it
when looking at the
webapp-minimal applications that ship with Struts and Spring,
respectively. These "starter" apps were not robust enough for me, and I
wanted something like AppFuse, only simpler -- with no build-time dependencies.
It's designed to show web app developers how to start a bare-bones Struts/Spring/Hibernate
app using the QuickStart Chapter in Spring Live . More functionality may be
added in the future, but the main goal is to provide a better implementation
of a bare-bones web app.
Equinox should mostly be used for writing tutorials and rapid prototyping.
I don't recommend using it for starting a full-fledged production application.
That's what AppFuse is for.
How Do I Start Using It?
The best way to get started using AppFuse is to
and read the QuickStart
Guide . AppFuse is a part of the Java
Enterprise Community on java.net. Its project homepage is at
If you're interested in Equinox, you can read the
QuickStart Chapter from Spring Live to build a quick and
easy application using Struts, Spring, and Hibernate.
If you like, you can view a demo of the MyUsers application that this chapter helps you build.
Equinox is a sub-project of AppFuse on java.net. Its project homepage is at