Spring이 실행되는 법을 해부해보자.. (1)에서 이어집니다.

Spring Boot가 실행되는 과정

지금까지의 진행 상황

1. Spring Container가 생성 된다.
2. 생성한 Spring Container를 refresh()한다. << 현재 여기!

refresh() 메서드에서는 빈 정의, 의존성 주입, 빈 생성 등등 스프링 컨테이너를 사용할 수 있도록 다양한 작업을 진행한다. 저번 1편에서는 Bean definition이 등록된 Bean Factory를 들고 오는 것까지 함께 지켜봤다.

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();
// -------------------------------------------- 1편에서 여기까지 진행했음! -------
			// 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();
	}
}

이제 의존성 주입부터 실행까지 어떻게 작동하는지 알아보자.

3. DI 설정 & Bean 생성

실제로 빈 객체를 생성하고 생성된 객체에 의존성을 주입하는 단계이다.

finishBeanFactoryInitialization()

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
	// Initialize bootstrap executor for this context.
	if (beanFactory.containsBean(BOOTSTRAP_EXECUTOR_BEAN_NAME) &&
			beanFactory.isTypeMatch(BOOTSTRAP_EXECUTOR_BEAN_NAME, Executor.class)) {
		beanFactory.setBootstrapExecutor(
				beanFactory.getBean(BOOTSTRAP_EXECUTOR_BEAN_NAME, Executor.class));
	}

	// Initialize conversion service for this context.
	if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
			beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
		beanFactory.setConversionService(
				beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
	}

	// Register a default embedded value resolver if no BeanFactoryPostProcessor
	// (such as a PropertySourcesPlaceholderConfigurer bean) registered any before:
	// at this point, primarily for resolution in annotation attribute values.
	if (!beanFactory.hasEmbeddedValueResolver()) {
		beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
	}

	// Call BeanFactoryInitializer beans early to allow for initializing specific other beans early.
	String[] initializerNames = beanFactory.getBeanNamesForType(BeanFactoryInitializer.class, false, false);
	for (String initializerName : initializerNames) {
		beanFactory.getBean(initializerName, BeanFactoryInitializer.class).initialize(beanFactory);
	}

	// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
	String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
	for (String weaverAwareName : weaverAwareNames) {
		try {
			beanFactory.getBean(weaverAwareName, LoadTimeWeaverAware.class);
		}
		catch (BeanNotOfRequiredTypeException ex) {
			if (logger.isDebugEnabled()) {
				logger.debug("Failed to initialize LoadTimeWeaverAware bean '" + weaverAwareName +
						"' due to unexpected type mismatch: " + ex.getMessage());
			}
		}
	}

	// Stop using the temporary ClassLoader for type matching.
	beanFactory.setTempClassLoader(null);

	// Allow for caching all bean definition metadata, not expecting further changes.
	beanFactory.freezeConfiguration();

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

1. Bootstrap executor를 초기화한다.
2. Conversion Service(타입 변환 시스템)를 초기화한다.
3. 만약 EmbeddedValueResolver가 없는 경우, default embedded value resolver를 등록한다.
   Value Resolver는 빈 설정 메타데이터 내의 ${ }를 실제 값으로 대체해주는 역할을 한다.
4. BeanFactoryInitializer.class인 빈을 호출한다.
   BeanFactoryInitializer.class를 구현한 빈은 다른 빈들보다 먼저 실행해야 하는 우선순위가 있기 때문에 먼저 실행한다.
5. LoadTimeWeaverAware 초기화
   런타임 시점에 AOP를 적용하는 기능인 LoadTimeWeaving과 관련된 빈이다. 당연히 먼저 해야겠지?
6. Bean 타입을 분석할 때 사용했던 임시 classloader를 제거한다.
7. 모든 bean definition들을 캐싱한다.
   이제 바뀌지 않을 거라는 점도 있고, 추가적인 변경을 막아 빈 생성 과정 속도를 빠르게 한다.
8. preInstantiateSingletons()에서 빈을 생성, 의존성을 주입한다.

preInstantiateSingletons()

