Dependency injection design pattern is introduced in order to solve some common issues due to explicit wiring between a component and its collaborator or service. Spring Framework and AngularJS are involved to show how dependency injection could simplify the way of writing code but above all testing. Clean and concise code is obtained using DI. Real example are provided on Github and Plunkr.

1. Introduction to dependency injection.
Spring, AngularJs
Dependency
Injection
Brief introduction

2. 0A pre-dependency injection
Base example
Advantages
• easily enable testability
• clean and concise code
• testing client and service in isolation
• client no need to know how to build the dependency object graph

3. 0A pre-dependency injection
Encapsulate creation
1 public class Emailer {
2
3 private SpellChecker spellChecker;
4
5 public Emailer() {
6 this.spellChecker = new SpellChecker();
7 }
8
9 public void send(String text) {
10 //some implementation
11 }
12 }
How to test?
• Impossible: MockSpellChecker cannot substitute the internal spellChecker.
Change implementation?
• Impossible: Emailer encapsulates the creation of its dependencies.

4. 0A pre-dependency injection
Construction by hand
1 public class Emailer {
2
3 private SpellChecker spellChecker;
4
5 public void send(String text) {
6 //some implementation
7 }
8
9 public void setSpellChecker(SpellChecker spellChecker) {
10 this.spellChecker = spellChecker;
11 }
12 }
Pros
• Setter method: different flavors of the service can be injected.
Cons
• Object construction knowledge: on the client of the service.
• Repeat wiring code
• What about: encapsulation principle and altering the object graph?

5. 0A pre-dependency injection
Construction by hand test
Pros
• Setter method: MockSpellChecker can be easily injected.
• Check if dependency has been correctly used.
Cons
• Repeat wiring code
1 @Test
2 public void testEmailerCheckSpelling() throws Exception {
3
4 MockSpellChecker mockSpellChecker = new MockSpellChecker();
5
6 Emailer emailer = new Emailer();
7
8 emailer.setSpellChecker(mockSpellChecker);
9 emailer.send("Hello World");
10
11 assert mock.isSpellCheckingDone();
12 }

6. 0A pre-dependency injection
Factory pattern
Pros
• Level of abstraction: Emailer client code is separated from the Emailer creation.
• No internal knowledge: client code only use a specific factory to obtain a dependency.
• Code clean and concise even with richer and more complex object graph.
Cons
• Extreme growth: factory classes tend to grow becoming really big and uncontrolled.
1 public class EmailerFactory {
2
3 public Emailer newFrenchEmailer() {
4 return new Emailer(new FrenchSpellChecker());
5 }
6
7 public Emailer newJapaneseEmailer() {
8 return new Emailer(new JapaneseSpellChecker());
9 }
10 }
11
12 //somewhere in the Client code
13 Emailer emailer = new EmailerFactory().newFrenchEmailer();

7. 0A pre-dependency injection
Factory pattern test
Pros
• Level of abstraction: Emailer client code is separated from the Emailer creation.
• No internal knowledge: client code only use a specific factory to obtain a dependency.
• Code clean and concise even with richer and more complex object graph.
Cons
• Extreme growth and maintenance: factory classes tend to grow becoming really big and uncontrolled.
1 public class EmailerFactory {
2
3 public Emailer newFrenchEmailer() {
4 return new Emailer(new FrenchSpellChecker());
5 }
6
7 public Emailer newJapaneseEmailer() {
8 return new Emailer(new JapaneseSpellChecker());
9 }
10 }
11
12 //somewhere in the Client code
13 Emailer emailer = new EmailerFactory().newFrenchEmailer();

8. 0A pre-dependency injection
Factory pattern test
1 public class EmailClient {
2 private Emailer emailer = new EmailerFactory.newEnglishEmailer();
3
4 public void run() {
5 emailer.send("Hello World");
6 }
7 }
8
9 @Test
10 public void testEmailClient() {
11 MockEmailer mock = new MockEmailer();
12 EmailerFactory.set(mock);
13
14 new EmailClient.run();
15
16 assert mock.correctlySent();
17 }
How & Cons to test with factory
• Heavily modify factory class code to support testing for any client, state is shared thus
code cleanup required after each test.
• Create a factory mock or stub which can easily grow, it must accompany every variation
of every service.

