public static Object newInstance(String fqcn) { return newInstance(forName(fqcn)); }
private boolean isEventSubscriber(Object bean) { List annotatedMethods = ClassUtils.getAnnotatedMethods(bean.getClass(), Subscribe.class); return !CollectionUtils.isEmpty(annotatedMethods); }
public static Object newInstance(Class clazz, Object... args) { Class[] argTypes = new Class[args.length]; for (int i = 0; i < args.length; i++) { argTypes[i] = args[i].getClass(); } Constructor ctor = getConstructor(clazz, argTypes); return instantiate(ctor, args); }
public Filter newInstance() { return (Filter) ClassUtils.newInstance(this.filterClass); }
public static boolean isAvailable(String fullyQualifiedClassName) { try { forName(fullyQualifiedClassName); return true; } catch (UnknownClassException e) { return false; } }
private static InputStream loadFromClassPath(String path) { log.debug("Opening resource from class path [{}]", path); return ClassUtils.getResourceAsStream(path); }
protected final HashFormat newHashFormatInstance(Class clazz) { assertHashFormatImpl(clazz); return (HashFormat) ClassUtils.newInstance(clazz); } }
protected Class lookupHashFormatClass(String name) { try { return ClassUtils.forName(name); } catch (UnknownClassException ignored) { } return null; }
private static InputStream loadFromClassPath(String path) { log.debug("Opening resource from class path [{}]", path); return ClassUtils.getResourceAsStream(path); }
public static Object newInstance(String fqcn, Object... args) { return newInstance(forName(fqcn), args); }
protected void createNewInstance(Map<String, Object> objects, String name, String value) { Object currentInstance = objects.get(name); if (currentInstance != null) { log.info("An instance with name '{}' already exists. " + "Redefining this object as a new instance of type {}", name, value); } Object instance;//name with no property, assume right hand side of equals sign is the class name: try { instance = ClassUtils.newInstance(value); if (instance instanceof Nameable) { ((Nameable) instance).setName(name); } } catch (Exception e) { String msg = "Unable to instantiate class [" + value + "] for object named '" + name + "'. " + "Please ensure you've specified the fully qualified class name correctly."; throw new ConfigurationException(msg, e); } objects.put(name, instance); }
/** * Resolves an {@link ObjectStreamClass} by delegating to Shiro's * {@link ClassUtils#forName(String)} utility method, which is known to work in all ClassLoader environments. * * @param osc the ObjectStreamClass to resolve the class name. * @return the discovered class * @throws IOException never - declaration retained for subclass consistency * @throws ClassNotFoundException if the class could not be found in any known ClassLoader */ @Override protected Class<?> resolveClass(ObjectStreamClass osc) throws IOException, ClassNotFoundException { try { return ClassUtils.forName(osc.getName()); } catch (UnknownClassException e) { throw new ClassNotFoundException("Unable to load ObjectStreamClass [" + osc + "]: ", e); } } }
private boolean isEventSubscriber(Object bean, String name) { List annotatedMethods = ClassUtils.getAnnotatedMethods(bean.getClass(), Subscribe.class); return !isEmpty(annotatedMethods); }
public static Object newInstance(Class clazz, Object... args) { Class[] argTypes = new Class[args.length]; for (int i = 0; i < args.length; i++) { argTypes[i] = args[i].getClass(); } Constructor ctor = getConstructor(clazz, argTypes); return instantiate(ctor, args); }
private static InputStream loadFromClassPath(String path) { log.debug("Opening resource from class path [{}]", path); return ClassUtils.getResourceAsStream(path); }
public static Object newInstance(String fqcn) { return newInstance(forName(fqcn)); }
@Test public void testMsgCauseConstructor() { ClassUtils.newInstance(getExceptionClass(), "Msg", new Throwable()); } }
private Class<? extends WebEnvironment> webEnvironmentClassFromServletContext(ServletContext servletContext) { Class<? extends WebEnvironment> webEnvironmentClass = null; String className = servletContext.getInitParameter(ENVIRONMENT_CLASS_PARAM); if (className != null) { try { webEnvironmentClass = ClassUtils.forName(className); } catch (UnknownClassException ex) { throw new ConfigurationException( "Failed to load custom WebEnvironment class [" + className + "]", ex); } } return webEnvironmentClass; }
@Override public <I> void hear(TypeLiteral<I> typeLiteral, TypeEncounter<I> typeEncounter) { final Provider<EventBus> eventBusProvider = typeEncounter.getProvider(EventBus.class); List<Method> methods = ClassUtils.getAnnotatedMethods(typeLiteral.getRawType(), Subscribe.class); if (methods != null && !methods.isEmpty()) { typeEncounter.register( new InjectionListener<I>() { @Override public void afterInjection(Object o) { eventBusProvider.get().register(o); } }); } } }
public static Object newInstance(Class clazz, Object... args) { Class[] argTypes = new Class[args.length]; for (int i = 0; i < args.length; i++) { argTypes[i] = args[i].getClass(); } Constructor ctor = getConstructor(clazz, argTypes); return instantiate(ctor, args); }