public void preInstantiateSingletons() throws BeansException {
	// Iterate over a copy to allow for init methods which in turn register new bean definitions.
	// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
	List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

	// Trigger initialization of all non-lazy singleton beans...
	List<CompletableFuture<?>> futures = new ArrayList<>();

	this.preInstantiationThread.set(PreInstantiation.MAIN);
	this.mainThreadPrefix = getThreadNamePrefix();
	try {
		for (String beanName : beanNames) {
			RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
			if (!mbd.isAbstract() && mbd.isSingleton()) {
				CompletableFuture<?> future = preInstantiateSingleton(beanName, mbd);
				if (future != null) {
					futures.add(future);
				}
			}
		}
	}
	finally {
		this.mainThreadPrefix = null;
		this.preInstantiationThread.remove();
	}

	if (!futures.isEmpty()) {
		try {
			CompletableFuture.allOf(futures.toArray(new CompletableFuture<?>[0])).join();
		}
		catch (CompletionException ex) {
			ReflectionUtils.rethrowRuntimeException(ex.getCause());
		}
	}


	// Trigger post-initialization callback for all applicable beans...
	for (String beanName : beanNames) {
		Object singletonInstance = getSingleton(beanName, false);
		if (singletonInstance instanceof SmartInitializingSingleton smartSingleton) {
			StartupStep smartInitialize = getApplicationStartup().start("spring.beans.smart-initialize")
					.tag("beanName", beanName);
			smartSingleton.afterSingletonsInstantiated();
			smartInitialize.end();
		}
	}
}

기존에 등록된 bean definitions를 통해 bean name들을 가져온다.
그리고 Thread, Future을 보아하니 빈 생성, 의존성 주입을 빠르게 하기 위해 병렬 처리를 하는 것 같고... try 블록 내의 메서드들을 통해 빈을 생성하는 것 같다.

CompletableFuture.allOf(futures.toArray(new CompletableFuture<?>[0])).join();을 통해 비동기 빈 생성 작업이 완료될 때까지 기다린다.

이후 for문으로 bean name별로 afterSingletonsInstantiated()를 호출한다. 이름만 보아도 알 수 있겠지만, singleton 인스턴스가 생성된 뒤 필요한 초기화 로직을 하나씩 실행한다.

그럼 이제 try 블록 내의 메서드들을 하나씩 보자.
우선 getMergedLocalBeanDefinition()

protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
	// Quick check on the concurrent map first, with minimal locking.
	RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
	if (mbd != null && !mbd.stale) {
		return mbd;
	}
	return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
}

getMergedLocalBeanDefinition()은 현재 빈이 child bean인 경우 parent bean definition까지 찾아내 merged definition을 반환한다. (만약 부모가 없는 bean인 경우 그냥 스스로를 RootBeanDefinition으로 변환해서 반환한다.)

RootBeanDefinition을 확인해보니 런타임에 사용하기 위한 여러 bean definition를 통합(unified) bean definition이라고 한다. 그러니까... child bean definition을 사용할 때, parent bean definition을 일일이 조회할 필요가 없도록 child bean definition에 parent bean definition을 합쳐 merge된 상태로 반환한다는 것이다.

이렇게 받아온 merged bean definition(이하 mbd)가 abstract(추상)이 아니고 singleton이면 preInstantiateSingleton()를 실행한다.

@Nullable
private CompletableFuture<?> preInstantiateSingleton(String beanName, RootBeanDefinition mbd) {
	if (mbd.isBackgroundInit()) {
		Executor executor = getBootstrapExecutor();
		if (executor != null) {
			String[] dependsOn = mbd.getDependsOn();
			if (dependsOn != null) {
				for (String dep : dependsOn) {
					getBean(dep);
				}
			}
			CompletableFuture<?> future = CompletableFuture.runAsync(
					() -> instantiateSingletonInBackgroundThread(beanName), executor);
			addSingletonFactory(beanName, () -> {
				try {
					future.join();
				}
				catch (CompletionException ex) {
					ReflectionUtils.rethrowRuntimeException(ex.getCause());
				}
				return future;  // not to be exposed, just to lead to ClassCastException in case of mismatch
			});
			return (!mbd.isLazyInit() ? future : null);
		}
		else if (logger.isInfoEnabled()) {
			logger.info("Bean '" + beanName + "' marked for background initialization " +
					"without bootstrap executor configured - falling back to mainline initialization");
		}
	}
    
	if (!mbd.isLazyInit()) {
		try {
			instantiateSingleton(beanName);
		}
		catch (BeanCurrentlyInCreationException ex) {
			logger.info("Bean '" + beanName + "' marked for pre-instantiation (not lazy-init) " +
					"but currently initialized by other thread - skipping it in mainline thread");
		}
	}
	return null;
}

