Introduction to Spring Framework

Spring is an open source framework that is created to address the complexities of enterprise application development. One of the main advantages of the framework is its layered architecture, which allows you to choose which components to use while providing an integrated framework for Java EE application development.

In the 1th part of this three-part Spring Series , I'll cover the spring framework. I first describe the framework's functionality from the perspective of the framework's underlying model, and then we'll discuss the two most interesting modules: Spring aspect-oriented programming (AOP) and control inversion (IOC) containers. A few examples are then used to demonstrate the application of the IOC container in a typical application use case scenario. These examples will also serve as the basis for an expanded discussion later in this series, which will explain how the spring framework implements AOP constructs through Spring AOP later in this article.

See download, download Spring framework and Apache Ant, which are required to run the sample application for this series.

Spring Framework

The Spring framework is a layered architecture consisting of 7 well-defined modules. The Spring modules are built on top of the core container, and the core container defines how the beans are created, configured, and managed, as shown in 1.

Figure 1. 7 Modules of the Spring framework

Each module (or component) that makes up the Spring framework can exist separately or be implemented in conjunction with one or more other modules. The functions of each module are as follows:

• Core Container : The core container provides the basic functionality of the Spring framework. The main component of the core container is BeanFactory that it is the implementation of the factory pattern. BeanFactoryUse the inversion of Control (IOC) pattern to separate the application's configuration and dependency specifications from the actual application code.
• Spring Context : The spring context is a configuration file that provides contextual information to the spring framework. The Spring context includes enterprise services such as JNDI, EJB, e-mail, internationalization, checksum scheduling.
• Spring AOP: With the configuration management feature, the Spring AOP module directly integrates aspect-oriented programming capabilities into the spring framework. Therefore, it is easy to enable any object managed by the Spring framework to support AOP. The spring AOP module provides transaction management services for objects in spring-based applications. By using Spring AOP, you can integrate declarative transaction management into your application without relying on EJB components.
• Spring DAO: The JDBC DAO abstraction layer provides a meaningful exception hierarchy that can be used to manage exception handling and error messages thrown by different database vendors. The exception hierarchy simplifies error handling and greatly reduces the number of exception codes that need to be written (such as opening and closing connections). Spring DAO's JDBC-oriented exception conforms to the common DAO exception hierarchy.
• Spring ORM: The Spring Framework inserts several ORM frameworks, providing ORM object-relational tools, including JDO, Hibernate, and IBatis SQL Map. All of these conform to Spring's common transaction and DAO exception hierarchies.
• Spring Web Module : The Web context module is built on top of the application context module and provides the context for Web-based applications. Therefore, the Spring framework supports integration with Jakarta Struts. The Web module also simplifies the process of working with multipart requests and binding request parameters to domain objects.
• Spring MVC Framework : The MVC framework is a full-featured MVC implementation of building WEB applications. With the policy interface, the MVC framework becomes highly configurable, and MVC accommodates a large number of view technologies, including JSP, Velocity, Tiles, IText, and POI.

The functionality of the Spring framework can be used in any Java EE server, and most features are also available in an out-of-management environment. The core point of Spring is to support reusable business and data access objects that are not tied to a particular Java EE service. There is no doubt that such objects can be reused across different Java EE environments (Web or EJB), standalone applications, and test environments.

Back to top of page

IOC and AOP

The basic concept of control reversal mode (also known as dependency intervention) is that you do not create objects, but describe how they are created. The code does not directly connect to objects and services, but describes in the configuration file which component requires which service. Containers (which are IOC containers in the Spring framework) are responsible for linking these together.

In a typical IOC scenario, the container creates all the objects and sets the necessary properties to connect them together, deciding when to invoke the method. The following table lists an implementation pattern for the IOC.

Type 1	services need to implement specialized interfaces through interfaces that provide these services from objects, and can query dependencies from objects (for example, additional services needed)
Type 2	Assigning dependencies through JavaBean properties, such as setter methods
Type 3	Dependencies are provided as constructors and are not exposed as JavaBean properties

The IOC container for the Spring framework is implemented with type 2 and type 3.

Aspect-oriented programming

aspect-oriented programming , AOP, is a programming technique that allows programmers to modularize the behavior of crosscutting concerns or crosscutting typical lines of responsibility, such as logging and transaction management. The core structure of AOP is the facet , which encapsulates behaviors that affect multiple classes into reusable modules.

AOP and IOC are complementary technologies that use a modular approach to solve complex problems in enterprise application development. In a typical object-oriented development approach, logging statements may be placed in all methods and Java classes in order to implement logging functionality. In the AOP approach, the log service can be modularized in turn and applied declaratively to the component that needs the log. Of course, the advantage is that the Java class does not need to know the existence of the log service and does not need to consider the associated code. Therefore, application code written in Spring AOP is loosely coupled.

The functionality of AOP is fully integrated into the context of Spring transaction management, logging, and various other features.

Back to top of page

IOC container

The core of Spring design is the org.springframework.beans package, which is designed to be used with the JavaBean component. This package is not usually used directly by the user, but is used by the server as the underlying intermediary for most other functions. The next highest-level abstraction is the BeanFactory interface, which is the implementation of the factory design pattern, allowing objects to be created and retrieved by name. BeanFactoryYou can also manage the relationships between objects.

BeanFactorySupports two object models.

• A single-state model provides a shared instance of an object with a specific name that can be retrieved at query time. Singleton is the default and most commonly used object model. Ideal for stateless service objects.
• The prototype model ensures that each retrieval creates a separate object. The prototype model works best when each user needs his or her own object.

The Bean Factory concept is the basis of Spring as an IOC container. The IOC shifts responsibility for handling things from application code to frameworks. As I will demonstrate in the next example, the Spring framework uses the JavaBean property and configuration data to indicate the dependencies that must be set.

