스프링 빈 설정 보충자료

1. 스프링 빈(Bean)이란?

1.1 빈(Bean)의 정의

**스프링 빈(Bean)**은 스프링 컨테이너에 의해 관리되는 객체를 의미합니다.
스프링은 애플리케이션 실행 시 필요한 객체(빈)를 생성하고, 의존성을 주입하며, 객체의 생명주기를 관리합니다.

1.2 빈의 역할

빈은 재사용 가능한 객체로, 개발자가 직접 객체를 생성하고 관리하는 대신 스프링 컨테이너가 객체를 생성하고 관리합니다.
빈은 다음과 같은 작업을 지원합니다:
- 의존성 주입(Dependency Injection)
- 객체 재사용
- 생명주기 관리 (생성, 초기화, 소멸)

2. 빈 등록 방식

스프링에서 빈을 등록하는 방법은 크게 두 가지로 나눌 수 있습니다:

2.1 어노테이션 기반 빈 등록

클래스에 @Component, @Service, @Repository, @Controller와 같은 어노테이션을 붙여 빈으로 등록합니다.
스프링이 클래스 경로를 스캔하여 자동으로 빈으로 등록합니다.

@Component
public class UserService {
    // 빈으로 등록됨
}

2.2 자바 코드 기반 빈 등록 (명시적 등록)

자바 클래스에 @Configuration을 선언하고, 메서드에 @Bean을 붙여 빈을 등록합니다.
이 방식은 빈 생성 과정을 명확히 제어할 수 있습니다.

@Configuration
public class AppConfig {
    @Bean
    public UserService userService() {
        return new UserService(userRepository());
    }

    @Bean
    public UserRepository userRepository() {
        return new UserRepositoryImpl();
    }
}

3. 자바 기반 빈 등록 설명

3.1 `@Configuration` 어노테이션

@Configuration은 스프링 컨테이너에 설정 정보를 제공하는 클래스에 붙입니다.
해당 클래스는 스프링 빈 정의를 포함하는 설정 파일 역할을 합니다.

@Configuration
public class AppConfig {
    // 빈 정의
}

3.2 `@Bean` 어노테이션

@Bean은 빈으로 등록할 객체를 반환하는 메서드에 사용됩니다.
스프링 컨테이너는 @Bean이 붙은 메서드를 호출하여 반환된 객체를 빈으로 등록하고 관리합니다.

@Bean
public UserService userService() {
    return new UserService(userRepository());
}

메서드 호출 순서

스프링 컨테이너가 AppConfig를 읽습니다.
@Bean이 붙은 메서드를 호출하여 반환된 객체를 빈으로 등록합니다.
필요 시 의존성을 주입합니다.

4. AppConfig 코드 설명

AppConfig 예제 코드

@Configuration
public class AppConfig {
    @Bean
    public UserService userService() {
        return new UserServiceImpl(userRepository());
    }

    @Bean
    public UserRepository userRepository() {
        return new UserRepositoryImpl();
    }
}

1) @Configuration

AppConfig 클래스는 스프링 빈 설정을 담당하는 클래스입니다.
이 클래스는 @Configuration 어노테이션을 통해 스프링 컨테이너에 의해 관리됩니다.

2) @Bean 메서드

userService 메서드와 userRepository 메서드에 @Bean을 붙여, 스프링 컨테이너가 이 메서드들을 호출하여 반환된 객체를 빈으로 등록합니다.

3) 의존성 주입

userService 메서드가 userRepository()를 호출하여 생성된 객체를 주입받습니다.
이 과정은 스프링 컨테이너가 관리합니다.

5. 빈 관리의 이점

5.1 의존성 주입

빈을 통해 객체를 생성하고 관리하므로, 코드 내에서 객체를 직접 생성할 필요가 없습니다.
객체 간의 결합도를 낮추고, 코드의 유연성과 테스트 가능성을 높입니다.

// 직접 생성 방식
UserService userService = new UserService(new UserRepositoryImpl());

// 스프링 빈 활용
ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
UserService userService = context.getBean(UserService.class);

5.2 코드 재사용성

빈은 컨테이너에서 한 번 생성되면 다양한 곳에서 재사용 가능합니다.

5.3 객체 생명주기 관리

스프링 컨테이너는 빈의 생성, 초기화, 소멸 등 생명주기를 자동으로 관리합니다.
이를 통해 리소스 누수를 방지하고 안정적인 객체 관리를 지원합니다.

6. 빈 등록과 의존성 흐름

6.1 AppConfig에서의 흐름

