@Override
protected void doParse(
final Element element,
final ParserContext parserContext,
final BeanDefinitionBuilder builder) {
String serviceRef = element.getAttribute("service-ref");
builder.addConstructorArgValue(":" + serviceRef);
builder.addConstructorArgReference(serviceRef);
String marker = element.getAttribute("marker");
if (StringUtils.hasLength(marker)) {
Class<?> theClass =
ClassUtils.resolveClassName(marker, Thread.currentThread().getContextClassLoader());
if (!theClass.isAnnotation()) {
throw new ConfigurationException(
String.format("The class '%s' is not an annotation", marker));
}
builder.addPropertyValue("markerAnnotation", theClass);
}
// Register the post processor if there is not already one in this context
String beanName = NamespaceBeanFactoryPostProcessor.class.getName();
if (!parserContext.getRegistry().containsBeanDefinition(beanName)) {
BeanDefinitionBuilder namespacePostProcessor =
BeanDefinitionBuilder.genericBeanDefinition(NamespaceBeanFactoryPostProcessor.class);
parserContext.registerBeanComponent(
new BeanComponentDefinition(namespacePostProcessor.getBeanDefinition(), beanName));
}
}
@Override
protected BeanMetadataElement parseSource(Element element, ParserContext parserContext) {
final BeanDefinitionBuilder jpaPollingChannelAdapterBuilder =
BeanDefinitionBuilder.genericBeanDefinition(JpaPollingChannelAdapter.class);
final BeanDefinitionBuilder jpaExecutorBuilder =
JpaParserUtils.getJpaExecutorBuilder(element, parserContext);
String maxNumberOfResults = element.getAttribute("max-number-of-results");
boolean hasMaxNumberOfResults = StringUtils.hasText(maxNumberOfResults);
String maxResults = element.getAttribute("max-results");
boolean hasMaxResults = StringUtils.hasText(maxResults);
if (hasMaxNumberOfResults) {
parserContext
.getReaderContext()
.warning("'max-number-of-results' is deprecated in favor of 'max-results'", element);
if (hasMaxResults) {
parserContext
.getReaderContext()
.error("'max-number-of-results' and 'max-results' are mutually exclusive", element);
} else {
element.setAttribute("max-results", maxNumberOfResults);
}
}
BeanDefinition definition =
IntegrationNamespaceUtils.createExpressionDefinitionFromValueOrExpression(
"max-results", "max-results-expression", parserContext, element, false);
if (definition != null) {
jpaExecutorBuilder.addPropertyValue("maxResultsExpression", definition);
}
IntegrationNamespaceUtils.setValueIfAttributeDefined(
jpaExecutorBuilder, element, "delete-after-poll");
IntegrationNamespaceUtils.setValueIfAttributeDefined(
jpaExecutorBuilder, element, "flush-after-delete", "flush");
IntegrationNamespaceUtils.setValueIfAttributeDefined(
jpaExecutorBuilder, element, "delete-in-batch");
IntegrationNamespaceUtils.setValueIfAttributeDefined(
jpaExecutorBuilder, element, "expect-single-result");
IntegrationNamespaceUtils.setReferenceIfAttributeDefined(
jpaExecutorBuilder, element, "parameter-source");
final BeanDefinition jpaExecutorBuilderBeanDefinition = jpaExecutorBuilder.getBeanDefinition();
final String channelAdapterId =
this.resolveId(
element, jpaPollingChannelAdapterBuilder.getRawBeanDefinition(), parserContext);
final String jpaExecutorBeanName = channelAdapterId + ".jpaExecutor";
parserContext.registerBeanComponent(
new BeanComponentDefinition(jpaExecutorBuilderBeanDefinition, jpaExecutorBeanName));
jpaPollingChannelAdapterBuilder.addConstructorArgReference(jpaExecutorBeanName);
return jpaPollingChannelAdapterBuilder.getBeanDefinition();
}
@SuppressWarnings({"rawtypes", "unchecked"})
public static ManagedList configureAdviceChain(
Element adviceChainElement,
Element txElement,
BeanDefinition parentBeanDefinition,
ParserContext parserContext) {
ManagedList adviceChain = null;
// Schema validation ensures txElement and adviceChainElement are mutually exclusive
if (txElement != null) {
adviceChain = new ManagedList();
adviceChain.add(IntegrationNamespaceUtils.configureTransactionAttributes(txElement));
}
if (adviceChainElement != null) {
adviceChain = new ManagedList();
NodeList childNodes = adviceChainElement.getChildNodes();
for (int i = 0; i < childNodes.getLength(); i++) {
Node child = childNodes.item(i);
if (child.getNodeType() == Node.ELEMENT_NODE) {
Element childElement = (Element) child;
String localName = child.getLocalName();
if ("bean".equals(localName)) {
BeanDefinitionHolder holder =
parserContext
.getDelegate()
.parseBeanDefinitionElement(childElement, parentBeanDefinition);
parserContext.registerBeanComponent(new BeanComponentDefinition(holder));
adviceChain.add(new RuntimeBeanReference(holder.getBeanName()));
} else if ("ref".equals(localName)) {
String ref = childElement.getAttribute("bean");
adviceChain.add(new RuntimeBeanReference(ref));
} else {
BeanDefinition customBeanDefinition =
parserContext.getDelegate().parseCustomElement(childElement, parentBeanDefinition);
if (customBeanDefinition == null) {
parserContext
.getReaderContext()
.error("failed to parse custom element '" + localName + "'", childElement);
}
adviceChain.add(customBeanDefinition);
}
}
}
}
return adviceChain;
}
private void registerEndpoint(
Element childElement, ParserContext parserContext, String contextId) {
String id = childElement.getAttribute("id");
// must have an id to be registered
if (ObjectHelper.isNotEmpty(id)) {
BeanDefinition definition = endpointParser.parse(childElement, parserContext);
definition
.getPropertyValues()
.addPropertyValue("camelContext", new RuntimeBeanReference(contextId));
// Need to add this dependency of CamelContext for Spring 3.0
try {
Method method = definition.getClass().getMethod("setDependsOn", String[].class);
method.invoke(definition, (Object) new String[] {contextId});
} catch (Exception e) {
// Do nothing here
}
parserContext.registerBeanComponent(new BeanComponentDefinition(definition, id));
}
}
/**
* Override this method to control the registration process and return the bean name. If parsing a
* bean definition whose name can be auto-generated, consider using {@link #parseConsumer(Element,
* ParserContext)} instead.
*
* @param element The element.
* @param parserContext The parser context.
* @return The bean component definition.
*/
protected BeanComponentDefinition doParseAndRegisterConsumer(
Element element, ParserContext parserContext) {
AbstractBeanDefinition definition = this.parseConsumer(element, parserContext);
if (definition == null) {
parserContext
.getReaderContext()
.error("Consumer parsing must return an AbstractBeanDefinition.", element);
}
String order = element.getAttribute(IntegrationNamespaceUtils.ORDER);
if (StringUtils.hasText(order)) {
definition.getPropertyValues().addPropertyValue(IntegrationNamespaceUtils.ORDER, order);
}
String beanName =
BeanDefinitionReaderUtils.generateBeanName(definition, parserContext.getRegistry());
String[] handlerAlias = IntegrationNamespaceUtils.generateAlias(element);
BeanComponentDefinition beanComponentDefinition =
new BeanComponentDefinition(definition, beanName, handlerAlias);
parserContext.registerBeanComponent(beanComponentDefinition);
return beanComponentDefinition;
}
@Override
protected BeanMetadataElement parseSource(Element element, ParserContext parserContext) {
BeanDefinitionBuilder builder =
BeanDefinitionBuilder.genericBeanDefinition(StoredProcPollingChannelAdapter.class);
final BeanDefinitionBuilder storedProcExecutorBuilder =
StoredProcParserUtils.getStoredProcExecutorBuilder(element, parserContext);
IntegrationNamespaceUtils.setValueIfAttributeDefined(
storedProcExecutorBuilder, element, "return-value-required");
IntegrationNamespaceUtils.setValueIfAttributeDefined(
storedProcExecutorBuilder, element, "function");
IntegrationNamespaceUtils.setValueIfAttributeDefined(
storedProcExecutorBuilder, element, "skip-undeclared-results");
final ManagedMap<String, BeanDefinition> returningResultsetMap =
StoredProcParserUtils.getReturningResultsetBeanDefinitions(element, parserContext);
if (!returningResultsetMap.isEmpty()) {
storedProcExecutorBuilder.addPropertyValue(
"returningResultSetRowMappers", returningResultsetMap);
}
final AbstractBeanDefinition storedProcExecutorBuilderBeanDefinition =
storedProcExecutorBuilder.getBeanDefinition();
final String storedProcPollingChannelAdapterId =
this.resolveId(element, builder.getRawBeanDefinition(), parserContext);
final String storedProcExecutorBeanName =
storedProcPollingChannelAdapterId + ".storedProcExecutor";
parserContext.registerBeanComponent(
new BeanComponentDefinition(
storedProcExecutorBuilderBeanDefinition, storedProcExecutorBeanName));
builder.addConstructorArgReference(storedProcExecutorBeanName);
IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "expect-single-result");
return builder.getBeanDefinition();
}
public BeanDefinition parse(Element element, ParserContext pc) {
Assert.state(
!pc.getRegistry().containsBeanDefinition(BeanIds.AUTHENTICATION_MANAGER),
"AuthenticationManager has already been registered!");
pc.pushContainingComponent(
new CompositeComponentDefinition(element.getTagName(), pc.extractSource(element)));
BeanDefinitionBuilder providerManagerBldr =
BeanDefinitionBuilder.rootBeanDefinition(ProviderManager.class);
String alias = element.getAttribute(ATT_ALIAS);
checkForDeprecatedSessionControllerRef(element, pc);
List<BeanMetadataElement> providers = new ManagedList<BeanMetadataElement>();
NamespaceHandlerResolver resolver = pc.getReaderContext().getNamespaceHandlerResolver();
NodeList children = element.getChildNodes();
for (int i = 0; i < children.getLength(); i++) {
Node node = children.item(i);
if (node instanceof Element) {
Element providerElt = (Element) node;
if (StringUtils.hasText(providerElt.getAttribute(ATT_REF))) {
providers.add(new RuntimeBeanReference(providerElt.getAttribute(ATT_REF)));
} else {
BeanDefinition provider =
resolver.resolve(providerElt.getNamespaceURI()).parse(providerElt, pc);
Assert.notNull(
provider,
"Parser for " + providerElt.getNodeName() + " returned a null bean definition");
String id = pc.getReaderContext().generateBeanName(provider);
pc.registerBeanComponent(new BeanComponentDefinition(provider, id));
providers.add(new RuntimeBeanReference(id));
}
}
}
if (providers.isEmpty()) {
providers.add(new RootBeanDefinition(NullAuthenticationProvider.class));
}
providerManagerBldr.addPropertyValue("providers", providers);
// Add the default event publisher
BeanDefinition publisher = new RootBeanDefinition(DefaultAuthenticationEventPublisher.class);
String id = pc.getReaderContext().generateBeanName(publisher);
pc.registerBeanComponent(new BeanComponentDefinition(publisher, id));
providerManagerBldr.addPropertyReference("authenticationEventPublisher", id);
pc.registerBeanComponent(
new BeanComponentDefinition(
providerManagerBldr.getBeanDefinition(), BeanIds.AUTHENTICATION_MANAGER));
if (StringUtils.hasText(alias)) {
pc.getRegistry().registerAlias(BeanIds.AUTHENTICATION_MANAGER, alias);
pc.getReaderContext()
.fireAliasRegistered(BeanIds.AUTHENTICATION_MANAGER, alias, pc.extractSource(element));
}
pc.popAndRegisterContainingComponent();
return null;
}