• mbd가 background에서 초기화되어도 괜찮다면(isBackgroundInit()) dependsOn을 통해 mbd가 의존하고 있는 객체들을 파악하고, 하나씩 get해 온다... getBean()은 하단에서 추가 서술하겠다.
  future를 통해 비동기적으로 instantiateSingletonInBackgroundThread()를 실행해 bean을 가져온다. 만약 lazyInit 설정이 되어있다면 future 값이 아닌 null을 받아간다.
• mbd가 background에서 초기화되면 안 된다면,
  그냥 instantiateSingleton()를 실행한다.
  

private void instantiateSingletonInBackgroundThread(String beanName) {
	this.preInstantiationThread.set(PreInstantiation.BACKGROUND);
	try {
		instantiateSingleton(beanName);
	}
	catch (RuntimeException | Error ex) {
		if (logger.isWarnEnabled()) {
			logger.warn("Failed to instantiate singleton bean '" + beanName + "' in background thread", ex);
		}
		throw ex;
	}
	finally {
		this.preInstantiationThread.remove();
	}
}

instantiateSingletonInBackgroundThread()은 스레드에서 instantiateSingleton()를 실행하는 메서드이며,

private void instantiateSingleton(String beanName) {
	if (isFactoryBean(beanName)) {
		Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
		if (bean instanceof SmartFactoryBean<?> smartFactoryBean && smartFactoryBean.isEagerInit()) {
			getBean(beanName);
		}
	}
	else {
		getBean(beanName);
	}
}

instantiateSingleton()은 getBean()을 통해 bean을 가져온다.

getBean

Bean을 어떻게 가져오는지 알아볼 차례다.

@Override
public Object getBean(String name) throws BeansException {
	return doGetBean(name, null, null, false);
}

@Override
public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
	return doGetBean(name, requiredType, null, false);
}

@Override
public Object getBean(String name, Object... args) throws BeansException {
	return doGetBean(name, null, args, false);
}

단순하다. 일단 doGetBean을 호출한다.

doGetBean

protected <T> T doGetBean(
	String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
		throws BeansException {

	String beanName = transformedBeanName(name);
	Object beanInstance;

	// Eagerly check singleton cache for manually registered singletons.
	Object sharedInstance = getSingleton(beanName);
	if (sharedInstance != null && args == null) {
		beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
	}
	// Check if bean definition exists in this factory.
	BeanFactory parentBeanFactory = getParentBeanFactory();
	if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
		// Not found -> check parent.
		String nameToLookup = originalBeanName(name);
		if (parentBeanFactory instanceof AbstractBeanFactory abf) {
			return abf.doGetBean(nameToLookup, requiredType, args, typeCheckOnly);
		} else if (args != null) {
			// Delegation to parent with explicit args.
			return (T) parentBeanFactory.getBean(nameToLookup, args);
		}
		else if (requiredType != null) {
		// No args -> delegate to standard getBean method.
			return parentBeanFactory.getBean(nameToLookup, requiredType);
		}
		else {
			return (T) parentBeanFactory.getBean(nameToLookup);
		}
	}

	if (!typeCheckOnly) {
		markBeanAsCreated(beanName);
	}

	StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate")
			.tag("beanName", name);
	try {
		if (requiredType != null) {
			beanCreation.tag("beanType", requiredType::toString);
		}
		RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
		checkMergedBeanDefinition(mbd, beanName, args);

		// Guarantee initialization of beans that the current bean depends on.
		String[] dependsOn = mbd.getDependsOn();
		if (dependsOn != null) {
			for (String dep : dependsOn) {
				if (isDependent(beanName, dep)) {
					throw new "생략";
				}
				registerDependentBean(dep, beanName);
				try {
					getBean(dep);
				} // 생략
			}
			throw ex;
		}
	}

	// Create bean instance.
	if (mbd.isSingleton()) {
		sharedInstance = getSingleton(beanName, () -> {
			try {
				return createBean(beanName, mbd, args);
			}
		});
		beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
	}

	else if (mbd.isPrototype()) {
		// It's a prototype -> create a new instance.
		Object prototypeInstance = null;
		try {
			beforePrototypeCreation(beanName);
			prototypeInstance = createBean(beanName, mbd, args);
		}
		finally {
			afterPrototypeCreation(beanName);
		}
		beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
	}
	// 생략
	return adaptBeanInstance(name, beanInstance, requiredType);
}

