From 8e59380f2fcd6774c3746f0ec3e16fda099fd872 Mon Sep 17 00:00:00 2001
From: Romain Manni-Bucau <rmannibucau@gmail.com>
Date: Wed, 31 Dec 2025 14:50:48 +0100
Subject: [PATCH 1/3] [XBEAN-453] try to explicit the parameter types matched
 instead of using ...

---
 .../apache/xbean/recipe/ReflectionUtil.java   | 88 ++++++++++++-------
 .../apache/xbean/recipe/ObjectRecipeTest.java | 31 +++++++
 2 files changed, 89 insertions(+), 30 deletions(-)

diff --git a/xbean-reflect/src/main/java/org/apache/xbean/recipe/ReflectionUtil.java b/xbean-reflect/src/main/java/org/apache/xbean/recipe/ReflectionUtil.java
index ca16f32d..fee91e0a 100644
--- a/xbean-reflect/src/main/java/org/apache/xbean/recipe/ReflectionUtil.java
+++ b/xbean-reflect/src/main/java/org/apache/xbean/recipe/ReflectionUtil.java
@@ -30,6 +30,7 @@
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.EnumSet;
+import java.util.HashSet;
 import java.util.LinkedHashSet;
 import java.util.LinkedList;
 import java.util.List;
@@ -601,7 +602,9 @@ public static ConstructorFactory findConstructor(Class typeClass, List<String> p
         boolean useNoArgConstructor = false;
         // verify parameter names and types are the same length
         if (parameterNames != null) {
-            if (!hasParameterTypes) parameterTypes = Collections.nCopies(parameterNames.size(), null);
+            if (!hasParameterTypes) {
+                parameterTypes = Collections.nCopies(parameterNames.size(), Object.class);
+            }
             if (parameterNames.size() != parameterTypes.size()) {
                 throw new ConstructionException("Invalid ObjectRecipe: recipe has " + parameterNames.size() +
                         " parameter names and " + parameterTypes.size() + " parameter types");
@@ -616,11 +619,14 @@ public static ConstructorFactory findConstructor(Class typeClass, List<String> p
 
 
         // get all methods sorted so that the methods with the most constructor args are first
-        List<Constructor> constructors = new ArrayList<Constructor>(Arrays.asList(typeClass.getConstructors()));
-        constructors.addAll(Arrays.asList(typeClass.getDeclaredConstructors()));
+        List<Constructor> constructors = new ArrayList<Constructor>(Arrays.asList(typeClass.getDeclaredConstructors()));
         Collections.sort(constructors, new Comparator<Constructor>() {
             public int compare(Constructor constructor1, Constructor constructor2) {
-                return constructor2.getParameterTypes().length - constructor1.getParameterTypes().length;
+                int diff = constructor2.getParameterTypes().length - constructor1.getParameterTypes().length;
+                if (diff == 0) { // prefer public over private
+                    return visibilityLevel(constructor1.getModifiers()) - visibilityLevel(constructor2.getModifiers());
+                }
+                return diff;
             }
         });
 
@@ -635,7 +641,7 @@ public int compare(Constructor constructor1, Constructor constructor2) {
                 if (constructor.getParameterTypes().length != parameterTypes.size()) {
                     if (matchLevel < 1) {
                         matchLevel = 1;
-                        missException = new MissingFactoryMethodException("Constructor has " + constructor.getParameterTypes().length + " arugments " +
+                        missException = new MissingFactoryMethodException("Constructor has " + constructor.getParameterTypes().length + " arguments " +
                                 "but expected " + parameterTypes.size() + " arguments: " + constructor);
                     }
                     continue;
@@ -686,11 +692,26 @@ public int compare(Constructor constructor1, Constructor constructor2) {
 
         if (missException != null) {
             throw missException;
-        } else {
-            StringBuffer buffer = new StringBuffer("Unable to find a valid constructor: ");
-            buffer.append("public void ").append(typeClass.getName()).append(toParameterList(parameterTypes));
-            throw new ConstructionException(buffer.toString());
         }
+
+        StringBuilder buffer = new StringBuilder("Unable to find a valid constructor: ");
+        buffer.append("public void ").append(typeClass.getName()).append(toParameterList(parameterTypes));
+        throw new ConstructionException(buffer.toString());
+    }
+
+    private static int visibilityLevel(int modifiers) {
+        if (Modifier.isPrivate(modifiers)) {
+            return 3;
+        }
+        if (Modifier.isProtected(modifiers)) {
+            return 2;
+        }
+        // 1 = package
+        if (Modifier.isPublic(modifiers)) {
+            return 0;
+        }
+        // unlikely
+        return 4;
     }
 
     public static StaticFactory findStaticFactory(Class typeClass, String factoryMethod, List<? extends Class<?>>  parameterTypes, Set<Option> options) {
@@ -714,8 +735,11 @@ public static StaticFactory findStaticFactory(Class typeClass, String factoryMet
         }
 
         // verify parameter names and types are the same length
+        boolean specifiedParameterTypes = parameterTypes != null;
         if (parameterNames != null) {
-            if (parameterTypes == null) parameterTypes = Collections.nCopies(parameterNames.size(), null);
+            if (parameterTypes == null) {
+                parameterTypes = Collections.nCopies(parameterNames.size(), Object.class);
+            }
             if (parameterNames.size() != parameterTypes.size()) {
                 throw new ConstructionException("Invalid ObjectRecipe: recipe has " + parameterNames.size() +
                         " parameter names and " + parameterTypes.size() + " parameter types");
@@ -725,6 +749,7 @@ public static StaticFactory findStaticFactory(Class typeClass, String factoryMet
             // so we will only use the no-arg constructor
             parameterNames = Collections.emptyList();
             parameterTypes = Collections.emptyList();
+            specifiedParameterTypes = true;
         }
 
         // get all methods sorted so that the methods with the most constructor args are first
@@ -732,29 +757,32 @@ public static StaticFactory findStaticFactory(Class typeClass, String factoryMet
         methods.addAll(Arrays.asList(typeClass.getDeclaredMethods()));
         Collections.sort(methods, new Comparator<Method>() {
             public int compare(Method method2, Method method1) {
-                return method1.getParameterTypes().length - method2.getParameterTypes().length;
+                int diff = method1.getParameterTypes().length - method2.getParameterTypes().length;
+                if (diff == 0) { // prefer public over private
+                    return visibilityLevel(method1.getModifiers()) - visibilityLevel(method2.getModifiers());
+                }
+                return diff;
             }
         });
 
-
         // as we check each constructor, we remember the closest invalid match so we can throw a nice exception to the user
         int matchLevel = 0;
         MissingFactoryMethodException missException = null;
 
         boolean allowPrivate = options.contains(Option.PRIVATE_FACTORY);
-        boolean caseInsesnitive = options.contains(Option.CASE_INSENSITIVE_FACTORY);
-        for (Method method : methods) {
+        boolean caseInsensitive = options.contains(Option.CASE_INSENSITIVE_FACTORY);
+        for (Method method : new LinkedHashSet<Method>(methods)) {
             // Only consider methods where the name matches
-            if (!method.getName().equals(factoryMethod) && (!caseInsesnitive || !method.getName().equalsIgnoreCase(method.getName()))) {
+            if (!method.getName().equals(factoryMethod) && (!caseInsensitive || !method.getName().equalsIgnoreCase(method.getName()))) {
                 continue;
             }
 
             // if an explicit constructor is specified (via parameter types), look a constructor that matches
-            if (parameterTypes != null) {
+            if (specifiedParameterTypes) {
                 if (method.getParameterTypes().length != parameterTypes.size()) {
                     if (matchLevel < 1) {
                         matchLevel = 1;
-                        missException = new MissingFactoryMethodException("Static factory method has " + method.getParameterTypes().length + " arugments " +
+                        missException = new MissingFactoryMethodException("Static factory method has " + method.getParameterTypes().length + " arguments " +
                                 "but expected " + parameterTypes.size() + " arguments: " + method);
                     }
                     continue;
@@ -821,12 +849,12 @@ public int compare(Method method2, Method method1) {
 
         if (missException != null) {
             throw missException;
-        } else {
-            StringBuffer buffer = new StringBuffer("Unable to find a valid factory method: ");
-            buffer.append("public void ").append(typeClass.getName()).append(".");
-            buffer.append(factoryMethod).append(toParameterList(parameterTypes));
-            throw new MissingFactoryMethodException(buffer.toString());
         }
+
+        StringBuilder buffer = new StringBuilder("Unable to find a valid factory method: ");
+        buffer.append("public void ").append(typeClass.getName()).append(".");
+        buffer.append(factoryMethod).append(toParameterList(parameterTypes));
+        throw new MissingFactoryMethodException(buffer.toString());
     }
 
     public static Method findInstanceFactory(Class typeClass, String factoryMethod, Set<Option> options) {
@@ -841,10 +869,10 @@ public static Method findInstanceFactory(Class typeClass, String factoryMethod,
         boolean allowPrivate = options.contains(Option.PRIVATE_FACTORY);
         boolean caseInsesnitive = options.contains(Option.CASE_INSENSITIVE_FACTORY);
 
-        List<Method> methods = new ArrayList<Method>(Arrays.asList(typeClass.getMethods()));
+        Set<Method> methods = new HashSet<Method>(Arrays.asList(typeClass.getMethods()));
         methods.addAll(Arrays.asList(typeClass.getDeclaredMethods()));
         for (Method method : methods) {
-            if (method.getName().equals(factoryMethod) || (caseInsesnitive && method.getName().equalsIgnoreCase(method.getName()))) {
+            if (method.getName().equals(factoryMethod) || (caseInsesnitive && method.getName().equalsIgnoreCase(factoryMethod))) {
                 if (Modifier.isStatic(method.getModifiers())) {
                     if (matchLevel < 1) {
                         matchLevel = 1;
@@ -898,12 +926,11 @@ public static Method findInstanceFactory(Class typeClass, String factoryMethod,
 
         if (missException != null) {
             throw missException;
-        } else {
-            StringBuffer buffer = new StringBuffer("Unable to find a valid factory method: ");
-            buffer.append("public void ").append(typeClass.getName()).append(".");
-            buffer.append(factoryMethod).append("()");
-            throw new MissingFactoryMethodException(buffer.toString());
         }
+        StringBuilder buffer = new StringBuilder("Unable to find a valid factory method: ");
+        buffer.append("public void ").append(typeClass.getName()).append(".");
+        buffer.append(factoryMethod).append("()");
+        throw new MissingFactoryMethodException(buffer.toString());
     }
 
     public static List<String> getParameterNames(Constructor<?> constructor) {
@@ -1028,8 +1055,9 @@ private static void setAccessible(final AccessibleObject accessibleObject) {
         accessibleObject.setAccessible(true);
     }
 
+    // should almost never be called with null as parameter to ensure we have explicit error messages
     private static String toParameterList(Class<?>[] parameterTypes) {
-        return toParameterList(parameterTypes != null ? Arrays.asList(parameterTypes) : null);
+        return parameterTypes != null ? toParameterList(Arrays.asList(parameterTypes)) : "...";
     }
 
     private static String toParameterList(List<? extends Class<?>> parameterTypes) {
diff --git a/xbean-reflect/src/test/java/org/apache/xbean/recipe/ObjectRecipeTest.java b/xbean-reflect/src/test/java/org/apache/xbean/recipe/ObjectRecipeTest.java
index a7e091f3..59878f7f 100644
--- a/xbean-reflect/src/test/java/org/apache/xbean/recipe/ObjectRecipeTest.java
+++ b/xbean-reflect/src/test/java/org/apache/xbean/recipe/ObjectRecipeTest.java
@@ -120,7 +120,38 @@ public void testWhitespaceInjection() throws Exception {
         assertEquals(name, c.name);
         assertEquals(ch, c.type);
     }
+
+    public void testMissedConstructor_TOMEECase() {
+        final String id = "Default Singleton Container";
+
+        { // failling case
+            final ObjectRecipe objectRecipe = new ObjectRecipe(SingletonContainer.class);
+            objectRecipe.setConstructorArgNames(new String[]{"id"});
+            objectRecipe.setProperty("id_typo", id);
+            try {
+                objectRecipe.create();
+                fail();
+            } catch (final ConstructionException ce) {
+                assertEquals("Unable to find a valid constructor: public void org.apache.xbean.recipe.ObjectRecipeTest$SingletonContainer(java.lang.Object)", ce.getMessage());
+            }
+        }
+
+        { // passing
+            final ObjectRecipe objectRecipe = new ObjectRecipe(SingletonContainer.class);
+            objectRecipe.setConstructorArgNames(new String[]{"id"});
+            objectRecipe.setProperty("id", id);
+            assertEquals(id, ((SingletonContainer) objectRecipe.create()).id);
+        }
+    }
     
+    public static class SingletonContainer {
+        public final String id;
+
+        public SingletonContainer(final String id) {
+            this.id = id;
+        }
+    }
+
     public static class Value {
         public String name;
         public char type;

From d1bc57347819bc81b77e51150027d9df3f7afc91 Mon Sep 17 00:00:00 2001
From: Richard Zowalla <rzo1@apache.org>
Date: Sat, 3 Jan 2026 15:22:57 +0100
Subject: [PATCH 2/3] Fix typo, fix comparison in findInstanceFactory(...)

---
 .../main/java/org/apache/xbean/recipe/ReflectionUtil.java   | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/xbean-reflect/src/main/java/org/apache/xbean/recipe/ReflectionUtil.java b/xbean-reflect/src/main/java/org/apache/xbean/recipe/ReflectionUtil.java
index fee91e0a..36ff003e 100644
--- a/xbean-reflect/src/main/java/org/apache/xbean/recipe/ReflectionUtil.java
+++ b/xbean-reflect/src/main/java/org/apache/xbean/recipe/ReflectionUtil.java
@@ -773,7 +773,7 @@ public int compare(Method method2, Method method1) {
         boolean caseInsensitive = options.contains(Option.CASE_INSENSITIVE_FACTORY);
         for (Method method : new LinkedHashSet<Method>(methods)) {
             // Only consider methods where the name matches
-            if (!method.getName().equals(factoryMethod) && (!caseInsensitive || !method.getName().equalsIgnoreCase(method.getName()))) {
+            if (!method.getName().equals(factoryMethod) && (!caseInsensitive || !method.getName().equalsIgnoreCase(factoryMethod))) {
                 continue;
             }
 
@@ -867,12 +867,12 @@ public static Method findInstanceFactory(Class typeClass, String factoryMethod,
         MissingFactoryMethodException missException = null;
 
         boolean allowPrivate = options.contains(Option.PRIVATE_FACTORY);
-        boolean caseInsesnitive = options.contains(Option.CASE_INSENSITIVE_FACTORY);
+        boolean caseInsensitive = options.contains(Option.CASE_INSENSITIVE_FACTORY);
 
         Set<Method> methods = new HashSet<Method>(Arrays.asList(typeClass.getMethods()));
         methods.addAll(Arrays.asList(typeClass.getDeclaredMethods()));
         for (Method method : methods) {
-            if (method.getName().equals(factoryMethod) || (caseInsesnitive && method.getName().equalsIgnoreCase(factoryMethod))) {
+            if (method.getName().equals(factoryMethod) || (caseInsensitive && method.getName().equalsIgnoreCase(factoryMethod))) {
                 if (Modifier.isStatic(method.getModifiers())) {
                     if (matchLevel < 1) {
                         matchLevel = 1;

From 4c1eac977891d31de05eeb90a2dc2e1e11dca577 Mon Sep 17 00:00:00 2001
From: Richard Zowalla <rzo1@apache.org>
Date: Sat, 3 Jan 2026 15:23:28 +0100
Subject: [PATCH 3/3] WIP - Additional tests

---
 .../apache/xbean/recipe/ObjectRecipeTest.java | 52 ++++++++++++++++++-
 .../org/apache/xbean/recipe/XBean353Test.java | 23 ++++++++
 2 files changed, 74 insertions(+), 1 deletion(-)

diff --git a/xbean-reflect/src/test/java/org/apache/xbean/recipe/ObjectRecipeTest.java b/xbean-reflect/src/test/java/org/apache/xbean/recipe/ObjectRecipeTest.java
index 59878f7f..9306edc6 100644
--- a/xbean-reflect/src/test/java/org/apache/xbean/recipe/ObjectRecipeTest.java
+++ b/xbean-reflect/src/test/java/org/apache/xbean/recipe/ObjectRecipeTest.java
@@ -143,7 +143,50 @@ public void testMissedConstructor_TOMEECase() {
             assertEquals(id, ((SingletonContainer) objectRecipe.create()).id);
         }
     }
-    
+
+    public void testViaStaticFactory_TomEECase() {
+        final String id = "Default Transaction Manager";
+
+        { // failling case
+            final ObjectRecipe objectRecipe = new ObjectRecipe(SingletonContainerFactory.class);
+            objectRecipe.setFactoryMethod("create");
+            objectRecipe.setConstructorArgNames(new String[]{"id"});
+            objectRecipe.setProperty("id_typo", id);
+            try {
+                objectRecipe.create();
+                fail();
+            } catch (final ConstructionException ce) {
+                //falls back to use default ctor + setter with invalid
+                assertEquals("Unable to find a valid setter method: public void org.apache.xbean.recipe.ObjectRecipeTest$SingletonContainerFactory.setId_typo(...)", ce.getMessage());
+            }
+        }
+        { // passing case
+            final ObjectRecipe objectRecipe = new ObjectRecipe(SingletonContainerFactory.class);
+            objectRecipe.setFactoryMethod("create");
+            objectRecipe.setConstructorArgNames(new String[]{"id"});
+            objectRecipe.setProperty("id", id);
+            assertEquals(id, ((SingletonContainer) objectRecipe.create()).id);
+        }
+
+        { // passing explicit type argument
+            final ObjectRecipe objectRecipe = new ObjectRecipe(SingletonContainerFactory.class);
+            objectRecipe.setFactoryMethod("create");
+            objectRecipe.setConstructorArgNames(new String[]{"id"});
+            objectRecipe.setConstructorArgTypes(new Class[]{String.class});
+            objectRecipe.setProperty("id", id);
+            assertEquals(id, ((SingletonContainer) objectRecipe.create()).id);
+        }
+
+        { // passing allow insensitive
+            final ObjectRecipe objectRecipe = new ObjectRecipe(SingletonContainerFactory.class);
+            objectRecipe.setFactoryMethod("create");
+            objectRecipe.setConstructorArgNames(new String[]{"id"});
+            objectRecipe.setProperty("iD", id);
+            objectRecipe.allow(Option.CASE_INSENSITIVE_PROPERTIES);
+            assertEquals(id, ((SingletonContainer) objectRecipe.create()).id);
+        }
+    }
+
     public static class SingletonContainer {
         public final String id;
 
@@ -152,6 +195,13 @@ public SingletonContainer(final String id) {
         }
     }
 
+    public static class SingletonContainerFactory {
+
+        public static SingletonContainer create(String id) {
+            return new SingletonContainer(id);
+        }
+    }
+
     public static class Value {
         public String name;
         public char type;
diff --git a/xbean-reflect/src/test/java/org/apache/xbean/recipe/XBean353Test.java b/xbean-reflect/src/test/java/org/apache/xbean/recipe/XBean353Test.java
index 3ad31fa5..a3e97472 100644
--- a/xbean-reflect/src/test/java/org/apache/xbean/recipe/XBean353Test.java
+++ b/xbean-reflect/src/test/java/org/apache/xbean/recipe/XBean353Test.java
@@ -44,6 +44,29 @@ public void testCreateObjectCaseInsensitive() {
         assertEquals(10, ((Constructor) o).poolSize);
     }
 
+    @Test
+    public void testCreateObjectCaseInsensitiveViaStaticFactory() {
+        final Map<String, Object> availableProperties = new HashMap<>();
+        availableProperties.put("PoolSize", 10);
+
+        final String[] paramNames = new String[]{"poolSize"};
+        ObjectRecipe recipe = new ObjectRecipe(ConstructorFactory.class, paramNames);
+        recipe.setFactoryMethod("create");
+        recipe.setAllProperties(availableProperties);
+        recipe.allow(Option.CASE_INSENSITIVE_PROPERTIES);
+
+        final Object o = recipe.create();
+        assertNotNull(o);
+        assertTrue(o instanceof Constructor);
+        assertEquals(10, ((Constructor) o).poolSize);
+    }
+
+    public static class ConstructorFactory{
+        public static Constructor create(int poolSize) {
+            return new Constructor(poolSize);
+        }
+    }
+
     public static class Constructor {
 
         int poolSize;