@Override
public Module createModule(final ModuleInfo info) {
final Module existing = getRegisteredModuleInstance(info);
if (existing != null) return existing;
try {
final Module module = info.createModule();
getContext().inject(module);
Priority.inject(module, info.getPriority());
return module;
} catch (final ModuleException exc) {
log.error("Cannot create module: " + info.getDelegateClassName());
}
return null;
}
/**
* Checks the {@link ObjectService} for a single registered {@link Module} instance of the given
* {@link ModuleInfo}. In this way, if you want to repeatedly reuse the same module instance
* instead of creating a new one with each execution, you can register it with the {@link
* ObjectService} and it will be automatically returned by the {@link #createModule(ModuleInfo)}
* method (and hence automatically used whenever a {@link #run} method with {@link ModuleInfo}
* argument is called).
*/
private Module getRegisteredModuleInstance(final ModuleInfo info) {
final Class<?> type = ClassUtils.loadClass(info.getDelegateClassName());
if (type == null || !Module.class.isAssignableFrom(type)) return null;
// the module metadata's delegate class extends Module, so there is hope
@SuppressWarnings("unchecked")
final Class<? extends Module> moduleType = (Class<? extends Module>) type;
// ask the object service for an instance of the delegate type
final List<? extends Module> objects = objectService.getObjects(moduleType);
if (objects == null || objects.isEmpty()) {
// the object service has no such instances
return null;
}
if (objects.size() > 1) {
// there are multiple instances; it's not clear which one to use
log.warn("Ignoring multiple candidate module instances for class: " + type.getName());
return null;
}
// found exactly one instance; return it!
return objects.get(0);
}
