[Spring] 스프링 의존성 주입(DI) 이란?

Spring 삼각형

스프링의 기반이 되는 설계 개념을 표현한 것

 

 

https://devlog-wjdrbs96.tistory.com/165

[Spring] 스프링 의존성 주입(DI) 이란?

출처 : https://sehun-kim.github.io/sehun/springbean-lifecycle/#2

스프링이란 IoC와 AOP를 지원하는 경량의 컨테이너 프레임워크이다. 

 

1. DI(Dependency Injection)이란? 

Inversion of Control 이라고도 하는 의존 관계 주입(Dependency Injection)이라고도 하며, 어떤 객체가 사용하는 의존 객체를 직접 만들어 사용하는게 아니라, 주입 받아 사용하는 방법이다. (new 연산자를 이용해서 객체를 생성하는 것이라고 생각하면 된다)

 

출처 : https://m.blog.naver.com/PostView.nhn?blogId=ljh0326s&logNo=221395815870&proxyReferer=https:%2F%2Fwww.google.com%2F

장난감들은 베터리가 있어야 움직일 수 있으며 즉 베터리에 의존하고 있다. 장난감들에게 베터리를 넣어주는 것을 의존성 주입이라고 생각하면 좋다.

 

자바코드로 예시를 들어보자

출처 : https://m.blog.naver.com/PostView.nhn?blogId=ljh0326s&logNo=221395815870&proxyReferer=https:%2F%2Fwww.google.com%2F

베터리의 일체형인 경우에는 생성자에서만 의존성을 주입해주는 상황이라 베터리가 떨어지게 된다면 다른 베터리로 교체하지 못하고 새로운 것으로 바꿔야 하기 때문에 유연하지 못한 방식이다.  

 

setter, 생성자를 이용해서 외부에서 주입해주는 상황은 외부에서 베터리를 교체해줄 수 있기 때문에 일체형보다 유연한 상황이다. 

 

 

의존성 예시와 정리

import org.springframework.stereotype.Service;

@Service
public class BookService {

    private BookRepository bookRepository;

    public BookService(BookRepository bookRepository) {
        this.bookRepository = bookRepository;
    }
}

@Service
public class BookRepository {
      // DI Test
}

위 코드와 같이 BookService 클래스가 만들어 지기 위해서는 BooRepository 클래스를 필요로 한다. 이것을 BookService 클래스는 BookRepository 클래스의 의존성을 가진다 라고 한다. 이와 같이 코드를 설계하였을 때, 코드의 재활용성이 떨어지고, 위 예제에서 BookRepository 클래스가 수정 되었을 때, BookService 클래스도 함께 수정해야하는 문제가 발생한다. 즉, 결합도(coupling)가 높아지게 된다. 그리고 위의 코드에서, BookRepository라는 클래스를 직접 new를 사용하여 객체를 주입하는 것이 아니라 생성자를 사용하여 주입받는 것을 Inversion of Control 이라고 한다.

 

강한 결합

객체 내부에서 다른 객체를 생성하는 것은 강한 결합도를 가지는 구조이다. A 클래스 내부에서 B 라는 객체를 직접 생성하고 있다면, B 객체를 C 객체로 바꾸고 싶은 경우에 A 클래스도 수정해야 하는 방식이기 때문에 강한 결합이다.

 

느슨한 결합

객체를 주입 받는다는 것은 외부에서 생성된 객체를 인터페이스를 통해서 넘겨받는 것이다. 이렇게 하면 결합도를 낮출 수 있고, 런타임시에 의존관계가 결정되기 때문에 유연한 구조를 가진다.

 

 

추가적으로 BookService와 BookRepository가 둘다 Bean으로 등록되어 있을 때 BookService의 생성자만 만들어주면 스프링 IoC 컨테이너가 BookRepository에 의존성 주입을 알아서 해준다.(스프링 4.3 이후부터는 생성자가 하나인 경우는 @Autowired를 사용하지 않아도 된다)

 

하지만 스프링이 없더라도 Inversion of control을 가능하다. 아래와 같이 직접 new 연산자로 주입을 하는 것이다.

import org.junit.Test;

public class BookServiceTest {

    @Test
    public void save() {
        BookRepository bookRepository = new BookRepository();
        BookService bookService = new BookService(bookRepository);
    }
}

