refactor(core): IoC 컨테이너 구조 전면 리팩토링 (Strategy / Chain / Phase 패턴 적용)

- BeanInstantiationStrategy로 빈 생성 로직 분리 (전략 패턴)
- 의존성 해결 로직을 Resolver 체인으로 대체 (책임 연쇄 패턴)
- BeanLifecyclePhaseManager 도입으로 생명주기 단계 확장성 확보
- BeanTypeMatchingService로 타입 매칭 로직 통합 및 중복 제거
- DefaultListableBeanFactory 책임 경량화 (357 → 280 LOC)
- SRP/OCP 준수, 테스트 용이성 및 유지보수성 향상
- 기존 동작 100% 하위 호환 유지

Author: yyubin

src/main/java/sprout/beans/instantiation/BeanInstantiationStrategy.java

@@ -0,0 +1,30 @@
+package sprout.beans.instantiation;
+
+import sprout.beans.BeanCreationMethod;
+import sprout.beans.BeanDefinition;
+import sprout.context.BeanFactory;
+
+/**
+ * 빈 인스턴스화 전략 인터페이스
+ * 다양한 방식으로 빈을 생성할 수 있도록 Strategy Pattern을 적용
+ */
+public interface BeanInstantiationStrategy {
+
+    /**
+     * 빈 인스턴스를 생성합니다
+     *
+     * @param def 빈 정의
+     * @param dependencyResolver 의존성 해결자
+     * @param beanFactory 빈 팩토리
+     * @return 생성된 빈 인스턴스
+     */
+    Object instantiate(BeanDefinition def, DependencyResolver dependencyResolver, BeanFactory beanFactory) throws Exception;
+
+    /**
+     * 이 전략이 주어진 빈 생성 방식을 지원하는지 확인
+     *
+     * @param method 빈 생성 방식
+     * @return 지원 여부
+     */
+    boolean supports(BeanCreationMethod method);
+}

src/main/java/sprout/beans/instantiation/CompositeDependencyResolver.java

@@ -0,0 +1,49 @@
+package sprout.beans.instantiation;
+
+import sprout.beans.BeanDefinition;
+
+import java.lang.reflect.Parameter;
+import java.util.List;
+
+/**
+ * 여러 DependencyTypeResolver를 조합하여 사용하는 Composite Resolver
+ * Chain of Responsibility 패턴 적용
+ */
+public class CompositeDependencyResolver implements DependencyResolver {
+
+    private final List<DependencyTypeResolver> typeResolvers;
+
+    public CompositeDependencyResolver(List<DependencyTypeResolver> typeResolvers) {
+        this.typeResolvers = typeResolvers;
+    }
+
+    @Override
+    public Object[] resolve(Class<?>[] dependencyTypes, Parameter[] params, BeanDefinition targetDef) {
+        Object[] deps = new Object[dependencyTypes.length];
+
+        for (int i = 0; i < dependencyTypes.length; i++) {
+            Class<?> paramType = dependencyTypes[i];
+            Parameter param = params[i];
+
+            // 적절한 resolver를 찾아서 의존성 해결
+            Object resolved = null;
+            for (DependencyTypeResolver resolver : typeResolvers) {
+                if (resolver.supports(paramType)) {
+                    resolved = resolver.resolve(paramType, param, targetDef);
+                    break;
+                }
+            }
+
+            if (resolved == null) {
+                throw new RuntimeException(
+                        "No DependencyTypeResolver found for type: " + paramType.getName() +
+                                " in bean: " + targetDef.getName()
+                );
+            }
+
+            deps[i] = resolved;
+        }
+
+        return deps;
+    }
+}

src/main/java/sprout/beans/instantiation/ConstructorBasedInstantiationStrategy.java

