Java Code Examples for org.apache.commons.lang3.ClassUtils#getClass()

private List<Class<?>> scanJaxrsClass() throws Exception {
	try (ScanResult scanResult = new ClassGraph().disableJarScanning().enableAnnotationInfo().scan()) {
		SetUniqueList<Class<?>> classes = SetUniqueList.setUniqueList(new ArrayList<Class<?>>());
		for (ClassInfo info : scanResult.getClassesWithAnnotation(ApplicationPath.class.getName())) {
			Class<?> applicationPathClass = ClassUtils.getClass(info.getName());
			for (Class<?> o : (Set<Class<?>>) MethodUtils.invokeMethod(applicationPathClass.newInstance(),
					"getClasses")) {
				Path path = o.getAnnotation(Path.class);
				JaxrsDescribe jaxrsDescribe = o.getAnnotation(JaxrsDescribe.class);
				if (null != path && null != jaxrsDescribe) {
					classes.add(o);
				}
			}
		}
		return classes;
	}
}
 

private List<Class<?>> scanJaxrsClass(String name) throws Exception {
	// String pack = "com." + name.replaceAll("_", ".");
	String pack = "";
	if (StringUtils.startsWith(name, "o2_")) {
		pack = name.replaceAll("_", ".");
	} else {
		pack = "com." + name.replaceAll("_", ".");
	}
	try (ScanResult scanResult = new ClassGraph().whitelistPackages(pack).enableAllInfo().scan()) {
		SetUniqueList<Class<?>> classes = SetUniqueList.setUniqueList(new ArrayList<Class<?>>());
		for (ClassInfo info : scanResult.getClassesWithAnnotation(ApplicationPath.class.getName())) {
			Class<?> applicationPathClass = ClassUtils.getClass(info.getName());
			for (Class<?> o : (Set<Class<?>>) MethodUtils.invokeMethod(applicationPathClass.newInstance(),
					"getClasses")) {
				Path path = o.getAnnotation(Path.class);
				JaxrsDescribe jaxrsDescribe = o.getAnnotation(JaxrsDescribe.class);
				if (null != path && null != jaxrsDescribe) {
					classes.add(o);
				}
			}
		}
		return classes;
	}
}
 

private List<Class<?>> scanJaxrsClass() throws Exception {
	try (ScanResult scanResult = new ClassGraph().disableJarScanning().enableAnnotationInfo().scan()) {
		SetUniqueList<Class<?>> classes = SetUniqueList.setUniqueList(new ArrayList<Class<?>>());
		for (ClassInfo info : scanResult.getClassesWithAnnotation(ApplicationPath.class.getName())) {
			Class<?> applicationPathClass = ClassUtils.getClass(info.getName());
			for (Class<?> o : (Set<Class<?>>) MethodUtils.invokeMethod(applicationPathClass.newInstance(),
					"getClasses")) {
				Path path = o.getAnnotation(Path.class);
				JaxrsDescribe jaxrsDescribe = o.getAnnotation(JaxrsDescribe.class);
				if (null != path && null != jaxrsDescribe) {
					classes.add(o);
				}
			}
		}
		return classes;
	}
}
 

@SuppressWarnings("unchecked")
protected void populatePageClasses(final Properties props) {
    Enumeration<String> propNames = (Enumeration<String>) props.propertyNames();
    while (propNames.hasMoreElements()) {
        String className = propNames.nextElement();
        if (className.startsWith("page.")) {
            try {
                Class<?> clazz = ClassUtils.getClass(props.getProperty(className));
                if (BasePage.class.isAssignableFrom(clazz)) {
                    pageClasses.put(
                            StringUtils.substringAfter("page.", className), (Class<? extends BasePage>) clazz);
                } else {
                    LOG.warn("{} does not extend {}, ignoring...", clazz.getName(), BasePage.class.getName());
                }
            } catch (ClassNotFoundException e) {
                LOG.error("While looking for class identified by property '{}'", className, e);
            }
        }
    }
}
 

