Spring Quick Guide
User Manual: Pdf
Open the PDF directly: View PDF 
.
Page Count: 67
Spring - Quick Guide
Spring Framework - Overview
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.
Spring framework is an open source Java platform. It was initially written by Rod Johnson and was first
released under the Apache 2.0 license in June 2003.
Spring is lightweight when it comes to size and transparency. The basic version of Spring framework is
around 2MB.
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 POJObased programming model.
Benefits of Using the Spring Framework
Following is the list of few of the great benefits of using Spring Framework −
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.
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.
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.
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.
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.
Spring provides a convenient API to translate technology-specific exceptions (thrown by JDBC,
Hibernate, or JDO, for example) into consistent, unchecked exceptions.
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.
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).
Dependency Injection (DI)
Spring - Quick Guide
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 postconstruction 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 crosscutting 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 Framework - Architecture
Spring could potentially be a one-stop shop for all your enterprise applications. However, Spring is
modular, allowing you to pick and choose which modules are applicable to you, without having to bring
in the rest. The following section provides details about all the modules available in Spring Framework.
The Spring Framework provides about 20 modules which can be used based on an application
requirement.
Spring - Quick Guide
Core Container
The Core Container consists of the Core, Beans, Context, and Expression Language modules the details
of which are as follows −
The Core module provides the fundamental parts of the framework, including the IoC and
Dependency Injection features.
The Bean module provides BeanFactory, which is a sophisticated implementation of the factory
pattern.
The Context module builds on the solid base provided by the Core and Beans modules and it is a
medium to access any objects defined and configured. The ApplicationContext interface is the
focal point of the Context module.
The SpEL module provides a powerful expression language for querying and manipulating an
object graph at runtime.
Data Access/Integration
The Data Access/Integration layer consists of the JDBC, ORM, OXM, JMS and Transaction modules
whose detail is as follows −
The JDBC module provides a JDBC-abstraction layer that removes the need for tedious JDBC
related coding.
Spring - Quick Guide
The ORM module provides integration layers for popular object-relational mapping APIs,
including JPA, JDO, Hibernate, and iBatis.
The OXM module provides an abstraction layer that supports Object/XML mapping
implementations for JAXB, Castor, XMLBeans, JiBX and XStream.
The Java Messaging Service JMS module contains features for producing and consuming
messages.
The Transaction module supports programmatic and declarative transaction management for
classes that implement special interfaces and for all your POJOs.
Web
The Web layer consists of the Web, Web-MVC, Web-Socket, and Web-Portlet modules the details of
which are as follows −
The Web 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.
The Web-MVC module contains Spring's Model-View-Controller (MVC) implementation for
web applications.
The Web-Socket module provides support for WebSocket-based, two-way communication
between the client and the server in web applications.
The Web-Portlet module provides the MVC implementation to be used in a portlet environment
and mirrors the functionality of Web-Servlet module.
Miscellaneous
There are few other important modules like AOP, Aspects, Instrumentation, Web and Test modules the
details of which are as follows −
The AOP module 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.
The Aspects module provides integration with AspectJ, which is again a powerful and mature
AOP framework.
The Instrumentation module provides class instrumentation support and class loader
implementations to be used in certain application servers.
The Messaging module provides support for STOMP as the WebSocket sub-protocol to use in
applications. It also supports an annotation programming model for routing and processing
STOMP messages from WebSocket clients.
The Test module supports the testing of Spring components with JUnit or TestNG frameworks.
Spring - Environment Setup
This chapter will guide you on how to prepare a development environment to start your work with Spring
Framework. It will also teach you how to set up JDK, Tomcat and Eclipse on your machine before you set
up Spring Framework −
Spring - Quick Guide
Step 1 - Setup Java Development Kit (JDK)
You can download the latest version of SDK from Oracle's Java site − Java SE Downloads. You will find
instructions for installing JDK in downloaded files, follow the given instructions to install and configure
the setup. Finally set PATH and JAVA_HOME environment variables to refer to the directory that
contains java and javac, typically java_install_dir/bin and java_install_dir respectively.
If you are running Windows and have installed the JDK in C:\jdk1.6.0_15, you would have to put the
following line in your C:\autoexec.bat file.
set PATH=C:\jdk1.6.0_15\bin;%PATH%
set JAVA_HOME=C:\jdk1.6.0_15
Alternatively, on Windows NT/2000/XP, you will have to right-click on My Computer, select Properties
→ Advanced → Environment Variables. Then, you will have to update the PATH value and click the OK
button.
On Unix (Solaris, Linux, etc.), if the SDK is installed in /usr/local/jdk1.6.0_15 and you use the C shell,
you will have to put the following into your .cshrc file.
setenv PATH /usr/local/jdk1.6.0_15/bin:$PATH
setenv JAVA_HOME /usr/local/jdk1.6.0_15
Alternatively, if you use an Integrated Development Environment (IDE) like Borland JBuilder, Eclipse,
IntelliJ IDEA, or Sun ONE Studio, you will have to compile and run a simple program to confirm that the
IDE knows where you have installed Java. Otherwise, you will have to carry out a proper setup as given
in the document of the IDE.
Step 2 - Install Apache Common Logging API
You can download the latest version of Apache Commons Logging API from
https://commons.apache.org/logging/. Once you download the installation, unpack the binary distribution
into a convenient location. For example, in C:\commons-logging-1.1.1 on Windows, or
/usr/local/commons-logging-1.1.1 on Linux/Unix. This directory will have the following jar files and
other supporting documents, etc.
Spring - Quick Guide
Make sure you set your CLASSPATH variable on this directory properly otherwise you will face a
problem while running your application.
Step 3 - Setup Eclipse IDE
All the examples in this tutorial have been written using Eclipse IDE. So we would suggest you should
have the latest version of Eclipse installed on your machine.
To install Eclipse IDE, download the latest Eclipse binaries from https://www.eclipse.org/downloads/.
Once you download the installation, unpack the binary distribution into a convenient location. For
example, in C:\eclipse on Windows, or /usr/local/eclipse on Linux/Unix and finally set PATH variable
appropriately.
Eclipse can be started by executing the following commands on Windows machine, or you can simply
double-click on eclipse.exe
%C:\eclipse\eclipse.exe
Eclipse can be started by executing the following commands on Unix (Solaris, Linux, etc.) machine −
$/usr/local/eclipse/eclipse
After a successful startup, if everything is fine then it should display the following result −
Spring - Quick Guide
Step 4 - Setup Spring Framework Libraries
Now if everything is fine, then you can proceed to set up your Spring framework. Following are the
simple steps to download and install the framework on your machine.
Make a choice whether you want to install Spring on Windows or Unix, and then proceed to the
next step to download .zip file for Windows and .tz file for Unix.
Download the latest version of Spring framework binaries from
https://repo.spring.io/release/org/springframework/spring.
At the time of developing this tutorial, spring-framework-4.1.6.RELEASE-dist.zip was
downloaded on Windows machine. After the downloaded file was unzipped, it gives the following
directory structure inside E:\spring.
You will find all the Spring libraries in the directory E:\spring\libs. Make sure you set your
CLASSPATH variable on this directory properly otherwise you will face a problem while running your
application. If you are using Eclipse, then it is not required to set CLASSPATH because all the setting
will be done through Eclipse.
Once you are done with this last step, you are ready to proceed to your first Spring Example in the next
chapter.
Spring - Hello World Example
Let us start actual programming with Spring Framework. Before you start writing your first example
using Spring framework, you have to make sure that you have set up your Spring environment properly as
explained in Spring - Environment Setup Chapter. We also assume that you have a bit of working
knowledge on Eclipse IDE.
Now let us proceed to write a simple Spring Application, which will print "Hello World!" or any other
message based on the configuration done in Spring Beans Configuration file.
Step 1 - Create Java Project
The first step is to create a simple Java Project using Eclipse IDE. Follow the option File → New →
Project and finally select Java Project wizard from the wizard list. Now name your project as
HelloSpring using the wizard window as follows −
Spring - Quick Guide
Once your project is created successfully, you will have the following content in your Project Explorer −
Spring - Quick Guide
Step 2 - Add Required Libraries
As a second step let us add Spring Framework and common logging API libraries in our project. To do
this, right-click on your project name HelloSpring and then follow the following option available in the
context menu − Build Path → Configure Build Path to display the Java Build Path window as follows −
Spring - Quick Guide
Now use Add External JARs button available under the Libraries tab to add the following core JARs
from Spring Framework and Common Logging installation directories −
commons-logging-1.1.1
spring-aop-4.1.6.RELEASE
spring-aspects-4.1.6.RELEASE
spring-beans-4.1.6.RELEASE
spring-context-4.1.6.RELEASE
spring-context-support-4.1.6.RELEASE
spring-core-4.1.6.RELEASE
spring-expression-4.1.6.RELEASE
spring-instrument-4.1.6.RELEASE
spring-instrument-tomcat-4.1.6.RELEASE
spring-jdbc-4.1.6.RELEASE
spring-jms-4.1.6.RELEASE
spring-messaging-4.1.6.RELEASE
spring-orm-4.1.6.RELEASE
spring-oxm-4.1.6.RELEASE
spring-test-4.1.6.RELEASE
spring-tx-4.1.6.RELEASE
spring-web-4.1.6.RELEASE
spring-webmvc-4.1.6.RELEASE
Spring - Quick Guide
spring-webmvc-portlet-4.1.6.RELEASE
spring-websocket-4.1.6.RELEASE
Step 3 - Create Source Files
Now let us create actual source files under the HelloSpring project. First we need to create a package
called com.tutorialspoint. To do this, right click on src in package explorer section and follow the option
− New → Package.
Next we will create HelloWorld.java and MainApp.java files under the com.tutorialspoint package.
Here is the content of HelloWorld.java file −
package com.tutorialspoint;
public class HelloWorld {
private String message;
public void setMessage(String message){
this.message = message;
}
public void getMessage(){
System.out.println("Your Message : " + message);
}
}
Following is the content of the second file MainApp.java −
Spring - Quick Guide
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
obj.getMessage();
}
}
Following two important points are to be noted about the main program −
The first step is to create an application context where we used framework API
ClassPathXmlApplicationContext(). This API loads beans configuration file and eventually
based on the provided API, it takes care of creating and initializing all the objects, i.e. beans
mentioned in the configuration file.
The second step is used to get the required bean using getBean() method of the created context.
This method uses bean ID to return a generic object, which finally can be casted to the actual
object. Once you have an object, you can use this object to call any class method.
Step 4 - Create Bean Configuration File
You need to create a Bean Configuration file which is an XML file and acts as a cement that glues the
beans, i.e. the classes together. This file needs to be created under the src directory as shown in the
following screenshot −
Spring - Quick Guide
Usually developers name this file as Beans.xml, but you are independent to choose any name you like.
You have to make sure that this file is available in CLASSPATH and use the same name in the main
application while creating an application context as shown in MainApp.java file.
The Beans.xml is used to assign unique IDs to different beans and to control the creation of objects with
different values without impacting any of the Spring source files. For example, using the following file
you can pass any value for "message" variable and you can print different values of message without
impacting HelloWorld.java and MainApp.java files. Let us see how it works −
When Spring application gets loaded into the memory, Framework makes use of the above configuration
file to create all the beans defined and assigns them a unique ID as defined in tag. You can use
tag to pass the values of different variables used at the time of object creation.
Step 5 - Running the Program
Once you are done with creating the source and beans configuration files, you are ready for this step,
which is compiling and running your program. To do this, keep MainApp.Java file tab active and use
either Run option available in the Eclipse IDE or use Ctrl + F11 to compile and run your MainApp
application. If everything is fine with your application, this will print the following message in Eclipse
IDE's console −
Your Message : Hello World!
Congratulations, you have successfully created your first Spring Application. You can see the flexibility
of the above Spring application by changing the value of "message" property and keeping both the source
files unchanged.
Spring - IoC Containers
The Spring container is at the core of the Spring Framework. The container will create the objects, wire
them together, configure them, and manage their complete life cycle from creation till destruction. The
Spring container uses DI to manage the components that make up an application. These objects are called
Spring Beans, which we will discuss in the next chapter.
The container gets its instructions on what objects to instantiate, configure, and assemble by reading the
configuration metadata provided. The configuration metadata can be represented either by XML, Java
annotations, or Java code. The following diagram represents a high-level view of how Spring works. The
Spring - Quick Guide
Spring IoC container makes use of Java POJO classes and configuration metadata to produce a fully
configured and executable system or application.
Spring provides the following two distinct types of containers.
Sr.No.
Container & Description
Spring BeanFactory Container
1
2
This is the simplest container providing the basic support for DI and is defined by the
org.springframework.beans.factory.BeanFactory interface. The BeanFactory and related
interfaces, such as BeanFactoryAware, InitializingBean, DisposableBean, are still present in
Spring for the purpose of backward compatibility with a large number of third-party frameworks
that integrate with Spring.
Spring ApplicationContext Container
This container adds more enterprise-specific functionality such as the ability to resolve textual
messages from a properties file and the ability to publish application events to interested event
listeners. This container is defined by the org.springframework.context.ApplicationContext
interface.
The ApplicationContext container includes all functionality of the BeanFactorycontainer, so it is
generally recommended over BeanFactory. BeanFactory can still be used for lightweight applications like
mobile devices or applet-based applications where data volume and speed is significant.
Spring - Bean Definition
The objects that form the backbone of your application and that are managed by the Spring IoC container
are called beans. A bean is an object that is instantiated, assembled, and otherwise managed by a Spring
IoC container. These beans are created with the configuration metadata that you supply to the container.
Spring - Quick Guide
For example, in the form of XML definitions which you have already seen in the previous
chapters.
Bean definition contains the information called configuration metadata, which is needed for the
container to know the following −
How to create a bean
Bean's lifecycle details
Bean's dependencies
All the above configuration metadata translates into a set of the following properties that make up each
bean definition.
Sr.No.
Properties & Description
class
1
This attribute is mandatory and specifies the bean class to be used to create the bean.
name
2
3
This attribute specifies the bean identifier uniquely. In XMLbased configuration metadata, you use
the id and/or name attributes to specify the bean identifier(s).
scope
This attribute specifies the scope of the objects created from a particular bean definition and it will
be discussed in bean scopes chapter.
constructor-arg
4
This is used to inject the dependencies and will be discussed in subsequent chapters.
properties
5
This is used to inject the dependencies and will be discussed in subsequent chapters.
autowiring mode
6
This is used to inject the dependencies and will be discussed in subsequent chapters.
lazy-initialization mode
7
8
9
A lazy-initialized bean tells the IoC container to create a bean instance when it is first requested,
rather than at the startup.
initialization method
A callback to be called just after all necessary properties on the bean have been set by the
container. It will be discussed in bean life cycle chapter.
destruction method
A callback to be used when the container containing the bean is destroyed. It will be discussed in
bean life cycle chapter.
Spring - Quick Guide
Spring Configuration Metadata
Spring IoC container is totally decoupled from the format in which this configuration metadata is actually
written. Following are the three important methods to provide configuration metadata to the Spring
Container −
XML based configuration file.
Annotation-based configuration
Java-based configuration
You already have seen how XML-based configuration metadata is provided to the container, but let us see
another sample of XML-based configuration file with different bean definitions including lazy
initialization, initialization method, and destruction method −
You can check Spring Hello World Example to understand how to define, configure and create Spring
Beans.
We will discuss about Annotation Based Configuration in a separate chapter. It is intentionally discussed
in a separate chapter as we want you to grasp a few other important Spring concepts, before you start
programming with Spring Dependency Injection with Annotations.
Spring - Bean Scopes
Spring - Quick Guide
When defining a you have the option of declaring a scope for that bean. For example, to force
Spring to produce a new bean instance each time one is needed, you should declare the bean's scope
attribute to be prototype. Similarly, if you want Spring to return the same bean instance each time one is
needed, you should declare the bean's scope attribute to be singleton.
The Spring Framework supports the following five scopes, three of which are available only if you use a
web-aware ApplicationContext.
Sr.No.
Scope & Description
singleton
1
This scopes the bean definition to a single instance per Spring IoC container (default).
prototype
2
This scopes a single bean definition to have any number of object instances.
request
3
4
5
This scopes a bean definition to an HTTP request. Only valid in the context of a web-aware Spring
ApplicationContext.
session
This scopes a bean definition to an HTTP session. Only valid in the context of a web-aware Spring
ApplicationContext.
global-session
This scopes a bean definition to a global HTTP session. Only valid in the context of a web-aware
Spring ApplicationContext.
In this chapter, we will discuss about the first two scopes and the remaining three will be discussed when
we discuss about web-aware Spring ApplicationContext.
The singleton scope
If a scope is set to singleton, the Spring IoC container creates exactly one instance of the object defined
by that bean definition. This single instance is stored in a cache of such singleton beans, and all
subsequent requests and references for that named bean return the cached object.
The default scope is always singleton. However, when you need one and only one instance of a bean, you
can set the scope property to singleton in the bean configuration file, as shown in the following code
snippet −
Example
Spring - Quick Guide
Let us have a working Eclipse IDE in place and take the following steps to create a Spring application −
Steps
1
2
3
4
5
Description
Create a project with a name SpringExample and create a package com.tutorialspoint under the src
folder in the created project.
Add required Spring libraries using Add External JARs option as explained in the Spring Hello
World Example chapter.
Create Java classes HelloWorld and MainApp under the com.tutorialspoint package.
Create Beans configuration file Beans.xml under the src folder.
The final step is to create the content of all the Java files and Bean Configuration file and run the
application as explained below.
Here is the content of HelloWorld.java file −
package com.tutorialspoint;
public class HelloWorld {
private String message;
public void setMessage(String message){
this.message = message;
}
public void getMessage(){
System.out.println("Your Message : " + message);
}
}
Following is the content of the MainApp.java file −
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
HelloWorld objA = (HelloWorld) context.getBean("helloWorld");
objA.setMessage("I'm object A");
objA.getMessage();
HelloWorld objB = (HelloWorld) context.getBean("helloWorld");
objB.getMessage();
}
}
Following is the configuration file Beans.xml required for singleton scope −
Once you are done creating the source and bean configuration files, let us run the application. If
everything is fine with your application, it will print the following message −
Your Message : I'm object A
Your Message : I'm object A
The prototype scope
If the scope is set to prototype, the Spring IoC container creates a new bean instance of the object every
time a request for that specific bean is made. As a rule, use the prototype scope for all state-full beans and
the singleton scope for stateless beans.
To define a prototype scope, you can set the scope property to prototype in the bean configuration file, as
shown in the following code snippet −
Example
Let us have working Eclipse IDE in place and follow the following steps to create a Spring application −
Steps
1
2
3
4
5
Description
Create a project with a name SpringExample and create a package com.tutorialspoint under the src
folder in the created project.
Add required Spring libraries using Add External JARs option as explained in the Spring Hello
World Example chapter.
Create Java classes HelloWorld and MainApp under the com.tutorialspoint package.
Create Beans configuration file Beans.xml under the src folder.
The final step is to create the content of all the Java files and Bean Configuration file and run the
application as explained below.
Here is the content of HelloWorld.java file
package com.tutorialspoint;
public class HelloWorld {
private String message;
public void setMessage(String message){
this.message = message;
Spring - Quick Guide
}
public void getMessage(){
System.out.println("Your Message : " + message);
}
}
Following is the content of the MainApp.java file −
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
HelloWorld objA = (HelloWorld) context.getBean("helloWorld");
objA.setMessage("I'm object A");
objA.getMessage();
HelloWorld objB = (HelloWorld) context.getBean("helloWorld");
objB.getMessage();
}
}
Following is the configuration file Beans.xml required for prototype scope −
Once you are done creating the source and bean configuration files, let us run the application. If
everything is fine with your application, it will print the following message −
Your Message : I'm object A
Your Message : null
Spring - Bean Life Cycle
The life cycle of a Spring bean is easy to understand. When a bean is instantiated, it may be required to
perform some initialization to get it into a usable state. Similarly, when the bean is no longer required and
is removed from the container, some cleanup may be required.
Spring - Quick Guide
Though, there are lists of the activities that take place behind the scene between the time of bean
Instantiation and its destruction, this chapter will discuss only two important bean life cycle callback
methods, which are required at the time of bean initialization and its destruction.
To define setup and teardown for a bean, we simply declare the with initmethod and/or destroymethod parameters. The init-method attribute specifies a method that is to be called on the bean
immediately upon instantiation. Similarly, destroymethod specifies a method that is called just before a
bean is removed from the container.
Initialization callbacks
The org.springframework.beans.factory.InitializingBean interface specifies a single method −
void afterPropertiesSet() throws Exception;
Thus, you can simply implement the above interface and initialization work can be done inside
afterPropertiesSet() method as follows −
public class ExampleBean implements InitializingBean {
public void afterPropertiesSet() {
// do some initialization work
}
}
In the case of XML-based configuration metadata, you can use the init-method attribute to specify the
name of the method that has a void no-argument signature. For example −
Following is the class definition −
public class ExampleBean {
public void init() {
// do some initialization work
}
}
Destruction callbacks
The org.springframework.beans.factory.DisposableBean interface specifies a single method −
void destroy() throws Exception;
Thus, you can simply implement the above interface and finalization work can be done inside destroy()
method as follows −
public class ExampleBean implements DisposableBean {
public void destroy() {
// do some destruction work
}
}
Spring - Quick Guide
In the case of XML-based configuration metadata, you can use the destroy-method attribute to specify
the name of the method that has a void no-argument signature. For example −
Following is the class definition −
public class ExampleBean {
public void destroy() {
// do some destruction work
}
}
If you are using Spring's IoC container in a non-web application environment; for example, in a rich
client desktop environment, you register a shutdown hook with the JVM. Doing so ensures a graceful
shutdown and calls the relevant destroy methods on your singleton beans so that all resources are
released.
It is recommended that you do not use the InitializingBean or DisposableBean callbacks, because XML
configuration gives much flexibility in terms of naming your method.
Example
Let us have a working Eclipse IDE in place and take the following steps to create a Spring application −
Steps
1
2
3
4
5
Description
Create a project with a name SpringExample and create a package com.tutorialspoint under the src
folder in the created project.
Add required Spring libraries using Add External JARs option as explained in the Spring Hello
World Example chapter.
Create Java classes HelloWorld and MainApp under the com.tutorialspoint package.
Create Beans configuration file Beans.xml under the src folder.
The final step is to create the content of all the Java files and Bean Configuration file and run the
application as explained below.
Here is the content of HelloWorld.java file −
package com.tutorialspoint;
public class HelloWorld {
private String message;
public void setMessage(String message){
this.message = message;
}
public void getMessage(){
System.out.println("Your Message : " + message);
}
public void init(){
System.out.println("Bean is going through init.");
}
public void destroy() {
Spring - Quick Guide
System.out.println("Bean will destroy now.");
}
}
Following is the content of the MainApp.java file. Here you need to register a shutdown hook
registerShutdownHook() method that is declared on the AbstractApplicationContext class. This will
ensure a graceful shutdown and call the relevant destroy methods.
package com.tutorialspoint;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
AbstractApplicationContext context = new
ClassPathXmlApplicationContext("Beans.xml");
HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
obj.getMessage();
context.registerShutdownHook();
}
}
Following is the configuration file Beans.xml required for init and destroy methods −
Once you are done creating the source and bean configuration files, let us run the application. If
everything is fine with your application, it will print the following message −
Bean is going through init.
Your Message : Hello World!
Bean will destroy now.
Default initialization and destroy methods
If you have too many beans having initialization and/or destroy methods with the same name, you don't
need to declare init-method and destroy-method on each individual bean. Instead, the framework
provides the flexibility to configure such situation using default-init-method and default-destroymethod attributes on the element as follows −
Spring - Quick Guide
Spring - Bean Post Processors
The BeanPostProcessor interface defines callback methods that you can implement to provide your own
instantiation logic, dependency-resolution logic, etc. You can also implement some custom logic after the
Spring container finishes instantiating, configuring, and initializing a bean by plugging in one or more
BeanPostProcessor implementations.
You can configure multiple BeanPostProcessor interfaces and you can control the order in which these
BeanPostProcessor interfaces execute by setting the order property provided the BeanPostProcessor
implements the Ordered interface.
The BeanPostProcessors operate on bean (or object) instances, which means that the Spring IoC container
instantiates a bean instance and then BeanPostProcessor interfaces do their work.
An ApplicationContext automatically detects any beans that are defined with the implementation of the
BeanPostProcessor interface and registers these beans as postprocessors, to be then called appropriately
by the container upon bean creation.
Example
The following examples show how to write, register, and use BeanPostProcessors in the context of an
ApplicationContext.
Let us have a working Eclipse IDE in place and take the following steps to create a Spring application −
Steps
1
2
3
4
5
Description
Create a project with a name SpringExample and create a package com.tutorialspoint under the src
folder in the created project.
Add required Spring libraries using Add External JARs option as explained in the Spring Hello
World Example chapter.
Create Java classes HelloWorld, InitHelloWorld and MainApp under the com.tutorialspoint
package.
Create Beans configuration file Beans.xml under the src folder.
The final step is to create the content of all the Java files and Bean Configuration file and run the
application as explained below.
Spring - Quick Guide
Here is the content of HelloWorld.java file −
package com.tutorialspoint;
public class HelloWorld {
private String message;
public void setMessage(String message){
this.message = message;
}
public void getMessage(){
System.out.println("Your Message : " + message);
}
public void init(){
System.out.println("Bean is going through init.");
}
public void destroy(){
System.out.println("Bean will destroy now.");
}
}
This is a very basic example of implementing BeanPostProcessor, which prints a bean name before and
after initialization of any bean. You can implement more complex logic before and after instantiating a
bean because you have access on bean object inside both the post processor methods.
Here is the content of InitHelloWorld.java file −
package com.tutorialspoint;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.beans.BeansException;
public class InitHelloWorld implements BeanPostProcessor {
public Object postProcessBeforeInitialization(Object bean, String beanName)
throws BeansException {
System.out.println("BeforeInitialization : " + beanName);
return bean; // you can return any other object as well
}
public Object postProcessAfterInitialization(Object bean, String beanName)
throws BeansException {
System.out.println("AfterInitialization : " + beanName);
return bean; // you can return any other object as well
}
}
Following is the content of the MainApp.java file. Here you need to register a shutdown hook
registerShutdownHook() method that is declared on the AbstractApplicationContext class. This will
ensures a graceful shutdown and calls the relevant destroy methods.
package com.tutorialspoint;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
Spring - Quick Guide
public static void main(String[] args) {
AbstractApplicationContext context = new
ClassPathXmlApplicationContext("Beans.xml");
HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
obj.getMessage();
context.registerShutdownHook();
}
}
Following is the configuration file Beans.xml required for init and destroy methods −
Once you are done with creating the source and bean configuration files, let us run the application. If
everything is fine with your application, it will print the following message −
BeforeInitialization : helloWorld
Bean is going through init.
AfterInitialization : helloWorld
Your Message : Hello World!
Bean will destroy now.
Spring - Bean Definition Inheritance
A bean definition can contain a lot of configuration information, including constructor arguments,
property values, and container-specific information such as initialization method, static factory method
name, and so on.
A child bean definition inherits configuration data from a parent definition. The child definition can
override some values, or add others, as needed.
Spring Bean definition inheritance has nothing to do with Java class inheritance but the inheritance
concept is same. You can define a parent bean definition as a template and other child beans can inherit
the required configuration from the parent bean.
When you use XML-based configuration metadata, you indicate a child bean definition by using the
parent attribute, specifying the parent bean as the value of this attribute.
Spring - Quick Guide
Example
Let us have a working Eclipse IDE in place and take the following steps to create a Spring application −
Steps
1
2
3
4
5
Description
Create a project with a name SpringExample and create a package com.tutorialspoint under the src
folder in the created project.
Add required Spring libraries using Add External JARs option as explained in the Spring Hello
World Example chapter.
Create Java classes HelloWorld, HelloIndia and MainApp under the com.tutorialspoint package.
Create Beans configuration file Beans.xml under the src folder.
The final step is to create the content of all the Java files and Bean Configuration file and run the
application as explained below.
Following is the configuration file Beans.xml where we defined "helloWorld" bean which has two
properties message1 and message2. Next "helloIndia" bean has been defined as a child of "helloWorld"
bean by using parent attribute. The child bean inherits message2 property as is, and overrides message1
property and introduces one more property message3.
Here is the content of HelloWorld.java file −
package com.tutorialspoint;
public class HelloWorld {
private String message1;
private String message2;
public void setMessage1(String message){
this.message1 = message;
}
public void setMessage2(String message){
this.message2 = message;
}
public void getMessage1(){
Spring - Quick Guide
System.out.println("World Message1 : " + message1);
}
public void getMessage2(){
System.out.println("World Message2 : " + message2);
}
}
Here is the content of HelloIndia.java file −
package com.tutorialspoint;
public class HelloIndia {
private String message1;
private String message2;
private String message3;
public void setMessage1(String message){
this.message1 = message;
}
public void setMessage2(String message){
this.message2 = message;
}
public void setMessage3(String message){
this.message3 = message;
}
public void getMessage1(){
System.out.println("India Message1 : " + message1);
}
public void getMessage2(){
System.out.println("India Message2 : " + message2);
}
public void getMessage3(){
System.out.println("India Message3 : " + message3);
}
}
Following is the content of the MainApp.java file −
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
HelloWorld objA = (HelloWorld) context.getBean("helloWorld");
objA.getMessage1();
objA.getMessage2();
HelloIndia objB = (HelloIndia) context.getBean("helloIndia");
objB.getMessage1();
objB.getMessage2();
objB.getMessage3();
}
}
Spring - Quick Guide
Once you are done creating the source and bean configuration files, let us run the application. If
everything is fine with your application, it will print the following message −
World
World
India
India
India
Message1
Message2
Message1
Message2
Message3
:
:
:
:
:
Hello World!
Hello Second World!
Hello India!
Hello Second World!
Namaste India!
If you observed here, we did not pass message2 while creating "helloIndia" bean, but it got passed
because of Bean Definition Inheritance.
Bean Definition Template
You can create a Bean definition template, which can be used by other child bean definitions without
putting much effort. While defining a Bean Definition Template, you should not specify the class
attribute and should specify abstract attribute and should specify the abstract attribute with a value of
true as shown in the following code snippet −
The parent bean cannot be instantiated on its own because it is incomplete, and it is also explicitly marked
as abstract. When a definition is abstract like this, it is usable only as a pure template bean definition that
serves as a parent definition for child definitions.
Spring - Dependency Injection
Every Java-based application has a few objects that work together to present what the end-user sees as a
working application. 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 (or sometime called wiring)
helps in gluing these classes together and at the same time keeping them independent.
Spring - Quick Guide
Consider you have an application which has a text editor component and you want to provide a spell
check. Your standard code would look something like this −
public class TextEditor {
private SpellChecker spellChecker;
public TextEditor() {
spellChecker = new SpellChecker();
}
}
What we've done here is, create a dependency between the TextEditor and the SpellChecker. In an
inversion of control scenario, we would instead do something like this −
public class TextEditor {
private SpellChecker spellChecker;
public TextEditor(SpellChecker spellChecker) {
this.spellChecker = spellChecker;
}
}
Here, the TextEditor should not worry about SpellChecker implementation. The SpellChecker will be
implemented independently and will be provided to the TextEditor at the time of TextEditor instantiation.
This entire procedure is controlled by the Spring Framework.
Here, we have removed total control from the TextEditor and kept it somewhere else (i.e. XML
configuration file) and the dependency (i.e. class SpellChecker) is being injected into the class TextEditor
through a Class Constructor. Thus the flow of control has been "inverted" by Dependency Injection (DI)
because you have effectively delegated dependances to some external system.
The second method of injecting dependency is through Setter Methods of the TextEditor class where we
will create a SpellChecker instance. This instance will be used to call setter methods to initialize
TextEditor's properties.
Thus, DI exists in two major variants and the following two sub-chapters will cover both of them with
examples −
Sr.No.
1
2
Dependency Injection Type & Description
Constructor-based dependency injection
Constructor-based DI is accomplished when the container invokes a class constructor with a
number of arguments, each representing a dependency on the other class.
Setter-based dependency injection
Setter-based DI is accomplished by the container calling setter methods on your beans after
invoking a no-argument constructor or no-argument static factory method to instantiate your bean.
You can mix both, Constructor-based and Setter-based DI but it is a good rule of thumb to use constructor
arguments for mandatory dependencies and setters for optional dependencies.
Spring - Quick Guide
The code is cleaner with the DI principle and decoupling is more effective when objects are provided with
their dependencies. The object does not look up its dependencies and does not know the location or class
of the dependencies, rather everything is taken care by the Spring Framework.
Spring - Injecting Inner Beans
As you know Java inner classes are defined within the scope of other classes, similarly, inner beans are
beans that are defined within the scope of another bean. Thus, a element inside the
or elements is called inner bean and it is shown below.
Example
Let us have working Eclipse IDE in place and follow the following steps to create a Spring application −
Steps
1
2
3
4
5
Description
Create a project with a name SpringExample and create a package com.tutorialspoint under the src
folder in the created project.
Add required Spring libraries using Add External JARs option as explained in the Spring Hello
World Example chapter.
Create Java classes TextEditor, SpellChecker and MainApp under the com.tutorialspoint package.
Create Beans configuration file Beans.xml under the src folder.
The final step is to create the content of all the Java files and Bean Configuration file and run the
application as explained below.
Here is the content of TextEditor.java file −
package com.tutorialspoint;
public class TextEditor {
private SpellChecker spellChecker;
// a setter method to inject the dependency.
public void setSpellChecker(SpellChecker spellChecker) {
System.out.println("Inside setSpellChecker." );
this.spellChecker = spellChecker;
}
Spring - Quick Guide
// a getter method to return spellChecker
public SpellChecker getSpellChecker() {
return spellChecker;
}
public void spellCheck() {
spellChecker.checkSpelling();
}
}
Following is the content of another dependent class file SpellChecker.java −
package com.tutorialspoint;
public class SpellChecker {
public SpellChecker(){
System.out.println("Inside SpellChecker constructor." );
}
public void checkSpelling(){
System.out.println("Inside checkSpelling." );
}
}
Following is the content of the MainApp.java file −
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
TextEditor te = (TextEditor) context.getBean("textEditor");
te.spellCheck();
}
}
Following is the configuration file Beans.xml which has configuration for the setter-based injection but
using inner beans −
Spring - Quick Guide
Once you are done creating the source and bean configuration files, let us run the application. If
everything is fine with your application, it will print the following message −
Inside SpellChecker constructor.
Inside setSpellChecker.
Inside checkSpelling.
Spring - Injecting Collection
You have seen how to configure primitive data type using value attribute and object references using ref
attribute of the tag in your Bean configuration file. Both the cases deal with passing singular
value to a bean.
Now what if you want to pass plural values like Java Collection types such as List, Set, Map, and
Properties. To handle the situation, Spring offers four types of collection configuration elements which
are as follows −
Sr.No
Element & Description
1
This helps in wiring ie injecting a list of values, allowing duplicates.
2
This helps in wiring a set of values but without any duplicates.
Source Exif Data:
File Type : PDF
File Type Extension : pdf
MIME Type : application/pdf
PDF Version : 1.5
Linearized : No
Page Count : 67
Language : es-ES
Tagged PDF : Yes
Author : Ezequiel Llarena Borges
Creator : Microsoft® Word 2010
Create Date : 2018:01:12 20:34:07+01:00
Modify Date : 2018:01:12 20:34:07+01:00
Producer : Microsoft® Word 2010
EXIF Metadata provided by EXIF.tools