안 단순하다.. 코드가 너무 길어 일부 코드를 생략했다.

1. transformedBeanName(name);을 통해 bean name을 정규화한다.
2. getSingleton(beanName);을 통해 이미 생성된 빈이 있는지 확인한다.
3. getParentBeanFactory();를 통해 Parent Bean Factory를 찾아온다.
   만약 parent bean factory가 존재하면 빈 정의를 찾아온다.
4. dependsOn과 isDependent()를 통해 순환 참조 문제를 먼저 확인한 뒤, 순환 참조 문제가 없다면 의존하고 있는 빈을 먼저 가져온다.
5. 가져온 mbd가 singleton인 경우 sharedInstance에 등록(2번에서 생성된 빈이 있는지 확인한 곳)하고 createBean()한다.
6. 만약 mbd가 prototype인 경우, 필요한 작업과 함께 createBean() 한다.
7. 생략된 코드지만 만약 스코프가 커스텀 스코프인 경우 해당 스코프의 관리자가 처리한다.

getSingleton

@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
	// Quick check for existing instance without full singleton lock.
	Object singletonObject = this.singletonObjects.get(beanName);
	if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
		singletonObject = this.earlySingletonObjects.get(beanName);
		if (singletonObject == null && allowEarlyReference) {
			if (!this.singletonLock.tryLock()) {
				// Avoid early singleton inference outside of original creation thread.
				return null;
			}
			try {
				// Consistent creation of early reference within full singleton lock.
				singletonObject = this.singletonObjects.get(beanName);
				if (singletonObject == null) {
					singletonObject = this.earlySingletonObjects.get(beanName);
					if (singletonObject == null) {
						ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
						if (singletonFactory != null) {
							singletonObject = singletonFactory.getObject();
							// Singleton could have been added or removed in the meantime.
							if (this.singletonFactories.remove(beanName) != null) {
								this.earlySingletonObjects.put(beanName, singletonObject);
							}
							else {
								singletonObject = this.singletonObjects.get(beanName);
							}
						}
					}
				}
			}
			finally {
				this.singletonLock.unlock();
			}
		}
	}
	return singletonObject;
}

lock을 사용하여 원하는 bean이 존재하는지 확인한다.

1. singletonObjects에서 beanName을 기반으로 가져와본다.
2. 없으면 earlySingletonObjects에서 beanName을 기반으로 가져와본다.
3. 또 없고 allowEarlyReference인 경우, 락을 걸고
   3-1. singletonObjects, earlySingletonObjects, singletonFactories에서 찾아본다.
   3-2. singletonFactories에서 가져온 Factory를 통해 singletonObject를 새로 가져오고 earlySingletonObjects에 새롭게 집어넣는다. 🔗 doCreateBean()에서 순환 참조성을 얘기할 때 또 나온다.
4. 그리고 락을 푼다.

왜 이렇게 하나 생각해봤더니, B 빈을 참조하는 A 빈과 A 빈을 참조하는 B 빈이 있을 때의 순환 참조 문제를 해결하기 위해서이다. A 빈도 B 빈도 서로 완전히 완료된 빈을 주입 받으려고만 한다면 영원히 서로를 기다리게 된다.
그래서 좀 덜 완성됐더라도 factory에 있는 람다를 실행해 미리 주입 받고, earlySingletonObjects에 넣어놓는다. 나중에 알게 되겠지만(doCreateBean()), 모든 빈들은 초기화를 진행하기 전후로 earlySingletonObjects를 한 번 확인한다.

