Introduction To Spring

Introduc)on to Spring
Ilio Catallo - info@iliocatallo.it

Outline
• What is Dependency Injec2on?
• The Spring Framework
• Wri2ng applica2ons in Spring
• References

Components
Applica'ons typically consist of components that work together to
form what the user sees as a coherent whole

Movie rental
Assume that we need to write a component that provides a list of
movies directed by a par5cular director1
1
This use case is an adapta/on from the Mar/n Fowler's seminal example on Inversion of Control (see references)

Movie rental
Moreover, assume we are told that movies are currently being
stored in a comma delimited ﬁle

MovieService
A"er much delibera/on, we delineate the following component,
which we decide to call MovieService
public class MovieService {
private CSVMovieRepository repository;
public List<Movie> moviesDirectedBy(String directorName) { ... }
}

MovieService
Note that MovieService depends on CSVMovieRepository
public List<Movie> moviesDirectedBy(String directorName) { ... }
}

CSVMovieRepository
CSVMovieRepository is an addi'onal component that abstracts
the comma delimited ﬁle containing the list of movies
public class CSVMovieRepository {
public CSVMovieRepository(String filename) { ... }
public List<Movie> findAll() { ... }
}

The moviesDirectedBy use case
An immediate implementa,on of moviesDirectedBy() is
therefore as follows:
public List<Movie> moviesDirectedBy(String directorName) {
List<Movie> movies = repository.findAll();
Iterator<Movie> it = movies.iterator();
while (it.hasNext()) {
Movie movie = it.next();
if (!movie.getDirector().equals(directorName))
it.remove();
}
return movies;
}

The moviesDirectedBy use case
Alterna(vely, we can use the Stream API in order to obtain a terser
implementa(on
repository.findAll()
.stream()
.filter(m -> m.getDirector().equals(directorName))
.collect(Collectors.toList());
}

MovieService class
public MovieService() {
this.repository = new CSVMovieRepository("movies.csv");
}
Iterator<Movie> it = movies.iterator();
while (it.hasNext()) {
Movie movie = it.next();
if (!movie.getDirector().equals(directorName))
it.remove();
}
return movies;
}
}

Unit tes(ng MovieService
Assume that we now want to unit test MovieService
public class MovieServiceTest {
@Test
public void moviesDirectedByTest() {
...
}
}

We want to ensure the correctness of moviesDirectedBy() by
checking its output against a set of controlled movies

For instance, given the following data
Sophia Coppola, Lost in Translation
Christopher Nolan, Inception
Christopher Nolan, The Dark Knight

We want to test if moviesDirectedBy("Sophia Coppola")
returns the expected output
@Test
List<Movie> movies = service.moviesDirectedBy("Shopia Coppola");
assertTrue(movies.length == 1);
assertTrue(movies.get(0).getDirector().equals("Sophia Coppola"));
assertTrue(movies.get(0).getTitle().equals("Lost in Translation"));
}

MockMovieRepository
We can therefore devise a MockMovieRepository:
public class MockMovieRepository {
public List<Movie> findAll() {
return Arrays.asList(
new Movie("Sophia Coppola", "Lost in Translation"),
new Movie("Christopher Nolan", "Inception"),
new Movie("Christopher Nolan", "The Dark Knight")
);
}
}

To use our test data, we need to replace CSVMovieRepository
with MockMovieRepository

We need to unplug MovieService from CSVMovieRepository

However, there is no way to replace CSVMovieRepository with
MockMovieRepository
}
}

This is because MovieService instan-ates its own dependency
}
}

MovieService cannot be tested
Thus, we found out that our solu1on is not unit testable
}
}

What could ever happen?
¯_( )_/¯

Variability
Apart from testability, we may face an even bigger issue with our
solu7on

Variability
Assume that we are suddenly been told that from now on movies
are going to be stored in a rela%on database

Variability
That requires changing MovieService, even though the real
change involves a diﬀerent component
public SQLMovieRepository repository;
this.repository = new SQLMovieRepository(...);
}
...
}

