SPRING

Springis a powerful lightweight application development framework used for Java Enterprise Edition (JEE). In a way, it is a framework of frameworks because it provides support to various frameworks such as Struts, Hibernate, Tapestry, EJB, JSF, etc.

Roderick B. Johnson, an Australian computer specialist officially released the Spring Framework in 2004. Since its origin, the Spring Framework has released many versions. 4.3.8 is the current Spring Framework version.

Spring is lightweight when it comes to size and transparency. The basic version of Spring framework is around 2MB.

Features Of Spring Framework

• Lightweight:- Spring Framework is lightweight with respect to size and transparency.

• Inversion Of Control (IoC):- In Spring Framework, loose coupling is achieved using Inversion of Control. The objects give their own dependencies instead of creating or looking for dependent objects.

• Aspect Oriented Programming (AOP):- By separating application business logic from system services, Spring Framework supports Aspect Oriented Programming and enables cohesive development.

• Container:- Spring Framework creates and manages the life cycle and configuration of application objects.

• MVC Framework:- Spring Framework is a MVC web application framework. This framework is configurable via interfaces and accommodates multiple view technologies.

• Transaction Management:- For transaction management, Spring framework provides a generic abstraction layer. It is not tied to J2EE environments and it can be used in container-less environments.

• JDBC Exception Handling:- The JDBC abstraction layer of the Spring Framework offers an exception hierarchy, which simplifies the error handling strategy.

Benefits of Using the Spring Framework

Following is the list of few of the great benefits of using Spring Framework −

• POJO Based:- Spring enables developers to develop enterprise-class applications using POJOs. The benefit of using only POJOs is that you do not need an EJB container product such as an application server but you have the option of using only a robust servlet container such as Tomcat or some commercial product.

• Modula:- Spring is organized in a modular fashion. Even though the number of packages and classes are substantial, you have to worry only about the ones you need and ignore the rest.

• Integration with existing frameworks:- Spring does not reinvent the wheel, instead it truly makes use of some of the existing technologies like several ORM frameworks, logging frameworks, JEE, Quartz and JDK timers, and other view technologies.

• Testablity:- Testing an application written with Spring is simple because environment-dependent code is moved into this framework. Furthermore, by using JavaBeanstyle POJOs, it becomes easier to use dependency injection for injecting test data.

• Web MVC:- Spring's web framework is a well-designed web MVC framework, which provides a great alternative to web frameworks such as Struts or other over-engineered or less popular web frameworks.

• Central Exception Handling:- Spring provides a convenient API to translate technology-specific exceptions (thrown by JDBC, Hibernate, or JDO, for example) into consistent, unchecked exceptions.

• Lightweight:- Lightweight IoC containers tend to be lightweight, especially when compared to EJB containers, for example. This is beneficial for developing and deploying applications on computers with limited memory and CPU resources.

• Transaction management:- Spring provides a consistent transaction management interface that can scale down to a local transaction (using a single database, for example) and scale up to global transactions (using JTA, for example).

Why to Learn Spring?

Spring is the most popular application development framework for enterprise Java. Millions of developers around the world use Spring Framework to create high performing, easily testable, and reusable code.

The core features of the Spring Framework can be used in developing any Java application, but there are extensions for building web applications on top of the Java EE platform. Spring framework targets to make J2EE development easier to use and promotes good programming practices by enabling a POJO-based programming model.

Dependency Injection (DI)

The technology that Spring is most identified with is the Dependency Injection (DI) flavor of Inversion of Control. The Inversion of Control (IoC) is a general concept, and it can be expressed in many different ways. Dependency Injection is merely one concrete example of Inversion of Control.

When writing a complex Java application, application classes should be as independent as possible of other Java classes to increase the possibility to reuse these classes and to test them independently of other classes while unit testing. Dependency Injection helps in gluing these classes together and at the same time keeping them independent.

What is dependency injection exactly? Let's look at these two words separately. Here the dependency part translates into an association between two classes. For example, class A is dependent of class B. Now, let's look at the second part, injection. All this means is, class B will get injected into class A by the IoC.

