コード例 #1
0
 private void bridgePollableToSubscribableChannel(
     MessageChannel pollableChannel, MessageChannel subscribableChannel) {
   ConsumerEndpointFactoryBean consumerEndpointFactoryBean = new ConsumerEndpointFactoryBean();
   consumerEndpointFactoryBean.setInputChannel(pollableChannel);
   PollerMetadata pollerMetadata = new PollerMetadata();
   pollerMetadata.setTrigger(new PeriodicTrigger(pollableBridgeDefaultFrequency));
   consumerEndpointFactoryBean.setPollerMetadata(pollerMetadata);
   consumerEndpointFactoryBean.setHandler(
       new MessageChannelBinderSupport.DirectHandler(subscribableChannel));
   consumerEndpointFactoryBean.setBeanFactory(beanFactory);
   try {
     consumerEndpointFactoryBean.afterPropertiesSet();
   } catch (Exception e) {
     throw new IllegalStateException(e);
   }
   consumerEndpointFactoryBean.start();
 }
  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());
  }
コード例 #3
0
 @Bean
 public PollerMetadata myPoller() {
   PollerMetadata pollerMetadata = new PollerMetadata();
   pollerMetadata.setTrigger(new PeriodicTrigger(11));
   return pollerMetadata;
 }
コード例 #4
0
 @Bean(name = PollerMetadata.DEFAULT_POLLER)
 public PollerMetadata defaultPoller() {
   PollerMetadata pollerMetadata = new PollerMetadata();
   pollerMetadata.setTrigger(new PeriodicTrigger(10));
   return pollerMetadata;
 }