순환 참조 문제 해결 안 되던데? -> 그건 생성자 주입만을 사용했기 때문이다. 생성자 주입 + 필드 주입(혹은 생성자 주입 + 세터 주입) 섞어서 사용하면 순환 참조를 할 수도 있다. (좋은 설계는 아님)

singletonObjects에는 생성이 완전히 완료된 빈, earlySingletonObjects은 생성은 됐지만 초기화는 되지 않은 빈, singletonFactories에는 빈 팩토리가 저장되어 있다고 한다.

createBean

@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
		throws BeanCreationException {

	RootBeanDefinition mbdToUse = mbd;
	
	// bean defintion 확정과 관련된 코드 생략
	}
	try {
		// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
		Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
		if (bean != null) {
			return bean;
		}
	} // 생략

	try {
		Object beanInstance = doCreateBean(beanName, mbdToUse, args);
		return beanInstance;
	} // 생략, 마찬가지로 log 관련된 부분을 일부 생략했다.
}

1. Bean definition 확정을 확실히 한다. (생략됨)
2. resolveBeforeInstantiation()를 통해 bean이 반환되면 더 이상 추가 작업을 하지 않는다. 실제 빈 대신 프록시 등 다른 객체를 반환하는 부분이다.
3. doCreateBean() gogo

doCreateBean

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
		throws BeanCreationException {

	// Instantiate the bean.
	BeanWrapper instanceWrapper = null;
	if (mbd.isSingleton()) {
		instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
	}
	if (instanceWrapper == null) {
		instanceWrapper = createBeanInstance(beanName, mbd, args);
	}
	Object bean = instanceWrapper.getWrappedInstance();
	Class<?> beanType = instanceWrapper.getWrappedClass();
	if (beanType != NullBean.class) {
		mbd.resolvedTargetType = beanType;
	}
	// Allow post-processors to modify the merged bean definition.
	synchronized (mbd.postProcessingLock) {
		if (!mbd.postProcessed) {
			try {
				applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
			}
			catch (Throwable ex) {
					throw new BeanCreationException(mbd.getResourceDescription(), beanName,
						"Post-processing of merged bean definition failed", ex);
			}
			mbd.markAsPostProcessed();
		}
	}

	// Eagerly cache singletons to be able to resolve circular references
	// even when triggered by lifecycle interfaces like BeanFactoryAware.
	boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
		isSingletonCurrentlyInCreation(beanName));
	if (earlySingletonExposure) {
		addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
	}

	// Initialize the bean instance.
	Object exposedObject = bean;
	try {
		populateBean(beanName, mbd, instanceWrapper);
		exposedObject = initializeBean(beanName, exposedObject, mbd);
	} // 생략

	if (earlySingletonExposure) {
		Object earlySingletonReference = getSingleton(beanName, false);
		if (earlySingletonReference != null) {
			if (exposedObject == bean) {
				exposedObject = earlySingletonReference;
			}
			else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
				String[] dependentBeans = getDependentBeans(beanName);
				Set<String> actualDependentBeans = CollectionUtils.newLinkedHashSet(dependentBeans.length);
				for (String dependentBean : dependentBeans) {
					if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
						actualDependentBeans.add(dependentBean);
					}
				}
				if (!actualDependentBeans.isEmpty()) {
					throw new BeanCurrentlyInCreationException("생략");
				}
			}
		}
	}

	// Register bean as disposable.
	try {
		registerDisposableBeanIfNecessary(beanName, bean, mbd);
	} // 생략, 마찬가지로 log 관련된 부분을 일부 생략했다.
	return exposedObject;
}

