Dependency Injection with Spring

TABLE OF CONTENTS

• Introduction
• DI Annotation in Spring
• Milestone #1: @AutoWired in Unit Tests
• Activity #1
• Activity #2
• Milestone #2: Mockito & Spring
• Activity #3
  • Code Segment #1
• Activity #4
• Activity #5
• Activity #6
• Key Takeaway

Introduction

The most popular use case of DI in the Java programming world would be undoubtedly the Spring framework. It’s widely popular and being used across various companies worldwide. Since the early 2000, it has been considered as a standard framework for application development. 

    At the core, Spring framework is a Dependency Injection Container, with a couple of convenience layers like service, controllers etc. It is responsible for creating and maintaining the object’s life cycle with few special annotations. You may have seen the annotations like @Autowired , @Service , @RestController & several others in various java classes in the java backend application code.

DI Annotation in Spring

The annotation @Autowired is used for injecting dependencies. This annotation is used for “auto-wiring” in the Spring. Autowiring is the process on which the framework figures out the dependencies of a Spring bean, instead of us explicitly specifying them. We can annotate fields and constructor using @Autowired to tell Spring framework to find dependencies for you.

    Let us see this with the example of the class CarFactory, which had a dependency on the class TyreFactory. In Spring, the only change that needs to be done is adding the annotation @Autowired before the dependent attribute. Rest all stays the same. It can be done in the following manner.

public class CarFactory {

   @Autowired
   private TyreFactory tyreFactory;

   public Car getCar(CarType type, String color, 
                     String model, double tyreDiameter, 
                     String tyreMaterials){

       Tyre tyre = tyreFactory.getTyre(type, tyreDiameter, tyreMaterials);

       return new Car(type, color, model, tyre);
   }
}

Milestone #1: @AutoWired in Unit Tests

Now, let’s experiment with Spring DI further using unit tests. Our earlier test class for TyreFactory now has a few more annotations added.

Car.java

package org.crio.qcar;

import org.crio.qcar.tyres.Tyre;
import org.crio.qcar.tyres.TyreFactory;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit.jupiter.SpringExtension;

import static org.junit.jupiter.api.Assertions.assertEquals;

@ExtendWith(MockitoExtension.class)
@SpringBootTest(classes = Driver.class)
public class TyreFactoryTest {

   @Autowired
   private TyreFactory tyreFactory;

   @Test
   public void TestSedanTyre(){
       Tyre tyre = tyreFactory.getTyre(CarType.Sedan, 26, "rubber");

       assertEquals("Michelin", tyre.getManufacturer().toString());
   }
}

Activity #1

Can you check, whether the instances created with  @Autowired creates a new object every time or are those singleton? 

Hint:

use System.identityHashCode() to your rescue. 

Follow-up Question:

What’s the advantage of doing so?

Answer:

Creating Singleton will save resources and time.

Activity #2

What happens if we remove the @autowired annotation for “TyreFactory” in the “TyreFactoryTest” class? 

Answer:

It will fail with a Null pointer exception as the object will not be initialized. This is one of the most common errors, where the Spring Boot application fails to start.

Milestone #2: Mockito & Spring

No, let’s see how we can use auto-wiring along with mocking dependencies. The test case we wrote earlier for CarFactory had dependency on the beans of CarFactory and TyreFactory. Here’s the new version of that test class.

package org.crio.qcar;

import org.crio.qcar.tyres.*;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.when;

@ExtendWith(MockitoExtension.class)
@SpringBootTest(classes = Driver.class)
public class CarFactoryTest {

   @MockBean
   private TyreFactory tyreFactory;

   @InjectMocks
   private CarFactory carFactory;

   @Test
   public void verifyCarCategoryHatchbackMRF(){
       when(tyreFactory.getTyre(any(CarType.class), any(Double.class), any(String.class)))
               .thenReturn(new MRFTyre(27, "rubber"));
       Car car = carFactory.getCar(CarType.Hatchback, "Steel Grey", "", 27, "rubber");

       assertTrue(car.getCategory().startsWith("Hatchback-MRF-"));
   }
}

We can see @SpringBootTest here as well along with the application class name. Here, 2 new annotations are being used here: @MockBean & @InjectMocks.

    @MockBean is used for automatically creating the bean for the class for mocking. Here, as we are mocking the instance for TyreFactory to return our preferred tyre, we are using this annotation here.

    @InjectMocks is used for auto-creation of beans, for which dependencies need to be mocked. Thus, we are using this for the CarFactory instance. Rest of the code remains the same as     before.

Activity #3

Predict the output of the following code segments for the class CarFactoryTest.java. In case of failures, debug the test cases to zero down the exact reason of failure.

public class CarFactoryTest {

   @Autowired
   private TyreFactory tyreFactory;

   @InjectMocks
   private CarFactory carFactory;
   @Test
   public void verifyCarCategoryHatchbackMRF(){
       Car car = carFactory.getCar(CarType.Hatchback, "Steel Grey", "", 27, "rubber");

       assertTrue(car.getCategory().startsWith("Hatchback-MRF-"));
   }
}

java.lang.NullPointerException
  at org.crio.qcar.CarFactory.getCar(CarFactory.java:17)
  at org.crio.qcar.CarFactoryTest.verifyCarCategoryHatchbackMRF(CarFactoryTest.java:25)
      …

CarFactoryTest > verifyCarCategoryHatchbackMRF() FAILED
    java.lang.NullPointerException at CarFactoryTest.java:25
1 test completed, 1 failed

public class CarFactoryTest {

   @Autowired
   private TyreFactory tyreFactory;

   @Autowired
   private CarFactory carFactory;

   @Test
   public void verifyCarCategoryHatchbackMRF(){
       Car car = carFactory.getCar(CarType.Hatchback, "Steel Grey", "", 27, "rubber");

       assertTrue(car.getCategory().startsWith("Hatchback-MRF-"));
   }
}

public class CarFactoryTest {

   @MockBean
   private TyreFactory tyreFactory;

   @InjectMocks
   private CarFactory carFactory;

   @Test
   public void verifyCarCategoryHatchbackMichelin(){
       MichelinTyre michelinTyre = new MichelinTyre(27, "rubber");
       when(tyreFactory.getTyre(any(CarType.class), any(Double.class), any(String.class)))
               .thenReturn(michelinTyre);
       Car car = carFactory.getCar(CarType.Hatchback, "Steel Grey", "", 27, "rubber");

       assertTrue(car.getCategory().startsWith("Hatchback-Michelin-"));
   }
}

public Car getCar(CarType type, String color, String model, double tyreDiameter, String tyreMaterials){
   Tyre tyre = new TyreFactory().getTyre(type, tyreDiameter, tyreMaterials);
   
   return new Car(type, color, model, tyre);
}

Key Takeaway

In this section, we’ve learned about the @Autowired annotation, where to use it and where we shouldn’t. We have also seen examples of writing test cases with auto-wiring and some common mistakes.