9. 0B dependency injection
Hollywood Principle: don’t call us; we’ll call you!
Enable
• Unawareness: client not aware of the Emailer kind.
• Reversal of responsibilities: service not explicitly required.
Pros
• Easily enable testability via setter method or constructor injection (construction by hand).
• Client no needs to know its dependencies and how to build them (factory pattern).
• Dependencies are not required but provided (new).
1 public class Emailer {
2 public void send(String text) {
3 //some implementation
4 }
5 //some other methods
6 }
7
8 public class SimpleEmailClient {
9 private Emailer emailer;
10
11 public SimpleEmailClient(Emailer emailer) {
12 this.emailer = emailer;
13 }
14 public void sendEmail() {
15 emailer.send(readMessage());
16 }
17 }

10. 0B dependency injection
Hollywood Principle: don’t call us; we’ll call you!
embodies the
Hollywood Principle
Dependency Injector
• Control over construction, wiring and assembly dependency or object graph.
• Separates infrastructure code (wiring and construction) from application code (core
purpose of the service)

11. 0C dependency injection with Spring
Spring Framework
Spring
• Open source application framework and inversion of control container for Java platform.
• 1 October 2002, release 1.0.0, 7 July 2014, release 4.0.6, now 4.1.0 RC1
• active development and evolution to meet new programming requirements
• Developed by Pivotal, a spin-out and joint venture of EMC Corporation and VMware.
• Excellent documentation, clean and tested code, wide community and support.
Projects
• Spring Framework
• core support for dependency injection, transaction management
• Spring Data
• provide consistent approach to data access
• relational, non-relational, map-reduce and much more
• Spring XD
• simplify the development of big data applications
• address analytics, batch jobs and data export
• much more…

12. 0C dependency injection with Spring
Example: the client of the service
Client
• SimpleEmailClient decoupled from the EmailerService implementation.
• SimpleEmailClient unaware of which implementation will be provided at runtime,
programming against interfaces (OOP principle).
1 @Component
2 public class SimpleEmailClient {
3
4 final private EmailerService service;
5
6 @Autowired
7 public SimpleEmailClient(EmailerService service) {
8 this.service = service;
9 }
10
11 public void printMessage() {
12 System.out.println(this.service.getMessage());
13 }
14 }

13. 1 @Configuration
2 @ComponentScan
3 public class Application {
4
5 @Bean
6 MessageService mockEmailerService() {
7 return new EmailerService() {
8 public String getMessage() {
9 return "Hello World!";
10 }
11 };
12 }
13
14 public static void main(String[] args) {
15 ApplicationContext context =
16 new AnnotationConfigApplicationContext(Application.class);
17 SimpleEmailClient client = context.getBean(SimpleEmailClient.class);
18 client.printMessage();
19 }
20 }
0C dependency injection with Spring
Example: the service and the mock
Injected mock
implements the
interface
Injector wires client
with its dependency

14. 0C dependency injection with Spring
Another example with integration test
1 @Entity
2 @Table(name = "MOVIE")
3 public class Movie extends AbstractEntity {
4
5 @Column(name = "TITLE")
6 private String title;
7
8 protected Movie() {...}
9 }
Movie example
• Simple Movie class annotated JPA 2.0, Hibernate, store and retrieve.
• A service interface is given.
• Repository and service should be created and implemented to support basic CRUD operations.
Code on Github
• The code of the example is available on Github
1 public interface MovieService {
2
3 List<Movie> findAll();
4
5 Movie create(final Movie movie);
6
7 Movie delete(final Movie movie);
8
9 Movie update(final Movie movie);
10 }