1. createBeanInstance()으로 bean instance를 생성한다. (mbd가 싱글톤인 경우, factoryBeanInstanceCache에서 해당 빈 인스턴스를 제거하고 재사용)
2. postProcessingLock을 걸고 applyMergedBeanDefinitionPostProcessors()로 post processor를 적용한다. 그리고 markAsPostProcessed()로 post processed 되었음을 마킹한다.
3. 순환 의존성(circular reference)을 대비하여 SingletonFactory에 빈을 반환할 수 있는 람다인 factory를 저장해둔다.
4. populateBean()로 의존성을 주입한다. 아래에서 추가로 설명한다.
5. initializeBean()으로 빈의 초기화 관련 메서드들을 실행한다. @PostConstruct 어노테이션이 여기서 실행된다! applyBeanPostProcessorsAfterInitialization()를 통해 AOP Proxy도 여기서 적용된다. (꼭 여기서 모든 AOP Proxy가 적용되는 것은 아니고, getEarlyReference()에서도 생성되는 경우도 존재한다. 순환 의존성 문제를 해결하기 위한 건데, 만약 early..에서 먼저 생성됐다면 여기선 재사용한다.)
6. earlySingletonExposure인 경우, 순환 의존성 문제를 해결하기 위해 earlySingletonReference과 현재 bean을 비교한다. earlySingletonReference는 getSingleton(beanName, false);을 통해 가져오는데, 이러면 singletonFactories는 제외한 singletonObject와 earlySingletonObjects만 확인하게 된다. (만약 다른 빈이 의존을 위해 factory에서 빈을 빼냈으면 singletonObject나 earlySingletonObjects에 등록되니까)
   문제가 되는 건 현재 빈과 getSingleton()을 통해 가져온 빈이 다를 때이다. (exposedObject != bean, !allowRawInjectionDespiteWrapping(프록시 말고 원본 빈 사용 불가) 경우) 현재는 initializeBean()를 통해 AOP가 적용된 상태인데, 다른 빈은 다른 버전을 사용하고 있다는 거다.
   만약 removeSingletonIfCreatedForTypeCheckOnly, 그러니까 타입 체크만 하려고 빈을 가져갔다면 신경 쓰지 않는다. 하지만 이 모든 것이 충족되어 순환 의존성 문제가 발생했다면, 예외를 터뜨린다.

populateBean()

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
	if (bw == null) {
		if (mbd.hasPropertyValues()) {
			throw new );
		}
		else {
			// Skip property population phase for null instance.
			return;
		}
	}

	if (bw.getWrappedClass().isRecord()) {
		if (mbd.hasPropertyValues()) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Cannot apply property values to a record");
		}
			else {
		// Skip property population phase for records since they are immutable.
			return;
		}
	}
	// Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
	// state of the bean before properties are set. This can be used, for example,
	// to support styles of field injection.
	if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
		for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
			if (!bp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
				return;
			}
		}
	}

	PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

	int resolvedAutowireMode = mbd.getResolvedAutowireMode();
	if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
		MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
		// Add property values based on autowire by name if applicable.
		if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
			autowireByName(beanName, mbd, bw, newPvs);
		}
		// Add property values based on autowire by type if applicable.
		if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
			autowireByType(beanName, mbd, bw, newPvs);
		}
		pvs = newPvs;
	}
	if (hasInstantiationAwareBeanPostProcessors()) {
		if (pvs == null) {
			pvs = mbd.getPropertyValues();
		}
		for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
			PropertyValues pvsToUse = bp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
			if (pvsToUse == null) {
				return;
			}
			pvs = pvsToUse;
		}
	}

	boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
	if (needsDepCheck) {
		PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
		checkDependencies(beanName, mbd, filteredPds, pvs);
	}
	if (pvs != null) {
		applyPropertyValues(beanName, mbd, bw, pvs);
	}
}

1. 사전 검증 단계를 통해 bean wrapper가 null인지, record 타입(record 타입은 불변이라 property 주입이 필요 없다)인지 등을 검증한다.
2. postProcessAfterInstantiation()로 의존성 주입을 건너뛰어야 하는지 확인한다.
3. 빈에 설정할 property values를 가져온다.
4. AUTOWIRE_BY_NAME 혹은 AUTOWIRE_BY_TYPE 등 설정된 값에 맞춰 이름이나 타입을 기준으로 필요한 빈을 가져오고, property values에 추가한다. (XML)
5. InstantiationAwareBeanPostProcessor를 가지고 있는 경우, 여기서 AutowiredAnnotationBeanPostProcessor를 실행한다. Autowired 그 Autowired 맞다. 여기서 @Autowired, @Value, @Inject를 처리한다. (Annotation)
   만약 Annotation 방식을 사용하면 4번은 스킵되고 5번만 실행된다.