스프링 컨테이너 초기화
- 스프링 애플리케이션이 실행되면, 스프링 컨테이너는 AppConfig를 읽어 빈 등록 작업을 시작합니다.
빈 생성
- @Bean 메서드를 호출하여 객체를 생성하고, 스프링 컨테이너에 등록합니다.
의존성 주입
- userService는 userRepository() 메서드의 결과를 인자로 받아 주입됩니다.
빈 관리
- 스프링 컨테이너는 생성된 빈을 관리하며 필요 시 재사용합니다.

7. AppConfig와 빈 등록의 장점

7.1 명시적 의존성 관리

빈 생성과 의존성 주입 과정을 명확히 정의하여, 객체 간의 의존성을 직관적으로 관리할 수 있습니다.

7.2 테스트 용이성

각 빈의 생성 로직을 독립적으로 정의할 수 있으므로, 단위 테스트가 용이합니다.

7.3 코드 유연성

구현체를 변경할 경우 AppConfig 클래스만 수정하면 되므로 코드의 변경 범위가 줄어듭니다.

1. ApplicationContext란?

1.1 정의

ApplicationContext는 스프링 프레임워크의 핵심 인터페이스로, 스프링 컨테이너를 대표합니다.
스프링 컨테이너는 애플리케이션에서 필요한 **스프링 빈(Bean)**을 생성, 관리, 의존성 주입, 생명주기 관리 등의 역할을 합니다.

1.2 역할

빈 관리: 스프링 애플리케이션에서 사용되는 객체(빈)를 생성하고 관리.
의존성 주입: 빈 간의 의존성을 설정 및 주입.
리소스 관리: 파일, URL, 데이터베이스 연결 등 리소스 로드 및 관리.
이벤트 관리: 이벤트 발생 및 처리(이벤트리스너).
메시지 소스 처리: 다국어 지원을 위한 메시지 관리.

2. ApplicationContext 사용 방법

2.1 ApplicationContext 생성

ApplicationContext는 스프링 애플리케이션에서 컨테이너를 생성하는 핵심 역할을 하며, 다양한 구현체가 제공됩니다.

1) AnnotationConfigApplicationContext

Java Config 기반 설정에서 사용.
@Configuration으로 설정된 클래스를 로드하여 빈을 등록.

ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

2) ClassPathXmlApplicationContext

XML 설정 파일 기반 설정에서 사용.

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

3) GenericWebApplicationContext

웹 애플리케이션에서 사용.
웹 환경에 맞춘 컨테이너 생성.

2.2 ApplicationContext를 사용한 빈 조회

ApplicationContext는 등록된 빈을 조회하고 사용할 수 있는 기능을 제공합니다.

ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

// 빈 이름으로 조회
UserService userService = (UserService) context.getBean("userService");

// 타입으로 조회
UserService userServiceByType = context.getBean(UserService.class);

2.3 빈 생명주기 관리

스프링 컨테이너는 빈의 생명주기를 관리합니다.
- 생성: 빈 생성 시 호출.
- 초기화: 빈 초기화 메서드 실행.
- 소멸: 애플리케이션 종료 시 빈 소멸 메서드 실행.

3. ApplicationContext의 주요 기능

3.1 빈 관리

스프링 빈 등록: @Bean, @Component 등으로 등록된 객체를 관리.
싱글톤 관리: 기본적으로 빈은 싱글톤 스코프로 관리됩니다.

3.2 의존성 주입

ApplicationContext는 스프링 컨테이너가 제공하는 Dependency Injection(DI) 기능을 활용하여 빈 간의 의존성을 설정하고 주입합니다.

@Bean
public UserService userService() {
    return new UserService(userRepository());
}

@Bean
public UserRepository userRepository() {
    return new UserRepositoryImpl();
}

3.3 다국어 지원 (MessageSource)

ApplicationContext는 다국어 지원을 위해 메시지 소스를 관리합니다.

String message = context.getMessage("greeting", null, Locale.US);

3.4 이벤트 관리 (ApplicationEventPublisher)

이벤트를 발생시키고 리스너에서 처리할 수 있도록 지원.

context.publishEvent(new CustomEvent(this));

3.5 리소스 관리

파일, URL, 클래스패스 등 다양한 리소스를 관리 및 로드.

Resource resource = context.getResource("classpath:application.properties");

4. ApplicationContext의 동작 과정

4.1 컨테이너 초기화

ApplicationContext 구현체 생성.
설정 파일(@Configuration 클래스 또는 XML) 로드.
빈 생성 및 의존성 주입.

4.2 빈 사용

컨테이너에서 빈을 가져와 사용.

4.3 애플리케이션 종료

ApplicationContext는 애플리케이션 종료 시 등록된 빈의 소멸 메서드를 호출하여 리소스를 정리.

