protected void setOutputChannelIfPresent(
     List<Annotation> annotations, AbstractReplyProducingMessageHandler handler) {
   String outputChannelName =
       MessagingAnnotationUtils.resolveAttribute(annotations, "outputChannel", String.class);
   if (StringUtils.hasText(outputChannelName)) {
     handler.setOutputChannelName(outputChannelName);
   }
 }
 @Override
 public final void onInit() {
   super.onInit();
   if (this.selector instanceof AbstractMessageProcessingSelector) {
     ((AbstractMessageProcessingSelector) this.selector)
         .setConversionService(this.getConversionService());
   }
   if (this.selector instanceof BeanFactoryAware) {
     ((BeanFactoryAware) this.selector).setBeanFactory(this.getBeanFactory());
   }
 }
 protected final void setAdviceChainIfPresent(
     String beanName, T annotation, MessageHandler handler) {
   String[] adviceChainNames =
       (String[]) AnnotationUtils.getValue(annotation, ADVICE_CHAIN_ATTRIBUTE);
   if (adviceChainNames != null && adviceChainNames.length > 0) {
     if (!(handler instanceof AbstractReplyProducingMessageHandler)) {
       throw new IllegalArgumentException(
           "Cannot apply advice chain to " + handler.getClass().getName());
     }
     List<Advice> adviceChain = new ArrayList<Advice>();
     for (String adviceChainName : adviceChainNames) {
       Object adviceChainBean = this.beanFactory.getBean(adviceChainName);
       if (adviceChainBean instanceof Advice) {
         adviceChain.add((Advice) adviceChainBean);
       } else if (adviceChainBean instanceof Advice[]) {
         for (Advice advice : (Advice[]) adviceChainBean) {
           adviceChain.add(advice);
         }
       } else if (adviceChainBean instanceof Collection) {
         @SuppressWarnings("unchecked")
         Collection<Advice> adviceChainEntries = (Collection<Advice>) adviceChainBean;
         for (Advice advice : adviceChainEntries) {
           adviceChain.add(advice);
         }
       } else {
         throw new IllegalArgumentException(
             "Invalid advice chain type:"
                 + adviceChainName.getClass().getName()
                 + " for bean '"
                 + beanName
                 + "'");
       }
     }
     ((AbstractReplyProducingMessageHandler) handler).setAdviceChain(adviceChain);
   }
 }
  @Override
  public Object postProcess(
      Object bean, String beanName, Method method, List<Annotation> annotations) {
    if (this.beanAnnotationAware()
        && AnnotatedElementUtils.isAnnotated(method, Bean.class.getName())) {
      try {
        resolveTargetBeanFromMethodWithBeanAnnotation(method);
      } catch (NoSuchBeanDefinitionException e) {
        if (this.logger.isDebugEnabled()) {
          this.logger.debug(
              "Skipping endpoint creation; "
                  + e.getMessage()
                  + "; perhaps due to some '@Conditional' annotation.");
        }
        return null;
      }
    }

    List<Advice> adviceChain = extractAdviceChain(beanName, annotations);

    MessageHandler handler = createHandler(bean, method, annotations);

    if (!CollectionUtils.isEmpty(adviceChain)
        && handler instanceof AbstractReplyProducingMessageHandler) {
      ((AbstractReplyProducingMessageHandler) handler).setAdviceChain(adviceChain);
    }

    if (handler instanceof Orderable) {
      Order orderAnnotation = AnnotationUtils.findAnnotation(method, Order.class);
      if (orderAnnotation != null) {
        ((Orderable) handler).setOrder(orderAnnotation.value());
      }
    }
    if (handler instanceof AbstractMessageProducingHandler
        || handler instanceof AbstractMessageRouter) {
      String sendTimeout =
          MessagingAnnotationUtils.resolveAttribute(annotations, "sendTimeout", String.class);
      if (sendTimeout != null) {
        Long value = Long.valueOf(this.beanFactory.resolveEmbeddedValue(sendTimeout));
        if (handler instanceof AbstractMessageProducingHandler) {
          ((AbstractMessageProducingHandler) handler).setSendTimeout(value);
        } else {
          ((AbstractMessageRouter) handler).setSendTimeout(value);
        }
      }
    }

    boolean handlerExists = false;
    if (this.beanAnnotationAware()
        && AnnotatedElementUtils.isAnnotated(method, Bean.class.getName())) {
      Object handlerBean = this.resolveTargetBeanFromMethodWithBeanAnnotation(method);
      handlerExists = handlerBean != null && handler == handlerBean;
    }

    if (!handlerExists) {
      String handlerBeanName = generateHandlerBeanName(beanName, method);
      this.beanFactory.registerSingleton(handlerBeanName, handler);
      handler = (MessageHandler) this.beanFactory.initializeBean(handler, handlerBeanName);
    }

    if (AnnotatedElementUtils.isAnnotated(method, IdempotentReceiver.class.getName())
        && !AnnotatedElementUtils.isAnnotated(method, Bean.class.getName())) {
      String[] interceptors =
          AnnotationUtils.getAnnotation(method, IdempotentReceiver.class).value();
      for (String interceptor : interceptors) {
        DefaultBeanFactoryPointcutAdvisor advisor = new DefaultBeanFactoryPointcutAdvisor();
        advisor.setAdviceBeanName(interceptor);
        NameMatchMethodPointcut pointcut = new NameMatchMethodPointcut();
        pointcut.setMappedName("handleMessage");
        advisor.setPointcut(pointcut);
        advisor.setBeanFactory(this.beanFactory);

        if (handler instanceof Advised) {
          ((Advised) handler).addAdvisor(advisor);
        } else {
          ProxyFactory proxyFactory = new ProxyFactory(handler);
          proxyFactory.addAdvisor(advisor);
          handler = (MessageHandler) proxyFactory.getProxy(this.beanFactory.getBeanClassLoader());
        }
      }
    }

    if (!CollectionUtils.isEmpty(adviceChain)) {
      for (Advice advice : adviceChain) {
        if (advice instanceof HandleMessageAdvice) {
          NameMatchMethodPointcutAdvisor handlerAdvice = new NameMatchMethodPointcutAdvisor(advice);
          handlerAdvice.addMethodName("handleMessage");
          if (handler instanceof Advised) {
            ((Advised) handler).addAdvisor(handlerAdvice);
          } else {
            ProxyFactory proxyFactory = new ProxyFactory(handler);
            proxyFactory.addAdvisor(handlerAdvice);
            handler = (MessageHandler) proxyFactory.getProxy(this.beanFactory.getBeanClassLoader());
          }
        }
      }
    }

    AbstractEndpoint endpoint = createEndpoint(handler, method, annotations);
    if (endpoint != null) {
      return endpoint;
    }
    return handler;
  }
 @Override
 protected void onInit() {
   super.onInit();
   this.jpaExecutor.setBeanFactory(this.getBeanFactory());
 }