6. DependencyCheck으로 필요한 의존성이 다 갖추어졌는지 확인한다.
7. 마지막으로 applyPropertyValues()를 통해 property value를 적용한다. 구체적으로는 리플렉션을 통해 적용하고 있다.

4. 마무리

finishRefresh()

protected void finishRefresh() {
	// Reset common introspection caches in Spring's core infrastructure.
	resetCommonCaches();

	// Clear context-level resource caches (such as ASM metadata from scanning).
	clearResourceCaches();

	// Initialize lifecycle processor for this context.
	initLifecycleProcessor();

	// Propagate refresh to lifecycle processor first.
	getLifecycleProcessor().onRefresh();

	// Publish the final event.
	publishEvent(new ContextRefreshedEvent(this));
}

finishRefresh()에서는 이제 필요 없게 된 캐시들을 제거하고, LifecycleProcessor를 생성하고 초기화한다.

Lifecycle processor는 Lifecycle 인터페이스를 구현한 빈들을 관리한다. Lifecycle을 구현한 빈들은 start(), stop()을 구현하게 되는데 이 메서드들을 통해서 Lifecycle processor가 빈을 시작하고 종료할 수 있다.

그리고 마지막으로 publishEvent()를 통해 컨테이너가 성공적으로 초기화되었음을 외부에 알리게 된다. (아마 이벤트 멀티캐스터로 이벤트를 받아볼 수 있을 것 같다.)

아주 길고 긴 여정이었다.. refresh()가 끝나면 컨테이너와 빈의 준비가 완료된 것이고, 이제 다시 처음의 run() 메서드로 돌아가자...

refresh가 끝나면 남은 작업은 몇 개 되지 않는다.

afterRefresh()

스프링 부트 환경의 최종_최종_최종_최종 작업을 처리한다. 초기화 작업을 마무리하고 상태를 정리, 웹 서버를 구동하는 등의 작업을 한다.

listeners.started(context, startup.timeTakenToStarted());

컨테이너가 시작되었음을 이벤트로 알린다.

callRunners(context, applicationArguments);

최종적으로 CommandLineRunner나 ApplicationRunner 빈을 호출해 사용자 정의 초기화 로직을 실행한다.

---

요약

1. Spring은 IoC 컨테이너의 역할을 하기 위해 Bean과 DI를 사용한다.
2. Spring의 실행 과정을 엄청나게 간략하게 요약하자면 다음과 같다.
   2-1. Application Context 생성
   2-2. Bean Definition 정의
   2-3. DI 실행 및 Bean 생성

회고

사실 원래 스프링 부트 자체 내부 코드를 직접 뜯어보는 것에 대한 공포심이 살짝 있었다... 내가 작성하지 않은 코드를 잘 읽을 수 있어야 한다는 걸 알고 있음에도 불구하고 이해가 잘 안 되지 않을까 하는 생각이 있었나보다.

하지만 읽어보며 차근차근 뜯어보니 그리 어려운 일도 아니었다! 단순히 공식 문서, 글 같은 걸 읽다 보면 그래서 대체 어떻게 구현한 거지? 라는 의문이 가끔 들 때가 있었는데, 이젠 곧바로 직접 코드를 뜯어봐야겠다 ㅎㅎ

그리고 주석, 메서드명, 변수명이 얼마나 중요한지 배운 것 같다. 구체적으로 어떻게 동작하는지 궁금해서 들어가 본 것을 제외하면, 엥간하면 엄청나게 친절한 주석과 메서드명, 변수명을 통해 대략 어떤 기능을 하는 건지 쉽게 짐작할 수 있었다.

프로젝트 할 때 주석, 메서드명, 변수명을 더 신중히 작성해야겠다는 생각이 들었다!

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