Obtaining the movie list
This appears even more suspicious if we no2ce that the
implementa2on of moviesDirectedBy() does not change
...
}

As a ma&er of fact, MovieService does not need to know how
the movies are stored
...
}

There are many diﬀerent ways of storing the movie list
• Database
• File system
• Remote web service

MovieRepository as an interface
We can explicitly model this variability by deﬁning a
MovieRepository interface with a unique method
public interface MovieRepository {
List<Movie> findAll();
}

MovieRepository as an interface
Each MovieRepository implementa-on has its own way of
retrieving the data
public class SQLMovieRepository implements MovieRepository {...}
public class CSVMovieRepository implements MovieRepository {...}
public class RESTMovieRepository implements MovieRepository {...}

External dependency
Instead of le,ng MovieService look up the right
implementa5on, we provide it as an external dependency
private MovieRepository repository;
public MovieService(MovieRepository repository) {
this.repository = repository;
}
...
}

Composing objects
We can now provide diﬀerent implementa2ons of
MovieRepository to MovieService
}
...
}

Composing objects
This allows diﬀerent developers to reuse the same components in
diﬀerent situa5ons
}
...
}

Dependency inversion principle
What we did in the above is a direct applica3on of the dependency
inversion principle

Dependency inversion principle
1. High-level modules should not depend on low-level modules.
Both should depend on abstrac:ons
2. Abstrac:ons should not depend upon details. Details should
depend upon abstrac:ons

Both should depend on abstrac1ons
+--------------+ +-----------------+
| | | |
| MovieService +----------> MovieRepository |
| | | |
+--------------+ +--------^--------+
|
|
|
+---------+----------+
| |
| SQLMovieRepository |
| |
+--------------------+

Details should depend upon abstrac2ons

Details should depend upon abstrac2ons
+--------------------------------------------------+
| |
| +--------------+ +-----------------+ |
| | | | | |
| | MovieService +----------> MovieRepository | |
| | | | | |
| +--------------+ +--------^--------+ |
| | |
+--------------------------------------------------+
|
+---------+----------+
| |
| |
+--------------------+

Testability
As a welcome byproduct, we gain the possibility of tes8ng
MovieService
@Test
MovieService ms = new MovieService(new MockMovieRepository());
List<Movie> movies = ms.moviesDirectedBy("Sophia Coppola");
assertTrue(movies.length == 1);
assertTrue(movies.get(0).getDirector().equals("Sophia Coppola"));
assertTrue(movies.get(0).getTitle().equals("Lost in Translation"));
}

Deciding for a MovieRepository
At a certain point we need to decide for a speciﬁc implementa-on
of MovieRepository

Factories
To this end, we write a factory class, whose responsibility is to
provide fully-constructed MovieService objects

Factories
For instance, we could devise the following simple factory2
public class MovieServiceFactory {
public MovieService create(String type) {
if (type.equals("CSV")) return new MovieService(new CSVMovieRepository(...));
if (type.equals("SQL")) ...
return null;
}
}
2
Here, we are using the so called simple factory pa/ern. Although it is in turn sub-op9mal, we decided for this
pa<ern because of the similarity of its interface with that of Spring's own factories

Factories
We can ﬁnally obtain a fully-constructed MovieService
public static void main(String[] args) {
...
MovieService service = factory.create("SQL");
List<Movie> movies = service.moviesDirectedBy("Sophia Coppola");
}

Wiring objects
Developers of the applica0on are in charge of wiring the diﬀerent
components together

Wiring objects
That is, developers are in control of the assembly phase of the
applica5on components

Wiring objects
Developers would happily give up this control to someone else

Wiring objects
That is, developers would happily stop wri$ng factories

Wiring objects
We would like a 3rd
-party factory to take care of crea0ng and
wiring the diﬀerent objects of the applica0on on our behalf
MovieService movieService = externFactory.getComponent("SQL");

Dependency Injec+on
Dependency injec+on (DI) is a pa*ern whereby the responsibility
of crea7ng and wiring applica7on objects is deferred to a 3rd
-party
factory