이렇게 코드를 사용하지 않고 스프링이 제공하는 IoC 컨테이너를 사용하는 이유는 지금까지의 개발자의 노하우와 여러 가장 좋은 기능들이 IoC 컨테이너에 쌓여있기 때문에 사용하는 것이다. 

 

 

 

스프링 IoC 컨테이너란?

• 가장 중요한 인터페이스는 BeanFactory, ApplicatonContext이다
• 애플리케이션 컴포넌트의 중앙 저장소이다.
• 빈 설정 소스로 부터 빈 정의를 읽어들이고, 빈을 구성하고 제공한다.
• 빈들의 의존 관계를 설정해준다.(객체의 생성을 책임지고, 의존성을 관리한다)

 

출처 : https://sehun-kim.github.io/sehun/springbean-lifecycle/#2

출처 : http://www.incodom.kr/spring/%EC%BB%A8%ED%85%8C%EC%9D%B4%EB%84%88

POJO

Plain Old Java Object, 직역하면 오래된 방식의 자바 객체라는 뜻으로 평범한 클래스이다. 종속되지 않는다는 것은 코드를 간결히 할 수 있고, 객체지향 설계를 충실히 이행하고 있음을 보여준다.

 

스프링 특징을 보다보면 POJO라는 단어가 존재한다. 과거에는 자바로 웹 어플리케이션을 개발하기 위해서는 Servlet 클래스를 상속받아서 사용했다. 이 Servlet 클래스는 POJO가 아닌 것이다. 즉 Servlet 클래스를 작성하지 않고 POJO만으로 웹 어플리케이션을 개발할 수 있다는 것이 스프링의 특징이다. 

 

 

IoC 사용 목적

클래스 호출 방식

클래스내에 선언과 구현이 같이 있기 때문에 다양한 형태로 변화가 불가능하다.

출처 : https://jongmin92.github.io/2018/02/11/Spring/spring-ioc-di/

인터페이스 호출 방식

클래스를 인터페이스와 인터페이스를 상속받아 구현하는 클래스로 분리했다. 구현클래스 교체가 용이하여 다양한 변화가 가능하다. 그러나 구현클래스 교체시 호출클래스의 코드에서 수정이 필요합니다. (부분적으로 종속적)

출처 : https://jongmin92.github.io/2018/02/11/Spring/spring-ioc-di/

팩토리 호출 방식

팩토리 방식은 팩토리가 구현클래스를 생성하기 때문에 호출클래스는 팩토리를 호출 하는 코드로 충분하다. 구현클래스 변경시 팩토리만 수정하면 되기 때문에 호출클래스에는 영향을 미치지 않는다. 그러나 호출클래스에서 팩토리를 호출하는 코드가 들어가야 하는 것 또한 팩토리에 의존함을 의미한다.

출처 : https://jongmin92.github.io/2018/02/11/Spring/spring-ioc-di/

 

 

IoC

팩토리 패턴의 장점을 더해 어떠한 것에도 의존하지 않는 형태가 되었다. 실행시점에 클래스간의 관계가 형성이 된다. 즉, 의존성이 삽입된다는 의미로 IoC를 DI라는 표현으로 사용한다.

 

출처 : https://jongmin92.github.io/2018/02/11/Spring/spring-ioc-di/

 

 

스프링 컨테이너 종류

BeanFactory

스프링 빈 컨테이너에 접근하기 위한 최상위 인터페이스이다.

Bean 객체를 생성하고 관리하는 인터페이스이다. 디자인패턴의 일종인 팩토리 패턴을 구현한 것이다. BeanFactory 컨테이너는 구동될 때 Bean 객체를 생성하는 것이 아니라. 클라이언트의 요청이 있을 때(getBean()) 객체를 생성한다.

ApplicationContext

ListableBeanFactory(BeanFactory에 하위 인터페이스이며, Bean을 Listable하게 보관하는 인터페이스를 말한다. 대표적으로 DefaultListableBeanFactory 클래스)를 상속하고 있으며, 여러 기능(ResourceLoader, ApplicationEventPublisher, MessageSource, Bean Lifecycle)을 추가로 제공한다.

BeanFactory를 상속받은 interface이며, ApplicationContext 컨테이너는 구동되는 시점에 등록된 Bean 객체들을 스캔하여 객체화한다

 

[추가기능]
- 국제화 지원 텍스트 메시지 관리
- 이미지 파일 로드
- Listener로 등록된 Bean에게 이벤트 발생 통보

 

 