private void setupAuthFilter(ServletContext servletContext, CoreSettings coreSettings) {
    Settings authSettings = coreSettings.getAuthSettings();
    String authProviderClassName = authSettings.get(CoreSettings.TAG_AUTH_PROVIDER, CoreSettings.class);
    if (!StringHelper.isNullOrEmpty(authProviderClassName)) {
        LOGGER.info("Turning on authentication.");
        try {
            Class<?> authConfigClass = ClassUtils.getClass(authProviderClassName);
            if (AuthProvider.class.isAssignableFrom(authConfigClass)) {
                Class<AuthProvider> filterConfigClass = (Class<AuthProvider>) authConfigClass;
                AuthProvider filterConfigurator = filterConfigClass.getDeclaredConstructor().newInstance();
                filterConfigurator.init(coreSettings);
                filterConfigurator.addFilter(servletContext, coreSettings);

                // If all went well, register the filter so it can upgrade its database.
                coreSettings.addLiquibaseUser(filterConfigClass);
            } else {
                throw new IllegalArgumentException("Configured class does not implement AuthProvider.");
            }
        } catch (InstantiationException | IllegalAccessException | ClassNotFoundException | NoSuchMethodException | SecurityException | IllegalArgumentException | InvocationTargetException ex) {
            throw new IllegalArgumentException("Could not find or load auth class: " + authProviderClassName, ex);
        }
    }

}
 

public AuthWrapper(CoreSettings coreSettings, String authProviderClassName, String frostClientId) {
    LOGGER.info("Initialising authentication.");
    this.frostClientId = frostClientId;
    Settings authSettings = coreSettings.getAuthSettings();
    anonymousRead = authSettings.getBoolean(TAG_AUTH_ALLOW_ANON_READ, CoreSettings.class);
    Map<AuthUtils.Role, String> roleMapping = AuthUtils.loadRoleMapping(authSettings);
    roleRead = roleMapping.get(AuthUtils.Role.READ);
    roleCeate = roleMapping.get(AuthUtils.Role.CREATE);

    AuthProvider tempAuthProvider;
    try {
        Class<?> authConfigClass = ClassUtils.getClass(authProviderClassName);
        if (AuthProvider.class.isAssignableFrom(authConfigClass)) {
            Class<AuthProvider> filterConfigClass = (Class<AuthProvider>) authConfigClass;
            tempAuthProvider = filterConfigClass.getDeclaredConstructor().newInstance();
            tempAuthProvider.init(coreSettings);
        } else {
            LOGGER.error("Configured class does not implement AuthProvider: {}", authProviderClassName);
            tempAuthProvider = AUTH_PROVIDER_DENY_ALL;
        }
    } catch (InstantiationException | IllegalAccessException | ClassNotFoundException | NoSuchMethodException | SecurityException | IllegalArgumentException | InvocationTargetException exc) {
        LOGGER.error("Could not initialise auth class.", exc);
        tempAuthProvider = AUTH_PROVIDER_DENY_ALL;
    }
    authProvider = tempAuthProvider;
}
 

@SuppressWarnings("unchecked")
@Override
public Object read(Kryo kryo, Input input, Class type) {
    try {
        ObjectMap graphContext = kryo.getGraphContext();
        ObjectInputStream objectStream = (ObjectInputStream) graphContext.get(this);
        if (objectStream == null) {
            objectStream = new ObjectInputStream(input) {
                @Override
                protected Class<?> resolveClass(ObjectStreamClass desc) throws ClassNotFoundException {
                    return ClassUtils.getClass(KryoSerialization.class.getClassLoader(), desc.getName());
                }
            };
            graphContext.put(this, objectStream);
        }
        return objectStream.readObject();
    } catch (Exception ex) {
        throw new KryoException("Error during Java deserialization.", ex);
    }
}
 