15. 0C dependency injection with Spring
Integration test: another example
Movie repository and service
• No need to implement basic CRUD methods as findAll(), delete(), save() etc.
• Methods are resolved based on attribute names, just declare in the repository interface findById() to have
it automatically implemented at runtime where Id is the attribute.
• More complex methods have to be directly implemented.
• Clean and concise code, no need to implement explicit SQL query, reduce boiler-plate code.
1 @Repository
2 @Transactional
3 public class MovieServiceImpl implements MovieService {
4
5 @Autowired
6 private MovieRepository movieRepository;
7
8 @Override
9 public final List<Movie> findAll() {
10 return Lists.newArrayList(movieRepository.findAll());
11 }
12 ...
13 }
1 public interface MovieRepository extends CrudRepository<Movie, Long> {
2 }

16. 0C dependency injection with Spring
Integration test: another example
1 @ActiveProfiles("test")
2 public class MovieServiceImplTest extends AbstractServiceImplTest {
3
4
5 @Autowired
6 private MovieService movieService;
7
8 @DataSets(setUpDataSet = "/MovieServiceImplTest.xls")
9 @Test
10 public final void testFindAll() throws Exception {
11 List<Movie> results = movieService.findAll();
12
13 assertNotNull(results);
14 assertThat(results.size(), equalTo(3));
15 }
16 }
Injected
implementation based
on the interface
Build ApplicationContext
based on the active
profile
Insert into the data source tables
from xls file before the method
execution.
After method execution
automatic rollback.

17. 1 @RunWith(SpringJUnit4ClassRunner.class)
2 @ContextConfiguration(classes = {ServiceTestConfig.class})
3 @TestExecutionListeners({ServiceTestExecutionListener.class})
4 @ActiveProfiles("test")
5 public abstract class AbstractServiceImplTest extends
AbstractTransactionalJUnit4SpringContextTests {
6
7 @PersistenceContext
8 protected EntityManager em;
9 }
0C dependency injection with Spring
ApplicationContext
configuration with a
specific data source,
schema and data.
Based on a standard
JUnit Runner.
Standard javax.persistence,
hibernate jpa 2.0 api.
Listener to intercept
standard test execution
lifecycle.
Test
• Non invasive solution to build integration tests based on standard frameworks like
JUnit and Hibernate
• It works on top of standard frameworks providing clean and concise code for complex
test cases.
Integration test: another example

18. 1 @Configuration
2 @ImportResource("classpath:datasource-tx-jpa.xml")
3 @ComponentScan(basePackages = {"com.contrastofbeauty.movieapp.service"})
4 @Profile("test")
5 public class ServiceTestConfig {
6
7 @Bean
8 public DataSource dataSource() {
9 return new EmbeddedDatabaseBuilder()
.setType(EmbeddedDatabaseType.H2)
.addScript("classpath:schema.sql").build();
10 }
11
12 @Bean(name = "databaseTester")
13 public DataSourceDatabaseTester dataSourceDatabaseTester() {
14 DataSourceDatabaseTester databaseTester = new DataSourceDatabaseTester(dataSource());
15 return databaseTester;
16 }
17
18 @Bean(name = "xlsDataFileLoader")
19 public XlsDataFileLoader xlsDataFileLoader() {
20 return new XlsDataFileLoader();
21 }
22 }
0C dependency injection with Spring Reuse transaction and
JPA configuration
DbUnit classes to load xls files
and setup the data source
Data source
configuration
Integration test: another example

19. 0C dependency injection with Spring
Considerations
Spring Debate
• Spring is not standard.
• Just pointless, Spring promote the use of standard.
• Really important to have a standard, but if the solution of your problem is not standard you will
wait three or more years?
• Spring Social (JSR-357 rejected in 2012, really opened debate on future)
• Widespread container testing done with Arquillan, JBoss specific.
• Spring is not compatible.
• Free to use JPA, CDI annotations etc.
• Use all Java EE technologies and additional features provide by Spring.
• Spring works with all Java EE application servers and more like Jetty and Tomcat.
• Spring is a must, best choice
• Not always and Just pointless, what are your requirements?
• Spring is a meta-framework, highly scalable, highly configurable but complex.
• Spring configuration could be difficult to manage when the project grows.
• Use only Spring dependency injection? May be consider what already provided by the container.

