MYFACES-4639 - Implementation ClassUtils needs "newInstance" methods added to support OSGI runtimes

Author: tandraschko

api/src/main/java/org/apache/myfaces/core/api/shared/lang/ClassUtils.java

@@ -116,36 +116,49 @@ public class ClassUtils
     }
 
     /**
-     * Tries a Class.loadClass with the context class loader of the current thread first and automatically falls back to
-     * the ClassUtils class loader (i.e. the loader of the myfaces.jar lib) if necessary.
-     * 
+     * Tries {@link Class#forName(String, boolean, ClassLoader)} with the context class loader first, then
+     * {@code fallbackLoader} (e.g. the ClassUtils defining module) if the type is not found.
+     *
      * @param type
      *            fully qualified name of a non-primitive non-array class
+     * @param fallbackLoader
+     *            loader used when the context class loader cannot resolve {@code type}; if {@code null}, no fallback
      * @return the corresponding Class
      * @throws NullPointerException
      *             if type is null
      * @throws ClassNotFoundException
+     *             if the type cannot be resolved
      */
-    public static <T> Class<T> classForName(String type) throws ClassNotFoundException
+    public static <T> Class<T> classForName(String type, ClassLoader fallbackLoader) throws ClassNotFoundException
     {
         Assert.notNull(type, "type");
- 
+
         try
         {
-            // Try WebApp ClassLoader first
             return (Class<T>) Class.forName(type,
-                    false, // do not initialize for faster startup
+                    false,
                     getContextClassLoader());
         }
         catch (ClassNotFoundException ignore)
         {
-            // fallback: Try ClassLoader for ClassUtils (i.e. the myfaces.jar lib)
+            if (fallbackLoader == null)
+            {
+                throw ignore;
+            }
             return (Class<T>) Class.forName(type,
-                    false, // do not initialize for faster startup
-                    ClassUtils.class.getClassLoader());
+                    false,
+                    fallbackLoader);
         }
     }
 
+    /**
+     * Same as {@link #classForName(String, ClassLoader)} using {@code ClassUtils.class.getClassLoader()} as fallback.
+     */
+    public static <T> Class<T> classForName(String type) throws ClassNotFoundException
+    {
+        return classForName(type, ClassUtils.class.getClassLoader());
+    }
+
     /**
      * Same as {@link #classForName(String)}, but throws a RuntimeException (FacesException) instead of a
      * ClassNotFoundException.
@@ -367,22 +380,62 @@ public static Object newInstance(String type) throws FacesException
         {
             return null;
         }
-        return newInstance(simpleClassForName(type));
+        return newInstance(type, ClassUtils.class.getClassLoader());
+    }
+
+    /**
+     * Like {@link #newInstance(String)} but uses {@code fallbackLoader} when resolving the class name (MYFACES-4639).
+     */
+    public static Object newInstance(String type, ClassLoader fallbackLoader) throws FacesException
+    {
+        if (type == null)
+        {
+            return null;
+        }
+        try
+        {
+            return newInstance(classForName(type, fallbackLoader));
+        }
+        catch (ClassNotFoundException e)
+        {
+            log.log(Level.SEVERE, "Class " + type + " not found", e);
+            throw new FacesException(e);
+        }
     }
 
     public static Object newInstance(String type, Class<?> expectedType) throws FacesException
     {
-        return newInstance(type, expectedType == null ? null : new Class[] { expectedType });
+        return newInstance(type, expectedType, ClassUtils.class.getClassLoader());
+    }
+
+    public static Object newInstance(String type, Class<?> expectedType, ClassLoader fallbackLoader)
+            throws FacesException
+    {
+        return newInstance(type, expectedType == null ? null : new Class[] { expectedType }, fallbackLoader);
     }
 
     public static Object newInstance(String type, Class<?>[] expectedTypes)
+    {
+        return newInstance(type, expectedTypes, ClassUtils.class.getClassLoader());
+    }
+
+    public static Object newInstance(String type, Class<?>[] expectedTypes, ClassLoader fallbackLoader)
     {
         if (type == null)
         {
             return null;
         }
 
-        Class<?> clazzForName = simpleClassForName(type);
+        Class<?> clazzForName;
+        try
+        {
+            clazzForName = classForName(type, fallbackLoader);
+        }
+        catch (ClassNotFoundException e)
+        {
+            log.log(Level.SEVERE, "Class " + type + " not found", e);
+            throw new FacesException(e);
+        }
 
         if (expectedTypes != null)
         {

impl/src/main/java/org/apache/myfaces/util/lang/ClassUtils.java

@@ -26,7 +26,6 @@
 import java.util.Collection;
 import java.util.logging.Level;
 import java.util.logging.Logger;
-import org.apache.myfaces.core.api.shared.lang.Assert;
 
 
 
@@ -190,36 +189,13 @@ public static <T> T wrapBackwardCompatible(Class<T> interfaceClass, Class<? exte
     }
 
     /**
-     * Tries a Class.loadClass with the context class loader of the current thread first and automatically falls back to
-     * the ClassUtils class loader (i.e. the loader of the myfaces.jar lib) if necessary.
-     *
-     * @param type
-     *            fully qualified name of a non-primitive non-array class
-     * @return the corresponding Class
-     * @throws NullPointerException
-     *             if type is null
-     * @throws ClassNotFoundException
+     * MYFACES-4449: Delegates to API {@code classForName(String, ClassLoader)} with this module's ClassLoader
+     * as fallback (OSGi / split API–impl).
      */
-    // @Override MYFACES-4449: Methods that call ClassUtils.class.getClassLoader() need to be here
-    //           as well as in the API ClassUtils so that the correct ClassLoader is used.
     public static <T> Class<T> classForName(String type) throws ClassNotFoundException
     {
-        Assert.notNull(type, "type");
-
-        try
-        {
-            // Try WebApp ClassLoader first
-            return (Class<T>) Class.forName(type,
-                    false, // do not initialize for faster startup
-                    getContextClassLoader());
-        }
-        catch (ClassNotFoundException ignore)
-        {
-            // fallback: Try ClassLoader for ClassUtils (i.e. the myfaces.jar lib)
-            return (Class<T>) Class.forName(type,
-                    false, // do not initialize for faster startup
-                    ClassUtils.class.getClassLoader());
-        }
+        return org.apache.myfaces.core.api.shared.lang.ClassUtils.classForName(type,
+                ClassUtils.class.getClassLoader());
     }
 
     /**
@@ -348,4 +324,28 @@ protected static final String paramString(Class<?>... types)
         return null;
     }
 
+    /**
+     * MYFACES-4639: Delegates to API {@code newInstance(String, ClassLoader)} with the impl module ClassLoader.
+     */
+    // @Override
+    public static Object newInstance(String type) throws FacesException
+    {
+        return org.apache.myfaces.core.api.shared.lang.ClassUtils.newInstance(type,
+                ClassUtils.class.getClassLoader());
+    }
+
+    // @Override
+    public static Object newInstance(String type, Class<?> expectedType) throws FacesException
+    {
+        return org.apache.myfaces.core.api.shared.lang.ClassUtils.newInstance(type, expectedType,
+                ClassUtils.class.getClassLoader());
+    }
+
+    // @Override
+    public static Object newInstance(String type, Class<?>[] expectedTypes)
+    {
+        return org.apache.myfaces.core.api.shared.lang.ClassUtils.newInstance(type, expectedTypes,
+                ClassUtils.class.getClassLoader());
+    }
+
 }