public Transformer(Map<String, byte[]> modifiedClassFiles) {
    for (String className : modifiedClassFiles.keySet()) {
        try {
            Class<?> actualClass = ClassUtils.getClass(className);
            classdata.put(actualClass, modifiedClassFiles.get(className));
        } catch (ClassNotFoundException e) {
            // If the class can't be found, just ignore it
            log.warn("Unable to reload class " + className, e);
        }
    }
}
 

public void setValue(final Object value) throws ConfigurationRuntimeException
{
    try
    {
        if (!(value instanceof String))
        {
            this.value = value;
            return;
        }
        final String val = (String) value;
        final String name = StringUtils.removeStartIgnoreCase(val, CLASS);
        final Class<?> clazz = ClassUtils.getClass(name);
        if (name.length() == val.length())
        {
            this.value = clazz.newInstance();
        }
        else
        {
            this.value = clazz;
        }
    }
    catch (final Exception e)
    {
        throw new ConfigurationRuntimeException("Unable to create " + value, e);
    }

}
 

@SuppressWarnings("unchecked")
public static <T> Class<T> getClass(final String name) throws ClassNotFoundException {
    try {
        return (Class<T>) ClassUtils.getClass(name);
    } catch (final Exception ex) {
        return (Class<T>) Class.forName(name);
    }
}
 

@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;
    }
}
 

/**
 * Parses a string into a type. Returns null if it doesn't succeed.
 * FIXME Only supports parameterized types with at most one type argument.
 * Doesn't support wildcard types.
 *
 * TODO make a real parser someday
 */
private static Type parseType(String t) {
    Matcher matcher = PARAM_TYPE_MATCHER.matcher(t.replaceAll("\\s+", ""));
    if (matcher.matches()) {
        String raw = matcher.group(1);
        Type result;
        try {
            result = ClassUtils.getClass(raw);
        } catch (ClassNotFoundException e) {
            return null;
        }

        String param = matcher.group(3);
        if (StringUtils.isNotBlank(param)) {
            Type paramType = parseType(param);
            if (paramType != null) {
                result = TypeUtils.parameterize((Class) result, paramType);
            }
        }

        String arrayDims = matcher.group(4);
        if (StringUtils.isNotBlank(arrayDims)) {
            int dimensions = StringUtils.countMatches(arrayDims, '[');
            while (dimensions-- > 0) {
                result = TypeUtils.genericArrayType(result);
            }
        }

        return result;
    }
    return null;
}
 

/** Utility method to get an input stream to a class file */
public static InputStream getClassFileStream(String className) throws ClassNotFoundException {
    Class<?> c = ClassUtils.getClass(className);
    ClassLoader loader = c.getClassLoader();
    if (loader == null) {
        loader = ClassLoader.getSystemClassLoader();
        while (loader != null && loader.getParent() != null) {
            loader = loader.getParent();
        }
    }
    if (loader == null) {
        return null;
    }
    return loader.getResourceAsStream(c.getName().replace(".", "/") + ".class");
}
 

public static Object getClass(String classname) {
    try {
        Class<?> cla = ClassUtils.getClass(getCurrentClassLoader(), classname);
        return cla;
    } catch (ClassNotFoundException e) {
        return null;
    }
}
 

/**
 * 加载指定名称的类，并指定是否执行静态初始代码块
 *
 * @param className 类名
 * @param initial   true表示执行初始代码块，otherwise 不执行初始代码块
 * @return 执行类名的Class对象
 */
public static Class<?> loadClass(String className, boolean initial) {

    try {
        Class<?> aClass = ClassUtils.getClass(className, initial);
        return aClass;
    } catch (ClassNotFoundException e) {
        LOGGER.error(e.getMessage(), e);
        return null;
    }

}
 

