Let's summarize the reasons why constructor injection is recommended

Constructor injection and field injection

• Recently? I feel that I have a firm understanding of why constructor injection is recommended, so I decided to write this article because I wanted to summarize my thoughts and understanding.
• The following code is assumed to be implemented using SpringBoot, Java, JPA.

Advantages and disadvantages of field injection

• merit
• In the case of field injection, it is easy to inject because you just add @Autowired above the field.
• If you have more things to inject, just add a field and add @Autowired.
• Demerit
• The test becomes painful. (See below)

Implementation example with field injection

@Service
public class BookService{
    
    @Autowired
    private BookDao bookDao;
    
    @Autowired
    private HogeDao hogeDao;

    /**
     *Returns a Book that matches the argument bookId
     */
    public Book selectById(int bookId){
        Optional<Book> wrappedBook = bookDao.findById(bookId);
        return wrappedBook.orElseThrow(() -> NotFoundException("No"));
    }
                          .
                          .
                          .
}

Advantages and disadvantages of constructor injection

• merit
• Although there is a disadvantage that the amount of description increases, the field can be made Immutable.
• Easy to test. (See below)
• Demerit
• In the case of constructor injection, the amount of description is larger than that of field injection.
• When more things are injected, it's a bit more cumbersome to make changes compared to field injection.

Implementation example in constructor injection

@Service
public class BookService{
    private final BookDao bookDao;
    private final HogeDao hogeDao;
    
    @Autowired // → Spring4.This annotation can be omitted if it is 3 or more
    public BookService(BookDao bookDao, HogeDao hogeDao){
        this.bookDao = bookdao;
        this.hogeDao = hogedao;
    }

    /**
     *Returns a Book that matches the argument bookId
     */
    public Book selectById(int bookId){
        Optional<Book> wrappedBook = bookDao.findById(bookId);
        return wrappedBook.orElseThrow(() -> NotFoundException("No"));
    }
                          .
                          .
                          .
}

Improved testability by constructor injection

• As mentioned above, the constructor injection makes it easier to test.

When testing a class implemented by field injection

• Fields injected with @ Autowired can be mocked by using @ MockBean provided by Spring Boot.
• Since the annotation provided by SpringBoot is used, @RunWith (SpringRunner.class) and @SpringBootTest are required.

@RunWith(SpringRunner.class)
@SpringBootTest
public class BookServiceTests{

    @Autowired    
    private BookService bookService;

    @MockBean
    private BookDao bookDao;

    @MockBean
    private HogeDao hogeDao;

 
    @Test
public void Being able to get books with the specified bookId(){
        // setUp
        var expected = new Book(1, "Book name"); 
        when(bookDao.findById(1)).thenReturn(expected);
        var bookService = new BookService();

        // execute
        var actual = bookService.selectById(1);

        // verify
        assertThat(...Omitted below
    }
}

• At first glance, it looks very easy because you only need to add @MockBean, but Spring Boot Test takes a lot of time for unit testing ...
• I often get the error Failed to create application context. (Experienced)
• Occurs when the DB information described in application.yml (.properties) is incorrect.
• If the DB is not running, the test will not run in the first place
• Not because the DB is not running, but because the implementation is such that if there is no table in @ Table, it is automatically generated ...?
• In a test that is not related to DB, the error "DB is ..." appears and the stress is great (great)

When testing a class implemented by constructor injection

• It may be a bit of a hassle to mock with the @Before method.
• @RunWith (SpringRunner.class) and @SpringBootTest were required for the test implemented by field injection, but they do not need to be added here.

public class BookServiceTests{ 
    private BookService bookService;
    private BookDao bookDao;
    private HogeDao hogeDao;

    @Before
    public void setUp(){
        bookDao = Mockito.mock(BookDao.class);
        hogeDao = Mockito.mock(HogeDao.class);
        bookService = new BookService(bookDao, hogeDao);
    }
 
    @Test
public void Being able to get books with the specified bookId(){
        // setUp
        var expected = new Book(1, "Book name"); 
        when(bookDao.findById(1)).thenReturn(expected);
        var bookService = new BookService();

        // execute
        var actual = bookService.selectById(1);

        // verify
        assertThat(...Omitted below
    }
}

• Since SpringBoot related annotations are not added, the test runs smoothly.

• You don't have to worry about errors like Failed to create application context or" DB ... "and you can test without stress: smile:

• If it is troublesome to mock by yourself with the method with @Before, you can easily mock by adding @Mock provided by Mockito.

@RunWith(MockitoJUnitRunner.class)
public class BookServiceTests{ 
    private BookService bookService;

    @Mock
    private BookDao bookDao;
    @Mock
    private HogeDao hogeDao;

    @Before
    public void setUp(){
        bookService = new BookService(bookDao, hogeDao);
    }
    //Omitted below

• Please note that @RunWith (MockitoJUnitRunner.class) is required.

reference

• https://humble-mumble.com/mockbean-vs-mock/#st-toc-h-1