Modules Of Spring Framework

Core Container

This container has the following four modules :

1. Spring Core: This module is the core of the Spring Framework. It provides implementation for features like  IoC (Inversion of Control) and Dependency Injection with singleton design pattern.
2. Spring Bean: This module provides implementation for the factory design pattern through BeanFactory.
3. Spring Context: This module is built on the solid base provided by the Core and the Beans modules and is a medium to access any object defined and configured.
4. Spring Expression Languages (SpEL): This module is an extension to expression language supported by Java server pages. It provides a powerful expression language for querying and manipulating an object graph, at runtime.

Spring Data Access/ Integration

It consists of the following five modules:

1. JDBC: This module provides JDBC (Java Database Connectivity) abstraction layer which eliminates the need of repetitive and unnecessary exception handling overhead.
2. ORM: ORM stands for Object Relational Mapping. This module provides consistency/ portability to our code regardless of data access technologies based on object oriented mapping concept.
3. OXM: OXM stands for Object XML Mappers. It is used to convert the objects into XML format and vice versa. The Spring OXM provides an uniform API to access any of these OXM frameworks.
4. JMS: JMS stands for Java Messaging Service. This module contains features for producing and consuming messages among various clients.
5. Transaction: This module supports programmatic and declarative transaction management for classes that implement special interfaces and for all your POJOs. All the enterprise level transaction implementation concepts can be implemented in Spring by using this module.

Spring Web

Web layer includes the following modules:

1. Web: This module using servlet listeners and a web-oriented application context, provides basic web-oriented integration features like multi-part file upload functionality and the initialization of the IoC container.
2. Web-Servlet: This module contains Model-View-Controller (MVC) based implementation for web applications. It provides all other features of MVC, including UI tags and data validations.
3. Web-Socket: This module provides support for WebSocket based and two-way communication between the client and the server in web applications.
4. Web-Portlet: This module is also known as Spring-MVC-Portlet module. It provides the support for Spring based Portlets and mirrors the functionality of a Web-Servlet module.

Let’s start off with Spring!

IDE Installation

Note: Before you start installing IDE, you need to have Java installed in your system. I hope you have knowledge regarding the installation of Java (JRE) in your computer.

1. Go to www.eclipse.org.
2. Download Eclipse Mars installer and install it on your Windows system.
3. Now you have to install Spring plugin. For that go to Help > Eclipse Marketplace
4. You have to type Spring in the search bar.
5. Click on “Install”.
6. Now you have to click on “Confirm” to proceed with the installation.
7. Let the installation finish, then restart the eclipse although it will automatically ask for it.

First Spring Application

Once you are done with the installation, you are ready to develop your first application in Spring. For that, you need to follow five simple steps:

1. Create the Bean.java class
2. Create a XML/ configuration file
3. Create the main class
4. Load the required jar files
5. Run the application

Let’s get started with the first step.

Step I: Creating the Bean class:

• For this go to File > New > Java Project.
• Now to create a package, right click on Project > New > package.
• Name the package and again right click on New > Class.
• Here is an example of Student bean class.

package org.kassa.firstSpring; 
public class StudentBean { 
 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 a 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 “student name” message.

Step II: Create a XML file

• Right click on src > New > Other > 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="org/kassa/firstSpring/StudentBean"> 
<property name="name" value="Kassa"></property> 
</bean>
</beans>

• The <bean> tag is used to define the bean for the given class.
• The <property> tag is a sub element of bean, and specifies the property of the Student class. The value specified in the property element will be set in the Student class object by the IoC container.

Step III: Create the main class

• Right click on package > New > Class
• Here is an example of StudentDemo class:

package org.kassa.firstSpring;
import org.springframework.context.ApplicationContext; 
import org.springframework.context.support.ClassPathXmlApplicationContext; 
public class StudentDemo { 
 public static void main(String[] args) { 
  ApplicationContext appCon=new ClassPathXmlApplicationContext("StudentConfig.xml"); 
  StudentBean factory=(StudentBean)appCon.getBean("studentbean"); 
  factory.displayInfo(); 
 } 
}

Step IV: Load the jar files

• Here is the list of the jar files needed. You have to download it and add it to your library.
  Step V: Run the program 

  • You can now test your code by running the StudentDemo class. You can see in the below output that the name Edureka is injected by the ApplicationContext at the run-time. Likewise you can change the name any time you want, just by changing the name in the configuration file