5. ApplicationContext와 BeanFactory의 차이

ApplicationContext는 BeanFactory의 확장 인터페이스입니다.

기능

BeanFactory

ApplicationContext

기본 빈 관리

지원

의존성 주입

지원

메시지 소스 관리

미지원

지원

이벤트 관리

미지원

지원

리소스 관리

제한적 지원

지원

초기화 및 소멸 콜백

제한적 지원

지원

6. 코드 예제와 분석

6.1 예제 코드

@SpringBootApplication
public class BasicApplication {
    public static void main(String[] args) {
        // ApplicationContext 생성
        ApplicationContext ac = new AnnotationConfigApplicationContext(AppConfig.class);

        // 빈 조회
        UserService userService = ac.getBean("userService", UserService.class);

        // 빈 사용
        User user1 = new User(1L, "name2", "admin", LocalDate.now(), LocalDate.now());
        userService.join(user1);
        System.out.println("user1 = " + user1);

        List<User> users = userService.getUsers();
        System.out.println("users.get(0).getName() = " + users.get(0).getName());
    }
}

6.2 실행 결과 분석

AnnotationConfigApplicationContext를 통해 AppConfig 클래스 기반으로 ApplicationContext 초기화.
AppConfig에 정의된 빈(userService, userRepository)이 스프링 컨테이너에 등록.
ac.getBean() 메서드로 userService 빈을 가져와 사용.
등록된 userService 빈을 통해 비즈니스 로직 수행.

7. ApplicationContext 사용 시 장점

의존성 관리
- 객체 간의 의존성을 컨테이너에서 자동으로 관리.
확장성
- 이벤트 처리, 다국어 지원 등 다양한 기능 제공.
유연성
- XML, Java Config, 어노테이션 기반 설정 모두 지원.
생명주기 관리
- 객체 생성부터 소멸까지 자동 관리.

1. 스프링에서 여러 설정 파일이 가능한 이유

1.1 스프링 컨테이너의 유연성

스프링의 **IoC 컨테이너(ApplicationContext)**는 다양한 설정 방식(Class 기반, XML 기반 등)을 지원하도록 설계되었습니다. 이러한 유연성은 스프링의 핵심 철학 중 하나인 **개방-폐쇄 원칙(OCP, Open-Closed Principle)**을 잘 반영한 구조 덕분입니다.

스프링은 ApplicationContext를 통해 설정 방식(Class, XML 등)에 관계없이 일관된 방식으로 빈 생성과 관리를 수행합니다.
내부적으로 BeanFactory를 사용하여 객체 생성, 의존성 주입, 생명주기 관리 등 기본적인 작업을 처리합니다.

2. ApplicationContext의 다양한 구현체

스프링은 설정 파일의 유형(Class, XML)에 따라 적절한 ApplicationContext 구현체를 제공합니다.

2.1 Class 기반 설정

Java Configuration 방식에서는 @Configuration 클래스와 자바 기반 설정을 사용합니다.

AnnotationConfigApplicationContext를 사용하여 자바 설정 파일을 로드.
코드에서 직접 객체를 정의하고 의존성을 주입할 수 있어 명확하고 타입 안전성이 높음.

예제

ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
UserService userService = context.getBean(UserService.class);

2.2 XML 기반 설정

XML Configuration 방식에서는 XML 파일을 사용하여 스프링 빈을 정의합니다.

GenericXmlApplicationContext를 사용하여 XML 파일을 로드.
설정 파일이 외부에 존재하므로 배포 환경에서 수정이 용이하지만, 자바 코드에 비해 가독성이 떨어질 수 있음.

예제

ApplicationContext context = new GenericXmlApplicationContext("applicationContext.xml");
UserService userService = context.getBean("userService", UserService.class);

3. ApplicationContext와 BeanFactory의 관계

스프링은 ApplicationContext를 통해 다양한 설정 방식을 통합적으로 지원하며, 이는 내부적으로 BeanFactory에 의존하여 빈 생성과 관리를 수행합니다.

3.1 BeanFactory의 역할

BeanFactory는 스프링 컨테이너의 핵심 구성 요소로, 기본적인 빈 생성과 관리를 담당합니다.
요청 시 빈을 생성(Lazy Initialization)하여 메모리 사용을 최소화.

3.2 ApplicationContext의 역할

BeanFactory를 확장한 인터페이스로, 고급 기능(이벤트 처리, 메시지 관리 등)을 추가적으로 제공합니다.
다양한 설정 파일(Class, XML 등)을 일관되게 처리.

4. 설정 방식에 따른 동작 구조