20. 0D AngularJS
$scope, $controller, $http and test with mocks
Where to find the code
• Github for source code: angulajs-popcorn
• Plunker online live editing: application and testing

21. 0D AngularJS
Definition
MVC Design Pattern
• View is projection of the model through the HTML template.
• Controller is a Javascript constructor function used to augment the Angular scope.
• Scope an object referring to application model, used along with data model, template and controller to keep
models and views in sync.
Template Model View
(model/view data binding)
Root
Scope
movieController
Scope
movies: Array
<!DOCTYPE html>
<html lang="en" ng-app="movieApp">
<body ng-controller="movieController">
<ul>
<li ng-repeat="movie in movies">
{{movie.title}}
</li>
</ul>
</body>
</html>
Repetear
Scope
movie: Object
▪ Commando
▪ Raw Deal
▪ Predator
n-times
ng-controller
ng-app
n-times

22. 0D AngularJS dependency injection
Definition
Angular Injection
• $scope injected into controller, scope is the glue between application controller and the view.
• $http injected, an Angular service to facilitate the communication with the remote HTTP server.
• $httpBackend mock of the real $httpBackend, backend used by the service to delegate to XMLHttpRequest.
1 var movieApp = angular.module('movieApp', ['xeditable', 'ngMockE2E']);
2
3 movieApp.controller('MovieController', function($scope, $http) {
4
5 $scope.loadMovies = function() {
6 return $http.get("/movies").success(function(response){
7 $scope.movies = response;
8 });
9 };
10 });
11
12 // --------------- mock $http requests ----------------------
13 movieApp.run(function($httpBackend) {
14 $httpBackend.whenGET('/movies').respond([
15 {id: 1, title: "Commando", actors: "Arnold Schwarzenegger"},
16 {id: 2, title: "Raw Deal", actors: "Arnold Schwarzenegger"},
17 {id: 3, title: "Predator", actors: "Arnold Schwarzenegger"}
18 ])
19 });

23. 0D AngularJS dependency injection
Test controller using Jasmine BDD framework
1 describe('Movie Controller test suite', function() {
2
3 describe('MovieController', function() {
4
5 var $scope, $httpBackend, createController, $http;
6
7 beforeEach(module('movieApp'));
8
9 beforeEach(inject(function($controller, $rootScope, _$httpBackend_, _$http_) {
10 $scope = $rootScope.$new();
11 $httpBackend = _$httpBackend_;
12 $http = _$http_;
13
14 createController = function() {
15 return $controller('MovieController', {
16 $scope: $scope
17 });
18 };
19 }));
20
21 it("should GET all the movies", function() {
22 $httpBackend.expectGET('/movies').respond(200, [{}, {}, {}]);
23 createController();
24 $scope.loadMovies();
25 $httpBackend.flush();
26 expect($scope.movies.length).toBe(3);
27 });
28 });
Jasmine description suite
Setup test context injecting
Angular services
Jasmine test declaration
or spec
Obtain the controller and
invoke the function to test
Assert the result

24. 0D AngularJS
Considerations
Advantages
• clean separation of concerns
• template is pure HTML, no other languages
• injection and made for testing
• two-way data binding, change in the view is reflected in the model and viceversa
• directives, markers on the DOM element to attach specific behavior or transform the element (ng-repeat)
• powerful and scalable to support big projects
• really well documented, excellent support, big community, fast growing set of libraries
Disadvantages
• learning curve, takes time
• best practices needed to avoid bad programming patterns i.e. code can be written inside of templates
• complexity, some parts are a bit complex to understand

25. 0D Bibliography
Dependency Injection
• Martin Fowler’s blog
• Inversion of Control
• SpringFramework
• Angular
• Google Guice
• JavaEE CDI