private ManagedList<AbstractBeanDefinition> parseListeners(
      Element element, ParserContext parserContext) {
    List<Element> listenersElements =
        DomUtils.getChildElementsByTagName(element, LISTENERS_ELEMENT);

    ManagedList<AbstractBeanDefinition> listeners = new ManagedList<AbstractBeanDefinition>();

    if (listenersElements.size() == 1) {
      Element listenersElement = listenersElements.get(0);
      CompositeComponentDefinition compositeDef =
          new CompositeComponentDefinition(
              listenersElement.getTagName(), parserContext.extractSource(element));
      parserContext.pushContainingComponent(compositeDef);
      listeners.setMergeEnabled(false);
      List<Element> listenerElements =
          DomUtils.getChildElementsByTagName(listenersElement, LISTENER_ELEMENT);
      for (Element listenerElement : listenerElements) {
        BeanDefinitionBuilder bd = BeanDefinitionBuilder.genericBeanDefinition(listenerType);
        bd.addPropertyValue(
            "delegate", new RuntimeBeanReference(listenerElement.getAttribute(REF_ATTRIBUTE)));
        listeners.add(bd.getBeanDefinition());
      }
      parserContext.popAndRegisterContainingComponent();
    } else if (listenersElements.size() > 1) {
      parserContext
          .getReaderContext()
          .error(
              "The '<listeners/>' element may not appear more than once in a single <job/>.",
              element);
    }

    return listeners;
  }
