namespaceResolvingClassloader = BeansCorePlugin.getClassLoader();
}
registry = new ScannedGenericBeanDefinitionSuppressingBeanDefinitionRegistry();
EntityResolver resolver = new XmlCatalogDelegatingEntityResolver(new BeansDtdResolver(), new PluggableSchemaResolver(namespaceResolvingClassloader));
final DocumentAccessor documentAccessor = new DocumentAccessor();
final SourceExtractor sourceExtractor = new DelegatingSourceExtractor(file.getProject());
final BeansConfigReaderEventListener eventListener = new BeansConfigReaderEventListener(this, resource, sourceExtractor, documentAccessor);
final NamespaceHandlerResolver namespaceHandlerResolver = new DelegatingNamespaceHandlerResolver(namespaceResolvingClassloader, this, documentAccessor);
problemReporter = new BeansConfigProblemReporter();
beanNameGenerator = new UniqueBeanNameGenerator(this);
final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(registry) {
@Override
public int loadBeanDefinitions(EncodedResource encodedResource)
throws BeanDefinitionStoreException {
// Capture the current resource being processed to handle parsing exceptions correctly and
// create the validation error on the correct resource
if (encodedResource != null && encodedResource.getResource() instanceof IAdaptable) {
currentResource = (IResource) ((IAdaptable) encodedResource.getResource()).getAdapter(IResource.class);
currentEncodedResource = encodedResource;
}
try {
// Delegate actual processing to XmlBeanDefinitionReader
int loadedBeans = 0;
if (encodedResource.getResource().exists()) {
loadedBeans = super.loadBeanDefinitions(encodedResource);
}
return loadedBeans;
}
finally {
// Reset currently processed resource before leaving
currentResource = null;
currentEncodedResource = null;
}
}
@Override
public int registerBeanDefinitions(Document doc, Resource resource)
throws BeanDefinitionStoreException {
try {
documentAccessor.pushDocument(doc);
return super.registerBeanDefinitions(doc, resource);
}
finally {
documentAccessor.popDocument();
}
}
@Override
public XmlReaderContext createReaderContext(Resource resource) {
return new ProfileAwareReaderContext(resource, problemReporter, eventListener,
sourceExtractor, this, namespaceHandlerResolver);
}
@Override
protected BeanDefinitionDocumentReader createBeanDefinitionDocumentReader() {
return new ToolingFriendlyBeanDefinitionDocumentReader(BeansConfig.this);
}
};
reader.setDocumentLoader(new XercesDocumentLoader());
reader.setResourceLoader(resourceLoader);
reader.setEntityResolver(resolver);
reader.setSourceExtractor(sourceExtractor);
reader.setEventListener(eventListener);
reader.setProblemReporter(problemReporter);
reader.setErrorHandler(new BeansConfigErrorHandler());
reader.setNamespaceHandlerResolver(namespaceHandlerResolver);
reader.setBeanNameGenerator(beanNameGenerator);
reader.setEnvironment(new ToolingAwareEnvironment());
final Map<Throwable, Integer> throwables = new HashMap<Throwable, Integer>();
try {
Callable<Integer> loadBeanDefinitionOperation = new Callable<Integer>() {
public Integer call() {
// Obtain thread context classloader and override with the project classloader
ClassLoader threadClassLoader = Thread.currentThread().getContextClassLoader();
Thread.currentThread().setContextClassLoader(resourceLoader.getClassLoader());
try {
// Load bean definitions
int count = reader.loadBeanDefinitions(resource);
// Finally register post processed beans and components
eventListener.registerComponents();
// Post process beans config if required
postProcess(resourceLoader.getClassLoader());
return count;
}
catch (Exception e) {
// Record the exception to throw it later
throwables.put(e, LineNumberPreservingDOMParser.getStartLineNumber(documentAccessor.getLastElement()));
}
finally {
// Reset the context classloader
Thread.currentThread().setContextClassLoader(threadClassLoader);
}