SPRING IS HERE!
We are delighted to announce the arrival of the
Spring Framework 1.0 Final Release
Thanks to all contributors and early adopters that have followed our 1.0 milestones and release candidates: Spring wouldn't be as mature as it is without you!
Read more here
Spring at OrlandoJUG
Spring is a layered Java/J2EE application framework, based on code published in Expert One-on-One J2EE
Design and Development by Rod Johnson (Wrox, 2002).
Keith Donald talked about Spring and the benefits of IoC as well as integration with other
J2EE technologies, including Struts, Hibernate, and EJB. Read more here
Spring at BeJUG
-- Alef Arendsen presented the Spring Framework at the
March 4th "Java Web Development" workshop at BeJUG in Brussels.
Read more here
You can use all of Spring's functionality in any J2EE server, and most of it also in non-managed environments.
A central focus of Spring is to allow for reusable business and data access objects that are not tied to specific
J2EE services. Such objects can be reused across J2EE environments (web or EJB), standalone applications, test
environments, etc without any hassle.
- Powerful JavaBeans-based configuration management, applying Inversion-of-Control principles. This makes
wiring up applications quick and easy. No more singletons littered throughout your codebase, no more arbitrary
properties files: one consistent and elegant approach everywhere. This core bean factory can be used in any
environment, from applets to J2EE containers.
- Generic abstraction layer for transaction management, allowing for pluggable transaction managers, and making
it easy to demarcate transactions without dealing with low-level issues. Generic strategies for JTA and a
single JDBC DataSource are included. In contrast to plain JTA or EJB CMT, Spring's transaction support is not
tied to J2EE environments.
- JDBC abstraction layer that offers a meaningful exception hierarchy (no more pulling vendor codes out of
SQLException), simplifies error handling, and greatly reduces the amount of code you'll need to write.
You'll never need to write another finally block to use JDBC again. The JDBC-oriented exceptions comply to
Spring's generic DAO exception hierarchy.
- Integration with Hibernate, JDO, and iBATIS SQL Maps: in terms of resource holders, DAO implementation
support, and transaction strategies. First-class Hibernate support with lots of IoC convenience features,
addressing many typical Hibernate integration issues. All of these comply to Spring's generic transaction
and DAO exception hierarchies.
- AOP functionality, fully integrated into Spring configuration management. You can AOP-enable any object managed
by Spring, adding aspects such as declarative transaction management. With Spring, you can have declarative
transaction management without EJB... even without JTA, if you're using a single database in Tomcat or another
web container without JTA support.
- Flexible MVC web application framework, built on core Spring functionality. This framework is highly configurable
via strategy interfaces, and accommodates multiple view technologies like JSP, Velocity, Tiles, iText, and POI.
Note that a Spring middle tier can easily be combined with a web tier based on any other web MVC framework,
like Struts, WebWork, or Tapestry.
Spring's layered architecture gives you a lot of flexibility. All its functionality builds on lower levels. So you can e.g. use the
JavaBeans configuration management without using the MVC framework or AOP support. But if you use the web MVC
framework or AOP support, you'll find they build on the configuration framework, so you can apply your knowledge
about it immediately.