示例#2
0
 /**
  * @param elt
  * @param parserContext
  * @param pkgs
  */
 private void parsePathsElement(Element element, ParserContext parserContext, Set<String> pkgs) {
   List<Element> pkgElts = DomUtils.getChildElementsByTagName(element, PATH_ELEMENT);
   for (Element pkgElt : pkgElts) {
     String value = DomUtils.getTextValue(pkgElt).trim();
     pkgs.add(value);
   }
 }
  @Override
  protected void doParse(
      Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
    super.doParse(element, parserContext, builder);

    BeanDefinitionBuilder redisConfigBeanBuilder =
        BeanDefinitionBuilder.genericBeanDefinition(RedisConnectionFactoryConfig.class.getName());

    BeanDefinition cloudPoolConfiguration = null;
    Element poolElement = DomUtils.getChildElementByTagName(element, ELEMENT_POOL);
    if (poolElement != null) {
      cloudPoolConfiguration = parsePoolElement(poolElement, parserContext);
    }
    redisConfigBeanBuilder.addConstructorArgValue(cloudPoolConfiguration);

    Element propertiesElement = DomUtils.getChildElementByTagName(element, CONNECTION_PROPERTIES);
    if (propertiesElement != null) {
      Map<?, ?> properties =
          parserContext
              .getDelegate()
              .parseMapElement(propertiesElement, builder.getRawBeanDefinition());
      redisConfigBeanBuilder.addConstructorArgValue(properties);
    }

    builder.addConstructorArgValue(redisConfigBeanBuilder.getBeanDefinition());
  }
 @SuppressWarnings("unchecked")
 public void handleListenersElement(
     Element stepElement, BeanDefinition beanDefinition, ParserContext parserContext) {
   MutablePropertyValues propertyValues = beanDefinition.getPropertyValues();
   List<Element> listenersElements =
       DomUtils.getChildElementsByTagName(stepElement, LISTENERS_ELE);
   if (listenersElements.size() == 1) {
     Element listenersElement = listenersElements.get(0);
     CompositeComponentDefinition compositeDef =
         new CompositeComponentDefinition(
             listenersElement.getTagName(), parserContext.extractSource(stepElement));
     parserContext.pushContainingComponent(compositeDef);
     ManagedList listenerBeans = new ManagedList();
     if (propertyValues.contains("listeners")) {
       listenerBeans = (ManagedList) propertyValues.getPropertyValue("listeners").getValue();
     }
     listenerBeans.setMergeEnabled(
         listenersElement.hasAttribute(MERGE_ATTR)
             && Boolean.valueOf(listenersElement.getAttribute(MERGE_ATTR)));
     List<Element> listenerElements =
         DomUtils.getChildElementsByTagName(listenersElement, "listener");
     if (listenerElements != null) {
       for (Element listenerElement : listenerElements) {
         listenerBeans.add(parse(listenerElement, parserContext));
       }
     }
     propertyValues.addPropertyValue("listeners", listenerBeans);
     parserContext.popAndRegisterContainingComponent();
   }
 }
  @SuppressWarnings("unchecked")
  public static BeanMetadataElement parseListenerElement(
      Element element, ParserContext parserContext, BeanDefinition enclosing) {
    String listenerRef = element.getAttribute(REF_ATTR);
    List<Element> beanElements = DomUtils.getChildElementsByTagName(element, BEAN_ELE);
    List<Element> refElements = DomUtils.getChildElementsByTagName(element, REF_ELE);

    verifyListenerAttributesAndSubelements(
        listenerRef, beanElements, refElements, element, parserContext);

    if (StringUtils.hasText(listenerRef)) {
      return new RuntimeBeanReference(listenerRef);
    } else if (beanElements.size() == 1) {
      Element beanElement = beanElements.get(0);
      BeanDefinitionHolder beanDefinitionHolder =
          parserContext.getDelegate().parseBeanDefinitionElement(beanElement, enclosing);
      parserContext
          .getDelegate()
          .decorateBeanDefinitionIfRequired(beanElement, beanDefinitionHolder);
      return beanDefinitionHolder;
    } else {
      return (BeanMetadataElement)
          parserContext.getDelegate().parsePropertySubElement(refElements.get(0), null);
    }
  }
  @SuppressWarnings({"unchecked"})
  private void parseProcessors(
      Element element, ParserContext parserContext, GenericBeanDefinition beanDefinition) {
    Element processorsElement =
        DomUtils.getChildElementByTagName(element, EVENT_PROCESSORS_ELEMENT);

    Element snapshotTriggerElement =
        DomUtils.getChildElementByTagName(element, SNAPSHOT_TRIGGER_ELEMENT);
    if (snapshotTriggerElement != null) {
      BeanDefinition triggerDefinition =
          snapshotterTriggerParser.parse(snapshotTriggerElement, parserContext);
      PropertyValue aggregateCache = beanDefinition.getPropertyValues().getPropertyValue("cache");
      if (aggregateCache != null) {
        triggerDefinition.getPropertyValues().add("aggregateCache", aggregateCache.getValue());
      }
      beanDefinition.getPropertyValues().add(SNAPSHOTTER_TRIGGER_PROPERTY, triggerDefinition);
    }

    if (processorsElement != null) {
      List<Object> processorsList =
          parserContext.getDelegate().parseListElement(processorsElement, beanDefinition);
      if (!processorsList.isEmpty()) {
        beanDefinition.getPropertyValues().add(EVENT_STREAM_DECORATORS_PROPERTY, processorsList);
      }
    }
  }
  @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;
  }
  @Override
  protected void doParse(
      Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
    String scriptLocation = element.getAttribute(LOCATION_ATTRIBUTE);
    String scriptText = DomUtils.getTextValue(element);
    if (!(StringUtils.hasText(scriptLocation) ^ StringUtils.hasText(scriptText))) {
      parserContext
          .getReaderContext()
          .error(
              "Either the 'location' attribute or inline script text must be provided, but not both.",
              element);
      return;
    }

    List<Element> variableElements = DomUtils.getChildElementsByTagName(element, "variable");
    String scriptVariableGeneratorName = element.getAttribute("script-variable-generator");

    if (StringUtils.hasText(scriptVariableGeneratorName) && variableElements.size() > 0) {
      parserContext
          .getReaderContext()
          .error(
              "'script-variable-generator' and 'variable' sub-elements are mutually exclusive.",
              element);
      return;
    }

    if (StringUtils.hasText(scriptLocation)) {
      builder.addConstructorArgValue(
          this.resolveScriptLocation(element, parserContext.getReaderContext(), scriptLocation));
    } else {
      if (getScriptSourceClassName() != null) {
        builder.addConstructorArgValue(
            new StaticScriptSource(scriptText, getScriptSourceClassName()));
      } else {
        builder.addConstructorArgValue(new StaticScriptSource(scriptText));
      }
    }

    BeanMetadataElement scriptVariableGeneratorDef = null;

    if (!StringUtils.hasText(scriptVariableGeneratorName)) {
      BeanDefinitionBuilder scriptVariableGeneratorBuilder =
          BeanDefinitionBuilder.genericBeanDefinition(DefaultScriptVariableGenerator.class);
      ManagedMap<String, Object> variableMap =
          buildVariablesMap(element, parserContext, variableElements);
      if (!CollectionUtils.isEmpty(variableMap)) {
        scriptVariableGeneratorBuilder.addConstructorArgValue(variableMap);
      }
      scriptVariableGeneratorDef = scriptVariableGeneratorBuilder.getBeanDefinition();
    } else {
      scriptVariableGeneratorDef = new RuntimeBeanReference(scriptVariableGeneratorName);
    }

    builder.addConstructorArgValue(scriptVariableGeneratorDef);
    postProcess(builder, element, parserContext);
  }