@@ -0,0 +1,51 @@
+package sprout.beans.instantiation;
+
+import net.sf.cglib.proxy.Enhancer;
+import sprout.beans.BeanCreationMethod;
+import sprout.beans.BeanDefinition;
+import sprout.beans.ConstructorBeanDefinition;
+import sprout.context.BeanFactory;
+import sprout.context.ConfigurationMethodInterceptor;
+
+import java.lang.reflect.Constructor;
+
+/**
+ * 생성자 기반 빈 인스턴스화 전략
+ */
+public class ConstructorBasedInstantiationStrategy implements BeanInstantiationStrategy {
+
+    @Override
+    public Object instantiate(BeanDefinition def, DependencyResolver dependencyResolver, BeanFactory beanFactory) throws Exception {
+        Constructor<?> constructor = def.getConstructor();
+        Object[] deps;
+
+        // ConstructorBeanDefinition인 경우 미리 준비된 생성자 인자 사용
+        if (def instanceof ConstructorBeanDefinition && ((ConstructorBeanDefinition) def).getConstructorArguments() != null) {
+            deps = ((ConstructorBeanDefinition) def).getConstructorArguments();
+        } else {
+            // 의존성 해결
+            deps = dependencyResolver.resolve(
+                    def.getConstructorArgumentTypes(),
+                    constructor.getParameters(),
+                    def
+            );
+        }
+
+        // Configuration 클래스의 경우 CGLIB 프록시 생성
+        if (def.isConfigurationClassProxyNeeded()) {
+            Enhancer enhancer = new Enhancer();
+            enhancer.setSuperclass(def.getType());
+            enhancer.setCallback(new ConfigurationMethodInterceptor(beanFactory));
+            return enhancer.create(def.getConstructorArgumentTypes(), deps);
+        } else {
+            // 접근 권한 설정 (private/package-private 생성자 접근 가능하게)
+            constructor.setAccessible(true);
+            return constructor.newInstance(deps);
+        }
+    }
+
+    @Override
+    public boolean supports(BeanCreationMethod method) {
+        return method == BeanCreationMethod.CONSTRUCTOR;
+    }
+}

src/main/java/sprout/beans/instantiation/DependencyResolver.java

@@ -0,0 +1,22 @@
+package sprout.beans.instantiation;
+
+import sprout.beans.BeanDefinition;
+
+import java.lang.reflect.Parameter;
+
+/**
+ * 의존성 해결 인터페이스
+ * 생성자나 팩토리 메서드의 파라미터들을 해결하는 역할
+ */
+public interface DependencyResolver {
+
+    /**
+     * 주어진 타입 배열과 파라미터 정보를 바탕으로 의존성을 해결합니다
+     *
+     * @param dependencyTypes 의존성 타입 배열
+     * @param params 파라미터 정보
+     * @param targetDef 현재 생성하려는 빈의 정의
+     * @return 해결된 의존성 배열
+     */
+    Object[] resolve(Class<?>[] dependencyTypes, Parameter[] params, BeanDefinition targetDef);
+}

src/main/java/sprout/beans/instantiation/DependencyTypeResolver.java

@@ -0,0 +1,27 @@
+package sprout.beans.instantiation;
+
+import sprout.beans.BeanDefinition;
+
+import java.lang.reflect.Parameter;
+
+// 특정 타입의 의존성을 해결하는 전략 인터페이스
+public interface DependencyTypeResolver {
+
+    /**
+     * 주어진 타입을 이 resolver가 처리할 수 있는지 확인
+     *
+     * @param type 의존성 타입
+     * @return 지원 여부
+     */
+    boolean supports(Class<?> type);
+
+    /**
+     * 의존성을 해결하여 반환
+     *
+     * @param type 의존성 타입
+     * @param param 파라미터 정보 (제네릭 타입 등 추출용)
+     * @param targetDef 현재 생성하려는 빈의 정의
+     * @return 해결된 의존성 객체
+     */
+    Object resolve(Class<?> type, Parameter param, BeanDefinition targetDef);
+}

src/main/java/sprout/beans/instantiation/FactoryMethodBasedInstantiationStrategy.java

