Dependency injection

Dependency Injection
With Spring
Presenter: Pranav Kumar, Mindfire Solutions

Agenda
 What is Dependency Injection ?
 Dependency Inversion Principle
 Types of Dependency Injection
 Why DI ?
 Understand DI with StudentSystem Example
 DI with Spring Configuration
 Benefits of DI
 DI Using Annotations

DI: What it is ?
 Dependency Injection is a software design pattern that allows removing hard
coded dependencies and making it possible to change them at run-time.
 Dependencies are injected into objects by a container.
 Also Known as Inversion Of Control (IoC).

DI Principle
 The dependency inversion principle was postulated by Robert C. Martin
 The principle states:
• Always use abstractions (Interface)
• Objects should define their dependencies only through
 Constructor arguments
 Arguments to a factory method.
 Properties which are set on the object instance

DI: Types
 Setter injection - Dependent module exposes a setter method that the framework uses to
inject the dependency.
 Constructor injection - Dependencies are provided through the class constructor.

DI: Why ?
 Dependency Injection enables 'POJO programming'
 POJO programming facilitate
- Simplicity
- Effective separation of concerns
- Proper unit testing
 Well-factored and well-tested code
- Tends to be well-designed code
- Evolves well into maintainable systems

Example: The Student System
 To improve your skills in Java development, you decide to develop a student system.
 You decide to use a file to store student information.
 You create a class FileStudentDAO responsible for writing and reading to the file
 You create a class StudentSystem responsible for performing the logic of the system.
 You’ve learned that it’s a good thing to program to interfaces

DI:

The DefaultStudentSystem

Works! Or .. ?
The system is a big success – University of Oslo wants to adopt it!

Works! Or .. ?
You make a new implementation of the StudentDAO for University of Oslo, a
MySQLStudentDAO:

Works! Or .. ?
 Won’t work! The FileStudentDAO is hard-coded into the StudentSystem:
 The DefaultStudentSystem implementation is responsible for obtaining a StudentDAO.
 Dependent both on the StudentDAO interface and the implementation
public class DefaultStudentSystem implements StudentSystem {
private StudentDAO studentDAO = new FileStudentDAO();
...

Problems: Student System
How to deploy the StudentSystem at different locations?
 Develop various versions for each location?
• Time consuming
• Confusing and error-prone
• Requires more efforts for versioning
Solution:
 Use Dependency Injection!
• More specific term derived from the term Inversion of Control

Traditional Vs DI

DI: With Spring
 Bean: A class that is managed by a Spring IoC container
 Setter based DI: Provide a public set-method for the dependency reference.

DI: Spring Configuration
 Configuration: How to instantiate, configure, and assemble the objects in your application
• The Spring container accepts many configuration formats
• XML based configuration most common.

studentDAO
Injected into
studentSystem
Refers to the
studentDAO
bean
Refers to the
studentDAO attribute in Java
class

Summary

DI: Benefits
 Easier to swap implementations of dependencies
 The system can be re-configured without changing the compiled code
 Easier testing
 Improved re-usability of your classes
 Cleaner code

DI: Using Annotations
 Annotation is a meta-tag – applied to classes, methods...
• Associated with program behaviour
 @Component
• Defines a class as a Spring container managed component
 @Autowired
• Tells Spring to inject a component
 Classpath scanning for components
• <context:component-scan base-package="org.example"/>

@Component
public class StudentService
{
@Autowired
StudentDAO studentDAO;
//constructors
//Getter setter methods
}
@Component
public class StudentDAO
{
@Override
public String toString() {
return "This is StudentDAO";
}
}
StudentService.java StudentDAO.java

<bean id="studentDAO" class="com.mindfire.spring.student.dao.StudentDAO"/>

<bean id="studentService" class="com.mindfire.spring.student.service.StudentService">
<property name="studentDAO" ref="studentDAO" />
<constructor-arg ref="studentDAO"> </constructor-arg>
</bean>

<context:component-scan base-package="com.mindfire.spring.student" />
Annotation configuration
XML Configuration

Resources
 Books
• Rod Johnson, Juergen Hoeller: Expert One-on-One J2EE
• Craig Walls and Ryan Breidenbach: Spring in Action
 The Spring reference documentation
• www.springframework.org

Questions ?

Dependency injection

Related slideshows

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (7)

Similar to Dependency injection

Similar to Dependency injection (20)

More from Mindfire Solutions

More from Mindfire Solutions (20)

Recently uploaded

Recently uploaded (20)

Dependency injection