示例#9
0
    /**
     * @param element
     * @param parserContext
     * @param xmlDataList
     */
    private void parseClassElement(
        Element element, ParserContext parserContext, List<Map<String, Object>> xmlDataList) {
      String className = element.getAttribute(CLASS_NAME_ATTR).replaceAll("//s+", "");
      if (StringUtils.hasText(className)) {
        List<Element> interfaceElts =
            DomUtils.getChildElementsByTagName(element, INTERFACE_ELEMENT);
        for (Element interfaceElt : interfaceElts) {
          String description = interfaceElt.getAttribute(DESCRIPTION_ATTR).replaceAll("//s+", "");
          if (StringUtils.hasText(description)) {
            List<Element> dataElts = DomUtils.getChildElementsByTagName(interfaceElt, DATA_ELEMENT);
            int dataEltsSize = dataElts.size();
            String[] datas = new String[dataEltsSize];
            for (int i = 0; i < dataEltsSize; i++) {
              String value = DomUtils.getTextValue(dataElts.get(i)).trim();
              datas[i] = value;
            }
            Object[] wrappedDatas = wrapSingleArray(datas);
            HashMap<String, Object> dataMap = new HashMap<String, Object>();
            Class<?> clazz = null;
            try {
              clazz = Class.forName(className);
            } catch (ClassNotFoundException e) {
              throw new RuntimeException(e);
            }
            String internalClassName = Type.getInternalName(clazz);

            String methodName = Util.getMethodNameFromMethodExternalDesc(description);
            Class<?>[] parameterTypes = Util.getParameterTypesFromMethodExternalDesc(description);

            Method method;
            try {
              method = clazz.getMethod(methodName, parameterTypes);
            } catch (Exception e) {
              throw new RuntimeException(e);
            }
            Object[] wrappedParameterTypes = wrapSingleArray(parameterTypes);
            String methodDesc = Type.getMethodDescriptor(method);
            Type returnType = Type.getReturnType(methodDesc);
            Class<?> returnClass = Util.getClass(returnType);

            dataMap.put("key", className + "." + description);
            dataMap.put("internalClassName", internalClassName);
            dataMap.put("className", className);
            dataMap.put("clazz", clazz);
            dataMap.put("methodName", methodName);
            dataMap.put("methodDesc", methodDesc);
            dataMap.put("returnClass", returnClass);
            dataMap.put("argumentClasses", wrappedParameterTypes);
            dataMap.put("datas", wrappedDatas);
            xmlDataList.add(dataMap);
          }
        }
      }
    }
 @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();
 }
