Examples with NameMatchMethodPointcutAdvisor org.springframework.aop.support.NameMatchMethodPointcutAdvisor used on opensource projects

Example 1 with NameMatchMethodPointcutAdvisor

use of org.springframework.aop.support.NameMatchMethodPointcutAdvisor in project spring-cloud-stream by spring-cloud.

the class DefaultPollableMessageSource method setSource.

public void setSource(MessageSource<?> source) {
    ProxyFactory pf = new ProxyFactory(source);
    class ReceiveAdvice implements MethodInterceptor {

        private final List<ChannelInterceptor> interceptors = new ArrayList<>();

        @Override
        public Object invoke(MethodInvocation invocation) throws Throwable {
            Object result = invocation.proceed();
            if (result instanceof Message) {
                Message<?> received = (Message<?>) result;
                for (ChannelInterceptor interceptor : this.interceptors) {
                    received = interceptor.preSend(received, null);
                    if (received == null) {
                        return null;
                    }
                }
                return received;
            }
            return result;
        }
    }
    final ReceiveAdvice advice = new ReceiveAdvice();
    advice.interceptors.addAll(this.interceptors);
    NameMatchMethodPointcutAdvisor sourceAdvisor = new NameMatchMethodPointcutAdvisor(advice);
    sourceAdvisor.addMethodName("receive");
    pf.addAdvisor(sourceAdvisor);
    this.source = (MessageSource<?>) pf.getProxy();
}

Example 2 with NameMatchMethodPointcutAdvisor

use of org.springframework.aop.support.NameMatchMethodPointcutAdvisor in project spring-integration by spring-projects.

the class AbstractMethodAnnotationPostProcessor method postProcess.

@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);
        if (handler instanceof ReplyProducingMessageHandlerWrapper && StringUtils.hasText(MessagingAnnotationUtils.endpointIdValue(method))) {
            handlerBeanName = handlerBeanName + ".wrapper";
        }
        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;
}

Example 3 with NameMatchMethodPointcutAdvisor

use of org.springframework.aop.support.NameMatchMethodPointcutAdvisor in project spring-integration by spring-projects.

the class SourcePollingChannelAdapter method adviceToReceiveAdvisor.

private NameMatchMethodPointcutAdvisor adviceToReceiveAdvisor(Advice advice) {
    NameMatchMethodPointcutAdvisor sourceAdvisor = new NameMatchMethodPointcutAdvisor(advice);
    sourceAdvisor.addMethodName("receive");
    return sourceAdvisor;
}

Example 4 with NameMatchMethodPointcutAdvisor

use of org.springframework.aop.support.NameMatchMethodPointcutAdvisor in project spring-integration by spring-projects.

the class ConsumerEndpointFactoryBean method afterPropertiesSet.

@Override
public void afterPropertiesSet() throws Exception {
    if (this.beanName == null) {
        logger.error("The MessageHandler [" + this.handler + "] will be created without a 'componentName'. " + "Consider specifying the 'beanName' property on this ConsumerEndpointFactoryBean.");
    } else {
        try {
            if (!this.beanName.startsWith("org.springframework")) {
                MessageHandler targetHandler = this.handler;
                if (AopUtils.isAopProxy(targetHandler)) {
                    Object target = ((Advised) targetHandler).getTargetSource().getTarget();
                    if (target instanceof MessageHandler) {
                        targetHandler = (MessageHandler) target;
                    }
                }
                if (targetHandler instanceof IntegrationObjectSupport) {
                    ((IntegrationObjectSupport) targetHandler).setComponentName(this.beanName);
                }
            }
        } catch (Exception e) {
            if (logger.isDebugEnabled()) {
                logger.debug("Could not set component name for handler " + this.handler + " for " + this.beanName + " :" + e.getMessage());
            }
        }
    }
    if (!CollectionUtils.isEmpty(this.adviceChain)) {
        /*
			 *  ARPMHs advise the handleRequestMessage method internally and already have the advice chain injected.
			 *  So we only advise handlers that are not reply-producing.
			 *  Or if one (or more) of advices is IdempotentReceiverInterceptor.
			 *  If the handler is already advised,
			 *  add the configured advices to its chain, otherwise create a proxy.
			 */
        Class<?> targetClass = AopUtils.getTargetClass(this.handler);
        boolean replyMessageHandler = AbstractReplyProducingMessageHandler.class.isAssignableFrom(targetClass);
        for (Advice advice : this.adviceChain) {
            if (!replyMessageHandler || advice instanceof HandleMessageAdvice) {
                NameMatchMethodPointcutAdvisor handlerAdvice = new NameMatchMethodPointcutAdvisor(advice);
                handlerAdvice.addMethodName("handleMessage");
                if (this.handler instanceof Advised) {
                    ((Advised) this.handler).addAdvisor(handlerAdvice);
                } else {
                    ProxyFactory proxyFactory = new ProxyFactory(this.handler);
                    proxyFactory.addAdvisor(handlerAdvice);
                    this.handler = (MessageHandler) proxyFactory.getProxy(this.beanClassLoader);
                }
            }
        }
    }
    if (this.channelResolver == null) {
        this.channelResolver = new BeanFactoryMessageChannelDestinationResolver(this.beanFactory);
    }
    initializeEndpoint();
}

Example 5 with NameMatchMethodPointcutAdvisor

use of org.springframework.aop.support.NameMatchMethodPointcutAdvisor in project spring-integration by spring-projects.

the class MessageMetricsAdviceTests method exportAdvisedHandler.

@Test
public void exportAdvisedHandler() throws Exception {
    DummyInterceptor interceptor = new DummyInterceptor();
    NameMatchMethodPointcutAdvisor advisor = new NameMatchMethodPointcutAdvisor(interceptor);
    advisor.addMethodName("handleMessage");
    ProxyFactory factory = new ProxyFactory(this.handler);
    factory.addAdvisor(advisor);
    MessageHandler advised = (MessageHandler) factory.getProxy();
    this.beanFactory.registerSingleton("test", advised);
    this.beanFactory.initializeBean(advised, "test");
    mBeanExporter.afterSingletonsInstantiated();
    MessageHandler exported = this.beanFactory.getBean("test", MessageHandler.class);
    exported.handleMessage(MessageBuilder.withPayload("test").build());
}