4.1 Class 기반 설정

AnnotationConfigApplicationContext를 통해 클래스 로드:
- @Configuration 클래스의 메서드에서 빈을 정의.
- 자바 코드를 통해 명확히 의존성을 주입할 수 있음.
ApplicationContext → BeanFactory:
- 내부적으로 BeanFactory를 사용해 빈을 생성하고 관리.
빈 생성 및 관리:
- 메서드 호출(@Bean)을 통해 빈을 생성하고 의존성을 주입.

4.2 XML 기반 설정

GenericXmlApplicationContext를 통해 XML 파일 로드:
- XML 파일에서 빈과 의존성을 정의.
ApplicationContext → BeanFactory:
- XML 파일 정보를 읽어 빈 생성 및 관리를 수행.
빈 생성 및 관리:
- XML에서 정의된 빈 정보를 기반으로 객체 생성.

5. 두 설정 방식의 장단점 비교

설정 방식

Class 기반 설정

XML 기반 설정

가독성

코드로 작성되어 IDE 지원, 가독성 우수

XML의 경우 가독성 떨어질 수 있음

타입 안전성

컴파일 시 타입 체크 가능

런타임 오류 발생 가능

수정 용이성

코드 수정 필요, 외부 배포 시 수정 어려움

외부 파일 수정으로 배포 환경에서 수정 용이

학습 곡선

자바 개발자에게 익숙, 비교적 쉬움

XML 구문 학습 필요

유연성

조건부 빈 등록(@Conditional 등) 가능

조건부 빈 등록이 제한적

6. 예제 코드

Class 기반 설정 예제

@Configuration
public class AppConfig {
    @Bean
    public UserService userService() {
        return new UserService(userRepository());
    }

    @Bean
    public UserRepository userRepository() {
        return new UserRepositoryImpl();
    }
}

ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
UserService userService = context.getBean(UserService.class);

XML 기반 설정 예제

applicationContext.xml

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="userService" class="com.example.UserService">
        <property name="userRepository" ref="userRepository"/>
    </bean>

    <bean id="userRepository" class="com.example.UserRepositoryImpl"/>
</beans>

ApplicationContext context = new GenericXmlApplicationContext("applicationContext.xml");
UserService userService = context.getBean("userService", UserService.class);

부모타입으로 조회시 중복 오류

import static org.assertj.core.api.Assertions.assertThatThrownBy;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

class ParentTypeDuplicateTest {

    @Test
    void whenMultipleBeansOfTypeParent_thenThrowException() {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(TestConfig.class);
        
        assertThatThrownBy(() -> {
            context.getBean(Parent.class).someMethod(); // Parent 타입을 조회하며 오류 발생 확인
        }).isInstanceOf(Exception.class) // 적절한 예외 타입으로 변경
          .hasMessageContaining("No qualifying bean of type");

        context.close();
    }

    interface Parent {
        void someMethod();
    }

    static class Child1 implements Parent {
        @Override
        public void someMethod() {
            System.out.println("Child1 method executed");
        }
    }

    static class Child2 implements Parent {
        @Override
        public void someMethod() {
            System.out.println("Child2 method executed");
        }
    }

    @Configuration
    static class TestConfig {

        @Bean
        @Primary
        public Parent child1() {
            return new Child1();
        }

        @Bean
        public Parent child2() {
            return new Child2();
        }
    }
}

스프링 조회시 동일한 타입 둘 이상일 때 발생하는 에러

import org.junit.jupiter.api.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

class NoUniqueBeanDefinitionExceptionTest {

    @Test
    void testNoUniqueBeanDefinitionException() {
        // ApplicationContext 초기화
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(TestConfig.class);

        try {
            // 동일한 타입의 빈이 두 개 이상 있을 경우 발생하는 오류 확인
            context.getBean(Service.class);
        } catch (Exception e) {
            System.out.println("Exception: " + e.getMessage());
            // 예외 메시지 출력: No qualifying bean of type 'Service' available: expected single matching bean but found 2
        } finally {
            context.close();
        }
    }

    interface Service {
        void execute();
    }

    static class ServiceA implements Service {
        @Override
        public void execute() {
            System.out.println("ServiceA executed");
        }
    }

    static class ServiceB implements Service {
        @Override
        public void execute() {
            System.out.println("ServiceB executed");
        }
    }

    @Configuration
    static class TestConfig {

        @Bean
        public Service serviceA() {
            return new ServiceA();
        }

        @Bean
        public Service serviceB() {
            return new ServiceB();
        }
    }
}

Previous05 스프링 빈 설정 Next06 싱글톤

Last updated 4 months ago