示例#11
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 void doParse(
     Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
   List<Element> childElements = DomUtils.getChildElementsByTagName(element, "script");
   if (!childElements.isEmpty()) {
     List<String> locations = new ArrayList<String>(childElements.size());
     for (Element childElement : childElements) {
       locations.add(childElement.getAttribute("location"));
     }
     builder.addPropertyValue("scripts", locations.toArray(new String[locations.size()]));
   }
   builder.addPropertyValue("engineName", element.getAttribute("engine-name"));
   if (element.hasAttribute("render-object")) {
     builder.addPropertyValue("renderObject", element.getAttribute("render-object"));
   }
   if (element.hasAttribute("render-function")) {
     builder.addPropertyValue("renderFunction", element.getAttribute("render-function"));
   }
   if (element.hasAttribute("charset")) {
     builder.addPropertyValue("charset", Charset.forName(element.getAttribute("charset")));
   }
   if (element.hasAttribute("resource-loader-path")) {
     builder.addPropertyValue("resourceLoaderPath", element.getAttribute("resource-loader-path"));
   }
   if (element.hasAttribute("shared-engine")) {
     builder.addPropertyValue("sharedEngine", element.getAttribute("shared-engine"));
   }
 }
 @Override
 protected AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
   if (DomUtils.getChildElementByTagName(element, "async") != null) {
     return async.parseInternal(element, parserContext);
   }
   return sync.parseInternal(element, parserContext);
 }
 public static BeanComponentDefinition parseInnerHandlerDefinition(
     Element element, ParserContext parserContext) {
   // parses out the inner bean definition for concrete implementation if defined
   List<Element> childElements = DomUtils.getChildElementsByTagName(element, "bean");
   BeanComponentDefinition innerComponentDefinition = null;
   if (childElements != null && childElements.size() == 1) {
     Element beanElement = childElements.get(0);
     BeanDefinitionParserDelegate delegate = parserContext.getDelegate();
     BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(beanElement);
     bdHolder = delegate.decorateBeanDefinitionIfRequired(beanElement, bdHolder);
     BeanDefinition inDef = bdHolder.getBeanDefinition();
     innerComponentDefinition = new BeanComponentDefinition(inDef, bdHolder.getBeanName());
   }
   String ref = element.getAttribute(REF_ATTRIBUTE);
   Assert.isTrue(
       !(StringUtils.hasText(ref) && innerComponentDefinition != null),
       "Ambiguous definition. Inner bean "
           + (innerComponentDefinition == null
               ? innerComponentDefinition
               : innerComponentDefinition.getBeanDefinition().getBeanClassName())
           + " declaration and \"ref\" "
           + ref
           + " are not allowed together.");
   return innerComponentDefinition;
 }
  @Override
  protected void doParse(
      Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
    String exchangeName = element.getAttribute(NAME_ATTRIBUTE);
    builder.addConstructorArgValue(new TypedStringValue(exchangeName));
    parseBindings(element, parserContext, builder, exchangeName);

    NamespaceUtils.addConstructorArgBooleanValueIfAttributeDefined(
        builder, element, DURABLE_ATTRIBUTE, true);
    NamespaceUtils.addConstructorArgBooleanValueIfAttributeDefined(
        builder, element, AUTO_DELETE_ATTRIBUTE, false);

    Element argumentsElement = DomUtils.getChildElementByTagName(element, ARGUMENTS_ELEMENT);
    if (argumentsElement != null) {

      String ref = argumentsElement.getAttribute(REF_ATTRIBUTE);
      Map<?, ?> map =
          parserContext
              .getDelegate()
              .parseMapElement(argumentsElement, builder.getRawBeanDefinition());
      if (StringUtils.hasText(ref)) {
        if (map != null && map.size() > 0) {
          parserContext
              .getReaderContext()
              .error("You cannot have both a 'ref' and a nested map", element);
        }
        builder.addConstructorArgReference(ref);
      } else {
        builder.addConstructorArgValue(map);
      }
    }

    NamespaceUtils.parseDeclarationControls(element, builder);
  }
 private ManagedList<?> getArgumentResolvers(Element element, ParserContext parserContext) {
   Element resolversElement = DomUtils.getChildElementByTagName(element, "argument-resolvers");
   if (resolversElement != null) {
     ManagedList<Object> resolvers = extractBeanSubElements(resolversElement, parserContext);
     return wrapLegacyResolvers(resolvers, parserContext);
   }
   return null;
 }
 protected void parseBindings(
     Element element,
     ParserContext parserContext,
     BeanDefinitionBuilder builder,
     String exchangeName) {
   Element bindingsElement = DomUtils.getChildElementByTagName(element, BINDINGS_ELE);
   doParseBindings(element, parserContext, exchangeName, bindingsElement, this);
 }
 private RuntimeBeanReference getAsyncExecutor(Element element) {
   Element asyncElement = DomUtils.getChildElementByTagName(element, "async-support");
   if (asyncElement != null) {
     if (asyncElement.hasAttribute("task-executor")) {
       return new RuntimeBeanReference(asyncElement.getAttribute("task-executor"));
     }
   }
   return null;
 }
  private RootBeanDefinition parseAttributeSource(Element attrEle, ParserContext parserContext) {
    List<Element> methods = DomUtils.getChildElementsByTagName(attrEle, METHOD_ELEMENT);
    ManagedMap<TypedStringValue, RuleBasedTransactionAttribute> transactionAttributeMap =
        new ManagedMap<TypedStringValue, RuleBasedTransactionAttribute>(methods.size());
    transactionAttributeMap.setSource(parserContext.extractSource(attrEle));

    for (Element methodEle : methods) {
      String name = methodEle.getAttribute(METHOD_NAME_ATTRIBUTE);
      TypedStringValue nameHolder = new TypedStringValue(name);
      nameHolder.setSource(parserContext.extractSource(methodEle));

      RuleBasedTransactionAttribute attribute = new RuleBasedTransactionAttribute();
      String propagation = methodEle.getAttribute(PROPAGATION_ATTRIBUTE);
      String isolation = methodEle.getAttribute(ISOLATION_ATTRIBUTE);
      String timeout = methodEle.getAttribute(TIMEOUT_ATTRIBUTE);
      String readOnly = methodEle.getAttribute(READ_ONLY_ATTRIBUTE);
      if (StringUtils.hasText(propagation)) {
        attribute.setPropagationBehaviorName(
            RuleBasedTransactionAttribute.PREFIX_PROPAGATION + propagation);
      }
      if (StringUtils.hasText(isolation)) {
        attribute.setIsolationLevelName(RuleBasedTransactionAttribute.PREFIX_ISOLATION + isolation);
      }
      if (StringUtils.hasText(timeout)) {
        try {
          attribute.setTimeout(Integer.parseInt(timeout));
        } catch (NumberFormatException ex) {
          parserContext
              .getReaderContext()
              .error("Timeout must be an integer value: [" + timeout + "]", methodEle);
        }
      }
      if (StringUtils.hasText(readOnly)) {
        attribute.setReadOnly(Boolean.valueOf(methodEle.getAttribute(READ_ONLY_ATTRIBUTE)));
      }

      List<RollbackRuleAttribute> rollbackRules = new LinkedList<RollbackRuleAttribute>();
      if (methodEle.hasAttribute(ROLLBACK_FOR_ATTRIBUTE)) {
        String rollbackForValue = methodEle.getAttribute(ROLLBACK_FOR_ATTRIBUTE);
        addRollbackRuleAttributesTo(rollbackRules, rollbackForValue);
      }
      if (methodEle.hasAttribute(NO_ROLLBACK_FOR_ATTRIBUTE)) {
        String noRollbackForValue = methodEle.getAttribute(NO_ROLLBACK_FOR_ATTRIBUTE);
        addNoRollbackRuleAttributesTo(rollbackRules, noRollbackForValue);
      }
      attribute.setRollbackRules(rollbackRules);

      transactionAttributeMap.put(nameHolder, attribute);
    }

    RootBeanDefinition attributeSourceDefinition =
        new RootBeanDefinition(NameMatchTransactionAttributeSource.class);
    attributeSourceDefinition.setSource(parserContext.extractSource(attrEle));
    attributeSourceDefinition.getPropertyValues().add("nameMap", transactionAttributeMap);
    return attributeSourceDefinition;
  }
  @SuppressWarnings("unchecked")
  public BeanDefinitionHolder decorate(
      Node node, BeanDefinitionHolder holder, ParserContext parserContext) {
    BeanDefinition filterChainProxy = holder.getBeanDefinition();

    ManagedList<BeanMetadataElement> securityFilterChains = new ManagedList<BeanMetadataElement>();
    Element elt = (Element) node;

    MatcherType matcherType = MatcherType.fromElement(elt);

    List<Element> filterChainElts = DomUtils.getChildElementsByTagName(elt, Elements.FILTER_CHAIN);

    for (Element chain : filterChainElts) {
      String path = chain.getAttribute(HttpSecurityBeanDefinitionParser.ATT_PATH_PATTERN);
      String filters = chain.getAttribute(HttpSecurityBeanDefinitionParser.ATT_FILTERS);

      if (!StringUtils.hasText(path)) {
        parserContext
            .getReaderContext()
            .error(
                "The attribute '"
                    + HttpSecurityBeanDefinitionParser.ATT_PATH_PATTERN
                    + "' must not be empty",
                elt);
      }

      if (!StringUtils.hasText(filters)) {
        parserContext
            .getReaderContext()
            .error(
                "The attribute '"
                    + HttpSecurityBeanDefinitionParser.ATT_FILTERS
                    + "'must not be empty",
                elt);
      }

      BeanDefinition matcher = matcherType.createMatcher(parserContext, path, null);

      if (filters.equals(HttpSecurityBeanDefinitionParser.OPT_FILTERS_NONE)) {
        securityFilterChains.add(createSecurityFilterChain(matcher, new ManagedList(0)));
      } else {
        String[] filterBeanNames = StringUtils.tokenizeToStringArray(filters, ",");
        ManagedList filterChain = new ManagedList(filterBeanNames.length);

        for (String name : filterBeanNames) {
          filterChain.add(new RuntimeBeanReference(name));
        }

        securityFilterChains.add(createSecurityFilterChain(matcher, filterChain));
      }
    }

    filterChainProxy.getConstructorArgumentValues().addGenericArgumentValue(securityFilterChains);

    return holder;
  }
 private ManagedList<Object> extractBeanSubElements(
     Element parentElement, ParserContext parserContext) {
   ManagedList<Object> list = new ManagedList<Object>();
   list.setSource(parserContext.extractSource(parentElement));
   for (Element beanElement : DomUtils.getChildElementsByTagName(parentElement, "bean", "ref")) {
     Object object = parserContext.getDelegate().parsePropertySubElement(beanElement, null);
     list.add(object);
   }
   return list;
 }
  /**
   * @param storedProcComponent
   * @param parserContext
   */
  public static ManagedList<BeanDefinition> getSqlParameterDefinitionBeanDefinitions(
      Element storedProcComponent, ParserContext parserContext) {
    List<Element> sqlParameterDefinitionChildElements =
        DomUtils.getChildElementsByTagName(storedProcComponent, "sql-parameter-definition");
    ManagedList<BeanDefinition> sqlParameterList = new ManagedList<BeanDefinition>();

    for (Element childElement : sqlParameterDefinitionChildElements) {

      String name = childElement.getAttribute("name");
      String sqlType = childElement.getAttribute("type");
      String direction = childElement.getAttribute("direction");
      String scale = childElement.getAttribute("scale");

      final BeanDefinitionBuilder parameterBuilder;

      if ("OUT".equalsIgnoreCase(direction)) {
        parameterBuilder = BeanDefinitionBuilder.genericBeanDefinition(SqlOutParameter.class);
      } else if ("INOUT".equalsIgnoreCase(direction)) {
        parameterBuilder = BeanDefinitionBuilder.genericBeanDefinition(SqlInOutParameter.class);
      } else {
        parameterBuilder = BeanDefinitionBuilder.genericBeanDefinition(SqlParameter.class);
      }

      if (StringUtils.hasText(name)) {
        parameterBuilder.addConstructorArgValue(name);
      } else {
        parserContext
            .getReaderContext()
            .error(
                "The 'name' attribute must be set for the Sql parameter element.",
                storedProcComponent);
      }

      if (StringUtils.hasText(sqlType)) {

        JdbcTypesEnum jdbcTypeEnum = JdbcTypesEnum.convertToJdbcTypesEnum(sqlType);

        if (jdbcTypeEnum != null) {
          parameterBuilder.addConstructorArgValue(jdbcTypeEnum.getCode());
        } else {
          parameterBuilder.addConstructorArgValue(sqlType);
        }

      } else {
        parameterBuilder.addConstructorArgValue(Types.VARCHAR);
      }

      if (StringUtils.hasText(scale)) {
        parameterBuilder.addConstructorArgValue(new TypedStringValue(scale, Integer.class));
      }

      sqlParameterList.add(parameterBuilder.getBeanDefinition());
    }
    return sqlParameterList;
  }
 private ManagedList<?> getDeferredResultInterceptors(
     Element element, Object source, ParserContext parserContext) {
   ManagedList<? super Object> interceptors = new ManagedList<Object>();
   Element asyncElement = DomUtils.getChildElementByTagName(element, "async-support");
   if (asyncElement != null) {
     Element interceptorsElement =
         DomUtils.getChildElementByTagName(asyncElement, "deferred-result-interceptors");
     if (interceptorsElement != null) {
       interceptors.setSource(source);
       for (Element converter : DomUtils.getChildElementsByTagName(interceptorsElement, "bean")) {
         BeanDefinitionHolder beanDef =
             parserContext.getDelegate().parseBeanDefinitionElement(converter);
         beanDef =
             parserContext.getDelegate().decorateBeanDefinitionIfRequired(converter, beanDef);
         interceptors.add(beanDef);
       }
     }
   }
   return interceptors;
 }
  private void parseEntries(
      Element element, String name, EntryType type, List<BeanDefinition> entries) {
    List<Element> cp = DomUtils.getChildElementsByTagName(element, name);

    for (Element entry : cp) {
      BeanDefinitionBuilder bd = BeanDefinitionBuilder.genericBeanDefinition(CacheEntry.class);
      bd.addConstructorArgValue(type);
      bd.addConstructorArgValue(entry.getAttribute("value"));
      entries.add(bd.getBeanDefinition());
    }
  }
  @Override
  public PreRenderActions getPreRenderActions() {
    validateScreenXmlDoc();

    Element preRenderActionElement =
        DomUtils.getChildElementByTagName(screenXmlDocument.getDocumentElement(), "pre-actions");
    GuiElementDefinitionParser parser =
        getParserDelegate().getScreenElementDefinitionParser("pre-actions");
    PreRenderActions preRenderActions =
        parser.parse(preRenderActionElement, PreRenderActions.class);
    return preRenderActions;
  }
