2025.10.02

우선 간단하게 Spring, IoC, DI, 그리고 Bean에 대해 짚고 넘어가보자.

Spring

스프링은 자바 플랫폼을 위한 애플리케이션 프레임워크이다.
애플리케이션 프레임워크라 함은 애플리케이션을 개발하는 데 필요한 기초 기능들을 제공하는 골조 같은 역할이다.

IoC 컨테이너는 스프링의 핵심 모듈 중 하나이다. IoC 컨테이너는 뭘까. IoC 컨테이너는 객체들 간의 의존성과 생명주기(생성, 제거)를 담당하는 모듈이다.

IoC는 제어의 역전(Inversion of Control)이라는 뜻이다. 무슨 제어를 역전했냐면, 객체의 의존성에 대한 제어이다. 객체의 의존성을 개발자가 구현하지 않고 스프링 컨테이너가 담당했기 때문이다.

스프링으로 백엔드 프로젝트를 해봤다면 알겠지만 코드를 짤 때, 우리는 Service에서 부르는 Repository 코드를 new로 생성하지 않는다.

아주 흔하게 볼 수 있는 코드이다. @RequiredArgsConstructor를 달고, 밑에는 final로 Service에 꼭 필요한 다른 객체들을 변수로 지정해둔다. 나는 생성자를 작성한 적도, setter로 이 변수들을 new로 생성하여 집어넣어준 적도 없다. 그런데도 코드는 잘 작동한다.
내가 모르는 사이 IoC 컨테이너가 DI로 물밑작업을 해준 것이다.

DI는 Dependency Injection, 의존성 주입이다. IoC와 뭐가 다른 걸까 싶겠지만, IoC는 좀 더 추상적인 개념으로 스프링에서 추구하는 제어를 역전시켜야 한다는 철학이라면 DI는 IoC를 실현하는 구체적인 방법이다.

Bean

위에서 열심히 말한 제어의 역전, 의존성 주입을 할 때 사용하는 객체들이 전부 Bean이다. 즉, Bean은 스프링 프레임워크에서 관리하는 객체라고 할 수 있겠다.

개발자가 컨테이너에 작성해준 빈 설정 메타데이터를 통해서 생성된다.

Spring Boot가 실행되는 과정을 해부하기 전 꼭 필요한 개념들을 간략히 정리했다. 이제 Spring Boot가 어떤 과정을 통해 실행되는지 한 번 알아보자.

---

Spring Boot가 실행되는 과정

1. Spring Container 생성

ApplicationContext가 생성된다.

혹은 BeanFactory가 생성되지만, 보통은 ApplicationContext를 사용한다. BeanFactory가 필요한 기본적인 기능만을 제공하는 IoC 컨테이너라면 ApplicationContext는 BeanFactory를 확장하여 국제화, 이벤트 발행 등등 추가적인 기능을 제공하기 때문이다.

