public Object construct(WireContext wireContext) { CommandService interceptedCommandService = commandService; if (interceptorDescriptors != null) { for (int i = interceptorDescriptors.size() - 1; i >= 0; i--) { Descriptor descriptor = interceptorDescriptors.get(i); Interceptor interceptor = (Interceptor) descriptor .construct(wireContext); interceptor.setNext(interceptedCommandService); interceptedCommandService = interceptor; } } return interceptedCommandService; }
@Override public String toString() { final String objectName = initializable.getName(); return "PendingInitialization[" + (objectName != null ? objectName + "|" : "") + object + "]"; } }
InitializationType getInitializationType(final Object object, final Descriptor descriptor, final boolean isDelayable) { if (object == null) { return InitializationType.NONE; } if (isDelayable && descriptor.isDelayable()) { return InitializationType.DELAYEBLE; } return InitializationType.IMMEDIATE; }
public void addDescriptor(Descriptor descriptor) { if (descriptor != null) { String name = descriptor.getName(); if (useTypes) { Class<?> type = descriptor.getType(this); if (type != null) { if ((name == null) && (descriptor instanceof AbstractDescriptor)) { name = type.getName(); ((AbstractDescriptor) descriptor).setName(type.getName()); } if ((name != null) && ((descriptors == null) || (!descriptors.containsKey(name)))) { // add all superclasses and interfaces to map to this descriptor addDescriptorType(type, descriptor, name); } } } if ((name != null) && (!hasDescriptor(name))) { putDescriptor(name, descriptor); if (descriptor.isEagerInit()) { addEagerInitObjectName(name); } } } }
Object construct(final Descriptor descriptor) { Object object; final String objectName = descriptor.getName(); if (objectName != null) { fireObjectEvent(Descriptor.EVENT_CONSTRUCTING, objectName, null); if (underConstruction == null) { underConstruction = new HashSet<String>(); } underConstruction.add(objectName); if (LOG.isLoggable(Level.FINE)) { LOG.fine("constructing " + objectName); } } try { object = descriptor.construct(this); } catch (final RuntimeException e) { addException(descriptor, e); throw e; } if (objectName != null) { underConstruction.remove(objectName); } return object; }
void performInitialization(final Object object, final Descriptor descriptor) { final String objectName = descriptor.getName(); if (objectName != null) { fireObjectEvent(Descriptor.EVENT_INITIALIZING, objectName, object); if (underInitialization == null) { underInitialization = new HashMap<String, Object>(); } underInitialization.put(objectName, object); if (LOG.isLoggable(Level.FINE)) { LOG.fine("initializing " + objectName); } } try { descriptor.initialize(object, this); } catch (final RuntimeException e) { addException(descriptor, e); throw e; } if (objectName != null) { underInitialization.remove(objectName); // event constructed is fired before the object is put in the cache // because that generates a set event fireObjectEvent(Descriptor.EVENT_CONSTRUCTED, objectName, object); set(objectName, object); } }
/** * Initializes all the eager objects defined in the {@link #wireDefinition}. */ void initializeEagerObjects() { if (wireDefinition != null) { final List<String> eagerInitObjectNames = wireDefinition.getEagerInitNames(); if (eagerInitObjectNames != null) { for (final String eagerInitObjectName : eagerInitObjectNames) { final Descriptor descriptor = wireDefinition.getDescriptor(eagerInitObjectName); if (descriptor.isEagerInit()) { if (LOG.isLoggable(Level.FINE)) { LOG.fine("eagerly initializing " + eagerInitObjectName); } get(eagerInitObjectName, descriptor.isDelayable()); } } while (!hasObjectUnderConstruction() && !hasObjectUnderInitialization() && hasPendingInitializations()) { processPendingInitializations(); } } } }
/** fires a {@link WireObjectEventInfo}. */ protected void fireObjectEvent(final String eventName, final String objectName, final Object object) { WireObjectEventInfo wireEvent = null; // first fire the event on the descriptor for object specific listeners if (wireDefinition != null) { final Map<String, Descriptor> descriptors = wireDefinition.getDescriptors(); if (descriptors != null) { final Descriptor descriptor = descriptors.get(objectName); if (descriptor != null) { wireEvent = new WireObjectEventInfo(eventName, objectName, object); descriptor.fire(eventName, wireEvent); } } } // then fire the event on this wiring environment for global listeners if (listeners != null && wireEvent == null) { wireEvent = new WireObjectEventInfo(eventName, objectName, object); } fire(eventName, wireEvent); }
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; }
protected void addException(final Descriptor descriptor, final Exception exception) { if (exceptions == null) { exceptions = new HashMap<String, Exception>(); } exceptions.put(descriptor.getName(), exception); }
void addPendingInitialization(final Object object, final Descriptor descriptor) { if (pendingInitializations == null) { pendingInitializations = new HashMap<String, PendingInitialization>(); } pendingInitializations.put(descriptor.getName(), new PendingInitialization(object, descriptor)); }
void processPendingInitializations() { if (pendingInitializations != null) { final Collection<PendingInitialization> pendingInitializationValues = new HashSet<PendingInitialization>( pendingInitializations.values()); for (PendingInitialization pi : pendingInitializationValues) { // move pi from pending initializations to under initialization final String objectName = pi.initializable.getName(); pi = pendingInitializations.remove(objectName); if (pi != null) { // initialize performInitialization(pi.object, pi.initializable); } } } }
void initialize(final Object object, final Descriptor descriptor, final boolean isDelayable) { final InitializationType initializationType = getInitializationType(object, descriptor, isDelayable); if (initializationType == InitializationType.IMMEDIATE) { performInitialization(object, descriptor); } else if (initializationType == InitializationType.DELAYEBLE) { addPendingInitialization(object, descriptor); } else { final String objectName = descriptor.getName(); if (objectName != null) { set(objectName, object); } } }