+ * Implementations of this interface are responsible for selecting which bean implementation + * to use for a given interface type. The selection is typically based on configuration properties + * that specify the bean name or class name. + *
+ *+ * The aliasing mechanism works as follows: + *
+ *+ * This class provides the {@link #alias(Class, String, ContainerBuilder, Properties, Scope)} method + * which is used to select and register bean implementations based on configuration properties. + *
+ * + *+ * The {@code alias} method selects a bean implementation using the following process: + *
+ *+ * // In struts.properties or struts.xml: + * // struts.objectFactory = spring + * // struts.converter.collection = myCustomCollectionConverter + * + * // In a subclass: + * alias(ObjectFactory.class, StrutsConstants.STRUTS_OBJECTFACTORY, builder, props); + * alias(CollectionConverter.class, StrutsConstants.STRUTS_CONVERTER_COLLECTION, builder, props); + *+ * + * @see BeanSelectionProvider + * @see StrutsBeanSelectionProvider */ public abstract class AbstractBeanSelectionProvider implements BeanSelectionProvider { @@ -73,7 +110,7 @@ protected void alias(Class type, String key, ContainerBuilder builder, Propertie // Perhaps a spring bean id, so we'll delegate to the object factory at runtime LOG.trace("Choosing bean ({}) for ({}) to be loaded from the ObjectFactory", foundName, type.getName()); if (DEFAULT_BEAN_NAME.equals(foundName)) { - // Probably an optional bean, will ignore + LOG.trace("No bean registered for type ({}) with default name '{}', skipping as optional", type.getName(), DEFAULT_BEAN_NAME); } else { if (ObjectFactory.class != type) { builder.factory(type, new ObjectFactoryDelegateFactory(foundName, type), scope); @@ -103,7 +140,7 @@ public Object create(Context context) throws Exception { try { return objFactory.buildBean(name, null, true); } catch (ClassNotFoundException ex) { - throw new ConfigurationException("Unable to load bean "+type.getName()+" ("+name+")"); + throw new ConfigurationException(String.format("Unable to load bean %s (name = %s)", type.getName(), name)); } } diff --git a/core/src/main/java/org/apache/struts2/config/StrutsBeanSelectionProvider.java b/core/src/main/java/org/apache/struts2/config/StrutsBeanSelectionProvider.java index e914b04524..e956d92865 100644 --- a/core/src/main/java/org/apache/struts2/config/StrutsBeanSelectionProvider.java +++ b/core/src/main/java/org/apache/struts2/config/StrutsBeanSelectionProvider.java @@ -65,6 +65,7 @@ import org.apache.struts2.StrutsConstants; import org.apache.struts2.components.UrlRenderer; import org.apache.struts2.components.date.DateFormatter; +import org.apache.struts2.conversion.UserConversionPropertiesProvider; import org.apache.struts2.dispatcher.DispatcherErrorHandler; import org.apache.struts2.dispatcher.StaticContentLoader; import org.apache.struts2.dispatcher.mapper.ActionMapper; @@ -88,7 +89,7 @@ * *
* The following is a list of the allowed extension points: - * + *
* *
| Provides access to resource bundles used to localise messages (since 2.5.11) | *
* * *
@@ -405,6 +406,7 @@ public void register(ContainerBuilder builder, LocatableProperties props) { alias(ConversionAnnotationProcessor.class, StrutsConstants.STRUTS_CONVERTER_ANNOTATION_PROCESSOR, builder, props); alias(TypeConverterCreator.class, StrutsConstants.STRUTS_CONVERTER_CREATOR, builder, props); alias(TypeConverterHolder.class, StrutsConstants.STRUTS_CONVERTER_HOLDER, builder, props); + alias(UserConversionPropertiesProvider.class, StrutsConstants.STRUTS_CONVERTER_USER_PROPERTIES_PROVIDER, builder, props); alias(TextProvider.class, StrutsConstants.STRUTS_TEXT_PROVIDER, builder, props, Scope.PROTOTYPE); alias(TextProviderFactory.class, StrutsConstants.STRUTS_TEXT_PROVIDER_FACTORY, builder, props, Scope.PROTOTYPE); diff --git a/core/src/main/java/org/apache/struts2/conversion/StrutsConversionPropertiesProcessor.java b/core/src/main/java/org/apache/struts2/conversion/StrutsConversionPropertiesProcessor.java index 0f509dfb47..a7257f0a07 100644 --- a/core/src/main/java/org/apache/struts2/conversion/StrutsConversionPropertiesProcessor.java +++ b/core/src/main/java/org/apache/struts2/conversion/StrutsConversionPropertiesProcessor.java @@ -35,7 +35,7 @@ import java.util.Map; import java.util.Properties; -public class StrutsConversionPropertiesProcessor implements ConversionPropertiesProcessor, EarlyInitializable { +public class StrutsConversionPropertiesProcessor implements ConversionPropertiesProcessor, EarlyInitializable, UserConversionPropertiesProvider { private static final Logger LOG = LogManager.getLogger(StrutsConversionPropertiesProcessor.class); @@ -58,8 +58,27 @@ public void setTypeConverterHolder(TypeConverterHolder converterHolder) { @Override public void init() { - LOG.debug("Processing default conversion properties files"); + // Early phase: Only process framework defaults (class names only) + // User properties are processed later in initUserConversions() when + // SpringObjectFactory is available for bean name resolution (WW-4291) + LOG.debug("Processing default conversion properties files (early phase)"); processRequired(STRUTS_DEFAULT_CONVERSION_PROPERTIES); + } + + /** + * Process user conversion properties. Called during late initialization + * when SpringObjectFactory is available for bean name resolution. + *
+ * This allows users to reference Spring bean names in struts-conversion.properties + * instead of only fully qualified class names. + *
+ * + * @see WW-4291 + * @since 7.2.0 + */ + @Override + public void initUserConversions() { + LOG.debug("Processing user conversion properties files (late phase)"); process(STRUTS_CONVERSION_PROPERTIES); process(XWORK_CONVERSION_PROPERTIES); } @@ -78,7 +97,7 @@ public void loadConversionProperties(String propsName, boolean require) { while (resources.hasNext()) { if (XWORK_CONVERSION_PROPERTIES.equals(propsName)) { LOG.warn("Instead of using deprecated {} please use the new file name {}", - XWORK_CONVERSION_PROPERTIES, STRUTS_CONVERSION_PROPERTIES); + XWORK_CONVERSION_PROPERTIES, STRUTS_CONVERSION_PROPERTIES); } URL url = resources.next(); Properties props = new Properties(); @@ -86,8 +105,7 @@ public void loadConversionProperties(String propsName, boolean require) { LOG.debug("Processing conversion file [{}]", propsName); - for (Object o : props.entrySet()) { - Map.Entry entry = (Map.Entry) o; + for (Map.Entry+ * Processes struts-conversion.properties and xwork-conversion.properties + * after the full container is built, allowing Spring bean name resolution. + * This enables users to reference Spring bean names instead of only fully + * qualified class names in their conversion property files. + *
+ * + * @see WW-4291 + * @see UserConversionPropertiesProvider + * @since 6.9.0 + */ +public class UserConversionPropertiesProcessor implements Initializable { + + private static final Logger LOG = LogManager.getLogger(UserConversionPropertiesProcessor.class); + + private UserConversionPropertiesProvider provider; + + @Inject + public void setUserConversionPropertiesProvider(UserConversionPropertiesProvider provider) { + this.provider = provider; + } + + @Override + public void init() { + LOG.debug("Initializing user conversion properties via late initialization"); + provider.initUserConversions(); + } +} diff --git a/core/src/main/java/org/apache/struts2/conversion/UserConversionPropertiesProvider.java b/core/src/main/java/org/apache/struts2/conversion/UserConversionPropertiesProvider.java new file mode 100644 index 0000000000..819782db15 --- /dev/null +++ b/core/src/main/java/org/apache/struts2/conversion/UserConversionPropertiesProvider.java @@ -0,0 +1,38 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 + * + * http://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.apache.struts2.conversion; + +/** + * Interface for processors that support late initialization of user conversion properties. + *+ * Implementations provide user conversion properties processing after the full container + * is built, allowing Spring bean name resolution for type converters. + *
+ * + * @see WW-4291 + * @since 6.9.0 + */ +public interface UserConversionPropertiesProvider { + + /** + * Process user conversion properties (struts-conversion.properties, xwork-conversion.properties). + * Called during late initialization when SpringObjectFactory is available. + */ + void initUserConversions(); +} diff --git a/core/src/main/resources/struts-beans.xml b/core/src/main/resources/struts-beans.xml index 6aad85ca68..be1838664b 100644 --- a/core/src/main/resources/struts-beans.xml +++ b/core/src/main/resources/struts-beans.xml @@ -114,6 +114,9 @@ class="org.apache.struts2.conversion.StrutsTypeConverterCreator"/>+ * Verifies that Spring bean names can be used in struts-conversion.properties + * instead of fully qualified class names via SpringObjectFactory.getClassInstance(). + *
+ * + * @see WW-4291 + */ +public class SpringTypeConverterTest extends TestCase { + + private StaticApplicationContext sac; + private SpringObjectFactory objectFactory; + + @Override + public void setUp() throws Exception { + super.setUp(); + sac = new StaticApplicationContext(); + objectFactory = new SpringObjectFactory(); + objectFactory.setApplicationContext(sac); + } + + @Override + public void tearDown() throws Exception { + sac = null; + objectFactory = null; + super.tearDown(); + } + + /** + * Tests that SpringObjectFactory.getClassInstance() can resolve Spring bean names. + * This is the core mechanism that enables WW-4291 - when user conversion properties + * are processed during late initialization, SpringObjectFactory will be available + * and can resolve bean names via containsBean() check. + */ + public void testGetClassInstanceBySpringBeanName() throws Exception { + // Register a class as a Spring bean + sac.registerSingleton("myTestBean", TestBean.class, new MutablePropertyValues()); + + // SpringObjectFactory.getClassInstance() should resolve bean name to class + Class clazz = objectFactory.getClassInstance("myTestBean"); + + assertNotNull("Should resolve Spring bean name to class", clazz); + assertEquals(TestBean.class, clazz); + } + + /** + * Tests that getClassInstance() falls back to class loading for fully qualified + * class names (backward compatibility). + */ + public void testGetClassInstanceByClassName() throws Exception { + // Should work with fully qualified class name even if not a Spring bean + Class clazz = objectFactory.getClassInstance(TestBean.class.getName()); + + assertNotNull("Should resolve class name", clazz); + assertEquals(TestBean.class, clazz); + } + + /** + * Tests that an invalid bean/class name produces ClassNotFoundException. + */ + public void testInvalidBeanNameThrowsException() { + try { + objectFactory.getClassInstance("nonExistentBeanOrClass"); + fail("Should throw ClassNotFoundException for non-existent bean/class"); + } catch (ClassNotFoundException e) { + // Expected + assertTrue("Exception message should mention the class name", + e.getMessage().contains("nonExistentBeanOrClass")); + } + } + + /** + * Tests that Spring bean takes precedence over class name when both exist. + * If a bean is registered with a name that could also be a class, the bean wins. + */ + public void testSpringBeanTakesPrecedence() throws Exception { + // Register a bean with a name that looks like a class + sac.registerSingleton("org.apache.struts2.spring.SpringTypeConverterTest$AnotherBean", + TestBean.class, new MutablePropertyValues()); + + // Should get TestBean.class (from Spring) not try to load the literal class name + Class clazz = objectFactory.getClassInstance( + "org.apache.struts2.spring.SpringTypeConverterTest$AnotherBean"); + + // The bean was registered with TestBean.class, so that's what we should get + assertEquals(TestBean.class, clazz); + } + + /** + * A simple test bean class. + */ + public static class TestBean { + private String value; + + public String getValue() { + return value; + } + + public void setValue(String value) { + this.value = value; + } + } + + /** + * Another test bean class for precedence testing. + */ + public static class AnotherBean { + // Empty + } +}