Dependency Injec+on
Namely, the 3rd
-party factory will:
• Instan'ate components
• Provide dependencies to each component
• Manage the lifecycle of each component

The Spring framework
Spring is a Java framework that provides comprehensive
infrastructure support for developing Java applica6ons

Spring DI Containers
In Spring, applica-on components are instan&ated and managed
directly by the framework

Objects live within a dependency-inversion container
+-------------------------------+
| +-------+ +-------+ |
| | | | | |
| | A +------> B | |
| | | | | |
| +---^---+ +---^---+ |
| | | |
| | | |
| +---+---+ | |
| | | | |
| | C +----------+ |
| | | |
| +-------+ |
+-------------------------------+
Spring DI container

Such a DI container plays the role of the 3rd
-party factory
+-------------------------------+
| +-------+ +-------+ |
| | | | | |
| | A +------> B | |
| | | | | |
| +---^---+ +---^---+ |
| | | |
| | | |
| +---+---+ | |
| | | | |
| | C +----------+ |
| | | |
| +-------+ |
+-------------------------------+
Spring DI container

It is responsible for instan&a&ng and assembling the objects
+-------------------------------+
| +-------+ +-------+ |
| | | | | |
| | A +------> B | |
| | | | | |
| +---^---+ +---^---+ |
| | | |
| | | |
| +---+---+ | |
| | | | |
| | C +----------+ |
| | | |
| +-------+ |
+-------------------------------+
Spring DI container

Spring beans
A bean is an applica)on object that is instan)ated, and otherwise
managed by a Spring DI container
+-------------------------------+
| +-------+ +-------+ |
| | | | | |
| | A +------> B | |
| | | | | |
| +---^---+ +---^---+ |
| | | |
| | | |
| +---+---+ | |
| | | | |
| | C +----------+ |
| | | |
| +-------+ |
+-------------------------------+
Spring DI container

Spring comes with two families of containers:
• Containers that implement the BeanFactory interface
• Containers that implement the ApplicationContext
interface

BeanFactory
The BeanFactory interface provides basic support for DI

ApplicationContext
The ApplicationContext interface extends BeanFactory,
providing addi4onal func4onali4es
• Interna(onaliza(on support
• The ability to load resource ﬁle

Bean retrieving
The ApplicationContext interface models a sophis2cated
implementa2on of the factory pa*ern
T getBean(String name, Class<T> requiredType)

Bean retrieving
By using the getBean() method, developers can retrieve
instances of the applica7on beans
T getBean(String name, Class<T> requiredType)

Bean retrieving
Example of bean retrieving:
ApplicationContext c = new ClassPathXmlApplicationContext("ex1.xml");
MovieService movieService = c.getBean("SQL", MovieService.class);

Bean retrieving
ClassPathXmlApplicationContext is an implementa+on of
ApplicationContext

Configura)on metadata
The container gets instruc/ons on what objects to instan/ate and
configure by reading some configura)on metadata
+ Business objects
|
|
|
|
+---------v---------+
| |
| Spring |
+-------------> Container |
| |
Configuration +---------+---------+
metadata |
(e.g., XML file) |
|
v Fully configured
system

The conﬁguring metadata can be represented in:
• XML
• Java annota,on
• Java code

The conﬁgura-on metadata ex1.xml is loaded from the
CLASSPATH

Dependencies vs. business logic
The DI Container allows decoupling the speciﬁca(on of
dependencies from the actual program logic

Wri$ng applica$ons with Spring

POJOs
Many Java frameworks require developers to extend classes or
implement interfaces provided by the framework itself
public class MyServlet extends HttpServlet {
public void doGet(HttpServletRequest request,
HttpServletResponse response);
public void doPost(HttpServletRequest request,
HttpServletResponse response);
public void init();
public void destroy();
}

POJOs
Spring beans are instead Plain Old Java Objects (POJOs)
}
...
}