@Override
public LocalServiceInvocationResult invoke(LocalServiceInvocation invocation) {
    if (invocation == null) {
        throw new IllegalArgumentException("Invocation is null");
    }

    LocalServiceInvocationResult result = new LocalServiceInvocationResult();
    ClassLoader clientClassLoader = Thread.currentThread().getContextClassLoader();
    try {
        ClassLoader classLoader = target.getClass().getClassLoader();
        Thread.currentThread().setContextClassLoader(classLoader);

        String[] parameterTypeNames = invocation.getParameterTypeNames();
        Class[] parameterTypes = new Class[parameterTypeNames.length];
        for (int i = 0; i < parameterTypeNames.length; i++) {
            Class<?> paramClass = ClassUtils.getClass(classLoader, parameterTypeNames[i]);
            parameterTypes[i] = paramClass;
        }

        byte[][] argumentsData = invocation.getArgumentsData();
        Object[] notSerializableArguments = invocation.getNotSerializableArguments();
        Object[] arguments;
        if (argumentsData == null) {
            arguments = null;
        } else {
            arguments = new Object[argumentsData.length];
            for (int i = 0; i < argumentsData.length; i++) {
                if (argumentsData[i] == null) {
                    if (notSerializableArguments[i] == null) {
                        arguments[i] = null;
                    } else {
                        arguments[i] = notSerializableArguments[i];
                    }
                } else {
                    arguments[i] = SerializationSupport.deserialize(argumentsData[i]);
                }
            }
        }

        SecurityContext targetSecurityContext = null;
        if (invocation.getSessionId() != null) {
            targetSecurityContext = new SecurityContext(invocation.getSessionId());
        }
        AppContext.setSecurityContext(targetSecurityContext);

        if (invocation.getLocale() != null) {
            Locale locale = Locale.forLanguageTag(invocation.getLocale());
            UserInvocationContext.setRequestScopeInfo(invocation.getSessionId(), locale, invocation.getTimeZone(),
                    invocation.getAddress(), invocation.getClientInfo());
        }

        Method method = target.getClass().getMethod(invocation.getMethodName(), parameterTypes);
        Object data = method.invoke(target, arguments);

        if (invocation.canResultBypassSerialization()) {
            result.setNotSerializableData(data);
        } else {
            result.setData(SerializationSupport.serialize(data));
        }
        return result;
    } catch (Throwable t) {
        if (t instanceof InvocationTargetException)
            t = ((InvocationTargetException) t).getTargetException();
        result.setException(SerializationSupport.serialize(t));
        return result;
    } finally {
        Thread.currentThread().setContextClassLoader(clientClassLoader);
        AppContext.setSecurityContext(null);
        UserInvocationContext.clearRequestScopeInfo();
    }
}
 

@Override
@SuppressWarnings({ "unchecked", "rawtypes" })
protected void populateItem(final ListItem<ConnConfProperty> item) {
    final ConnConfProperty property = item.getModelObject();

    final String label = StringUtils.isBlank(property.getSchema().getDisplayName())
            ? property.getSchema().getName() : property.getSchema().getDisplayName();

    final FieldPanel<? extends Serializable> field;
    boolean required = false;
    boolean isArray = false;

    if (property.getSchema().isConfidential()
            || IdMConstants.GUARDED_STRING.equalsIgnoreCase(property.getSchema().getType())
            || IdMConstants.GUARDED_BYTE_ARRAY.equalsIgnoreCase(property.getSchema().getType())) {

        field = new AjaxPasswordFieldPanel("panel", label, new Model<>(), false);
        ((PasswordTextField) field.getField()).setResetPassword(false);

        required = property.getSchema().isRequired();
    } else {
        Class<?> propertySchemaClass;
        try {
            propertySchemaClass = ClassUtils.getClass(property.getSchema().getType());
            if (ClassUtils.isPrimitiveOrWrapper(propertySchemaClass)) {
                propertySchemaClass = ClassUtils.primitiveToWrapper(propertySchemaClass);
            }
        } catch (ClassNotFoundException e) {
            LOG.error("Error parsing attribute type", e);
            propertySchemaClass = String.class;
        }

        if (ClassUtils.isAssignable(Number.class, propertySchemaClass)) {
            @SuppressWarnings("unchecked")
            Class<Number> numberClass = (Class<Number>) propertySchemaClass;
            field = new AjaxSpinnerFieldPanel.Builder<>().build("panel", label, numberClass, new Model<>());
            required = property.getSchema().isRequired();
        } else if (ClassUtils.isAssignable(Boolean.class, propertySchemaClass)) {
            field = new AjaxCheckBoxPanel("panel", label, new Model<>());
        } else {
            field = new AjaxTextFieldPanel("panel", label, new Model<>());
            required = property.getSchema().isRequired();
        }

        if (propertySchemaClass.isArray()) {
            isArray = true;
        }
    }

    field.setIndex(item.getIndex());
    field.setTitle(property.getSchema().getHelpMessage(), true);

    final AbstractFieldPanel<? extends Serializable> fieldPanel;
    if (isArray) {
        final MultiFieldPanel multiFieldPanel = new MultiFieldPanel.Builder(
                new PropertyModel<>(property, "values")).setEventTemplate(true).build("panel", label, field);
        item.add(multiFieldPanel);
        fieldPanel = multiFieldPanel;
    } else {
        setNewFieldModel(field, property.getValues());
        item.add(field);
        fieldPanel = field;
    }

    if (required) {
        fieldPanel.addRequiredLabel();
    }

    if (withOverridable) {
        fieldPanel.showExternAction(addCheckboxToggle(property));
    }
}
 

