From cc57b55c61fa35d97d7a16db1b389f6b85ec8633 Mon Sep 17 00:00:00 2001 From: Stephane Nicoll Date: Fri, 4 Mar 2022 12:06:34 +0100 Subject: [PATCH] Expose a way to resolved a merged inner bean definition This commit extracts the logic of resolving a merged bean definition for an inner bean to a public method so that other components can reuse it. Closes gh-28093 --- .../support/BeanDefinitionValueResolver.java | 36 ++++++++++----- .../BeanDefinitionValueResolverTests.java | 44 +++++++++++++++++++ 2 files changed, 70 insertions(+), 10 deletions(-) create mode 100644 spring-beans/src/test/java/org/springframework/beans/factory/support/BeanDefinitionValueResolverTests.java diff --git a/spring-beans/src/main/java/org/springframework/beans/factory/support/BeanDefinitionValueResolver.java b/spring-beans/src/main/java/org/springframework/beans/factory/support/BeanDefinitionValueResolver.java index be3a62e2945..efa3725cc72 100644 --- a/spring-beans/src/main/java/org/springframework/beans/factory/support/BeanDefinitionValueResolver.java +++ b/spring-beans/src/main/java/org/springframework/beans/factory/support/BeanDefinitionValueResolver.java @@ -23,6 +23,7 @@ import java.util.List; import java.util.Map; import java.util.Properties; import java.util.Set; +import java.util.function.BiFunction; import org.springframework.beans.BeanWrapper; import org.springframework.beans.BeanWrapperImpl; @@ -57,6 +58,7 @@ import org.springframework.util.StringUtils; * * @author Juergen Hoeller * @author Sam Brannen + * @author Stephane Nicoll * @since 1.2 * @see AbstractAutowireCapableBeanFactory */ @@ -143,13 +145,12 @@ public class BeanDefinitionValueResolver { } else if (value instanceof BeanDefinitionHolder bdHolder) { // Resolve BeanDefinitionHolder: contains BeanDefinition with name and aliases. - return resolveInnerBean(argName, bdHolder.getBeanName(), bdHolder.getBeanDefinition()); + return resolveInnerBean(bdHolder.getBeanName(), bdHolder.getBeanDefinition(), + (name, mbd) -> resolveInnerBeanValue(argName, name, mbd)); } else if (value instanceof BeanDefinition bd) { - // Resolve plain BeanDefinition, without contained name: use dummy name. - String innerBeanName = "(inner bean)" + BeanFactoryUtils.GENERATED_BEAN_NAME_SEPARATOR + - ObjectUtils.getIdentityHexString(bd); - return resolveInnerBean(argName, innerBeanName, bd); + return resolveInnerBean(null, bd, + (name, mbd) -> resolveInnerBeanValue(argName, name, mbd)); } else if (value instanceof DependencyDescriptor dependencyDescriptor) { Set autowiredBeanNames = new LinkedHashSet<>(4); @@ -243,6 +244,23 @@ public class BeanDefinitionValueResolver { } } + /** + * Resolve an inner bean definition and invoke the specified {@code resolver} + * on its merged bean definition. + * @param innerBeanName the inner bean name (or {@code null} to assign one) + * @param innerBd the inner raw bean definition + * @param resolver the function to invoke to resolve + * @param the type of the resolution + * @return a resolved inner bean, as a result of applying the {@code resolver} + */ + public T resolveInnerBean(@Nullable String innerBeanName, BeanDefinition innerBd, + BiFunction resolver) { + String nameToUse = (innerBeanName != null ? innerBeanName : "(inner bean)" + + BeanFactoryUtils.GENERATED_BEAN_NAME_SEPARATOR + ObjectUtils.getIdentityHexString(innerBd)); + return resolver.apply(nameToUse, this.beanFactory.getMergedBeanDefinition( + nameToUse, innerBd, this.beanDefinition)); + } + /** * Evaluate the given value as an expression, if necessary. * @param value the candidate value (may be an expression) @@ -362,14 +380,12 @@ public class BeanDefinitionValueResolver { * Resolve an inner bean definition. * @param argName the name of the argument that the inner bean is defined for * @param innerBeanName the name of the inner bean - * @param innerBd the bean definition for the inner bean + * @param mbd the merged bean definition for the inner bean * @return the resolved inner bean instance */ @Nullable - private Object resolveInnerBean(Object argName, String innerBeanName, BeanDefinition innerBd) { - RootBeanDefinition mbd = null; + private Object resolveInnerBeanValue(Object argName, String innerBeanName, RootBeanDefinition mbd) { try { - mbd = this.beanFactory.getMergedBeanDefinition(innerBeanName, innerBd, this.beanDefinition); // Check given bean name whether it is unique. If not already unique, // add counter - increasing the counter until the name is unique. String actualInnerBeanName = innerBeanName; @@ -400,7 +416,7 @@ public class BeanDefinitionValueResolver { throw new BeanCreationException( this.beanDefinition.getResourceDescription(), this.beanName, "Cannot create inner bean '" + innerBeanName + "' " + - (mbd != null && mbd.getBeanClassName() != null ? "of type [" + mbd.getBeanClassName() + "] " : "") + + (mbd.getBeanClassName() != null ? "of type [" + mbd.getBeanClassName() + "] " : "") + "while setting " + argName, ex); } } diff --git a/spring-beans/src/test/java/org/springframework/beans/factory/support/BeanDefinitionValueResolverTests.java b/spring-beans/src/test/java/org/springframework/beans/factory/support/BeanDefinitionValueResolverTests.java new file mode 100644 index 00000000000..dde5fb27b24 --- /dev/null +++ b/spring-beans/src/test/java/org/springframework/beans/factory/support/BeanDefinitionValueResolverTests.java @@ -0,0 +1,44 @@ +/* + * Copyright 2002-2022 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.springframework.beans.factory.support; + +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThat; + +/** + * Tests for {@link BeanDefinitionValueResolver}. + * + * @author Stephane Nicoll + */ +class BeanDefinitionValueResolverTests { + + @Test + void resolveInnerBean() { + DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory(); + RootBeanDefinition parentBd = new RootBeanDefinition(); + GenericBeanDefinition innerBd = new GenericBeanDefinition(); + innerBd.setAttribute("test", 42); + BeanDefinitionValueResolver bdvr = new BeanDefinitionValueResolver(beanFactory, "test", parentBd); + RootBeanDefinition resolvedInnerBd = bdvr.resolveInnerBean(null,innerBd, (name, mbd) -> { + assertThat(name).isNotNull().startsWith("(inner bean"); + return mbd; + }); + assertThat(resolvedInnerBd.getAttribute("test")).isEqualTo(42); + } + +}