From f7f164f8ee12f41bb86642529816da9ea0da40c3 Mon Sep 17 00:00:00 2001 From: KNU-K Date: Fri, 19 Sep 2025 00:28:53 +0900 Subject: [PATCH 1/7] Refactor Improve performance by inducing hot path from the point of view of the jit compilor Signed-off-by: KNU-K --- .../support/DefaultListableBeanFactory.java | 204 +++++++++++------- 1 file changed, 132 insertions(+), 72 deletions(-) diff --git a/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java b/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java index 9803e6b1eb72..027cfe28d731 100644 --- a/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java +++ b/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java @@ -615,81 +615,125 @@ private String[] doGetBeanNamesForType(ResolvableType type, boolean includeNonSi List result = new ArrayList<>(); // Check all bean definitions. + processBeanDefinitions(result, type, includeNonSingletons, allowEagerInit); + + // Check manually registered singletons too. + processManualSingletons(result, type, includeNonSingletons); + + return StringUtils.toStringArray(result); + } + + private void processBeanDefinitions(List result, ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit) { for (String beanName : this.beanDefinitionNames) { // Only consider bean as eligible if the bean name is not defined as alias for some other bean. - if (!isAlias(beanName)) { - try { - RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); - // Only check bean definition if it is complete. - if (!mbd.isAbstract() && (allowEagerInit || - (mbd.hasBeanClass() || !mbd.isLazyInit() || isAllowEagerClassLoading()) && - !requiresEagerInitForType(mbd.getFactoryBeanName()))) { - boolean isFactoryBean = isFactoryBean(beanName, mbd); - BeanDefinitionHolder dbd = mbd.getDecoratedDefinition(); - boolean matchFound = false; - boolean allowFactoryBeanInit = (allowEagerInit || containsSingleton(beanName)); - boolean isNonLazyDecorated = (dbd != null && !mbd.isLazyInit()); - if (!isFactoryBean) { - if (includeNonSingletons || isSingleton(beanName, mbd, dbd)) { - matchFound = isTypeMatch(beanName, type, allowFactoryBeanInit); - } - } - else { - if (includeNonSingletons || isNonLazyDecorated) { - matchFound = isTypeMatch(beanName, type, allowFactoryBeanInit); - } - else if (allowFactoryBeanInit) { - // Type check before singleton check, avoiding FactoryBean instantiation - // for early FactoryBean.isSingleton() calls on non-matching beans. - matchFound = isTypeMatch(beanName, type, allowFactoryBeanInit) && - isSingleton(beanName, mbd, dbd); - } - if (!matchFound) { - // In case of FactoryBean, try to match FactoryBean instance itself next. - beanName = FACTORY_BEAN_PREFIX + beanName; - if (includeNonSingletons || isSingleton(beanName, mbd, dbd)) { - matchFound = isTypeMatch(beanName, type, allowFactoryBeanInit); - } - } - } - if (matchFound) { - result.add(beanName); - } - } - } - catch (CannotLoadBeanClassException | BeanDefinitionStoreException ex) { - if (allowEagerInit) { - throw ex; - } - // Probably a placeholder: let's ignore it for type matching purposes. - LogMessage message = (ex instanceof CannotLoadBeanClassException ? - LogMessage.format("Ignoring bean class loading failure for bean '%s'", beanName) : - LogMessage.format("Ignoring unresolvable metadata in bean definition '%s'", beanName)); - logger.trace(message, ex); - // Register exception, in case the bean was accidentally unresolvable. - onSuppressedException(ex); - } - catch (NoSuchBeanDefinitionException ex) { - // Bean definition got removed while we were iterating -> ignore. + if (isAlias(beanName)) { + continue; + } + + RootBeanDefinition mbd; + try { + mbd = getMergedLocalBeanDefinition(beanName); + } + catch (CannotLoadBeanClassException | BeanDefinitionStoreException ex) { + if (allowEagerInit) { + throw ex; } + handleBeanDefinitionException(beanName, ex); + continue; + } + catch (NoSuchBeanDefinitionException ex) { + // Bean definition got removed while we were iterating -> ignore. + continue; + } + + if (processBeanDefinition(result, beanName, mbd, type, includeNonSingletons, allowEagerInit)) { + result.add(beanName); } } + } - // Check manually registered singletons too. + private void handleBeanDefinitionException(String beanName, Exception ex) { + // Probably a placeholder: let's ignore it for type matching purposes. + LogMessage message = (ex instanceof CannotLoadBeanClassException ? + LogMessage.format("Ignoring bean class loading failure for bean '%s'", beanName) : + LogMessage.format("Ignoring unresolvable metadata in bean definition '%s'", beanName)); + logger.trace(message, ex); + // Register exception, in case the bean was accidentally unresolvable. + onSuppressedException(ex); + } + + private boolean processBeanDefinition(List result, String beanName, RootBeanDefinition mbd, + ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit) { + // Cache merged bean definition properties to avoid repeated access + boolean isAbstract = mbd.isAbstract(); + boolean hasBeanClass = mbd.hasBeanClass(); + boolean isLazyInit = mbd.isLazyInit(); + String factoryBeanName = mbd.getFactoryBeanName(); + BeanDefinitionHolder dbd = mbd.getDecoratedDefinition(); + + // Only check bean definition if it is complete. + if (isAbstract) { + return false; + } + + if (!allowEagerInit && + !(hasBeanClass || !isLazyInit || isAllowEagerClassLoading()) && + requiresEagerInitForType(factoryBeanName)) { + return false; + } + + boolean isFactoryBean = isFactoryBean(beanName, mbd); + boolean allowFactoryBeanInit = (allowEagerInit || containsSingleton(beanName)); + boolean isNonLazyDecorated = (dbd != null && !isLazyInit); + + if (!isFactoryBean) { + return processRegularBean(beanName, mbd, dbd, type, includeNonSingletons, allowFactoryBeanInit); + } else { + return processFactoryBean(result, beanName, mbd, dbd, type, includeNonSingletons, allowFactoryBeanInit, isNonLazyDecorated); + } + } + + private boolean processRegularBean(String beanName, RootBeanDefinition mbd, @Nullable BeanDefinitionHolder dbd, + ResolvableType type, boolean includeNonSingletons, boolean allowFactoryBeanInit) { + if (includeNonSingletons || isSingleton(beanName, mbd, dbd)) { + return isTypeMatch(beanName, type, allowFactoryBeanInit); + } + return false; + } + + private boolean processFactoryBean(List result, String beanName, RootBeanDefinition mbd, @Nullable BeanDefinitionHolder dbd, + ResolvableType type, boolean includeNonSingletons, boolean allowFactoryBeanInit, boolean isNonLazyDecorated) { + boolean matchFound = false; + + if (includeNonSingletons || isNonLazyDecorated) { + matchFound = isTypeMatch(beanName, type, allowFactoryBeanInit); + } + else if (allowFactoryBeanInit) { + // Type check before singleton check, avoiding FactoryBean instantiation + // for early FactoryBean.isSingleton() calls on non-matching beans. + matchFound = isTypeMatch(beanName, type, allowFactoryBeanInit) && + isSingleton(beanName, mbd, dbd); + } + + if (!matchFound) { + // In case of FactoryBean, try to match FactoryBean instance itself next. + String factoryBeanName = FACTORY_BEAN_PREFIX + beanName; + if (includeNonSingletons || isSingleton(factoryBeanName, mbd, dbd)) { + matchFound = isTypeMatch(factoryBeanName, type, allowFactoryBeanInit); + } + if (matchFound) { + result.add(factoryBeanName); + return false; // Don't add original beanName + } + } + + return matchFound; + } + + private void processManualSingletons(List result, ResolvableType type, boolean includeNonSingletons) { for (String beanName : this.manualSingletonNames) { try { - // In case of FactoryBean, match object created by FactoryBean. - if (isFactoryBean(beanName)) { - if ((includeNonSingletons || isSingleton(beanName)) && isTypeMatch(beanName, type)) { - result.add(beanName); - // Match found for this bean: do not match FactoryBean itself anymore. - continue; - } - // In case of FactoryBean, try to match FactoryBean itself next. - beanName = FACTORY_BEAN_PREFIX + beanName; - } - // Match raw bean instance (might be raw FactoryBean). - if (isTypeMatch(beanName, type)) { + if (processManualSingleton(result, beanName, type, includeNonSingletons)) { result.add(beanName); } } @@ -699,8 +743,24 @@ else if (allowFactoryBeanInit) { "Failed to check manually registered singleton with name '%s'", beanName), ex); } } + } - return StringUtils.toStringArray(result); + private boolean processManualSingleton(List result, String beanName, ResolvableType type, boolean includeNonSingletons) { + // In case of FactoryBean, match object created by FactoryBean. + if (isFactoryBean(beanName)) { + if ((includeNonSingletons || isSingleton(beanName)) && isTypeMatch(beanName, type)) { + return true; // Match found for this bean + } + // In case of FactoryBean, try to match FactoryBean itself next. + String factoryBeanName = FACTORY_BEAN_PREFIX + beanName; + if (isTypeMatch(factoryBeanName, type)) { + result.add(factoryBeanName); + } + return false; // Don't add original beanName + } + + // Match raw bean instance (might be raw FactoryBean). + return isTypeMatch(beanName, type); } private boolean isSingleton(String beanName, RootBeanDefinition mbd, @Nullable BeanDefinitionHolder dbd) { @@ -1267,7 +1327,7 @@ public void registerBeanDefinition(String beanName, BeanDefinition beanDefinitio else { // alias pointing to non-existing bean definition throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName, "Cannot register bean definition for bean '" + beanName + - "' since there is already an alias for bean '" + aliasedName + "' bound."); + "' since there is already an alias for bean '" + aliasedName + "' bound."); } } else { @@ -2148,7 +2208,7 @@ else if (candidatePriority < highestPriority) { if (highestPriorityConflictDetected) { throw new NoUniqueBeanDefinitionException(requiredType, candidates.size(), "Multiple beans found with the same highest priority (" + highestPriority + - ") among candidates: " + candidates.keySet()); + ") among candidates: " + candidates.keySet()); } return highestPriorityBeanName; @@ -2277,7 +2337,7 @@ private void raiseNoMatchingBeanFound( throw new NoSuchBeanDefinitionException(resolvableType, "expected at least 1 bean which qualifies as autowire candidate. " + - "Dependency annotations: " + ObjectUtils.nullSafeToString(descriptor.getAnnotations())); + "Dependency annotations: " + ObjectUtils.nullSafeToString(descriptor.getAnnotations())); } /** @@ -2755,4 +2815,4 @@ private enum PreInstantiation { MAIN, BACKGROUND } -} +} \ No newline at end of file From 2ab28695397af3fe0944ab7f3b1bb586575b936a Mon Sep 17 00:00:00 2001 From: KNU-K Date: Fri, 19 Sep 2025 00:47:07 +0900 Subject: [PATCH 2/7] fix the lint Signed-off-by: KNU-K --- .../beans/factory/support/DefaultListableBeanFactory.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java b/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java index 027cfe28d731..80dfe0d9bf80 100644 --- a/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java +++ b/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java @@ -1327,7 +1327,7 @@ public void registerBeanDefinition(String beanName, BeanDefinition beanDefinitio else { // alias pointing to non-existing bean definition throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName, "Cannot register bean definition for bean '" + beanName + - "' since there is already an alias for bean '" + aliasedName + "' bound."); + "' since there is already an alias for bean '" + aliasedName + "' bound."); } } else { @@ -2208,7 +2208,7 @@ else if (candidatePriority < highestPriority) { if (highestPriorityConflictDetected) { throw new NoUniqueBeanDefinitionException(requiredType, candidates.size(), "Multiple beans found with the same highest priority (" + highestPriority + - ") among candidates: " + candidates.keySet()); + ") among candidates: " + candidates.keySet()); } return highestPriorityBeanName; @@ -2337,7 +2337,7 @@ private void raiseNoMatchingBeanFound( throw new NoSuchBeanDefinitionException(resolvableType, "expected at least 1 bean which qualifies as autowire candidate. " + - "Dependency annotations: " + ObjectUtils.nullSafeToString(descriptor.getAnnotations())); + "Dependency annotations: " + ObjectUtils.nullSafeToString(descriptor.getAnnotations())); } /** @@ -2815,4 +2815,4 @@ private enum PreInstantiation { MAIN, BACKGROUND } -} \ No newline at end of file +} From cd81381939db5220b8021d6fa9229206a9cde7d5 Mon Sep 17 00:00:00 2001 From: KNU-K Date: Fri, 19 Sep 2025 00:54:23 +0900 Subject: [PATCH 3/7] style: Improve code readability by adjusting else statement formatting Signed-off-by: KNU-K --- .../beans/factory/support/DefaultListableBeanFactory.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java b/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java index 80dfe0d9bf80..6cd6d48eaa0d 100644 --- a/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java +++ b/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java @@ -688,7 +688,8 @@ private boolean processBeanDefinition(List result, String beanName, Root if (!isFactoryBean) { return processRegularBean(beanName, mbd, dbd, type, includeNonSingletons, allowFactoryBeanInit); - } else { + } + else { return processFactoryBean(result, beanName, mbd, dbd, type, includeNonSingletons, allowFactoryBeanInit, isNonLazyDecorated); } } From 5335ecceb495e074858083c65671ea93068668a5 Mon Sep 17 00:00:00 2001 From: KNU-K Date: Fri, 19 Sep 2025 02:17:38 +0900 Subject: [PATCH 4/7] refactor: Simplify bean processing logic in DefaultListableBeanFactory Signed-off-by: KNU-K --- .../support/DefaultListableBeanFactory.java | 177 ++++++------------ 1 file changed, 62 insertions(+), 115 deletions(-) diff --git a/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java b/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java index 6cd6d48eaa0d..182b5dfeb1d8 100644 --- a/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java +++ b/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java @@ -614,10 +614,7 @@ public String[] getBeanNamesForType(@Nullable Class type, boolean includeNonS private String[] doGetBeanNamesForType(ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit) { List result = new ArrayList<>(); - // Check all bean definitions. processBeanDefinitions(result, type, includeNonSingletons, allowEagerInit); - - // Check manually registered singletons too. processManualSingletons(result, type, includeNonSingletons); return StringUtils.toStringArray(result); @@ -625,145 +622,95 @@ private String[] doGetBeanNamesForType(ResolvableType type, boolean includeNonSi private void processBeanDefinitions(List result, ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit) { for (String beanName : this.beanDefinitionNames) { - // Only consider bean as eligible if the bean name is not defined as alias for some other bean. if (isAlias(beanName)) { continue; } - RootBeanDefinition mbd; try { - mbd = getMergedLocalBeanDefinition(beanName); - } - catch (CannotLoadBeanClassException | BeanDefinitionStoreException ex) { - if (allowEagerInit) { - throw ex; - } - handleBeanDefinitionException(beanName, ex); - continue; - } - catch (NoSuchBeanDefinitionException ex) { - // Bean definition got removed while we were iterating -> ignore. - continue; - } - - if (processBeanDefinition(result, beanName, mbd, type, includeNonSingletons, allowEagerInit)) { - result.add(beanName); - } - } - } - - private void handleBeanDefinitionException(String beanName, Exception ex) { - // Probably a placeholder: let's ignore it for type matching purposes. - LogMessage message = (ex instanceof CannotLoadBeanClassException ? - LogMessage.format("Ignoring bean class loading failure for bean '%s'", beanName) : - LogMessage.format("Ignoring unresolvable metadata in bean definition '%s'", beanName)); - logger.trace(message, ex); - // Register exception, in case the bean was accidentally unresolvable. - onSuppressedException(ex); - } - - private boolean processBeanDefinition(List result, String beanName, RootBeanDefinition mbd, - ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit) { - // Cache merged bean definition properties to avoid repeated access - boolean isAbstract = mbd.isAbstract(); - boolean hasBeanClass = mbd.hasBeanClass(); - boolean isLazyInit = mbd.isLazyInit(); - String factoryBeanName = mbd.getFactoryBeanName(); - BeanDefinitionHolder dbd = mbd.getDecoratedDefinition(); - - // Only check bean definition if it is complete. - if (isAbstract) { - return false; - } + RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); - if (!allowEagerInit && - !(hasBeanClass || !isLazyInit || isAllowEagerClassLoading()) && - requiresEagerInitForType(factoryBeanName)) { - return false; - } + // cache merged bean definition + boolean isAbstract = mbd.isAbstract(); + boolean hasBeanClass = mbd.hasBeanClass(); + boolean isLazyInit = mbd.isLazyInit(); + String factoryBeanName = mbd.getFactoryBeanName(); + BeanDefinitionHolder dbd = mbd.getDecoratedDefinition(); - boolean isFactoryBean = isFactoryBean(beanName, mbd); - boolean allowFactoryBeanInit = (allowEagerInit || containsSingleton(beanName)); - boolean isNonLazyDecorated = (dbd != null && !isLazyInit); + if (isAbstract || (!allowEagerInit && + ((!hasBeanClass && isLazyInit && !isAllowEagerClassLoading()) || + requiresEagerInitForType(factoryBeanName)))) { + continue; + } - if (!isFactoryBean) { - return processRegularBean(beanName, mbd, dbd, type, includeNonSingletons, allowFactoryBeanInit); - } - else { - return processFactoryBean(result, beanName, mbd, dbd, type, includeNonSingletons, allowFactoryBeanInit, isNonLazyDecorated); - } - } + boolean isFactoryBean = isFactoryBean(beanName, mbd); + boolean matchFound = false; + boolean allowFactoryBeanInit = (allowEagerInit || containsSingleton(beanName)); + boolean isNonLazyDecorated = (dbd != null && !isLazyInit); - private boolean processRegularBean(String beanName, RootBeanDefinition mbd, @Nullable BeanDefinitionHolder dbd, - ResolvableType type, boolean includeNonSingletons, boolean allowFactoryBeanInit) { - if (includeNonSingletons || isSingleton(beanName, mbd, dbd)) { - return isTypeMatch(beanName, type, allowFactoryBeanInit); - } - return false; - } + if (!isFactoryBean && (includeNonSingletons || isSingleton(beanName, mbd, dbd))) { + matchFound = isTypeMatch(beanName, type, allowFactoryBeanInit); + } + else { + if (includeNonSingletons || isNonLazyDecorated) { + matchFound = isTypeMatch(beanName, type, allowFactoryBeanInit); + } + else if (allowFactoryBeanInit) { + matchFound = isTypeMatch(beanName, type, allowFactoryBeanInit) && + isSingleton(beanName, mbd, dbd); + } - private boolean processFactoryBean(List result, String beanName, RootBeanDefinition mbd, @Nullable BeanDefinitionHolder dbd, - ResolvableType type, boolean includeNonSingletons, boolean allowFactoryBeanInit, boolean isNonLazyDecorated) { - boolean matchFound = false; + if (!matchFound) { + String factoryBeanFullName = FACTORY_BEAN_PREFIX + beanName; + if (includeNonSingletons || isSingleton(factoryBeanFullName, mbd, dbd)) { + matchFound = isTypeMatch(factoryBeanFullName, type, allowFactoryBeanInit); + } + if (matchFound) { + result.add(factoryBeanFullName); + continue; + } + } + } - if (includeNonSingletons || isNonLazyDecorated) { - matchFound = isTypeMatch(beanName, type, allowFactoryBeanInit); - } - else if (allowFactoryBeanInit) { - // Type check before singleton check, avoiding FactoryBean instantiation - // for early FactoryBean.isSingleton() calls on non-matching beans. - matchFound = isTypeMatch(beanName, type, allowFactoryBeanInit) && - isSingleton(beanName, mbd, dbd); - } + if (matchFound) { + result.add(beanName); + } - if (!matchFound) { - // In case of FactoryBean, try to match FactoryBean instance itself next. - String factoryBeanName = FACTORY_BEAN_PREFIX + beanName; - if (includeNonSingletons || isSingleton(factoryBeanName, mbd, dbd)) { - matchFound = isTypeMatch(factoryBeanName, type, allowFactoryBeanInit); - } - if (matchFound) { - result.add(factoryBeanName); - return false; // Don't add original beanName + } catch (CannotLoadBeanClassException | BeanDefinitionStoreException ex) { + if (allowEagerInit) { + throw ex; + } + LogMessage message = (ex instanceof CannotLoadBeanClassException ? + LogMessage.format("Ignoring bean class loading failure for bean '%s'", beanName) : + LogMessage.format("Ignoring unresolvable metadata in bean definition '%s'", beanName)); + logger.trace(message, ex); + onSuppressedException(ex); + } catch (NoSuchBeanDefinitionException ex) { + // Bean definition got removed while we were iterating -> ignore } } - - return matchFound; } private void processManualSingletons(List result, ResolvableType type, boolean includeNonSingletons) { for (String beanName : this.manualSingletonNames) { try { - if (processManualSingleton(result, beanName, type, includeNonSingletons)) { + if (isFactoryBean(beanName)) { + if ((includeNonSingletons || isSingleton(beanName)) && isTypeMatch(beanName, type)) { + result.add(beanName); + continue; + } + beanName = FACTORY_BEAN_PREFIX + beanName; + } + + if (isTypeMatch(beanName, type)) { result.add(beanName); } - } - catch (NoSuchBeanDefinitionException ex) { - // Shouldn't happen - probably a result of circular reference resolution... + } catch (NoSuchBeanDefinitionException ex) { logger.trace(LogMessage.format( "Failed to check manually registered singleton with name '%s'", beanName), ex); } } } - private boolean processManualSingleton(List result, String beanName, ResolvableType type, boolean includeNonSingletons) { - // In case of FactoryBean, match object created by FactoryBean. - if (isFactoryBean(beanName)) { - if ((includeNonSingletons || isSingleton(beanName)) && isTypeMatch(beanName, type)) { - return true; // Match found for this bean - } - // In case of FactoryBean, try to match FactoryBean itself next. - String factoryBeanName = FACTORY_BEAN_PREFIX + beanName; - if (isTypeMatch(factoryBeanName, type)) { - result.add(factoryBeanName); - } - return false; // Don't add original beanName - } - - // Match raw bean instance (might be raw FactoryBean). - return isTypeMatch(beanName, type); - } - private boolean isSingleton(String beanName, RootBeanDefinition mbd, @Nullable BeanDefinitionHolder dbd) { return (dbd != null ? mbd.isSingleton() : isSingleton(beanName)); } From e381151824e43ee7aef66648ef26e43e816783ee Mon Sep 17 00:00:00 2001 From: KNU-K Date: Fri, 19 Sep 2025 02:24:44 +0900 Subject: [PATCH 5/7] refactor: Simplify bean processing logic in DefaultListableBeanFactory Signed-off-by: KNU-K --- .../factory/support/DefaultListableBeanFactory.java | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java b/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java index 182b5dfeb1d8..9488494d90ba 100644 --- a/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java +++ b/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java @@ -674,8 +674,8 @@ else if (allowFactoryBeanInit) { if (matchFound) { result.add(beanName); } - - } catch (CannotLoadBeanClassException | BeanDefinitionStoreException ex) { + } + catch (CannotLoadBeanClassException | BeanDefinitionStoreException ex) { if (allowEagerInit) { throw ex; } @@ -684,7 +684,8 @@ else if (allowFactoryBeanInit) { LogMessage.format("Ignoring unresolvable metadata in bean definition '%s'", beanName)); logger.trace(message, ex); onSuppressedException(ex); - } catch (NoSuchBeanDefinitionException ex) { + } + catch (NoSuchBeanDefinitionException ex) { // Bean definition got removed while we were iterating -> ignore } } @@ -704,7 +705,8 @@ private void processManualSingletons(List result, ResolvableType type, b if (isTypeMatch(beanName, type)) { result.add(beanName); } - } catch (NoSuchBeanDefinitionException ex) { + } + catch (NoSuchBeanDefinitionException ex) { logger.trace(LogMessage.format( "Failed to check manually registered singleton with name '%s'", beanName), ex); } From 37bbf28830b7d99b12b3c93d198b0a51ba5a41af Mon Sep 17 00:00:00 2001 From: KNU-K Date: Fri, 19 Sep 2025 02:30:27 +0900 Subject: [PATCH 6/7] refactor: Extract bean definition skipping logic into a separate method Signed-off-by: KNU-K --- .../support/DefaultListableBeanFactory.java | 21 ++++++++++++++++--- 1 file changed, 18 insertions(+), 3 deletions(-) diff --git a/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java b/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java index 9488494d90ba..0c2fd21e12c6 100644 --- a/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java +++ b/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java @@ -636,9 +636,7 @@ private void processBeanDefinitions(List result, ResolvableType type, bo String factoryBeanName = mbd.getFactoryBeanName(); BeanDefinitionHolder dbd = mbd.getDecoratedDefinition(); - if (isAbstract || (!allowEagerInit && - ((!hasBeanClass && isLazyInit && !isAllowEagerClassLoading()) || - requiresEagerInitForType(factoryBeanName)))) { + if (shouldSkipBeanDefinition(isAbstract, allowEagerInit, hasBeanClass, isLazyInit, factoryBeanName)) { continue; } @@ -713,6 +711,23 @@ private void processManualSingletons(List result, ResolvableType type, b } } + private boolean shouldSkipBeanDefinition( + boolean isAbstract, boolean allowEagerInit, + boolean hasBeanClass, boolean isLazyInit, @Nullable String factoryBeanName) { + + if (isAbstract) { + return true; + } + if (!allowEagerInit) { + boolean needsEagerInit = (!hasBeanClass && isLazyInit && !isAllowEagerClassLoading()) + || requiresEagerInitForType(factoryBeanName); + if (needsEagerInit) { + return true; + } + } + return false; + } + private boolean isSingleton(String beanName, RootBeanDefinition mbd, @Nullable BeanDefinitionHolder dbd) { return (dbd != null ? mbd.isSingleton() : isSingleton(beanName)); } From f44e9899aa89783455c45de9875f9bc2f4fb2b08 Mon Sep 17 00:00:00 2001 From: KNU-K Date: Fri, 19 Sep 2025 02:38:38 +0900 Subject: [PATCH 7/7] refactor: Extract bean definition skipping logic into a separate method Signed-off-by: KNU-K --- .../beans/factory/support/DefaultListableBeanFactory.java | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java b/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java index 0c2fd21e12c6..82315acbf07e 100644 --- a/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java +++ b/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java @@ -711,16 +711,15 @@ private void processManualSingletons(List result, ResolvableType type, b } } - private boolean shouldSkipBeanDefinition( - boolean isAbstract, boolean allowEagerInit, + private boolean shouldSkipBeanDefinition(boolean isAbstract, boolean allowEagerInit, boolean hasBeanClass, boolean isLazyInit, @Nullable String factoryBeanName) { if (isAbstract) { return true; } if (!allowEagerInit) { - boolean needsEagerInit = (!hasBeanClass && isLazyInit && !isAllowEagerClassLoading()) - || requiresEagerInitForType(factoryBeanName); + boolean needsEagerInit = (!hasBeanClass && isLazyInit && !isAllowEagerClassLoading()) || + requiresEagerInitForType(factoryBeanName); if (needsEagerInit) { return true; }