Esempio n. 1
0
  /**
   * Processes a new {@link Trigger} being added. Currently, it supports adding {@link
   * CronTrigger}s. The {@link Trigger} is added to the common {@link
   * ConfigurableApplicationContext}.
   */
  @Override
  public void preProcessModule(Module module) {
    if (!TRIGGER.equals(module.getType())) {
      return;
    }
    Assert.notNull(
        commonApplicationContext, "The 'commonApplicationContext' property must not be null.");

    Map<String, Trigger> triggers = new HashMap<String, Trigger>();
    if (module.getProperties().containsKey(TriggerType.cron.name())) {
      Trigger trigger =
          new CronTrigger(module.getProperties().getProperty(TriggerType.cron.name()));
      triggers.put(TriggerType.cron.name(), trigger);
    }
    if (module.getProperties().containsKey(TriggerType.fixedDelay.name())) {
      Trigger trigger =
          new PeriodicTrigger(
              Long.parseLong(module.getProperties().getProperty(TriggerType.fixedDelay.name())));
      triggers.put(TriggerType.fixedDelay.name(), trigger);
    }
    if (module.getProperties().containsKey(TriggerType.fixedRate.name())) {
      PeriodicTrigger trigger =
          new PeriodicTrigger(
              Long.parseLong(module.getProperties().getProperty(TriggerType.fixedRate.name())));
      trigger.setFixedRate(true);
      triggers.put(TriggerType.fixedRate.name(), trigger);
    }
    if (triggers.size() == 0) {
      throw new ResourceDefinitionException(
          "No valid trigger property. Expected one of: cron, fixedDelay or fixedRate");
    } else if (triggers.size() > 1) {
      throw new ResourceDefinitionException(
          "Only one trigger property allowed, but received: "
              + StringUtils.collectionToCommaDelimitedString(triggers.keySet()));
    }
    commonApplicationContext
        .getBeanFactory()
        .registerSingleton(makeTriggerBeanName(module), triggers.values().iterator().next());
    configureProperties(module);
  }
  protected void configurePollingEndpoint(
      AbstractPollingEndpoint pollingEndpoint, List<Annotation> annotations) {
    PollerMetadata pollerMetadata = null;
    Poller[] pollers =
        MessagingAnnotationUtils.resolveAttribute(annotations, "poller", Poller[].class);
    if (!ObjectUtils.isEmpty(pollers)) {
      Assert.state(
          pollers.length == 1,
          "The 'poller' for an Annotation-based endpoint can have only one '@Poller'.");
      Poller poller = pollers[0];

      String ref = poller.value();
      String triggerRef = poller.trigger();
      String executorRef = poller.taskExecutor();
      String fixedDelayValue = this.beanFactory.resolveEmbeddedValue(poller.fixedDelay());
      String fixedRateValue = this.beanFactory.resolveEmbeddedValue(poller.fixedRate());
      String maxMessagesPerPollValue =
          this.beanFactory.resolveEmbeddedValue(poller.maxMessagesPerPoll());
      String cron = this.beanFactory.resolveEmbeddedValue(poller.cron());
      String errorChannel = this.beanFactory.resolveEmbeddedValue(poller.errorChannel());

      if (StringUtils.hasText(ref)) {
        Assert.state(
            !StringUtils.hasText(triggerRef)
                && !StringUtils.hasText(executorRef)
                && !StringUtils.hasText(cron)
                && !StringUtils.hasText(fixedDelayValue)
                && !StringUtils.hasText(fixedRateValue)
                && !StringUtils.hasText(maxMessagesPerPollValue),
            "The '@Poller' 'ref' attribute is mutually exclusive with other attributes.");
        pollerMetadata = this.beanFactory.getBean(ref, PollerMetadata.class);
      } else {
        pollerMetadata = new PollerMetadata();
        if (StringUtils.hasText(maxMessagesPerPollValue)) {
          pollerMetadata.setMaxMessagesPerPoll(Long.parseLong(maxMessagesPerPollValue));
        } else if (pollingEndpoint instanceof SourcePollingChannelAdapter) {
          // SPCAs default to 1 message per poll
          pollerMetadata.setMaxMessagesPerPoll(1);
        }

        if (StringUtils.hasText(executorRef)) {
          pollerMetadata.setTaskExecutor(this.beanFactory.getBean(executorRef, TaskExecutor.class));
        }

        Trigger trigger = null;
        if (StringUtils.hasText(triggerRef)) {
          Assert.state(
              !StringUtils.hasText(cron)
                  && !StringUtils.hasText(fixedDelayValue)
                  && !StringUtils.hasText(fixedRateValue),
              "The '@Poller' 'trigger' attribute is mutually exclusive with other attributes.");
          trigger = this.beanFactory.getBean(triggerRef, Trigger.class);
        } else if (StringUtils.hasText(cron)) {
          Assert.state(
              !StringUtils.hasText(fixedDelayValue) && !StringUtils.hasText(fixedRateValue),
              "The '@Poller' 'cron' attribute is mutually exclusive with other attributes.");
          trigger = new CronTrigger(cron);
        } else if (StringUtils.hasText(fixedDelayValue)) {
          Assert.state(
              !StringUtils.hasText(fixedRateValue),
              "The '@Poller' 'fixedDelay' attribute is mutually exclusive with other attributes.");
          trigger = new PeriodicTrigger(Long.parseLong(fixedDelayValue));
        } else if (StringUtils.hasText(fixedRateValue)) {
          trigger = new PeriodicTrigger(Long.parseLong(fixedRateValue));
          ((PeriodicTrigger) trigger).setFixedRate(true);
        }
        // 'Trigger' can be null. 'PollingConsumer' does fallback to the 'new PeriodicTrigger(10)'.
        pollerMetadata.setTrigger(trigger);

        if (StringUtils.hasText(errorChannel)) {
          MessagePublishingErrorHandler errorHandler = new MessagePublishingErrorHandler();
          errorHandler.setDefaultErrorChannelName(errorChannel);
          errorHandler.setBeanFactory(this.beanFactory);
          pollerMetadata.setErrorHandler(errorHandler);
        }
      }
    } else {
      pollerMetadata = PollerMetadata.getDefaultPollerMetadata(this.beanFactory);
      Assert.notNull(
          pollerMetadata,
          "No poller has been defined for Annotation-based endpoint, "
              + "and no default poller is available within the context.");
    }
    pollingEndpoint.setTaskExecutor(pollerMetadata.getTaskExecutor());
    pollingEndpoint.setTrigger(pollerMetadata.getTrigger());
    pollingEndpoint.setAdviceChain(pollerMetadata.getAdviceChain());
    pollingEndpoint.setMaxMessagesPerPoll(pollerMetadata.getMaxMessagesPerPoll());
    pollingEndpoint.setErrorHandler(pollerMetadata.getErrorHandler());
    if (pollingEndpoint instanceof PollingConsumer) {
      ((PollingConsumer) pollingEndpoint).setReceiveTimeout(pollerMetadata.getReceiveTimeout());
    }
    pollingEndpoint.setTransactionSynchronizationFactory(
        pollerMetadata.getTransactionSynchronizationFactory());
  }