protected String formatValue(Object value, String parameterName, String fullParameterName, String stringFunction) {
    checkThreadInterrupted();
    String valueString;
    String formatString = getFormatString(parameterName, fullParameterName);
    if (formatString != null) {
        if (Boolean.TRUE.equals(isGroovyScript(parameterName, fullParameterName))) {
            valueString = scripting.evaluateGroovy(formatString, Collections.singletonMap(VALUE, value));
        } else if (formatString.startsWith("class:")) {
            String className = formatString.replaceFirst("class:", "");
            ValueFormat valueFormat;
            try {
                Class<?> valueFormatterClass = ClassUtils.getClass(className);
                valueFormat = (ValueFormat) ConstructorUtils.invokeConstructor(valueFormatterClass);
            } catch (ReflectiveOperationException e) {
                throw new ReportingException("An error occurred while applying custom format", e);
            }
            valueString = valueFormat.format(value);
        } else if (value == null) {
            valueString = "";
        } else if (value instanceof Number) {
            DecimalFormat decimalFormat = new DecimalFormat(formatString);
            valueString = decimalFormat.format(value);
        } else if (value instanceof Date) {
            SimpleDateFormat dateFormat = new SimpleDateFormat(formatString);
            valueString = dateFormat.format(value);
        } else if (value instanceof TemporalAccessor) {
            DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(formatString);
            valueString = dateTimeFormatter.format((TemporalAccessor) value);
        } else if (value instanceof String && !formatString.startsWith("${")) {//do not use inliner alias as format string
            valueString = String.format(formatString, value);
        } else {
            valueString = value.toString();
        }
    } else {
        valueString = defaultFormat(value);
    }

    if (stringFunction != null) {
        valueString = applyStringFunction(valueString, stringFunction);
    }

    return valueString != null ? valueString : "";
}
 

public static Class loadClass(ClassLoader classLoader, String className) throws ClassNotFoundException {
    if (classLoader == null) {
        classLoader = Thread.currentThread().getContextClassLoader();
    }
    return ClassUtils.getClass(classLoader, className);
}
 

/**
 * Returns a {@code java.lang.Class} object for the specified name.
 * Because class loading can be tricky in some environments the code for
 * retrieving a class by its name was extracted into this helper method. So
 * if changes are necessary, they can be made at a single place.
 *
 * @param name the name of the class to be loaded
 * @return the class object for the specified name
 * @throws ClassNotFoundException if the class cannot be loaded
 */
static Class<?> loadClass(final String name) throws ClassNotFoundException
{
    return ClassUtils.getClass(name);
}