/**
  * Builds and configures a {@link BeanDefinitionBuilder} for {@link
  * HdfsStoreMessageHandlerFactoryBean}.
  *
  * @param element The element.
  * @param parserContext The parser context.
  * @return The bean definition builder
  */
 static BeanDefinitionBuilder configure(Element element, ParserContext parserContext) {
   BeanDefinitionBuilder builder =
       BeanDefinitionBuilder.genericBeanDefinition(HdfsStoreMessageHandlerFactoryBean.class);
   IntegrationNamespaceUtils.setReferenceIfAttributeDefined(
       builder, element, "writer", "storeWriter");
   IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "auto-startup");
   return builder;
 }
  @Override
  protected BeanDefinitionBuilder parseHandler(Element element, ParserContext parserContext) {
    BeanDefinitionBuilder builder =
        BeanDefinitionBuilder.genericBeanDefinition(
            "org.springframework.integration.http.outbound.HttpRequestExecutingMessageHandler");
    builder.addConstructorArgValue(element.getAttribute("url"));
    IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "http-method");

    String restTemplate = element.getAttribute("rest-template");
    if (StringUtils.hasText(restTemplate)) {
      HttpAdapterParsingUtils.verifyNoRestTemplateAttributes(element, parserContext);
      builder.addConstructorArgReference(restTemplate);
    } else {
      for (String referenceAttributeName :
          HttpAdapterParsingUtils.REST_TEMPLATE_REFERENCE_ATTRIBUTES) {
        IntegrationNamespaceUtils.setReferenceIfAttributeDefined(
            builder, element, referenceAttributeName);
      }
    }

    String headerMapper = element.getAttribute("header-mapper");
    String mappedRequestHeaders = element.getAttribute("mapped-request-headers");
    String mappedResponseHeaders = element.getAttribute("mapped-response-headers");
    if (StringUtils.hasText(headerMapper)) {
      if (StringUtils.hasText(mappedRequestHeaders) || StringUtils.hasText(mappedResponseHeaders)) {
        parserContext
            .getReaderContext()
            .error(
                "Neither 'mappped-request-headers' or 'mapped-response-headers' "
                    + "attributes are allowed when a 'header-mapper' has been specified.",
                parserContext.extractSource(element));
        return null;
      }
      builder.addPropertyReference("headerMapper", headerMapper);
    } else {
      BeanDefinitionBuilder headerMapperBuilder =
          BeanDefinitionBuilder.genericBeanDefinition(
              "org.springframework.integration.http.support.DefaultHttpHeaderMapper");
      headerMapperBuilder.setFactoryMethod("outboundMapper");
      IntegrationNamespaceUtils.setValueIfAttributeDefined(
          headerMapperBuilder, element, "mapped-request-headers", "outboundHeaderNames");
      IntegrationNamespaceUtils.setValueIfAttributeDefined(
          headerMapperBuilder, element, "mapped-response-headers", "inboundHeaderNames");
      builder.addPropertyValue("headerMapper", headerMapperBuilder.getBeanDefinition());
    }
    IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "charset");
    IntegrationNamespaceUtils.setValueIfAttributeDefined(
        builder, element, "extract-request-payload", "extractPayload");
    IntegrationNamespaceUtils.setValueIfAttributeDefined(
        builder, element, "expected-response-type");
    IntegrationNamespaceUtils.setValueIfAttributeDefined(
        builder, element, "reply-timeout", "sendTimeout");
    IntegrationNamespaceUtils.setReferenceIfAttributeDefined(
        builder, element, "reply-channel", "outputChannel");
    HttpAdapterParsingUtils.configureUriVariableExpressions(builder, element);
    IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "transfer-cookies");
    return builder;
  }
  /**
   * Create a new {@link BeanDefinitionBuilder} for the class {@link StoredProcExecutor}. Initialize
   * the wrapped {@link StoredProcExecutor} with common properties.
   *
   * @param element Must not be Null
   * @param parserContext Must not be Null
   * @return The {@link BeanDefinitionBuilder} for the {@link StoredProcExecutor}
   */
  public static BeanDefinitionBuilder getStoredProcExecutorBuilder(
      final Element element, final ParserContext parserContext) {

    Assert.notNull(element, "The provided element must not be Null.");
    Assert.notNull(parserContext, "The provided parserContext must not be Null.");

    final String dataSourceRef = element.getAttribute("data-source");

    final BeanDefinitionBuilder storedProcExecutorBuilder =
        BeanDefinitionBuilder.genericBeanDefinition(StoredProcExecutor.class);
    storedProcExecutorBuilder.addConstructorArgReference(dataSourceRef);

    final String storedProcedureName = element.getAttribute("stored-procedure-name");
    final String storedProcedureNameExpression =
        element.getAttribute("stored-procedure-name-expression");
    boolean hasStoredProcedureName = StringUtils.hasText(storedProcedureName);
    boolean hasStoredProcedureNameExpression = StringUtils.hasText(storedProcedureNameExpression);

    if (!(hasStoredProcedureName ^ hasStoredProcedureNameExpression)) {
      parserContext
          .getReaderContext()
          .error(
              "Exactly one of 'stored-procedure-name' or 'stored-procedure-name-expression' is required",
              element);
    }

    BeanDefinitionBuilder expressionBuilder;
    if (hasStoredProcedureNameExpression) {
      expressionBuilder = BeanDefinitionBuilder.genericBeanDefinition(ExpressionFactoryBean.class);
      expressionBuilder.addConstructorArgValue(storedProcedureNameExpression);
    } else {
      expressionBuilder = BeanDefinitionBuilder.genericBeanDefinition(LiteralExpression.class);
      expressionBuilder.addConstructorArgValue(storedProcedureName);
    }
    storedProcExecutorBuilder.addPropertyValue(
        "storedProcedureNameExpression", expressionBuilder.getBeanDefinition());

    IntegrationNamespaceUtils.setValueIfAttributeDefined(
        storedProcExecutorBuilder, element, "ignore-column-meta-data");
    IntegrationNamespaceUtils.setValueIfAttributeDefined(
        storedProcExecutorBuilder, element, "jdbc-call-operations-cache-size");

    final ManagedList<BeanDefinition> procedureParameterList =
        StoredProcParserUtils.getProcedureParameterBeanDefinitions(element, parserContext);
    final ManagedList<BeanDefinition> sqlParameterDefinitionList =
        StoredProcParserUtils.getSqlParameterDefinitionBeanDefinitions(element, parserContext);

    if (!procedureParameterList.isEmpty()) {
      storedProcExecutorBuilder.addPropertyValue("procedureParameters", procedureParameterList);
    }
    if (!sqlParameterDefinitionList.isEmpty()) {
      storedProcExecutorBuilder.addPropertyValue("sqlParameters", sqlParameterDefinitionList);
    }

    return storedProcExecutorBuilder;
  }
  @Override
  protected BeanDefinitionBuilder parseHandler(Element element, ParserContext parserContext) {
    final BeanDefinitionBuilder builder =
        BeanDefinitionBuilder.genericBeanDefinition(ContentEnricher.class);

    IntegrationNamespaceUtils.setReferenceIfAttributeDefined(builder, element, "request-channel");
    IntegrationNamespaceUtils.setReferenceIfAttributeDefined(builder, element, "reply-channel");
    IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "request-timeout");
    IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "reply-timeout");
    IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "requires-reply");

    List<Element> subElements = DomUtils.getChildElementsByTagName(element, "property");
    if (!CollectionUtils.isEmpty(subElements)) {
      ManagedMap<String, Object> expressions = new ManagedMap<String, Object>();
      for (Element subElement : subElements) {
        String name = subElement.getAttribute("name");
        BeanDefinition beanDefinition =
            IntegrationNamespaceUtils.createExpressionDefinitionFromValueOrExpression(
                "value", "expression", parserContext, subElement, true);
        expressions.put(name, beanDefinition);
      }
      builder.addPropertyValue("propertyExpressions", expressions);
    }

    subElements = DomUtils.getChildElementsByTagName(element, "header");
    if (!CollectionUtils.isEmpty(subElements)) {
      ManagedMap<String, Object> expressions = new ManagedMap<String, Object>();
      for (Element subElement : subElements) {
        String name = subElement.getAttribute("name");
        BeanDefinition expressionDefinition =
            IntegrationNamespaceUtils.createExpressionDefinitionFromValueOrExpression(
                "value", "expression", parserContext, subElement, true);
        BeanDefinitionBuilder valueProcessorBuilder =
            BeanDefinitionBuilder.genericBeanDefinition(
                IntegrationNamespaceUtils.BASE_PACKAGE
                    + ".transformer.support.ExpressionEvaluatingHeaderValueMessageProcessor");
        valueProcessorBuilder
            .addConstructorArgValue(expressionDefinition)
            .addConstructorArgValue(subElement.getAttribute("type"));
        IntegrationNamespaceUtils.setValueIfAttributeDefined(
            valueProcessorBuilder, subElement, "overwrite");
        expressions.put(name, valueProcessorBuilder.getBeanDefinition());
      }
      builder.addPropertyValue("headerExpressions", expressions);
    }

    IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "should-clone-payload");

    String requestPayloadExpression = element.getAttribute("request-payload-expression");

    if (StringUtils.hasText(requestPayloadExpression)) {
      BeanDefinitionBuilder expressionBuilder =
          BeanDefinitionBuilder.genericBeanDefinition(ExpressionFactoryBean.class);
      expressionBuilder.addConstructorArgValue(requestPayloadExpression);
      builder.addPropertyValue("requestPayloadExpression", expressionBuilder.getBeanDefinition());
    }

    return builder;
  }
  private void configureRequestHandlerAdviceChain(
      Element element,
      ParserContext parserContext,
      BeanDefinition handlerBeanDefinition,
      BeanDefinitionBuilder consumerBuilder) {
    Element adviceChainElement =
        DomUtils.getChildElementByTagName(
            element, IntegrationNamespaceUtils.REQUEST_HANDLER_ADVICE_CHAIN);
    @SuppressWarnings("rawtypes")
    ManagedList adviceChain =
        IntegrationNamespaceUtils.configureAdviceChain(
            adviceChainElement, null, handlerBeanDefinition, parserContext);
    if (adviceChain != null) {
      /*
       * For ARPMH, the advice chain is injected so just the handleRequestMessage method is advised.
       * Sometime ARPMHs do double duty as a gateway and a channel adapter. The parser subclass
       * can indicate this by overriding isUsingReplyProducer(), or we can try to determine it from
       * the bean class.
       */
      boolean isReplyProducer = this.isUsingReplyProducer();
      if (!isReplyProducer) {
        Class<?> beanClass = null;
        if (handlerBeanDefinition instanceof AbstractBeanDefinition) {
          AbstractBeanDefinition abstractBeanDefinition =
              (AbstractBeanDefinition) handlerBeanDefinition;
          if (abstractBeanDefinition.hasBeanClass()) {
            beanClass = abstractBeanDefinition.getBeanClass();
          }
        }
        isReplyProducer =
            beanClass != null
                && AbstractReplyProducingMessageHandler.class.isAssignableFrom(beanClass);
      }

      if (isReplyProducer) {
        handlerBeanDefinition.getPropertyValues().add("adviceChain", adviceChain);
      } else if (consumerBuilder != null) {
        consumerBuilder.addPropertyValue("adviceChain", adviceChain);
      } else {
        String elementDescription = IntegrationNamespaceUtils.createElementDescription(element);
        parserContext
            .getReaderContext()
            .error(
                "'request-handler-advice-chain' isn't allowed for "
                    + elementDescription
                    + " within a <chain/>, because its Handler "
                    + "isn't an AbstractReplyProducingMessageHandler",
                element);
      }
    }
  }
  @Override
  protected AbstractBeanDefinition doParse(
      Element element, ParserContext parserContext, String channelName) {
    BeanDefinitionBuilder builder =
        ReactorNamespaceUtils.createBeanDefinitionBuilder(
            SyslogInboundChannelAdapter.class, element);

    IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "host", "host");
    IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "port", "port");

    IntegrationNamespaceUtils.setReferenceIfAttributeDefined(
        builder, element, "channel", "outputChannel");
    IntegrationNamespaceUtils.setReferenceIfAttributeDefined(
        builder, element, "error-channel", "errorChannel");

    return builder.getBeanDefinition();
  }
  @Override
  protected AbstractBeanDefinition parseConsumer(Element element, ParserContext parserContext) {
    BeanDefinitionBuilder builder =
        BeanDefinitionBuilder.genericBeanDefinition(RedisCollectionPopulatingMessageHandler.class);

    String redisTemplateRef = element.getAttribute("redis-template");
    String connectionFactory = element.getAttribute("connection-factory");
    if (StringUtils.hasText(redisTemplateRef) && StringUtils.hasText(connectionFactory)) {
      parserContext
          .getReaderContext()
          .error("Only one of 'redis-template' or 'connection-factory'" + " is allowed", element);
    }

    if (StringUtils.hasText(redisTemplateRef)) {
      builder.addConstructorArgReference(redisTemplateRef);
    } else {
      if (!StringUtils.hasText(connectionFactory)) {
        connectionFactory = "redisConnectionFactory";
      }
      builder.addConstructorArgReference(connectionFactory);
    }

    boolean atLeastOneRequired = false;
    RootBeanDefinition expressionDef =
        IntegrationNamespaceUtils.createExpressionDefinitionFromValueOrExpression(
            "key", "key-expression", parserContext, element, atLeastOneRequired);
    IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "collection-type");
    IntegrationNamespaceUtils.setValueIfAttributeDefined(
        builder, element, "extract-payload-elements");

    if (expressionDef != null) {
      builder.addConstructorArgValue(expressionDef);
    }

    String mapKeyExpression = element.getAttribute("map-key-expression");
    if (StringUtils.hasText(mapKeyExpression)) {
      RootBeanDefinition mapKeyExpressionDef = new RootBeanDefinition(ExpressionFactoryBean.class);
      mapKeyExpressionDef.getConstructorArgumentValues().addGenericArgumentValue(mapKeyExpression);
      builder.addPropertyValue("mapKeyExpression", mapKeyExpressionDef);
    }

    return builder.getBeanDefinition();
  }
  @Override
  protected AbstractBeanDefinition doParse(
      Element element, ParserContext parserContext, String channelName) {
    if (parserContext.isNested()) {
      if (channelName != null) {
        String elementDescription = IntegrationNamespaceUtils.createElementDescription(element);
        parserContext
            .getReaderContext()
            .error(
                "The 'channel' attribute isn't allowed for "
                    + elementDescription
                    + " when it is used as a nested element,"
                    + " e.g. inside a <chain/>",
                element);
      }
      AbstractBeanDefinition consumerBeanDefinition = this.parseConsumer(element, parserContext);
      this.configureRequestHandlerAdviceChain(element, parserContext, consumerBeanDefinition, null);
      return consumerBeanDefinition;
    }
    BeanDefinitionBuilder builder =
        BeanDefinitionBuilder.genericBeanDefinition(ConsumerEndpointFactoryBean.class);
    Element pollerElement = DomUtils.getChildElementByTagName(element, "poller");
    BeanComponentDefinition handlerBeanComponentDefinition =
        this.doParseAndRegisterConsumer(element, parserContext);
    builder.addPropertyReference("handler", handlerBeanComponentDefinition.getBeanName());
    IntegrationNamespaceUtils.checkAndConfigureFixedSubscriberChannel(
        element, parserContext, channelName, handlerBeanComponentDefinition.getBeanName());
    if (pollerElement != null) {
      if (!StringUtils.hasText(channelName)) {
        parserContext
            .getReaderContext()
            .error(
                "outbound channel adapter with a 'poller' requires a 'channel' to poll", element);
      }
      IntegrationNamespaceUtils.configurePollerMetadata(pollerElement, builder, parserContext);
    }
    builder.addPropertyValue("inputChannelName", channelName);

    this.configureRequestHandlerAdviceChain(
        element, parserContext, handlerBeanComponentDefinition.getBeanDefinition(), builder);

    return builder.getBeanDefinition();
  }
  @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();
  }
 @Override
 protected AbstractBeanDefinition doParse(
     Element element, ParserContext parserContext, String channelName) {
   BeanMetadataElement source = this.parseSource(element, parserContext);
   if (source == null) {
     parserContext.getReaderContext().error("failed to parse source", element);
   }
   BeanDefinitionBuilder adapterBuilder =
       BeanDefinitionBuilder.genericBeanDefinition(SourcePollingChannelAdapterFactoryBean.class);
   adapterBuilder.addPropertyValue("source", source);
   adapterBuilder.addPropertyReference("outputChannel", channelName);
   IntegrationNamespaceUtils.setValueIfAttributeDefined(adapterBuilder, element, "send-timeout");
   Element pollerElement = DomUtils.getChildElementByTagName(element, "poller");
   if (pollerElement != null) {
     IntegrationNamespaceUtils.configurePollerMetadata(
         pollerElement, adapterBuilder, parserContext);
   }
   IntegrationNamespaceUtils.setValueIfAttributeDefined(adapterBuilder, element, "auto-startup");
   IntegrationNamespaceUtils.setValueIfAttributeDefined(adapterBuilder, element, "phase");
   return adapterBuilder.getBeanDefinition();
 }
  @Override
  protected BeanDefinitionBuilder buildBeanDefinition(
      Element element, ParserContext parserContext) {
    BeanDefinitionBuilder builder =
        BeanDefinitionBuilder.genericBeanDefinition(SubscribableRedisChannel.class);
    String connectionFactory = element.getAttribute("connection-factory");
    if (!StringUtils.hasText(connectionFactory)) {
      connectionFactory = "redisConnectionFactory";
    }
    builder.addConstructorArgReference(connectionFactory);
    String topicName = element.getAttribute("topic-name");
    builder.addConstructorArgValue(topicName);

    IntegrationNamespaceUtils.setReferenceIfAttributeDefined(builder, element, "task-executor");
    IntegrationNamespaceUtils.setReferenceIfAttributeDefined(builder, element, "message-converter");
    IntegrationNamespaceUtils.setReferenceIfAttributeDefined(builder, element, "serializer");
    // The following 2 attributes should be added once configurable on the
    // RedisMessageListenerContainer
    // IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "phase");
    // IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "auto-startup");
    return builder;
  }
  @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;
 }
 @Override
 protected AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
   BeanDefinitionBuilder builder =
       BeanDefinitionBuilder.genericBeanDefinition(RequestHandlerRetryAdvice.class);
   BeanDefinitionBuilder retryTemplateBuilder =
       BeanDefinitionBuilder.genericBeanDefinition(RetryTemplate.class);
   boolean customTemplate = false;
   Element backOffPolicyEle = DomUtils.getChildElementByTagName(element, "fixed-back-off");
   BeanDefinitionBuilder backOffBuilder = null;
   if (backOffPolicyEle != null) {
     backOffBuilder = BeanDefinitionBuilder.genericBeanDefinition(FixedBackOffPolicy.class);
     IntegrationNamespaceUtils.setValueIfAttributeDefined(
         backOffBuilder, backOffPolicyEle, "interval", "backOffPeriod");
   } else {
     backOffPolicyEle = DomUtils.getChildElementByTagName(element, "exponential-back-off");
     if (backOffPolicyEle != null) {
       backOffBuilder =
           BeanDefinitionBuilder.genericBeanDefinition(ExponentialBackOffPolicy.class);
       IntegrationNamespaceUtils.setValueIfAttributeDefined(
           backOffBuilder, backOffPolicyEle, "initial", "initialInterval");
       IntegrationNamespaceUtils.setValueIfAttributeDefined(
           backOffBuilder, backOffPolicyEle, "multiplier");
       IntegrationNamespaceUtils.setValueIfAttributeDefined(
           backOffBuilder, backOffPolicyEle, "maximum", "maxInterval");
     }
   }
   if (backOffBuilder != null) {
     retryTemplateBuilder.addPropertyValue("backOffPolicy", backOffBuilder.getBeanDefinition());
     customTemplate = true;
   }
   String maxAttemptsAttr = element.getAttribute("max-attempts");
   if (StringUtils.hasText(maxAttemptsAttr)) {
     BeanDefinitionBuilder retryPolicyBuilder =
         BeanDefinitionBuilder.genericBeanDefinition(SimpleRetryPolicy.class);
     IntegrationNamespaceUtils.setValueIfAttributeDefined(
         retryPolicyBuilder, element, "max-attempts");
     retryTemplateBuilder.addPropertyValue("retryPolicy", retryPolicyBuilder.getBeanDefinition());
     customTemplate = true;
   }
   if (customTemplate) {
     builder.addPropertyValue("retryTemplate", retryTemplateBuilder.getBeanDefinition());
   }
   String recoveryChannelAttr = element.getAttribute("recovery-channel");
   if (StringUtils.hasText(recoveryChannelAttr)) {
     BeanDefinitionBuilder emsrBuilder =
         BeanDefinitionBuilder.genericBeanDefinition(ErrorMessageSendingRecoverer.class);
     emsrBuilder.addConstructorArgReference(recoveryChannelAttr);
     IntegrationNamespaceUtils.setValueIfAttributeDefined(emsrBuilder, element, "send-timeout");
     builder.addPropertyValue("recoveryCallback", emsrBuilder.getBeanDefinition());
   }
   return builder.getBeanDefinition();
 }
  /** Utility method to configure HeaderMapper for Inbound and Outbound channel adapters/gateway */
  public static void configureHeaderMapper(
      Element element,
      BeanDefinitionBuilder rootBuilder,
      ParserContext parserContext,
      Class<?> headerMapperClass,
      String replyHeaderValue) {
    String defaultMappedReplyHeadersAttributeName = "mapped-reply-headers";
    if (!StringUtils.hasText(replyHeaderValue)) {
      replyHeaderValue = defaultMappedReplyHeadersAttributeName;
    }
    boolean hasHeaderMapper = element.hasAttribute("header-mapper");
    boolean hasMappedRequestHeaders = element.hasAttribute("mapped-request-headers");
    boolean hasMappedReplyHeaders = element.hasAttribute(replyHeaderValue);

    if (hasHeaderMapper && (hasMappedRequestHeaders || hasMappedReplyHeaders)) {
      parserContext
          .getReaderContext()
          .error(
              "The 'header-mapper' attribute is mutually exclusive with"
                  + " 'mapped-request-headers' or 'mapped-reply-headers'. "
                  + "You can only use one or the others",
              element);
    }

    IntegrationNamespaceUtils.setReferenceIfAttributeDefined(rootBuilder, element, "header-mapper");

    if (hasMappedRequestHeaders || hasMappedReplyHeaders) {
      BeanDefinitionBuilder headerMapperBuilder =
          BeanDefinitionBuilder.genericBeanDefinition(headerMapperClass);

      if (hasMappedRequestHeaders) {
        headerMapperBuilder.addPropertyValue(
            "requestHeaderNames", element.getAttribute("mapped-request-headers"));
      }
      if (hasMappedReplyHeaders) {
        headerMapperBuilder.addPropertyValue(
            "replyHeaderNames", element.getAttribute(replyHeaderValue));
      }

      rootBuilder.addPropertyValue("headerMapper", headerMapperBuilder.getBeanDefinition());
    }
  }
 /**
  * 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;
 }
Esempio n. 17
0
  @Override
  protected AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
    BeanDefinitionBuilder metadataBuilder =
        BeanDefinitionBuilder.genericBeanDefinition(PollerMetadata.class);
    if (element.hasAttribute("ref")) {
      parserContext
          .getReaderContext()
          .error(
              "the 'ref' attribute must not be present on the top-level 'poller' element", element);
    }

    configureTrigger(element, metadataBuilder, parserContext);

    IntegrationNamespaceUtils.setValueIfAttributeDefined(
        metadataBuilder, element, "max-messages-per-poll");
    IntegrationNamespaceUtils.setValueIfAttributeDefined(
        metadataBuilder, element, "receive-timeout");
    IntegrationNamespaceUtils.setReferenceIfAttributeDefined(
        metadataBuilder, element, "task-executor");

    Element txElement = DomUtils.getChildElementByTagName(element, "transactional");
    Element adviceChainElement = DomUtils.getChildElementByTagName(element, "advice-chain");
    IntegrationNamespaceUtils.configureAndSetAdviceChainIfPresent(
        adviceChainElement, txElement, metadataBuilder.getRawBeanDefinition(), parserContext);

    if (txElement != null) {
      IntegrationNamespaceUtils.setReferenceIfAttributeDefined(
          metadataBuilder,
          txElement,
          "synchronization-factory",
          "transactionSynchronizationFactory");
    } else if (adviceChainElement != null) {
      IntegrationNamespaceUtils.setReferenceIfAttributeDefined(
          metadataBuilder,
          adviceChainElement,
          "synchronization-factory",
          "transactionSynchronizationFactory");
    }

    String errorChannel = element.getAttribute("error-channel");
    if (StringUtils.hasText(errorChannel)) {
      BeanDefinitionBuilder errorHandler =
          BeanDefinitionBuilder.genericBeanDefinition(MessagePublishingErrorHandler.class);
      errorHandler.addPropertyReference("defaultErrorChannel", errorChannel);
      metadataBuilder.addPropertyValue("errorHandler", errorHandler.getBeanDefinition());
    }
    return metadataBuilder.getBeanDefinition();
  }
  @Override
  protected AbstractBeanDefinition parseConsumer(Element element, ParserContext parserContext) {
    BeanDefinitionBuilder builder =
        BeanDefinitionBuilder.genericBeanDefinition(AmqpOutboundEndpoint.class);
    String amqpTemplateRef = element.getAttribute("amqp-template");
    if (!StringUtils.hasText(amqpTemplateRef)) {
      amqpTemplateRef = "amqpTemplate";
    }
    builder.addConstructorArgReference(amqpTemplateRef);
    IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "exchange-name", true);
    IntegrationNamespaceUtils.setValueIfAttributeDefined(
        builder, element, "exchange-name-expression");
    IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "routing-key", true);
    IntegrationNamespaceUtils.setValueIfAttributeDefined(
        builder, element, "routing-key-expression");
    IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "default-delivery-mode");
    IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "lazy-connect");

    IntegrationNamespaceUtils.configureHeaderMapper(
        element, builder, parserContext, DefaultAmqpHeaderMapper.class, null);

    IntegrationNamespaceUtils.setValueIfAttributeDefined(
        builder, element, "confirm-correlation-expression");
    IntegrationNamespaceUtils.setReferenceIfAttributeDefined(
        builder, element, "confirm-ack-channel");
    IntegrationNamespaceUtils.setReferenceIfAttributeDefined(
        builder, element, "confirm-nack-channel");
    IntegrationNamespaceUtils.setReferenceIfAttributeDefined(builder, element, "return-channel");

    return builder.getBeanDefinition();
  }
 @Override
 protected void doParse(
     Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
   builder.addConstructorArgValue(this.expectReply);
   String inputChannelAttributeName = this.getInputChannelAttributeName();
   String inputChannelRef = element.getAttribute(inputChannelAttributeName);
   if (!StringUtils.hasText(inputChannelRef)) {
     parserContext
         .getReaderContext()
         .error("a '" + inputChannelAttributeName + "' reference is required", element);
   }
   builder.addPropertyReference("requestChannel", inputChannelRef);
   if (this.expectReply) {
     IntegrationNamespaceUtils.setReferenceIfAttributeDefined(builder, element, "reply-channel");
     IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "request-timeout");
     IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "reply-timeout");
     IntegrationNamespaceUtils.setValueIfAttributeDefined(
         builder, element, "extract-reply-payload");
     IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "reply-key");
     IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "convert-exceptions");
   } else {
     IntegrationNamespaceUtils.setValueIfAttributeDefined(
         builder, element, "send-timeout", "requestTimeout");
   }
   IntegrationNamespaceUtils.setValueIfAttributeDefined(
       builder, element, "supported-methods", "supportedMethodNames");
   IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "request-payload-type");
   IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "view-name");
   IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "errors-key");
   IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "error-code");
   IntegrationNamespaceUtils.setReferenceIfAttributeDefined(
       builder, element, "message-converters");
   IntegrationNamespaceUtils.setReferenceIfAttributeDefined(builder, element, "header-mapper");
 }
 @Override
 protected BeanDefinitionBuilder buildBeanDefinition(
     Element element, ParserContext parserContext) {
   BeanDefinitionBuilder builder =
       BeanDefinitionBuilder.genericBeanDefinition(AmqpChannelFactoryBean.class);
   String messageDriven = element.getAttribute("message-driven");
   if (StringUtils.hasText(messageDriven)) {
     builder.addConstructorArgValue(messageDriven);
   }
   String connectionFactory = element.getAttribute("connection-factory");
   if (!StringUtils.hasText(connectionFactory)) {
     connectionFactory = "rabbitConnectionFactory";
   }
   builder.addPropertyReference("connectionFactory", connectionFactory);
   if ("channel".equals(element.getLocalName())) {
     builder.addPropertyValue("pubSub", false);
   } else if ("publish-subscribe-channel".equals(element.getLocalName())) {
     builder.addPropertyValue("pubSub", true);
   }
   IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "acknowledge-mode");
   IntegrationNamespaceUtils.setReferenceIfAttributeDefined(builder, element, "advice-chain");
   IntegrationNamespaceUtils.setReferenceIfAttributeDefined(builder, element, "amqp-admin");
   IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "auto-startup");
   IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "channel-transacted");
   IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "concurrent-consumers");
   IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "encoding");
   IntegrationNamespaceUtils.setReferenceIfAttributeDefined(builder, element, "error-handler");
   IntegrationNamespaceUtils.setReferenceIfAttributeDefined(builder, element, "exchange");
   IntegrationNamespaceUtils.setValueIfAttributeDefined(
       builder, element, "expose-listener-channel");
   IntegrationNamespaceUtils.setReferenceIfAttributeDefined(builder, element, "message-converter");
   IntegrationNamespaceUtils.setReferenceIfAttributeDefined(
       builder, element, "message-properties-converter");
   IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "phase");
   IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "prefetch-count");
   IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "queue-name");
   IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "receive-timeout");
   IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "recovery-interval");
   IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "shutdown-timeout");
   IntegrationNamespaceUtils.setReferenceIfAttributeDefined(builder, element, "task-executor");
   IntegrationNamespaceUtils.setReferenceIfAttributeDefined(
       builder, element, "transaction-attribute");
   IntegrationNamespaceUtils.setReferenceIfAttributeDefined(
       builder, element, "transaction-manager");
   IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "tx-size");
   return builder;
 }
  private ManagedMap<String, Object> buildVariablesMap(
      final Element element, final ParserContext parserContext, List<Element> variableElements) {
    @SuppressWarnings("serial")
    ManagedMap<String, Object> variableMap =
        new ManagedMap<String, Object>() {

          @Override
          public Object put(String key, Object value) {
            if (this.containsKey(key)) {
              parserContext.getReaderContext().error("Duplicated variable: " + key, element);
            }
            return super.put(key, value);
          }
        };

    for (Element childElement : variableElements) {
      String variableName = childElement.getAttribute("name");
      String variableValue = childElement.getAttribute("value");
      String variableRef = childElement.getAttribute("ref");
      if (!(StringUtils.hasText(variableValue) ^ StringUtils.hasText(variableRef))) {
        parserContext
            .getReaderContext()
            .error(
                "Exactly one of the 'ref' attribute or 'value' attribute, "
                    + " is required for element "
                    + IntegrationNamespaceUtils.createElementDescription(element)
                    + ".",
                element);
      }
      if (StringUtils.hasText(variableValue)) {
        variableMap.put(variableName, variableValue);
      } else {
        variableMap.put(variableName, new RuntimeBeanReference(variableRef));
      }
    }

    String variables = element.getAttribute("variables");
    if (StringUtils.hasText(variables)) {
      String[] variablePairs = StringUtils.commaDelimitedListToStringArray(variables);
      for (String variablePair : variablePairs) {
        String[] variableValue = variablePair.split("=");
        if (variableValue.length != 2) {
          parserContext
              .getReaderContext()
              .error(
                  "Variable declarations in the 'variable' attribute must have the "
                      + "form 'var=value'; found : '"
                      + variablePair
                      + "'",
                  element);
        }
        String variable = variableValue[0].trim();
        String value = variableValue[1];
        if (variable.endsWith("-ref")) {
          variable = variable.substring(0, variable.indexOf("-ref"));
          variableMap.put(variable, new RuntimeBeanReference(value));
        } else {
          variableMap.put(variable, value);
        }
      }
    }

    return variableMap;
  }
Esempio n. 22
0
  @Override
  @SuppressWarnings("rawtypes")
  public BeanDefinition parse(final Element element, ParserContext parserContext) {
    boolean isNested = parserContext.isNested();

    final Map<String, Object> gatewayAttributes = new HashMap<String, Object>();
    gatewayAttributes.put("name", element.getAttribute(AbstractBeanDefinitionParser.ID_ATTRIBUTE));
    gatewayAttributes.put(
        "defaultPayloadExpression", element.getAttribute("default-payload-expression"));
    gatewayAttributes.put(
        "defaultRequestChannel",
        element.getAttribute(isNested ? "request-channel" : "default-request-channel"));
    gatewayAttributes.put(
        "defaultReplyChannel",
        element.getAttribute(isNested ? "reply-channel" : "default-reply-channel"));
    gatewayAttributes.put("errorChannel", element.getAttribute("error-channel"));
    gatewayAttributes.put("asyncExecutor", element.getAttribute("async-executor"));
    gatewayAttributes.put("mapper", element.getAttribute("mapper"));
    gatewayAttributes.put(
        "defaultReplyTimeout",
        element.getAttribute(isNested ? "reply-timeout" : "default-reply-timeout"));
    gatewayAttributes.put(
        "defaultRequestTimeout",
        element.getAttribute(isNested ? "request-timeout" : "default-request-timeout"));

    List<Element> headerElements = DomUtils.getChildElementsByTagName(element, "default-header");
    if (!CollectionUtils.isEmpty(headerElements)) {
      List<Map<String, Object>> headers = new ArrayList<Map<String, Object>>(headerElements.size());
      for (Element e : headerElements) {
        Map<String, Object> header = new HashMap<String, Object>();
        header.put("name", e.getAttribute("name"));
        header.put("value", e.getAttribute("value"));
        header.put("expression", e.getAttribute("expression"));
        headers.add(header);
      }
      gatewayAttributes.put("defaultHeaders", headers.toArray(new Map[headers.size()]));
    }

    List<Element> methodElements = DomUtils.getChildElementsByTagName(element, "method");
    if (!CollectionUtils.isEmpty(methodElements)) {
      Map<String, BeanDefinition> methodMetadataMap = new ManagedMap<String, BeanDefinition>();
      for (Element methodElement : methodElements) {
        String methodName = methodElement.getAttribute("name");
        BeanDefinitionBuilder methodMetadataBuilder =
            BeanDefinitionBuilder.genericBeanDefinition(GatewayMethodMetadata.class);
        methodMetadataBuilder.addPropertyValue(
            "requestChannelName", methodElement.getAttribute("request-channel"));
        methodMetadataBuilder.addPropertyValue(
            "replyChannelName", methodElement.getAttribute("reply-channel"));
        methodMetadataBuilder.addPropertyValue(
            "requestTimeout", methodElement.getAttribute("request-timeout"));
        methodMetadataBuilder.addPropertyValue(
            "replyTimeout", methodElement.getAttribute("reply-timeout"));

        boolean hasMapper = StringUtils.hasText(element.getAttribute("mapper"));
        Assert.state(
            !hasMapper || !StringUtils.hasText(element.getAttribute("payload-expression")),
            "'payload-expression' is not allowed when a 'mapper' is provided");

        IntegrationNamespaceUtils.setValueIfAttributeDefined(
            methodMetadataBuilder, methodElement, "payload-expression");

        List<Element> invocationHeaders =
            DomUtils.getChildElementsByTagName(methodElement, "header");
        if (!CollectionUtils.isEmpty(invocationHeaders)) {
          Assert.state(!hasMapper, "header elements are not allowed when a 'mapper' is provided");

          Map<String, Object> headerExpressions = new ManagedMap<String, Object>();
          for (Element headerElement : invocationHeaders) {
            BeanDefinition expressionDef =
                IntegrationNamespaceUtils.createExpressionDefinitionFromValueOrExpression(
                    "value", "expression", parserContext, headerElement, true);

            headerExpressions.put(headerElement.getAttribute("name"), expressionDef);
          }
          methodMetadataBuilder.addPropertyValue("headerExpressions", headerExpressions);
        }
        methodMetadataMap.put(methodName, methodMetadataBuilder.getBeanDefinition());
      }

      gatewayAttributes.put("methods", methodMetadataMap);
    }

    gatewayAttributes.put("serviceInterface", element.getAttribute("service-interface"));

    BeanDefinitionHolder gatewayHolder = this.registrar.parse(gatewayAttributes);
    if (isNested) {
      return gatewayHolder.getBeanDefinition();
    } else {
      BeanDefinitionReaderUtils.registerBeanDefinition(gatewayHolder, parserContext.getRegistry());
      return null;
    }
  }