示例#26
0
  /**
   * Parse the split and turn it into a list of transitions.
   *
   * @param element the &lt;split/gt; element to parse
   * @param parserContext the parser context for the bean factory
   * @return a collection of bean definitions for {@link
   *     org.springframework.batch.core.job.flow.support.StateTransition} instances objects
   */
  public Collection<BeanDefinition> parse(Element element, ParserContext parserContext) {

    String idAttribute = element.getAttribute("id");

    BeanDefinitionBuilder stateBuilder =
        BeanDefinitionBuilder.genericBeanDefinition(
            "org.springframework.batch.core.job.flow.support.state.SplitState");

    String taskExecutorBeanId = element.getAttribute("task-executor");
    if (StringUtils.hasText(taskExecutorBeanId)) {
      RuntimeBeanReference taskExecutorRef = new RuntimeBeanReference(taskExecutorBeanId);
      stateBuilder.addPropertyValue("taskExecutor", taskExecutorRef);
    }

    List<Element> flowElements = DomUtils.getChildElementsByTagName(element, "flow");

    if (flowElements.size() < 2) {
      parserContext
          .getReaderContext()
          .error("A <split/> must contain at least two 'flow' elements.", element);
    }

    Collection<BeanDefinition> flows = new ManagedList<BeanDefinition>();
    int i = 0;
    String prefix = idAttribute;
    for (Element nextElement : flowElements) {
      String ref = nextElement.getAttribute(PARENT_ATTR);
      if (StringUtils.hasText(ref)) {
        if (nextElement.getElementsByTagName("*").getLength() > 0) {
          parserContext
              .getReaderContext()
              .error(
                  "A <flow/> in a <split/> must have ref= or nested <flow/>, but not both.",
                  nextElement);
        }
        AbstractBeanDefinition flowDefinition = new GenericBeanDefinition();
        flowDefinition.setParentName(ref);
        MutablePropertyValues propertyValues = flowDefinition.getPropertyValues();
        propertyValues.addPropertyValue("name", prefix + "." + i);
        flows.add(flowDefinition);
      } else {
        InlineFlowParser flowParser = new InlineFlowParser(prefix + "." + i, jobFactoryRef);
        flows.add(flowParser.parse(nextElement, parserContext));
      }
      i++;
    }

    stateBuilder.addConstructorArgValue(flows);
    stateBuilder.addConstructorArgValue(prefix);

    return InlineFlowParser.getNextElements(
        parserContext, stateBuilder.getBeanDefinition(), element);
  }