@SpringBootApplication
public class Application {

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

아주아주 많이 본 코드다.
스프링(부트) 애플리케이션을 실행할 때 이 run 메서드를 통해 실행된다. 이 run 메서드를 뜯어보자...

주석에 아주 친절하게 설명되어 있다. 실행 중인 ApplicationContext를 반환해주는 메서드라고 한다. 제일 관련 있어보이는 건 createApplicationContext()이다.

createApplicationContext()

protected ConfigurableApplicationContext createApplicationContext() {
	return this.applicationContextFactory.create(this.properties.getWebApplicationType());

아직 refresh 되지 않은 Application Context를 반환한다고 한다. 그럼 refresh에서는 어떤 작업을 하는 걸까?

2. Bean Definition

refresh()에서는 개발자가 작성해준 XML, 어노테이션, config 파일 등을 읽어와서 Bean을 정의한다. (그리고 나중에 DI도 하고 생성도 해준다!) refresh 메서드의 코드 전문은 아래와 같다.

public void refresh() throws BeansException, IllegalStateException {
	this.startupShutdownLock.lock();
	try {
		this.startupShutdownThread = Thread.currentThread();

		StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");

		// Prepare this context for refreshing.
		prepareRefresh();

		// Tell the subclass to refresh the internal bean factory.
		ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

		// Prepare the bean factory for use in this context.
		prepareBeanFactory(beanFactory);

		try {
			// Allows post-processing of the bean factory in context subclasses.
			postProcessBeanFactory(beanFactory);

			StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");

			// Invoke factory processors registered as beans in the context.
			invokeBeanFactoryPostProcessors(beanFactory);

			// Register bean processors that intercept bean creation.
			registerBeanPostProcessors(beanFactory);
			beanPostProcess.end();

			// Initialize message source for this context.
			initMessageSource();

			// Initialize event multicaster for this context.
			initApplicationEventMulticaster();

			// Initialize other special beans in specific context subclasses.
			onRefresh();

			// Check for listener beans and register them.
			registerListeners();

			// Instantiate all remaining (non-lazy-init) singletons.
			finishBeanFactoryInitialization(beanFactory);

			// Last step: publish corresponding event.
			finishRefresh();
		}

		catch (RuntimeException | Error ex ) {
			if (logger.isWarnEnabled()) {
				logger.warn("Exception encountered during context initialization - " +
						"cancelling refresh attempt: " + ex);
			}

			// Destroy already created singletons to avoid dangling resources.
			destroyBeans();

			// Reset 'active' flag.
			cancelRefresh(ex);

			// Propagate exception to caller.
			throw ex;
		}

		finally {
			contextRefresh.end();
		}
	}
	finally {
		this.startupShutdownThread = null;
		this.startupShutdownLock.unlock();
	}
}

길다.. 그리고 주석이 아주아주 친절하게 달려있다. 실행하는 메서드가 각자 어떤 역할을 하는지 정리해보겠다.

obtainFreshBeanFactory()

obtainFreshBeanFactory()의 내부 구조는 다음과 같다.

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
	refreshBeanFactory();
	return getBeanFactory();
}

Bean factory를 refresh한 다음 가져오는 듯하다. refreshBeanFactory()에서는 무엇을 할까?

@Override
protected final void refreshBeanFactory() throws BeansException {
	if (hasBeanFactory()) {
		destroyBeans();
		closeBeanFactory();
	}
	try {
		DefaultListableBeanFactory beanFactory = createBeanFactory();
		beanFactory.setSerializationId(getId());
		beanFactory.setApplicationStartup(getApplicationStartup());
		customizeBeanFactory(beanFactory);
		loadBeanDefinitions(beanFactory);
		this.beanFactory = beanFactory;
	}
	catch (IOException ex) {
		throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
	}
}

먼저 기존의 bean factory가 존재하면 bean들을 전부 제거하고 bean factory도 닫는다.
이후 bean factory를 생성하고, 해당 bean factory에 serialization id, bean definition override를 허용하는지, circular reference를 허용하는지 여부 등을 설정한다.
이후 loadBeanDefinitions()로 빈 정의를 불러온다.

@Override
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
	// Create a new XmlBeanDefinitionReader for the given BeanFactory.
	XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

	// Configure the bean definition reader with this context's
	// resource loading environment.
	beanDefinitionReader.setEnvironment(getEnvironment());
	beanDefinitionReader.setResourceLoader(this);
	beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

	// Allow a subclass to provide custom initialization of the reader,
	// then proceed with actually loading the bean definitions.
	initBeanDefinitionReader(beanDefinitionReader);
	loadBeanDefinitions(beanDefinitionReader);
}

loadBeanDefinitions()를 구현한 메서드가 많았다. 위처럼 XML에서 불러오는 메서드, Annotation을 기반으로 불러오는 메서드, Groovy에서 불러오는 메서드 등이 있었다. Spring Boot에서는 Annotation을 기반으로 동작하므로 AnnotationConfigWebApplicationContext 파일에 작성된 loadBeanDefinitions()를 기반으로 설명하겠다.