@@ -0,0 +1,36 @@
+package sprout.beans.instantiation;
+
+import sprout.beans.BeanCreationMethod;
+import sprout.beans.BeanDefinition;
+import sprout.context.BeanFactory;
+
+import java.lang.reflect.Method;
+
+/**
+ * 팩토리 메서드 기반 빈 인스턴스화 전략
+ */
+public class FactoryMethodBasedInstantiationStrategy implements BeanInstantiationStrategy {
+
+    @Override
+    public Object instantiate(BeanDefinition def, DependencyResolver dependencyResolver, BeanFactory beanFactory) throws Exception {
+        // 팩토리 빈 조회
+        Object factoryBean = beanFactory.getBean(def.getFactoryBeanName());
+        Method factoryMethod = def.getFactoryMethod();
+
+        // 팩토리 메서드의 의존성 해결
+        Object[] deps = dependencyResolver.resolve(
+                def.getFactoryMethodArgumentTypes(),
+                factoryMethod.getParameters(),
+                def
+        );
+
+        // 팩토리 메서드 호출 (접근 권한 설정)
+        factoryMethod.setAccessible(true);
+        return factoryMethod.invoke(factoryBean, deps);
+    }
+
+    @Override
+    public boolean supports(BeanCreationMethod method) {
+        return method == BeanCreationMethod.FACTORY_METHOD;
+    }
+}

src/main/java/sprout/beans/instantiation/ListBeanDependencyResolver.java

@@ -0,0 +1,42 @@
+package sprout.beans.instantiation;
+
+import sprout.beans.BeanDefinition;
+import sprout.context.PendingListInjection;
+
+import java.lang.reflect.Parameter;
+import java.lang.reflect.ParameterizedType;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * List 타입 의존성을 해결하는 resolver
+ * List 주입의 경우 나중에 postProcessListInjections에서 채워지므로
+ * 빈 리스트를 반환하고 pending 목록에 등록
+ */
+public class ListBeanDependencyResolver implements DependencyTypeResolver {
+
+    private final List<PendingListInjection> pendingListInjections;
+
+    public ListBeanDependencyResolver(List<PendingListInjection> pendingListInjections) {
+        this.pendingListInjections = pendingListInjections;
+    }
+
+    @Override
+    public boolean supports(Class<?> type) {
+        return List.class.isAssignableFrom(type);
+    }
+
+    @Override
+    public Object resolve(Class<?> type, Parameter param, BeanDefinition targetDef) {
+        List<Object> emptyList = new ArrayList<>();
+
+        // 제네릭 타입 추출
+        Class<?> genericType = (Class<?>) ((ParameterizedType) param.getParameterizedType())
+                .getActualTypeArguments()[0];
+
+        // 나중에 채울 수 있도록 pending 목록에 등록
+        pendingListInjections.add(new PendingListInjection(null, emptyList, genericType));
+
+        return emptyList;
+    }
+}

src/main/java/sprout/beans/internal/BeanGraph.java

@@ -2,6 +2,7 @@
 
 import sprout.beans.BeanCreationMethod;
 import sprout.beans.BeanDefinition;
+import sprout.beans.matching.BeanTypeMatchingService;
 
 import java.lang.reflect.Modifier;
 import java.util.*;