示例#27
0
  /**
   * @see org.springframework.beans.factory.xml.BeanDefinitionParser#parse(org.w3c.dom.Element,
   *     org.springframework.beans.factory.xml.ParserContext)
   */
  public BeanDefinition parse(Element element, ParserContext parserContext) {
    BeanDefinitionBuilder beanDefinition =
        BeanDefinitionBuilder.rootBeanDefinition(AntRunAction.class);

    DescriptionElementParser.doParse(element, beanDefinition);

    BeanDefinitionParserUtils.setPropertyValue(
        beanDefinition, element.getAttribute("build-file"), "buildFilePath");

    Element executeElement = DomUtils.getChildElementByTagName(element, "execute");
    BeanDefinitionParserUtils.setPropertyValue(
        beanDefinition, executeElement.getAttribute("target"), "target");
    BeanDefinitionParserUtils.setPropertyValue(
        beanDefinition, executeElement.getAttribute("targets"), "targets");

    Properties properties = new Properties();
    Element propertiesElement = DomUtils.getChildElementByTagName(element, "properties");
    if (propertiesElement != null) {
      BeanDefinitionParserUtils.setPropertyValue(
          beanDefinition, propertiesElement.getAttribute("file"), "propertyFilePath");

      List<?> propertyElements = DomUtils.getChildElementsByTagName(propertiesElement, "property");
      if (propertyElements.size() > 0) {
        for (Iterator<?> iter = propertyElements.iterator(); iter.hasNext(); ) {
          Element propertyElement = (Element) iter.next();
          properties.put(
              propertyElement.getAttribute("name"), propertyElement.getAttribute("value"));
        }

        beanDefinition.addPropertyValue("properties", properties);
      }
    }

    BeanDefinitionParserUtils.setPropertyReference(
        beanDefinition, element.getAttribute("build-listener"), "buildListener");

    beanDefinition.addPropertyValue("name", element.getLocalName());

    return beanDefinition.getBeanDefinition();
  }