@Override
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) {
	AnnotatedBeanDefinitionReader reader = getAnnotatedBeanDefinitionReader(beanFactory);
	ClassPathBeanDefinitionScanner scanner = getClassPathBeanDefinitionScanner(beanFactory);

	BeanNameGenerator beanNameGenerator = getBeanNameGenerator();
	if (beanNameGenerator != null) {
		reader.setBeanNameGenerator(beanNameGenerator);
		scanner.setBeanNameGenerator(beanNameGenerator);
		beanFactory.registerSingleton(AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR, beanNameGenerator);
	}

	ScopeMetadataResolver scopeMetadataResolver = getScopeMetadataResolver();
	if (scopeMetadataResolver != null) {
		reader.setScopeMetadataResolver(scopeMetadataResolver);
		scanner.setScopeMetadataResolver(scopeMetadataResolver);
	}

	if (!this.componentClasses.isEmpty()) {
		if (logger.isDebugEnabled()) {
			logger.debug("Registering component classes: [" +
					StringUtils.collectionToCommaDelimitedString(this.componentClasses) + "]");
		}
		reader.register(ClassUtils.toClassArray(this.componentClasses));
	}

	if (!this.basePackages.isEmpty()) {
		if (logger.isDebugEnabled()) {
			logger.debug("Scanning base packages: [" +
						StringUtils.collectionToCommaDelimitedString(this.basePackages) + "]");
		}
		scanner.scan(StringUtils.toStringArray(this.basePackages));
	}

	String[] configLocations = getConfigLocations();
	if (configLocations != null) {
		for (String configLocation : configLocations) {
			try {
				Class<?> clazz = ClassUtils.forName(configLocation, getClassLoader());
				if (logger.isTraceEnabled()) {
					logger.trace("Registering [" + configLocation + "]");
				}
				reader.register(clazz);
			}
			catch (ClassNotFoundException ex) {
				if (logger.isTraceEnabled()) {
					logger.trace("Could not load class for config location [" + configLocation +
							"] - trying package scan. " + ex);
				}
				int count = scanner.scan(configLocation);
				if (count == 0 && logger.isDebugEnabled()) {
					logger.debug("No component classes found for specified class/package [" + configLocation + "]");
				}
			}
		}
	}
}

Annotation이 등록된 빈의 정의를 읽어오는 reader, class path에 등록된 bean definition를 읽어오는 scanner를 선언하고 beanNameGenerator를 설정한다. beanNameGenerator는 bean definition에 부여할 이름에 대한 규칙을 정의한다. 이후 bean definition을 읽어올 때, @Scope 어노테이션을 읽어 bean의 scope를 결정하는 scopeMetadataResolver를 등록한다.

설정 도구(beanNameGenerator, scopeMetadataResolver)를 등록하고 나면 실제로 reader, scanner를 사용하여 bean factory에 bean definition을 등록한다.

Component Class

this.componentClass에 등록되어 있는 클래스 목록을 reader로 bean definition에 등록한다.

메인 애플리케이션 클래스(@SpringBootApplication)와 @Configuration이 붙은 클래스가 이 시점에 로딩된다.

Base Package

this.basePackages를 scanner를 사용하여 스캔하고, 스캔 과정에서 발견된 모든 컴포넌트 클래스를 bean definition에 등록한다.

Base package 아래의 서브 패키지들을 탐색하여 @Component, @Service 등등 어노테이션이 붙은 클래스를 bean definition으로 등록한다. Base package는 자동으로 @SpringBootApplication이 어노테이션이 위치한 패키지로 설정된다.

Config Location

config location이 class인 경우 reader를 통해 등록하고 package인 경우 scanner를 통해 등록한다.

Context에 등록되어 있는 bean definition을 로드할 수 있는 추가적인 소스의 경로, 이름을 말한다.

이러한 과정을 거쳐 bean definition을 bean factory에 등록한 뒤, 이 bean factory를 들고 돌아온다.

prepareBeanFactory()

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
	// Tell the internal bean factory to use the context's class loader etc.
	beanFactory.setBeanClassLoader(getClassLoader());
	beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
	beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

	// Configure the bean factory with context callbacks.
	beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
	beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
	beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
	beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
	beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
	beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
	beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
	beanFactory.ignoreDependencyInterface(ApplicationStartupAware.class);

	// BeanFactory interface not registered as resolvable type in a plain factory.
	// MessageSource registered (and found for autowiring) as a bean.
	beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
	beanFactory.registerResolvableDependency(ResourceLoader.class, this);
	beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
	beanFactory.registerResolvableDependency(ApplicationContext.class, this);

	// Register early post-processor for detecting inner beans as ApplicationListeners.
	beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

	// Detect a LoadTimeWeaver and prepare for weaving, if found.
	if (!NativeDetector.inNativeImage() && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
		beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
		// Set a temporary ClassLoader for type matching.
		beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
	}

	// Register default environment beans.
	if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
		beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
	}
	if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
		beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
	}
	if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
		beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
	}
	if (!beanFactory.containsLocalBean(APPLICATION_STARTUP_BEAN_NAME)) {
		beanFactory.registerSingleton(APPLICATION_STARTUP_BEAN_NAME, getApplicationStartup());
	}
}

