@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; }