示例#28
0
    @Override
    protected void doParse(
        Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
      super.doParse(element, parserContext, builder);
      Set<String> paths = new HashSet<String>();
      List<Map<String, Object>> xmlDataList = new ArrayList<Map<String, Object>>();
      String privilegeBean = null;
      /*List<Element> childElts = DomUtils.getChildElements(element);
      for (Element elt: childElts) {
          String localName = parserContext.getDelegate().getLocalName(elt);
          if (PATHS_ELEMENT.equals(localName)) {
              annotationScan = true;
              parsePathsElement(elt, parserContext, paths);
          } else if (CLASS_ELEMENT.equals(localName)) {
              parseClassElement(elt, parserContext, xmlDataList);
          } else if (PRIVILEGE_ELEMENT.equals(localName)) {
              privilegeBean = elt.getAttribute("ref");
          }
      }*/
      Element pathsElement = DomUtils.getChildElementByTagName(element, PATHS_ELEMENT);
      if (pathsElement != null) {
        parsePathsElement(pathsElement, parserContext, paths);
      }
      Element classElement = DomUtils.getChildElementByTagName(element, CLASS_ELEMENT);
      if (classElement != null) {
        parseClassElement(classElement, parserContext, xmlDataList);
      }
      Element privilegeElement = DomUtils.getChildElementByTagName(element, PRIVILEGE_ELEMENT);
      if (privilegeElement != null) {
        privilegeBean = privilegeElement.getAttribute("ref");
        builder.addPropertyReference("imtPrivilege", privilegeBean);
      }

      builder.addPropertyValue("annotationScan", annotationScan);
      builder.addPropertyValue("paths", paths);
      builder.addPropertyValue("xmlDataList", xmlDataList);
      builder.addPropertyValue("beanAdapter", new SpringBeanAdapter());
      builder.addPropertyValue("scanner", new SpringClassScanner());
      builder.setInitMethodName("init");
    }