  Spring IoC Container

  Since we are done with the first basic program, I hope you have got an idea about Spring Framework. Let’s now discuss on some of the concepts working at the core of Spring Framework. We will begin with IoC container.

  So what exactly is an IoC container in Spring? Well, Spring IoC stands for Inversion of Control. It is the heart of the Spring Framework. The important tasks performed by the IoC container are:

  1. Instantiating the bean
  2. Wiring the beans together
  3. Configuring the beans
  4. Managing the bean’s entire life-cycle

  Here is a diagrammatic representation of how beans are wired together by IoC container.

  The IoC container receives metadata from either an XML file, Java

  There are two types of IoC containers:

  1. BeanFactory
  2. ApplicationContext

  Lets discuss them in detail.

  BeanFactory

  • It is an interface defined in org.springframework.beans.factory.BeanFactory.
  • Bean Factory provides the basic support for Dependency Injection.
  • It is based on factory design pattern which creates the beans of any type.
  • BeanFactory follows lazy-initialization technique which means beans are loaded as soon as bean factory instance is created but the beans are created only when getBean() method is called.
  • The XmlBeanFactory is the implementation class for the BeanFactory interface. To use the BeanFactory, you need to create the instance of XmlBeanFactory class as shown below:
• annotations, or Java code and works accordingly. IoC adds the flexibility and control of application, and provides a central place of configuration management for Plain Old Java Objects (POJO) of our application. This diagram represents an abstract view of the working of Spring Framework. It shows how Spring makes use of Java POJO classes and configuration metadata to produce a fully configured and executable system or application.

BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("beans.xml"));

ApplicationContext

• It is an interface defined in org.springframework.context.ApplicationContext.
• It is the advanced Spring container and is built on top of the BeanFactory interface.
• ApplicationContext supports the features supported by Bean Factory but also provides some additional functionalities.
• ApplicationContext follows eager-initialization technique which means instance of beans are created as soon as you create the instance of Application context.
• The ClassPathXmlApplicationContext class is the implementation class of ApplicationContext interface. You need to instantiate the ClassPathXmlApplicationContext class to use the ApplicationContext as shown below:

ApplicationContext context=new ClassPathXmlApplicationContext("beans.xml");

Dependency Injection

Dependency Injection is also one of the core concepts of Spring Framework.

It is a design pattern that removes the dependency from the code. That is, the Spring Framework provides the dependencies of the class itself so that it can be easy to manage and test the application. You can provide information from external source such as XML file. Here, you do not create the objects instead you just define how they should be created and IoC container will create the objects for you.

In Spring, dependencies can be injected in two ways:

1. By constructor
2. By setter method

Lets see how they are done.

By Constructor

• The <constructor-arg> subelement of <bean> is used for constructor injection. e.g:

<constructor-arg value="101" type="int"></constructor-arg>

• By default when the Spring container loads the bean, it instantiates the bean with the default constructor. But you can also define a constructor argument in bean definition, using an argument constructor.

By setter method

• The <property> subelement of <bean> is used for setter injection.e.g:

<property name="id" value="101"></property>

• Setter-based Dependency Injection is accomplished by the container calling setter methods on your beans after invoking a no-argument.

Spring MVC (Model-View-Controller)

Spring MVC helps in building flexible and loosely coupled web applications. The Model-View-Controller design pattern helps in separating the business logic, presentation logic and navigation logic. It provides an elegant solution to use MVC in Spring Framework with the help of DispatcherServlet.

When a request is sent to the Spring MVC Framework, the following takes place.

• A request is received by DispatcherServlet.
• The DispatcherServlet communicates with HandlerMapping and calls the Controller associated with the request.
• The request is processed by the Controller by calling the appropriate service methods and a ModelAndView object to the DispatcherServlet is returned.
• The view name is sent to a ViewResolver by the DispatcherServlet to find the actual View to invoke.
• Now the model object DispatcherServlet is passed to View to render the result.
• With the help of the model data, the View renders the result back to the user.

So, this brings us to the end of the post on Spring Tutorial. I wrote this post from the concise knowledge I gained from my six month internship and the articles from the internet. I tried my best to keep the concepts short and clear. Hope it helped you in understanding Spring Framework and its various features.

Got a question? Please mention it in the comments section and I will get back to you.

.