POJOs
Because of this, components in a Spring-based applica8on o9en
have no indica(on that they are being used by Spring

Movie rental
Assume that we want to take advantage of the Spring framework
for our movie rental applica.on

Movie rental
We need to instruct the Spring DI container about the dependency
between MovieService and MovieRepository
+--------------+ +-----------------+
| | | |
| MovieService +----------> MovieRepository |
| | | |
+--------------+ +--------^--------+
|
|
|
+---------+----------+
| |
| |
+--------------------+

Conﬁguring the container
We need to conﬁgure Spring to tell it what beans it should contain,
and how to wire those beans
+---------------------------------------------------+
| +--------------+ +-----------------+ |
| | | | | |
| | MovieService +----------> MovieRepository | |
| | | | | |
| +--------------+ +--------^--------+ |
| | |
| | |
| | |
| +---------+----------+ |
| | | |
| | SQLMovieRepository | |
| | | |
| +--------------------+ |
+---------------------------------------------------+
Spring DI container

Conﬁguring the container
For now, we will focus on tradi2onal XML conﬁgura-on

The <beans> element
The root element of the Spring conﬁgura4on ﬁle is the <beans>
element
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/
spring-beans.xsd">

</beans>

The <bean> element
Each applica)on bean is associated with a <bean> element in the
XML conﬁgura)on ﬁle
<bean id="inMemoryMovieRepository”
class="it.polimi.awt.repository.InMemoryMovieRepository">
...
</bean>

The <bean> element
Every bean has one (or more) id a0ribute, and a class a0ribute
<bean id="inMemoryMovieRepository”
class="it.polimi.awt.repository.InMemoryMovieRepository">
...
</bean>

The <bean> element
Namely:
• If more iden,ﬁers are speciﬁed, the extra ones are considered as
aliases
• The class a8ribute could either specify the class of the bean to
be constructed or the name of a sta,c factory method

How to inject dependencies
In Spring, dependencies are injected through:
• Construc*on-based injec*on
• Se4er-based injec*on
• Arguments to a factory method

Constructor-based injec1on
Constructor-based injec1on is accomplished by the container
invoking the bean constructor
<bean id="movieService" class="it.polimi.awt.service.MovieService">
<constructor-arg ref="inMemoryMovieRepository"/>
</bean>

Constructor-based injec1on
The <constructor-arg> element allows injec0ng a dependency
through a constructor call
<bean id="movieService" class="it.polimi.awt.spring.MovieService">
<constructor-arg ref="inMemoryMovieRepository"/>
</bean>

Se#er-based injec/on
Se#er-based injec/on is accomplished by the container calling
se3er methods on the bean3
<bean id="lostInTranslation" class="it.polimi.awt.domain.Movie">
<property name="title" value="Lost in Translation"/>
<property name="director" value="Sophia Coppola"/>
</bean>
3
As we will see, Movies are domain objects, which usually do not need injec5on. Here, we are doing this for the
sole sake of presen5ng an example of se>er-based injec5on

Se#er-based injec/on
The <property> element injects the dependency by calling the
property se5er
<bean id="lostInTranslation" class="it.polimi.awt.domain.Movie">
<property name="title" value="Lost in Translation"/>
<property name="director" value="Sophia Coppola"/>
</bean>

Constructor vs. se-ers
As a rule of thumb, use constructor arguments for mandatory
dependencies and se6ers for op*onal dependencies

Spring beans vs. JavaBeans
Despite the similar name, keep in mind that a DI container is not
limited to JavaBeans4
and it can manage virtually any class
4
Recall that JavaBeans are objects with i) only a default constructor; and ii) appropriate ge<ers and se<ers

References
• Mar%n Fowler, Inversion of Control and Dependency Injec%on
pa;ern
• SpringSource, Spring Framework Reference
• Craig Walls, Spring in Ac%on (3rd Edi%on), Manning Publica%ons

Introduction To Spring

More Related Content

Viewers also liked (20)

Similar to Introduction To Spring (20)

More from Ilio Catallo (20)

Recently uploaded (20)

Introduction To Spring