Spring3.0 Framework Architecture (Modules)


The Spring Framework consists about 20 modules. These modules are  grouped into following:
  • Core Container
  • Data Access/Integration
  • Web
  • AOP (Aspect Oriented Programming)
  • Instrumentation and
  • Test
We can see all these modules in the following diagram.


Core Container
The Core Container contains Core, Beans, Context, and Expression Language modules.

 Core: Core is a fundamental parts of spring framework. It consist IOC and Dependency Injection features
 Beans: It provides BeanFactory which is implementation of the factory design pattern.
 Context: It is based on the Core and Beans modules. It is used to access objects as like JNDI registry. It supports internationalization (using, for example, resource bundles), event-propagation, resource-loading, and the transparent creation of contexts. The ApplicationContext interface is the focal point of the Context module.
 Expression Language: It provides a powerful expression language for querying and manipulating an object graph at runtime. It is an extension of the unified expression language (unified EL) as specified in the JSP 2.1 specification. It also supports list projection and selection as well as common list aggregations.
Data Access/Integration
The Data Access/Integration layer consists of the JDBC, ORM, OXM, JMS and Transaction modules.

  JDBC: As we know that for core JBDC we have to write lot of codes which are tedious. So to remove the Spring JDBC module provides a JDBC-abstraction layer which is database vendor specific error codes.
  ORM: It provides integration layers for object-relational mapping APIs.
  OXM: It provides an abstraction layer that supports Object/XML mapping implementations for JAXB, Castor, XMLBeans, JiBX and XStream.
  JMS: Java Messaging Service module contains features for producing and consuming messages.
  Transaction: This module supports programmatic and declarative transaction management for classes that implement special interfaces and for all your POJOs (plain old Java objects).
Web
The Web consists of the Web, Web-Servlet, Web-Struts, and Web-Portlet modules.

  Web: This module provides basic web-oriented integration features such as multipart file-upload functionality and the initialization of the IoC container using servlet listeners and a  web-oriented application context.
  Web-Servlet: This module contains Spring's model-view-controller (MVC) implementation for web applications.
  Web-Portlet: This module provides the MVC implementation to be used in a portlet environment and mirrors the functionality of Web-Servlet module.
  Web-Struts: This module contains the support classes for integrating a classic Struts web tier within a Spring application.
AOP and Instrumentation
Spring's AOP module provides an AOP Alliance-compliant aspect-oriented programming implementation allowing you to define, for example, method-interceptors and point cuts to cleanly decouple code that implements functionality that should be separated.

Aspects
Aspects module is a separate module which provides integration with AspectJ.

Instrumentation
This module provides class instrumentation support and class loader implementations to be used in certain application servers.

Test
The Test module supports the testing of Spring components with JUnit or TestNG. It provides consistent loading of Spring ApplicationContexts and caching of those contexts. It also provides mock objects that you can use to test your code in isolation.

2 comments :

  1. It is a good tutorial....but u should have go through in depth...

    ReplyDelete
  2. thanks for feedback,in this tutorial only overview is given, in next post explain in depth.

    ReplyDelete