@@ -11,6 +12,7 @@ public class BeanGraph {
     private final Map<String, BeanDefinition> nodeMap = new HashMap<>();
     private final Map<String, List<String>> edges = new HashMap<>();
     private final Map<String, Integer> indegree = new HashMap<>();
+    private final BeanTypeMatchingService typeMatchingService;
 
     public BeanGraph(Collection<BeanDefinition> definitions) {
         definitions.forEach(d -> {
@@ -19,6 +21,10 @@ public BeanGraph(Collection<BeanDefinition> definitions) {
             // 초기 indegree는 0으로 설정
             indegree.putIfAbsent(d.getName(), 0);
         });
+
+        // 타입 매칭 서비스 초기화 (BeanGraph는 싱글톤이 아니므로 빈 Map 전달)
+        this.typeMatchingService = new BeanTypeMatchingService(nodeMap, Collections.emptyMap());
+
         buildEdges();
         System.out.println(indegree);
     }
@@ -103,13 +109,7 @@ private void buildEdges() {
     }
 
     private Set<String> getBeanNamesForType(Class<?> type) {
-        Set<String> names = new HashSet<>();
-        for (BeanDefinition beanDef : nodeMap.values()) {
-            if (type.isAssignableFrom(beanDef.getType())) {
-                names.add(beanDef.getName());
-            }
-        }
-        return names;
+        return typeMatchingService.getBeanNamesForType(type);
     }
 
     public static class CircularDependencyException extends RuntimeException {

src/main/java/sprout/beans/matching/BeanTypeMatchingService.java

@@ -0,0 +1,91 @@
+package sprout.beans.matching;
+
+import sprout.beans.BeanDefinition;
+
+import java.util.*;
+
+/**
+ * 빈 타입 매칭 서비스
+ * 타입을 기반으로 빈을 찾고 매칭하는 로직을 담당
+ */
+public class BeanTypeMatchingService {
+
+    private final Map<String, BeanDefinition> beanDefinitions;
+    private final Map<String, Object> singletons;
+
+    public BeanTypeMatchingService(Map<String, BeanDefinition> beanDefinitions, Map<String, Object> singletons) {
+        this.beanDefinitions = beanDefinitions;
+        this.singletons = singletons;
+    }
+
+    // 주어진 타입에 대한 후보 빈 이름들을 찾습니다
+    public Set<String> findCandidateNamesForType(Class<?> type) {
+        Set<String> names = new HashSet<>();
+
+        // 1) 이미 등록된 싱글턴에서 찾기
+        for (Map.Entry<String, Object> entry : singletons.entrySet()) {
+            if (type.isAssignableFrom(entry.getValue().getClass())) {
+                names.add(entry.getKey());
+            }
+        }
+
+        // 2) 아직 생성되지 않은 BeanDefinition에서 찾기
+        for (Map.Entry<String, BeanDefinition> entry : beanDefinitions.entrySet()) {
+            if (type.isAssignableFrom(entry.getValue().getType())) {
+                names.add(entry.getKey());
+            }
+        }
+
+        return names;
+    }
+
+    /**
+     * 후보 빈들 중에서 primary 빈을 선택
+     *
+     * @param requiredType 요청된 타입
+     * @param candidates 후보 빈 이름들
+     * @param primaryTypeToNameMap 타입별 primary 빈 매핑
+     * @return primary 빈 이름 (없으면 null)
+     */
+    public String choosePrimary(Class<?> requiredType, Set<String> candidates, Map<Class<?>, String> primaryTypeToNameMap) {
+        // 1) BeanDefinition 중 primary=true인 빈 찾기
+        List<String> primaries = candidates.stream()
+                .filter(name -> {
+                    BeanDefinition def = beanDefinitions.get(name);
+                    return def != null && def.isPrimary();
+                })
+                .toList();
+
+        if (primaries.size() == 1) {
+            return primaries.get(0);
+        }
+        if (primaries.size() > 1) {
+            throw new RuntimeException("@Primary beans conflict for type " + requiredType.getName() + ": " + primaries);
+        }
+
+        // 2) primaryTypeToNameMap fallback
+        String mapped = primaryTypeToNameMap.get(requiredType);
+        if (mapped != null && candidates.contains(mapped)) {
+            return mapped;
+        }
+
+        return null;
+    }
+
+    /**
+     * 주어진 타입의 모든 빈 이름을 BeanDefinition에서 찾기
+     * (BeanGraph에서 사용)
+     *
+     * @param type 찾을 타입
+     * @return 빈 이름 집합
+     */
+    public Set<String> getBeanNamesForType(Class<?> type) {
+        Set<String> names = new HashSet<>();
+        for (BeanDefinition beanDef : beanDefinitions.values()) {
+            if (type.isAssignableFrom(beanDef.getType())) {
+                names.add(beanDef.getName());
+            }
+        }
+        return names;
+    }
+}