| home / programming / spring |    [previous] [next] |
|
|
|
Spring’s core container provides the fundamental functionality of the Spring
framework. In this module you’ll find Spring’s BeanFactory, the heart of any
Spring-based application. A BeanFactory is an implementation of the factory pattern
that applies IoC to separate your application’s configuration and dependency
specifications from the actual application code.
We’ll be discussing the core module (the center of any Spring application) throughout this book, starting in chapter 2, when we cover bean wiring using IoC.
The core module’s BeanFactory makes Spring a container, but the context module
is what makes it a framework. This module extends the concept of BeanFactory, adding support for internationalization (I18N) messages, application life
cycle events, and validation.
In addition, this module supplies many enterprise services such as e-mail, JNDI access, EJB integration, remoting, and scheduling. Also included is support for integration with templating frameworks such as Velocity and FreeMarker.
Spring provides rich support for aspect-oriented programming in its AOP module. This module serves as the basis for developing your own aspects for your Spring-enabled application.
To ensure interoperability between Spring and other AOP frameworks, much of Spring’s AOP support is based on the API defined by the AOP Alliance. The AOP Alliance is an open-source project whose goal is to promote adoption of AOP and interoperability among different AOP implementations by defining a common set of interfaces and components. You can find out more about the AOP Alliance by visiting their website at http://aopalliance.sourceforge.net. The Spring AOP module also introduces metadata programming to Spring. Using Spring’s metadata support, you are able to add annotations to your source code that instruct Spring on where and how to apply aspects.
Working with JDBC often results in a lot of boilerplate code that gets a connection, creates a statement, processes a result set, and then closes the connection. Spring’s JDBC and Data Access Objects (DAO) module abstracts away the boilerplate code so that you can keep your database code clean and simple, and prevents problems that result from a failure to close database resources. This module also builds a layer of meaningful exceptions on top of the error messages given by several database servers. No more trying to decipher cryptic and proprietary SQL error messages!
In addition, this module uses Spring’s AOP module to provide transaction management services for objects in a Spring application.
For those who prefer using an object/relational mapping (ORM) tool over straight JDBC, Spring provides the ORM module. Spring doesn’t attempt to implement its own ORM solution, but does provide hooks into several popular ORM frameworks, including Hibernate, JDO, and iBATIS SQL Maps. Spring’s transaction management supports each of these ORM frameworks as well as JDBC.
The web context module builds on the application context module, providing a context that is appropriate for web-based applications. In addition, this module contains support for several web-oriented tasks such as transparently handling multipart requests for file uploads and programmatic binding of request parameters to your business objects. It also cotains integration support with Jakarta Struts.
Spring comes with a full-featured Model/View/Controller (MVC) framework for building web applications. Although Spring can easily be integrated with other MVC frameworks, such as Struts, Spring’s MVC framework uses IoC to provide for a clean separation of controller logic from business objects. It also allows you to declaratively bind request parameters to your business objects, What’s more, Spring’s MVC framework can take advantage of any of Spring’s other services, such as I18N messaging and validation.
Now that you know what Spring is all about, let’s jump right into writing Spring applications, starting with the simplest possible example that we could come up with.
In the grand tradition of programming books, we’ll start by showing you how Spring works with the proverbial “Hello World” example. Unlike the original Hello World program, however, our example will be modified a bit to demonstrate the basics of Spring.
NOTE To find out how to download Spring and plug it into your project’s build routine, refer to appendix A.
Spring-enabled applications are like any Java application. They are made up of several classes, each performing a specific purpose within the application. What makes Spring-enabled applications different, however, is how these classes are configured and introduced to each other. Typically, a Spring application has an XML file that describes how to configure the classes, known as the Spring configuration file.
The first class that our Springified Hello World example needs is a service
class whose purpose is to print the infamous greeting. Listing 1.1 shows GreetingService.java, an interface that defines the contract for our service class.
Listing 1.1 The GreetingService interface separates
the service’s implementation from its interface. |
package com.springinaction.chapter01.hello; |
GreetingService interface.
Although it’s not necessary to hide the implementation behind an interface, it’s
highly recommended as a way to separate the implementation from its contract.
Listing 1.2 GreetingServiceImpl.java: Responsible for printing the greeting |
| home / programming / spring | [previous] [next] |
Legal Notices, Licensing, Reprints, Permissions, Privacy Policy.
Advertise | Newsletters | Shopping | E-mail Offers | Freelance Jobs 
Created: March 27, 2003
Revised: March 07, 2005
URL: http://webreference.com/programing/spring/1