示例#29
0
  public Document getDocument() {
    if (document == null) {
      return null;
    }

    Element documentElement = document.getDocumentElement();
    Element entityEle = DomUtils.getChildElementByTagName(documentElement, "entity");

    Document retXmlDoc = UtilXml.makeEmptyXmlDocument(entityEle.getAttribute("name"));

    List<Element> fieldEles = DomUtils.getChildElementsByTagName(entityEle, "field");
    for (Element fieldEle : fieldEles) {
      String name = fieldEle.getAttribute("name");
      String type = fieldEle.getAttribute("type");

      Element namedFieldEl = retXmlDoc.createElement(name);
      namedFieldEl.setAttribute("type", type);
      retXmlDoc.getDocumentElement().appendChild(namedFieldEl);
    }

    return retXmlDoc;
  }
  /**
   * @param storedProcComponent
   * @param parserContext
   */
  public static ManagedList<BeanDefinition> getProcedureParameterBeanDefinitions(
      Element storedProcComponent, ParserContext parserContext) {

    ManagedList<BeanDefinition> procedureParameterList = new ManagedList<BeanDefinition>();

    List<Element> parameterChildElements =
        DomUtils.getChildElementsByTagName(storedProcComponent, "parameter");

    for (Element childElement : parameterChildElements) {

      BeanDefinitionBuilder parameterBuilder =
          BeanDefinitionBuilder.genericBeanDefinition(ProcedureParameter.class);

      String name = childElement.getAttribute("name");
      String expression = childElement.getAttribute("expression");
      String value = childElement.getAttribute("value");
      String type = childElement.getAttribute("type");

      if (StringUtils.hasText(name)) {
        parameterBuilder.addPropertyValue("name", name);
      }

      if (StringUtils.hasText(expression)) {
        parameterBuilder.addPropertyValue("expression", expression);
      }

      if (StringUtils.hasText(value)) {

        if (!StringUtils.hasText(type)) {

          if (LOGGER.isInfoEnabled()) {
            LOGGER.info(
                String.format(
                    "Type attribute not set for Store "
                        + "Procedure parameter '%s'. Defaulting to "
                        + "'java.lang.String'.",
                    value));
          }

          parameterBuilder.addPropertyValue("value", new TypedStringValue(value, String.class));

        } else {
          parameterBuilder.addPropertyValue("value", new TypedStringValue(value, type));
        }
      }

      procedureParameterList.add(parameterBuilder.getBeanDefinition());
    }

    return procedureParameterList;
  }