Container 정리

컨테이너의 사전적 의미는 무언가를 담는 용기, 그릇이다. 스프링의 컨테이너는 프로그래머가 작성한 코드의 처리과정을 위임받아 독립적으로 처리하는 존재이다

출처 : http://www.incodom.kr/spring/%EC%BB%A8%ED%85%8C%EC%9D%B4%EB%84%88

지금까지 객체를 사용하기 위해서 위의 그림과 같이 new 생성자를 이용하거나 getter/setter 기능을 써야만 했다.

어플리케이션에는 이러한 객체가 무수히 많이 존재하고 서로 참조하고 있을 것이다.

서로 참조하고 있는 정도가 심할 수록 의존성이 높다고 표현한다. 낮은 결합도와 높은 캡슐화로 대변되는 OOP에서 높은 의존성은 매우 지양된다.

 

출처 : https://sehun-kim.github.io/sehun/springbean-lifecycle/

 

스프링 입문자가 DI를 접할 경우 필요성과 어떻게 코드를 짜고 사용해야 할지에 대해서 느끼기 쉽지 않다. 경험이 많지 않은 상태에서 필요성을 느낄 수 있는 좋은 방법은 테스트 코드를 구현할 때이다.

 

의존성 제어, 즉 객체 간의 의존성을 낮추기 위해 바로 위의 사진의 Spring IoC 컨테이너가 사용된다

 

 

의존성 주입을 사용하는 이유

1. 재사용성을 높여준다.

2. 테스트에 용이하다.

3. 코드를 단순화 시켜준다.

4. 사용하는 이유를 파악하기 수월하고 코드가 읽기 쉬워지는 점이 있다.

5. 종속성이 감소하기 때문에 변경에 민감하지 않다.

6. 결합도(coupling)는 낮추면서 유연성과 확장성은 향상 시킬 수 있다.

7. 객체간의 의존관계를 설정할 수 있다.

 

 

 

빈(Bean)이란 무엇인가?

• 스프링 IoC 컨테이너가 관리하는 객체
  • 빈으로 등록됐을 때의 장점
    • 스프링 IoC 컨테이너에 등록된 Bean들은 의존성 관리가 수월해진다. 
    • 스프링 IoC 컨테이너에 등록된 Bean들은 싱글톤의 형태이다

 

singleton : 기본(Default) 싱글톤 스코프. 하나의 Bean 정의에 대해서 Container 내에 단 하나의 객체만 존재한다.
prototype : 어플리케이션에서 요청시 (getBean()) 마다 스프링이 새 인스턴스를 생성

 

이러한 장점들 때문에 우리가 직접 Inversion of Control의 코드를 작성해서 사용하는 것이 아니라 스프링의 IoC 컨테이너를 사용하는 것이다. 

 

 

 

빈을 등록하는 방법

1. xml 설정파일을 통한 등록

예전에 스프링에서는 xml에서 하나하나 bean을 등록해 사용하였다 예를들면 아래 코드와 같다.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/util https://www.springframework.org/schema/util/spring-util.xsd">

    <bean id="bookService" class="com.example.demo.BookService">
        <property name="bookRepository" ref="bookRepository" />
    </bean>

    <bean id="bookRepository" class="com.example.demo.BookRepository">
    </bean>

</beans>

위와 같은 xml 파일에서 bean을 하나하나 등록하여 사용하였다. 예전에는 그냥 이런식으로 했구나 정도만 받아들이자. 

BookRepository, BookService가 Bean으로 등록되어 있는지 확인해보자.

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.util.Arrays;

public class DemoApplication {

    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
        String[] getBeanDefinitionNames = context.getBeanDefinitionNames();
        System.out.println(Arrays.toString(getBeanDefinitionNames));
    }
}

AppicationContext는 IoC 컨테이너를 담당하는 인터페이스이기 때문에 위의 코드처럼 IoC 컨테이너에 등록된 Bean을 확인하는 것이 가능하다. 따라서 위의 코드를 실행해보면 [bookService, bookRepository]가 결과로 나오는 것을 알 수 있다. 이렇게 하나하나 Bean으로 등록하는 방법은 굉장히 번거롭기 때문에 새로운 방법이 등장했는데 그것이 바로 component-scan이다. 

 

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:util="http://www.springframework.org/schema/util"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/util https://www.springframework.org/schema/util/spring-util.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="com.example.demo"/>

