/** * Returns the (initialized) class represented by {@code className} * using the current thread's context class loader. This implementation * supports the syntaxes "{@code java.util.Map.Entry[]}", * "{@code java.util.Map$Entry[]}", "{@code [Ljava.util.Map.Entry;}", * and "{@code [Ljava.util.Map$Entry;}". * * @param className the class name * @return the class represented by {@code className} using the current thread's context class loader * @throws ClassNotFoundException if the class is not found */ public static Class<?> getClass(final String className) throws ClassNotFoundException { return getClass(className, true); }
/** * Returns the (initialized) class represented by {@code className} * using the {@code classLoader}. This implementation supports * the syntaxes "{@code java.util.Map.Entry[]}", * "{@code java.util.Map$Entry[]}", "{@code [Ljava.util.Map.Entry;}", * and "{@code [Ljava.util.Map$Entry;}". * * @param classLoader the class loader to use to load the class * @param className the class name * @return the class represented by {@code className} using the {@code classLoader} * @throws ClassNotFoundException if the class is not found */ public static Class<?> getClass(final ClassLoader classLoader, final String className) throws ClassNotFoundException { return getClass(classLoader, className, true); }
/** * Returns the class represented by {@code className} using the * current thread's context class loader. This implementation supports the * syntaxes "{@code java.util.Map.Entry[]}", "{@code java.util.Map$Entry[]}", * "{@code [Ljava.util.Map.Entry;}", and "{@code [Ljava.util.Map$Entry;}". * * @param className the class name * @param initialize whether the class must be initialized * @return the class represented by {@code className} using the current thread's context class loader * @throws ClassNotFoundException if the class is not found */ public static Class<?> getClass(final String className, final boolean initialize) throws ClassNotFoundException { final ClassLoader contextCL = Thread.currentThread().getContextClassLoader(); final ClassLoader loader = contextCL == null ? ClassUtils.class.getClassLoader() : contextCL; return getClass(loader, className, initialize); }
@Override public boolean apply(@Nullable String s) { if (s==null) return false; if (preregisteredAutoType.containsKey(s)) return true; try { Class clazz = ClassUtils.getClass(s); return DefaultSchemaMaker.class.isAssignableFrom(clazz); } catch (ClassNotFoundException e) { return false; } } });
@Override public boolean apply(@Nullable String s) { if (s==null) return false; if (preregisteredAutoType.containsKey(s)) return true; try { Class<?> clazz = ClassUtils.getClass(s); return DefaultSchemaMaker.class.isAssignableFrom(clazz); } catch (ClassNotFoundException e) { return false; } } });
private static Class<?> loadClass(final ClassLoader nullableClassLoader, final String clazzName) { try { ClassLoader classLoader = nullableClassLoader; if (classLoader == null) { // Using the system classloader then classLoader = ClassLoader.getSystemClassLoader(); } // If the requested type is in the classpath, using the same classloader should work return ClassUtils.getClass(classLoader, clazzName); } catch (ClassNotFoundException ignored) { // The requested type is not on the auxclasspath. This might happen, if the type node // is probed for a specific type (e.g. is is a JUnit5 Test Annotation class). // Failing to resolve clazzName does not necessarily indicate an incomplete auxclasspath. } catch (final LinkageError expected) { // We found the class but it's invalid / incomplete. This may be an incomplete auxclasspath // if it was a NoClassDefFoundError. TODO : Report it? } return null; }
public Class<?> loadClass(String className) { Class<?> result = null; try { result = ClassUtils.getClass(classLoader, className); } catch (ClassNotFoundException e) { try { result = ClassUtils.getClass(Thread.currentThread().getContextClassLoader(), className); } catch (ClassNotFoundException cnfe) { MappingUtils.throwMappingException(e); } } return result; }
private Object buildConstant() { Object constant; if (ConstantType.CLASS == constantType) { String className = (String) literal; try { String binaryClassName = ClassNameUtils.internalToBinary(className); constant = ClassUtils.getClass(classLoader, binaryClassName); } catch (ClassNotFoundException e) { return e; } } else { constant = literal; } return constant; }
return getClass(classLoader, className.substring(0, lastDotIndex) + INNER_CLASS_SEPARATOR_CHAR + className.substring(lastDotIndex + 1), initialize);
private static String getDefaultValue(Field field) throws ClassNotFoundException { if (field.getType().isAssignableFrom(String.class)) { return ""; } else if (Collection.class.isAssignableFrom(field.getType()) || field.getType().isArray()) { return "[]"; } else { return String.valueOf(Defaults.defaultValue(ClassUtils.getClass(field.getType().getSimpleName()))); } } }
private void parseSingleProperty(Element propertyElement, SimpleBeanModelNode owner) { String typeName = propertyElement.getAttribute(SCHEMA_PROPERTY_TYPE); String name = propertyElement.getAttribute(SCHEMA_PROPERTY_NAME); Class<?> type; try { type = ClassUtils.getClass(typeName); } catch (ClassNotFoundException e) { e.printStackTrace(); return; } ConvertUtils.convert(new Object()); Object value = ConvertUtils.convert(propertyElement.getTextContent(), type); owner.addProperty(name, value, type); }
public static IPerfLogger getPerfLogger(boolean resetPerfLogger) { IPerfLogger result = perfLogger.get(); if (resetPerfLogger || result == null) { try { result = (IPerfLogger) ClassUtils.getClass(KylinConfig.getInstanceFromEnv().getPerfLoggerClassName()) .newInstance(); } catch (ClassNotFoundException e) { LOG.error("Performance Logger Class not found:" + e.getMessage()); result = new SimplePerfLogger(); } catch (IllegalAccessException | InstantiationException e) { e.printStackTrace(); } perfLogger.set(result); } return result; }
@Test public void testGetClassByNormalNameArrays2D() throws ClassNotFoundException { assertEquals( int[][].class, ClassUtils.getClass( "int[][]" ) ); assertEquals( long[][].class, ClassUtils.getClass( "long[][]" ) ); assertEquals( short[][].class, ClassUtils.getClass( "short[][]" ) ); assertEquals( byte[][].class, ClassUtils.getClass( "byte[][]" ) ); assertEquals( char[][].class, ClassUtils.getClass( "char[][]" ) ); assertEquals( float[][].class, ClassUtils.getClass( "float[][]" ) ); assertEquals( double[][].class, ClassUtils.getClass( "double[][]" ) ); assertEquals( boolean[][].class, ClassUtils.getClass( "boolean[][]" ) ); assertEquals( String[][].class, ClassUtils.getClass( "java.lang.String[][]" ) ); }
@Test public void testGetClassRawPrimitives() throws ClassNotFoundException { assertEquals( int.class, ClassUtils.getClass( "int" ) ); assertEquals( long.class, ClassUtils.getClass( "long" ) ); assertEquals( short.class, ClassUtils.getClass( "short" ) ); assertEquals( byte.class, ClassUtils.getClass( "byte" ) ); assertEquals( char.class, ClassUtils.getClass( "char" ) ); assertEquals( float.class, ClassUtils.getClass( "float" ) ); assertEquals( double.class, ClassUtils.getClass( "double" ) ); assertEquals( boolean.class, ClassUtils.getClass( "boolean" ) ); assertEquals( void.class, ClassUtils.getClass( "void" ) ); }
private void assertGetClassReturnsClass( final Class<?> c ) throws Exception { assertEquals( c, ClassUtils.getClass( c.getName() ) ); }
@Test public void testWithInterleavingWhitespace() throws ClassNotFoundException { assertEquals( int[].class, ClassUtils.getClass( " int [ ] " ) ); assertEquals( long[].class, ClassUtils.getClass( "\rlong\t[\n]\r" ) ); assertEquals( short[].class, ClassUtils.getClass( "\tshort \t\t[]" ) ); assertEquals( byte[].class, ClassUtils.getClass( "byte[\t\t\n\r] " ) ); }
@Test public void testGetInnerClass() throws ClassNotFoundException { assertEquals( Inner.DeeplyNested.class, ClassUtils.getClass( "org.apache.commons.lang3.ClassUtilsTest.Inner.DeeplyNested" ) ); assertEquals( Inner.DeeplyNested.class, ClassUtils.getClass( "org.apache.commons.lang3.ClassUtilsTest.Inner$DeeplyNested" ) ); assertEquals( Inner.DeeplyNested.class, ClassUtils.getClass( "org.apache.commons.lang3.ClassUtilsTest$Inner$DeeplyNested" ) ); assertEquals( Inner.DeeplyNested.class, ClassUtils.getClass( "org.apache.commons.lang3.ClassUtilsTest$Inner.DeeplyNested" ) ); }
@Test public void testGetClassByNormalNameArrays() throws ClassNotFoundException { assertEquals( int[].class, ClassUtils.getClass( "int[]" ) ); assertEquals( long[].class, ClassUtils.getClass( "long[]" ) ); assertEquals( short[].class, ClassUtils.getClass( "short[]" ) ); assertEquals( byte[].class, ClassUtils.getClass( "byte[]" ) ); assertEquals( char[].class, ClassUtils.getClass( "char[]" ) ); assertEquals( float[].class, ClassUtils.getClass( "float[]" ) ); assertEquals( double[].class, ClassUtils.getClass( "double[]" ) ); assertEquals( boolean[].class, ClassUtils.getClass( "boolean[]" ) ); assertEquals( String[].class, ClassUtils.getClass( "java.lang.String[]" ) ); assertEquals( java.util.Map.Entry[].class, ClassUtils.getClass( "java.util.Map.Entry[]" ) ); assertEquals( java.util.Map.Entry[].class, ClassUtils.getClass( "java.util.Map$Entry[]" ) ); assertEquals( java.util.Map.Entry[].class, ClassUtils.getClass( "[Ljava.util.Map.Entry;" ) ); assertEquals( java.util.Map.Entry[].class, ClassUtils.getClass( "[Ljava.util.Map$Entry;" ) ); }
private void assertGetClassThrowsException( final String className, final Class<?> exceptionType ) throws Exception { try { ClassUtils.getClass( className ); fail( "ClassUtils.getClass() should fail with an exception of type " + exceptionType.getName() + " when given class name \"" + className + "\"." ); } catch( final Exception e ) { assertTrue( exceptionType.isAssignableFrom( e.getClass() ) ); } }
public static Object buildArray(String internalName, int length, ClassLoader classLoader) throws ClassNotFoundException { String baseClassName = ClassNameUtils.getComponentBase(internalName); String binaryName = ClassNameUtils.internalToBinary(baseClassName); int dimensionCount = ClassNameUtils.getDimensionCount(internalName) - 1; String classNameWithDimensions = ClassNameUtils.addDimensionsToBinaryClassName(binaryName, dimensionCount); Class<?> klazz = ClassUtils.getClass(classLoader, classNameWithDimensions); Object array = Array.newInstance(klazz, length); return array; }