public static Field getField(Class<?> clazz, String fieldName) { return getField(clazz, fieldName, clazz); }
public static Method getMethod(Class<?> clazz, String methodName, Class<?>[] parameterTypes) { return getMethod(clazz, methodName, parameterTypes, clazz); }
public static String getUnqualifiedClassName(Class<?> clazz) { if (clazz == null) { return null; } return getUnqualifiedClassName(clazz.getSimpleName()); }
public static Class<?>[] loadClasses(ClassLoader classLoader, List<String> constructorArgTypeNames) { if (constructorArgTypeNames == null) return null; Class<?>[] classes = new Class[constructorArgTypeNames.size()]; for (int i = 0; i < constructorArgTypeNames.size(); i++) { classLoader = resolveClassLoader(classLoader); classes[i] = loadClass(classLoader, constructorArgTypeNames.get(i)); } return classes; }
private static void addInterceptor(final Configuration configuration) { final String interceptorClassName = configuration.getProperty("bonita.hibernate.interceptor"); if (interceptorClassName != null) { if (LOG.isLoggable(Level.INFO)) { LOG.info("Adding interceptor: " + interceptorClassName); } final Class<?> interceptorClass = ReflectUtil.loadClass(Thread.currentThread().getContextClassLoader(), interceptorClassName); final EmptyInterceptor interceptor = (EmptyInterceptor) ReflectUtil.newInstance(interceptorClass); configuration.setInterceptor(interceptor); } }
public synchronized void startMatcher() { if (!isMatcherActive()) { if (LOG.isLoggable(Level.INFO)) { LOG.info("Starting matcher of message correlation based on correlation keys/no expression '" + name + "'..."); } final Class<EventMatcher> eventMatcherClass = (Class<EventMatcher>) ReflectUtil.loadClass(Thread.currentThread() .getContextClassLoader(), eventMatcherClassName); final Constructor<EventMatcher> constructor = ReflectUtil.getConstructor(eventMatcherClass, new Class[] { EventExecutor.class, String.class }); eventMatcher = ReflectUtil.newInstance(constructor, new Object[] { this, eventMatcherClassName + "-" + Misc.getHostName() + "-" + domain }); eventMatcher.setMaxCouples(matcherMaxCouples); eventMatcher.setMatchingConditionMatcher(expressionMatcherEnable); eventMatcher.start(); } }
public static InputStream getResourceAsStream(ClassLoader classLoader, String resource) { classLoader = resolveClassLoader(classLoader); if (LOG.isLoggable(Level.FINE)) { LOG.fine("getting resource as stream " + resource); } return classLoader.getResourceAsStream(resource); }
public void setParameterValues(Properties properties) { converterNames = new HashMap<Class< ? >, String>(); converters = new HashMap<String, Converter>(); for (Object key : properties.keySet()) { String converterClassName = (String) key; try { ClassLoader classLoader = Thread.currentThread() .getContextClassLoader(); Class< ? > converterClass = ReflectUtil.loadClass(classLoader, converterClassName); String converterName = properties.getProperty(converterClassName); converterNames.put(converterClass, converterName); Converter converter = (Converter) converterClass.newInstance(); converters.put(converterName, converter); } catch (Exception e) { String message = ExceptionManager.getInstance().getFullMessage( "bp_CT_1", converterClassName); throw new BonitaRuntimeException(message, e); } } } }
private static Method getMethod(Class<?> clazz, String methodName, Class<?>[] parameterTypes, Class<?> original) { Method method = null; try { method = clazz.getDeclaredMethod(methodName, parameterTypes); if (LOG.isLoggable(Level.FINE)) { LOG.fine("found method " + clazz.getName() + "." + methodName + "(" + ArrayUtil.toString(parameterTypes) + ")"); } } catch (SecurityException e) { String message = ExceptionManager.getInstance().getFullMessage( "bp_RU_10", clazz.getName(), methodName, getParameterTypesText(parameterTypes)); throw new BonitaRuntimeException(message, e); } catch (NoSuchMethodException e) { if (clazz.getSuperclass() != null) { return getMethod(clazz.getSuperclass(), methodName, parameterTypes, original); } else { String message = ExceptionManager.getInstance().getFullMessage( "bp_RU_11", original.getName(), methodName, getParameterTypesText(parameterTypes)); throw new BonitaRuntimeException(message, e); } } return method; }
public static <T> T newInstance(Constructor<T> constructor, Object[] args) { return newInstance(null, constructor, args); }
@Override public void apply(final Object target, final WireContext wireContext) { if (target != null) { // Get field synchronized (this) { if (field == null) { final Class<?> clazz = target.getClass(); field = ReflectUtil.getField(clazz, fieldName); } } // Create value final Object value = wireContext.create(descriptor, true); // Set the field value try { ReflectUtil.set(field, target, value); } catch (final Exception e) { final String message = ExceptionManager.getInstance().getFullMessage("bp_FO_1", fieldName, value); throw new WireException(message, e); } } }
@Override public InputStream openStream() { final InputStream stream = ReflectUtil.getResourceAsStream(classLoader, resource); if (stream == null) { final String message = ExceptionManager.getInstance().getFullMessage("bp_RSS_2"); throw new BonitaRuntimeException(message); } return stream; }
public static <T> Constructor<T> getConstructor(Class<T> clazz, Class<?>[] parameterTypes) { Constructor<T> constructor = null; try { constructor = clazz.getDeclaredConstructor(parameterTypes); if (LOG.isLoggable(Level.FINE)) { LOG.fine("found constructor " + clazz.getName() + "(" + ArrayUtil.toString(parameterTypes) + ")"); } } catch (SecurityException e) { String message = ExceptionManager.getInstance().getFullMessage( "bp_RU_6", clazz.getName(), getParameterTypesText(parameterTypes)); throw new BonitaRuntimeException(message, e); } catch (NoSuchMethodException e) { String message = ExceptionManager.getInstance().getFullMessage( "bp_RU_7", clazz.getName(), getParameterTypesText(parameterTypes)); throw new BonitaRuntimeException(message, e); } return constructor; }
final String resources = configElement.getAttribute("resource"); try { final URL url = ReflectUtil.getResource(parse.getClassLoader(), resources); if (url != null) { if (LOG.isLoggable(Level.FINE)) {
public static Class<?>[] loadClasses(ClassLoader classLoader, List<String> constructorArgTypeNames) { if (constructorArgTypeNames == null) return null; Class<?>[] classes = new Class[constructorArgTypeNames.size()]; for (int i = 0; i < constructorArgTypeNames.size(); i++) { classLoader = resolveClassLoader(classLoader); classes[i] = loadClass(classLoader, constructorArgTypeNames.get(i)); } return classes; }
final Class<JobExecutor> jobExecutorClass = (Class<JobExecutor>) ReflectUtil.loadClass(Thread.currentThread() .getContextClassLoader(), jobExecutorClassName); final Constructor<JobExecutor> jobExecutorConstructor = ReflectUtil.getConstructor(jobExecutorClass, new Class[] { EventExecutor.class, String.class, int.class, int.class, int.class }); jobExecutor = ReflectUtil.newInstance(jobExecutorConstructor, new Object[] { this, jobExecutorClass.getSimpleName() + "-" + Misc.getHostName() + "-" + domain, nbrOfThreads, locksToQuery, lockIdleTime }); final Class<MasterChecker> masterCheckerClass = (Class<MasterChecker>) ReflectUtil.loadClass(Thread .currentThread().getContextClassLoader(), masterCheckerClassName); final Constructor<MasterChecker> masterCheckerConstructor = ReflectUtil.getConstructor(masterCheckerClass, new Class[] { EventExecutor.class, String.class }); masterChecker = ReflectUtil.newInstance(masterCheckerConstructor, new Object[] { this, masterCheckerClass.getSimpleName() + "-" + Misc.getHostName() + "-" + domain }); masterChecker.setEnable(masterCheckerEnable);
@Override public Object construct(final WireContext wireContext) { // instantiation of the configuration Configuration configuration = null; if (className != null) { final ClassLoader classLoader = wireContext.getClassLoader(); if (LOG.isLoggable(Level.FINE)) { LOG.fine("instantiating hibernate configation class " + className); } final Class<?> configurationClass = ReflectUtil.loadClass(classLoader, className); configuration = (Configuration) ReflectUtil.newInstance(configurationClass); } else { if (LOG.isLoggable(Level.FINE)) { LOG.fine("instantiating default hibernate configation"); } configuration = new Configuration(); } return configuration; }
public static InputStream getResourceAsStream(ClassLoader classLoader, String resource) { classLoader = resolveClassLoader(classLoader); if (LOG.isLoggable(Level.FINE)) { LOG.fine("getting resource as stream " + resource); } return classLoader.getResourceAsStream(resource); }
/** * verifies if the given classname is specified and implements the collection * interface */ public static boolean verify(String className, Class<?> collectionInterface, Parse parse, Parser parser) { if (className == null) { return false; } try { Class<?> collectionClass = ReflectUtil.loadClass(parse.getClassLoader(), className); if (collectionInterface.isAssignableFrom(collectionClass)) { return true; } else { parse.addProblem("class " + className + " is not a " + collectionInterface.getName()); } } catch (BonitaRuntimeException e) { parse.addProblem("class " + className + " could not be found"); } return false; }