Welcome to the home of the Spring Framework. As the leading full-stack Java/J2EE application framework, Spring delivers significant benefits for many projects, reducing development effort and costs while improving test coverage and quality.
Spring is the full meal deal for those of use who love to develop web applications. It can also easily be used in stand-alone (outside of the web envrionment) for client apps.
At the core of Spring development are Spring Beans, which are POJO's along with some XML describing them. Beans are the essentially the Spring plug-in mechanism. One of the nice things is that spring comes out of the box with a huge of beans for doing various things: JMX,JDBC,Web Services, etc...
Spring also offers the WebMVC framework. Those who are familiar with struts should feel right at home with WebMVC. It is the Spring Model-View-Controller framework for building views. And before you ask "Why not just use Struts?", I have found WebMVC to be less verbose and more intuitive then Struts. But for all you Struts lovers out there, Spring contains support for integrating with Struts.
Enough talk, lets SPRING into action (Sorry I had to).
As stated before, everything in Spring is a bean. A bean consists of a POJO and some XML describing it. Lets create some beans for our Service example.
That was easy, onto the client which will make use of the Spring WebMVC framework.
This document is not intended to be an introduction to WebMVC. It is recommened that you read this tutorial before continuing on.
The client will be a simple controller that performs the following task:
When a http request comes in, the url of the request is used to locate a particular service. If a service is located then the service outputs its capabilities document, otherwise an error is output.
Like everything else in Spring, the controller is a bean. The controller will need access to the wms and wfs (and any other service) beans. Therefore it must implement the org.springframework.context.ApplicationContextAware interface. This interface gives a bean access to its context, which in turn gives it access to other beans as shown below.
Being a bean, we need to describe the controller with some xml.
We need to link our controller to a url. This acheived with the following bean declaration.
The final set of bean delcarations is placed in a file called 'example-servlet.xml'. It is called the application context and follows the Spring naming convention.
And the final step is to set up a dispatch servlet, that will do the above mapping. The servlet is declared in a standard web.xml web application descriptor.
And that is it, we should be ready to roll. Download example.war and drop into your favorite servlet container. Try out the following:
This of course assumes your servlet container runs over port 8080.
Enough about the technology, lets apply our criteria.
To be done...
Spring IDE is a graphical user interface for the configuration files used by the Spring Framework. It's built as a set of plugins for the Eclipse platform.
This is one of the main pros of Spring. It claims to be powerful and complete, yet light and flexible enough to be used with or without other technologies and containers.
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 across J2EE environments (web or EJB), standalone applications, test environments, etc without any hassle.
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.
To be done...