Beanfactory interface

Because org.springframework.beans.factory.BeanFactory it is a simple interface, it can be implemented for a variety of underlying storage methods. The most common BeanFactory definition is XmlBeanFactory that it loads the bean according to the definition in the XML file, as shown in Listing 1.

Listing 1. Xmlbeanfactory

Beanfactory factory = new Xmlbeanfactory (New Fileinputsteam ("Mybean.xml"));

The beans defined in the XML file are negatively loaded, which means that the bean itself will not be initialized until the bean is needed. To BeanFactory retrieve a bean, simply call the getBean() method and pass in the name of the bean that will be retrieved, as shown in Listing 2.

Listing 2. Getbean ()

Mybean Mybean = (Mybean) factory.getbean ("Mybean");

Each bean's definition can be POJO (with the class name and JavaBean initialization property definition) or FactoryBean . FactoryBeaninterface adds an indirect level to an application built using the Spring framework.

Back to top of page

IOC Example

The simplest way to understand control inversion is to look at its practical application. In summarizing the 1th part of the Spring Series , which consists of three parts, I used an example that showed how to inject the application's dependencies through the Spring IOC container (rather than building them in).

I use the use case as a starting point for opening an online credit account. For this implementation, opening a credit account requires the user to interact with the following services:

• Credit rating service, which queries the user's credit history information.
• Remote information linking service, inserting customer information, connecting customer information to credit card and bank information for automatic debit (if necessary).
• e-mail Service to send users an email about the status of the credit card.

Back to top of page

Three interfaces

For this example, I assume that the service already exists, and ideally the situation is to integrate them in a loosely coupled fashion. The following list shows the application interfaces for three services.

Listing 3. Creditratinginterface

Public interface Creditratinginterface {public   boolean getusercredithistoryinformation (Icustomer icustomer);}

The credit rating interface shown in Listing 3 provides credit history information. It requires an object that contains customer information Customer . The implementation of this interface is CreditRating provided by the class.

Listing 4. Creditlinkinginterface

Public interface Creditlinkinginterface {public String getUrl ();p ublic void seturl (String url);p ublic void Linkcreditbankaccount () throws Exception;}

The credit link interface connects the credit history information with the bank information (if necessary) and inserts the user's credit card information. The credit link interface is a remote service, and its query is getUrl() done by means of a method. The URL is set by the Spring framework's bean configuration mechanism, which I'll discuss later. The implementation of this interface is CreditLinking provided by the class.

Listing 5. Emailinterface

Public interface Emailinterface {public      void SendEmail (Icustomer icustomer);      Public String getfromemail ();      public void Setfromemail (String fromemail);      Public String GetPassword ();      public void SetPassword (String password);      Public String getsmtphost ();      public void Setsmtphost (String smtphost);      Public String getUserId ();      public void Setuserid (String userId);   

EmailInterfaceResponsible for sending emails to customers about the status of the customer's credit card. The message configuration parameters (such as the SMPT host, user name, password) are set by the bean configuration mechanism mentioned earlier. Emailclass provides an implementation of this interface.

Back to top of page

Spring keeps it loose

After these interfaces are in place, the next thing to consider is how to integrate them in a loosely coupled fashion. You can see the implementation of the credit card account use case in Listing 6.

Note that all setter methods are implemented by Spring's configuration bean. All dependencies (that is, three interfaces) can be injected by the Spring framework with these beans. createCreditCardAccount()method uses the service to perform the rest of the implementation. You can see the Spring configuration file in Listing 7. I use arrows to highlight these definitions.

Back to top of page

Running the application

To run the sample application, you must first download the Spring framework and all of its dependent files. Next, release the framework to (for example) disk \ c, which creates a folder such as C:\spring-framework-1.2-rc2 (for the current release). You must also download and release Apache Ant before proceeding with the following operations.

Next, release the source code to the folder, such as the C: \ disk, and then create the springproject. The Spring library ( Spring.jar and C:\spring-framework-1.2-rc2\lib\ under the C:\spring-framework-1.2-rc2\dist Jakarta-commons Commons-logging.jar) is copied to the springproject\lib folder. Once you have completed these tasks, you have the necessary build dependency set.

Open a command prompt, switch the current directory to Springproject, and enter the following command at a command prompt: build .

This builds and runs the class CreateCreditAccountClient , which creates the Customer class object and populates it, and invokes the class to CreateCreditCardAccount create and link the credit card account. CreateCreditAccountClientIt also ClassPathXmlApplicationContext loads the Spring configuration file. After the beans have been loaded, they can be getBean() accessed through methods, as shown in Listing 8.

Listing 8. Loading the Spring configuration file

Classpathxmlapplicationcontext AppContext =                     new Classpathxmlapplicationcontext (new string[] {     " Springexample-creditaccount.xml "    }); Createcreditcardaccountinterface CreditCardAccount =                     (createcreditcardaccountinterface) AppContext.getBean (" Createcreditcard ");

Back to top of page

Conclusion

In the first article in this three-part Spring Series , I introduced the basics of the spring framework. I started with a discussion of the 7 modules that make up the spring hierarchy, and then I covered two of them: Spring AOP and IOC container.

Because the best way to learn is practice, I used a working example to introduce how the IOC pattern, as implemented by the Spring IOC container, integrates disparate systems in a loosely coupled manner. As you can see in this example, it is much easier to inject dependencies or services into the credit card account application at work than to build them from scratch.

Stay tuned for the next article in this series, where I'll learn the basics of how the Spring AOP module provides durable support in enterprise applications and lets you get started with spring MVC modules and related plug-ins.

Introduction to Spring Framework