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; }
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 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); } } } }
@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 Object instantiate(ClassLoader classLoader, String className) { Object newObject; try { classLoader = resolveClassLoader(classLoader); Class<?> clazz = loadClass(classLoader, className); if (LOG.isLoggable(Level.FINE)) { LOG.fine("instantiating " + className); } newObject = clazz.newInstance(); } catch (Exception e) { String message = ExceptionManager.getInstance().getFullMessage("bp_RU_5", className); throw new BonitaRuntimeException(message, e); } return newObject; }
public static Object instantiate(ClassLoader classLoader, String className) { Object newObject; try { classLoader = resolveClassLoader(classLoader); Class<?> clazz = loadClass(classLoader, className); if (LOG.isLoggable(Level.FINE)) { LOG.fine("instantiating " + className); } newObject = clazz.newInstance(); } catch (Exception e) { String message = ExceptionManager.getInstance().getFullMessage("bp_RU_5", className); throw new BonitaRuntimeException(message, e); } return newObject; }
/** * 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; }
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(); } }
/** * loads the class from the class loader of the specified WireContext. * * @throws WireException * if the class could not be loaded. */ public Object construct(WireContext wireContext) { ClassLoader classLoader = wireContext.getClassLoader(); try { return ReflectUtil.loadClass(classLoader, text); } catch (BonitaRuntimeException e) { Throwable cause = e.getCause(); String message = ExceptionManager.getInstance().getFullMessage( "bp_CD_1", text, cause.getMessage()); throw new WireException(message, cause); } }
final Class<?> clazz = ReflectUtil.loadClass(classLoader, className); object = clazz.newInstance();
if (bindingClassName != null) { try { Class<?> bindingClass = ReflectUtil.loadClass(classLoader, bindingClassName); binding = (Binding) bindingClass.newInstance();
final Class<JobExecutor> jobExecutorClass = (Class<JobExecutor>) ReflectUtil.loadClass(Thread.currentThread() .getContextClassLoader(), jobExecutorClassName); final Constructor<JobExecutor> jobExecutorConstructor = ReflectUtil.getConstructor(jobExecutorClass, new Class[] { final Class<MasterChecker> masterCheckerClass = (Class<MasterChecker>) ReflectUtil.loadClass(Thread .currentThread().getContextClassLoader(), masterCheckerClassName); final Constructor<MasterChecker> masterCheckerConstructor = ReflectUtil.getConstructor(masterCheckerClass,
@Override public Class<?> getType(final WireDefinition wireDefinition) { if (className != null) { try { return ReflectUtil.loadClass(wireDefinition.getClassLoader(), className); } catch (final BonitaRuntimeException e) { final String message = ExceptionManager.getInstance().getFullMessage("bp_HCD_1", className, e.getMessage()); throw new WireException(message, e.getCause()); } } return Configuration.class; }
ClassLoader classLoader = parse.getClassLoader(); try { Class<?> converterClass = ReflectUtil.loadClass(classLoader, converterClassName); converter = (Converter) converterClass.newInstance(); ClassLoader classLoader = parse.getClassLoader(); try { variableClass = ReflectUtil.loadClass(classLoader, variableClassName); } catch (Exception e) { parse.addProblem("couldn't instantiate variable-class "
public Class<?> getType(WireDefinition wireDefinition) { if (className != null) { try { return ReflectUtil .loadClass(wireDefinition.getClassLoader(), className); } catch (BonitaRuntimeException e) { String message = ExceptionManager.getInstance().getFullMessage( "bp_OD_10", (name != null ? name : className), e.getMessage()); throw new WireException(message, e .getCause()); } } Descriptor descriptor = null; if (factoryDescriptor != null) { descriptor = factoryDescriptor; } else if (factoryObjectName != null) { descriptor = wireDefinition.getDescriptor(factoryObjectName); } if (descriptor != null) { Class<?> factoryClass = descriptor.getType(wireDefinition); if (factoryClass != null) { Method method = ReflectUtilDescriptor.findMethod(factoryClass, methodName, argDescriptors, null); if (method != null) { return method.getReturnType(); } } } return null; }
try { ClassLoader classLoader = wireContext.getClassLoader(); clazz = ReflectUtil.loadClass(classLoader, className); } catch (Exception e) { String message = ExceptionManager.getInstance().getFullMessage(