Bean factory에 설정을 부여한다. classLoader bean을 등록하기도 하고... 너무 길어서 생략하겠다.

postProcessBeanFactory()

Bean Post Processor를 등록하고 다양한 설정을 진행한다.

invokeBeanFactoryPostProcessors()

1. 제일 먼저 BeanDefinitionRegistryPostProcessor들을 실행한다.
   BeanDefinitionRegistryPostProcessor는 새로운 빈 설계도를 등록, 수정하는 역할이라 제일 먼저 실행되어야 한다.
2. 남아있는 BeanFactoryPostProcessor들을 전부 실행한다.
   컨테이너에 등록된 BeanFactoryPostProcessor 빈들을 조회해서 이름을 가져오고 순서를 정렬한다. 이후 정렬된 순서대로 postProcessBeanFactory()로 속성값 수정을 진행한다. (위의 postProcessBeanFactory과는 다른 메서드다.)
3. 메타데이터 캐시를 정리한다.

registerBeanPostProcessors()

Bean Post Processor들을 우선 순위에 따라 분류해 bean factory에 등록한다.

BeanFactoryPostProcessor, BeanPostProcessor?

BeanFactoryPostProcessor와 BeanPostProcessor가 이름이 유사해서 헷갈릴 수 있을 것 같다...(사실 내가 그랬다.)

이름과 코드로 파악해보자면...

전자는 "Factory"의 post processor이며, 이름만 보면 Factory에서 post process를 진행하는 거니 bean이 생성되기 전에 실행될 것 같다. 내부에 존재하는 유일한 메서드 postProcessBeanFactory()의 주석을 읽어보니 Application Context의 internal bean factory의 기본적인 초기화가 끝난 뒤 bean factory를 수정한다고 한다. 단, 빈 설정은 모두 로딩되어 있어야 하나 빈 인스턴스화는 아직 진행되면 안 되고... eager 초기화되는 빈들의 속성을 override하거나 추가하는 걸 허용한다고 한다.

BeanPostProcessor 내부에는 postProcessBeforeInitialization(), postProcessAfterInitialization() 메서드가 존재한다. postProcessBefore~은 새로운 빈 인스턴스에 초기화 콜백이 진행되기 전에 이 메서드를 적용한다.(이미 프로퍼티 값은 주입됨) postProcessAfter~은 빈 인스턴스가 초기화 된 후 적용된다. 아마 빈이 생성된 전/후로 동작하는 것 같다.

스택오버플로우 링크를 참고하자면
BeanFactoryPostProcessor는
- 빈 정의 로드 && 빈 생성(인스턴스화) 전에 호출
- eager 초기화되는 빈에도 속성을 재정의, 추가하는 용도
BeanPostProcessor는
- 빈에 작동하기 때문에 빈 인스턴스화를 할 때 작동

그러면 Bean Definition → BeanFactoryPostProcessor → BeanPostProcessor.postProcessBeforeInitialization → Bean instantiate → BeanPostProcessor.postProcessAfterInitialization 대략 이런 순서가 되는 것 같다.

BeanPostProcessor 내부 메서드들의 행동 방식이 프록시와도 유사한 것 같아 추가로 찾아보니, 해당 메서드들이 반환하는 객체가 빈일 수도, 프록시로 감싼 빈일 수도 있어 AOP 기능이 여기서 구현된다고 한다. (스프링 링크 참조)

initMessageSource()

국제화(i18n) 기능을 담당하는 메시지 소스 빈을 초기화한다.

ApplicationContext가 BeanFactory와 다른 점 중 하나가 이 국제화 지원이다!

initApplicationEventMulticaster()

애플리케이션 이벤트(컨텍스트 초기화, 사용자 정의 이벤트 등)를 멀티캐스트하는 빈을 초기화한다.

onRefresh()

기타 스페셜 빈들을 초기화한다.

registerListeners()

이벤트 리스너 타입의 빈들을 찾아서 이벤트 멀티캐스터에 등록한다.

---

틀린 점 지적/질문 댓글 언제든 환영입니다_へ(▭-▭)✨