Dependency injection can happen in the way of passing parameters to the constructor or by post-construction using setter methods. As Dependency Injection is the heart of Spring Framework, we will explain this concept in a separate chapter with relevant example.

Aspect Oriented Programming (AOP)

One of the key components of Spring is the Aspect Oriented Programming (AOP) framework. The functions that span multiple points of an application are called cross-cutting concerns and these cross-cutting concerns are conceptually separate from the application's business logic. There are various common good examples of aspects including logging, declarative transactions, security, caching, etc.

The key unit of modularity in OOP is the class, whereas in AOP the unit of modularity is the aspect. DI helps you decouple your application objects from each other, while AOP helps you decouple cross-cutting concerns from the objects that they affect.

The AOP module of Spring Framework provides an aspect-oriented programming implementation allowing you to define method-interceptors and pointcuts to cleanly decouple code that implements functionality that should be separated. We will discuss more about Spring AOP concepts in a separate chapter.

Spring Example

Here, we are going to learn the simple steps to create the first spring application. Let's see the simple steps to create the spring application

• Create the class.
• Create the xml file to provide the values.
• Create the test class.
• Load the spring jar files.
• Run the test class.

Steps to create spring application

Let's see the 5 steps to create the first spring application.

1.Create Java class

This is the simple java bean class containing the name property only.

package com.javatpoint;  
  
public class Student 
{  
    private String name;  
    
    public String getName() 
    {  
      return name;  
    }  
  
    public void setName(String name) 
    {  
      this.name = name;  
    }  
  
    public void displayInfo()
    {  
      System.out.println("Hello: "+name);  
    }  
}  

This is simple bean class, containing only one property name with its getters and setters method. This class contains one extra method named displayInfo() that prints the student name by the hello message.

---

2.Create the xml file

<?xml version="1.0" encoding="UTF-8"?>  
<beans  
    xmlns="http://www.springframework.org/schema/beans"  
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
    xmlns:p="http://www.springframework.org/schema/p"  
    xsi:schemaLocation="http://www.springframework.org/schema/beans  
               http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">  
  
<bean id="studentbean" class="com.javatpoint.Student">  
<property name="name" value="Vimal Jaiswal"></property>  
</bean>    
</beans>  

The bean element is used to define the bean for the given class. The property subelement of bean specifies the property of the Student class named name. The value specified in the property element will be set in the Student class object by the IOC container.

---

3.Create the test class

Create the java class e.g. Test. Here we are getting the object of Student class from the IOC container using the getBean() method of BeanFactory. Let's see the code of test class.

package com.javatpoint;  
  
import org.springframework.beans.factory.BeanFactory;  
import org.springframework.beans.factory.xml.XmlBeanFactory;  
import org.springframework.core.io.ClassPathResource;  
import org.springframework.core.io.Resource;  
  
public class Test 
{  
    public static void main(String[] args) 
    {  
      Resource resource=new ClassPathResource("applicationContext.xml");  
      BeanFactory factory=new XmlBeanFactory(resource);  
      
      Student student=(Student)factory.getBean("studentbean");  
      student.displayInfo();  
    }  
}  

The Resource object represents the information of applicationContext.xml file. The Resource is the interface and the ClassPathResource is the implementation class of the Reource interface. The BeanFactory is responsible to return the bean. The XmlBeanFactory is the implementation class of the BeanFactory. There are many methods in the BeanFactory interface. One method is getBean(), which returns the object of the associated class.

---

4.Load the jar files required for spring framework

There are mainly three jar files required to run this application.

• org.springframework.core-3.0.1.RELEASE-A
• com.springsource.org.apache.commons.logging-1.1.1
• org.springframework.beans-3.0.1.RELEASE-A

You can download the required jar files for spring core application.

• download the core jar files for spring
• download the all jar files for spring including core, web, aop, mvc, j2ee, remoting, oxm, jdbc, orm etc.

---

5.Run the test class

Now run the Test class.

Here is a complete video tutorial on Spring framework.

REFERENCES:-

• Javatpoint
• Tutorialspoint