</beans>

이번에도 xml 파일 안에서 component-scan을 사용하여 base-package에 현재 패키지 이름을 작성하면 Class-Path 아래에 @Repository, @Service 등의 Bean으로 등록할 수 있는 어노테이션을 찾아서 Bean으로 등록을 해준다.(Component-Scan은 아래에서 다시 설명한다) 하지만 여기서 다시 자바코드로 빈을 등록할 수 있는 없을까? 라는 의문이 생겼다.

 

 

2. Java 코드를 이용해서 Bean 등록

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class ApplicationConfig {

    @Bean
    public BookRepository bookRepository() {
        return new BookRepository();
    }

    @Bean
    public BookService bookService() {
        BookService bookService = new BookService();
        bookService.setBookRepository(bookRepository());
        return bookService;
    }
}

위와 같이 ApplicationConfig 라는 자바파일을 만들 후에 @Configuration이라는 어노테이션을 달고 빈으로 등록할 곳에 @Bean 어노테이션과 함께 코드를 작성하면 빈으로 등록이 된다. 하지만 이것도 하나하나 빈으로 등록해야 하는 번거로움이 있기 때문에 좋은 것 같지 않다. 그래서 하나 더 나온 방법이 현재 스프링부트에 가장 가까운 방법이다.

 

Spring-Boot는 어노테이션을 통해 Bean을 설정하고 주입받는 것을 표준으로 삼는다.

• Container에 Spring Bean으로 등록시켜주는 Annotation

 

ex) @Bean, @Component, @Controller, @Service, @Repository 

- @Bean은 개발자가 컨트롤 할 수 없는 외부 라이브러리 Bean으로 등록하고 싶은 경우 (메소드로 return 되는 객체를 Bean으로 등록) 
- @Component는 개발자가 직접 컨트롤할 수 있는 클래스(직접 만든)를 Bean으로 등록하고 싶은 경우 (선언된 Class를 Bean으로 등록) 
- @Controller, @Service, @Repository 등 은 @Component를 비즈니스 레이어에 따라 명칭을 달리 지정해준 것Container에 있는 Spring Bean을 찾아 주입시켜주는 Annotation

 

• Container에 있는 Spring Bean을 찾아 주입시켜주는 Annotation

 

- @Autowired : IoC 컨테이너에 있는 참조할 Bean을 찾아 주입한다. (SPRING 표준)

 

 

@ComponentScan 이란?

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan(basePackageClasses = DemoApplication.class)
public class ApplicationConfig {
    
}

 

com.example.demo는 프로젝트를 만들었을 때 등록한 패키지 이름이다. com.example.demo 패키지와 같거나 아래에 있는 파일들의 경로를 Class-Path라고 한다.

그리고 위와 같이 @ComponentScan이라는 어노테이션을 사용하고 Class-Path(현재 패키지)를 적어주면 패키지 아래에 있는 빈으로 등록해야할 어노테이션을 찾아 전부 빈으로 등록해주기 때문에 아주 사용하기 편리하다. (따라서com.example.demo 패키지 외부에 있는 어노테이션은 Component-Scan의 대상이 되지 않기 때문에 유의하자)

@Component, @Service, @Repository, @Controller, @RestController 어노테이션을 찾아서 Bean으로 등록해준다!

 

스프링부트에서는 DemoApplication 파일(프로젝트를 만들면 자동으로 생기는 파일)에서 ApplicationContext를 직접 만들어 사용할 필요 없이 @SpringBootApplication이라는 어노테이션 때문에 @ComponentScan 등 여러가지 기능을 편리하게 사용할 수 있다.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

@SpringBootApplication이라는 어노테이션 안에 보면 Component, Configuration 어노테이션이 존재한다.

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {

 

 

 

 

[Reference]

https://jongmin92.github.io/2018/02/11/Spring/spring-ioc-di/

https://asfirstalways.tistory.com/334

https://m.blog.naver.com/PostView.nhn?blogId=ljh0326s&logNo=221395815870&proxyReferer=https:%2F%2Fwww.google.com%2F

https://medium.com/@jang.wangsu/di-dependency-injection-%EC%9D%B4%EB%9E%80-1b12fdefec4f

https://blog.woniper.net/338

https://www.inflearn.com/course/spring-framework_core/dashboard