Examples with MessageProducer org.springframework.integration.core.MessageProducer used on opensource projects

Example 1 with MessageProducer

use of org.springframework.integration.core.MessageProducer in project spring-integration by spring-projects.

the class AbstractSimpleMessageHandlerFactoryBean method createHandlerInternal.

protected final H createHandlerInternal() {
    synchronized (this.initializationMonitor) {
        if (this.initialized) {
            // There was a problem when this method was called already
            return null;
        }
        this.handler = createHandler();
        if (this.handler instanceof ApplicationContextAware && this.applicationContext != null) {
            ((ApplicationContextAware) this.handler).setApplicationContext(this.applicationContext);
        }
        if (this.handler instanceof BeanFactoryAware && getBeanFactory() != null) {
            ((BeanFactoryAware) this.handler).setBeanFactory(getBeanFactory());
        }
        if (this.handler instanceof BeanNameAware && this.beanName != null) {
            ((BeanNameAware) this.handler).setBeanName(this.beanName);
        }
        if (this.handler instanceof ApplicationEventPublisherAware && this.applicationEventPublisher != null) {
            ((ApplicationEventPublisherAware) this.handler).setApplicationEventPublisher(this.applicationEventPublisher);
        }
        if (this.handler instanceof MessageProducer && this.outputChannel != null) {
            ((MessageProducer) this.handler).setOutputChannel(this.outputChannel);
        }
        Object actualHandler = extractTarget(this.handler);
        if (actualHandler == null) {
            actualHandler = this.handler;
        }
        if (actualHandler instanceof IntegrationObjectSupport) {
            if (this.componentName != null) {
                ((IntegrationObjectSupport) actualHandler).setComponentName(this.componentName);
            }
            if (this.channelResolver != null) {
                ((IntegrationObjectSupport) actualHandler).setChannelResolver(this.channelResolver);
            }
        }
        if (!CollectionUtils.isEmpty(this.adviceChain)) {
            if (actualHandler instanceof AbstractReplyProducingMessageHandler) {
                ((AbstractReplyProducingMessageHandler) actualHandler).setAdviceChain(this.adviceChain);
            } else if (this.logger.isDebugEnabled()) {
                String name = this.componentName;
                if (name == null && actualHandler instanceof NamedComponent) {
                    name = ((NamedComponent) actualHandler).getComponentName();
                }
                this.logger.debug("adviceChain can only be set on an AbstractReplyProducingMessageHandler" + (name == null ? "" : (", " + name)) + ".");
            }
        }
        if (this.async != null) {
            if (actualHandler instanceof AbstractMessageProducingHandler) {
                ((AbstractMessageProducingHandler) actualHandler).setAsync(this.async);
            }
        }
        if (this.handler instanceof Orderable && this.order != null) {
            ((Orderable) this.handler).setOrder(this.order);
        }
        this.initialized = true;
    }
    if (this.handler instanceof InitializingBean) {
        try {
            ((InitializingBean) this.handler).afterPropertiesSet();
        } catch (Exception e) {
            throw new BeanInitializationException("failed to initialize MessageHandler", e);
        }
    }
    return this.handler;
}

Example 2 with MessageProducer

use of org.springframework.integration.core.MessageProducer in project spring-integration by spring-projects.

the class ScatterGatherHandler method doInit.

@Override
protected void doInit() {
    if (this.gatherChannel == null) {
        this.gatherChannel = new FixedSubscriberChannel(this.gatherer);
    } else {
        if (this.gatherChannel instanceof SubscribableChannel) {
            this.gatherEndpoint = new EventDrivenConsumer((SubscribableChannel) this.gatherChannel, this.gatherer);
        } else if (this.gatherChannel instanceof PollableChannel) {
            this.gatherEndpoint = new PollingConsumer((PollableChannel) this.gatherChannel, this.gatherer);
            ((PollingConsumer) this.gatherEndpoint).setReceiveTimeout(this.gatherTimeout);
        } else {
            throw new MessagingException("Unsupported 'replyChannel' type [" + this.gatherChannel.getClass() + "]." + "SubscribableChannel or PollableChannel type are supported.");
        }
        this.gatherEndpoint.setBeanFactory(this.getBeanFactory());
        this.gatherEndpoint.afterPropertiesSet();
    }
    ((MessageProducer) this.gatherer).setOutputChannel(new FixedSubscriberChannel(message -> {
        MessageHeaders headers = message.getHeaders();
        if (headers.containsKey(GATHER_RESULT_CHANNEL)) {
            Object gatherResultChannel = headers.get(GATHER_RESULT_CHANNEL);
            if (gatherResultChannel instanceof MessageChannel) {
                messagingTemplate.send((MessageChannel) gatherResultChannel, message);
            } else if (gatherResultChannel instanceof String) {
                messagingTemplate.send((String) gatherResultChannel, message);
            }
        } else {
            throw new MessageDeliveryException(message, "The 'gatherResultChannel' header is required to delivery gather result.");
        }
    }));
    this.replyChannelRegistry = getBeanFactory().getBean(IntegrationContextUtils.INTEGRATION_HEADER_CHANNEL_REGISTRY_BEAN_NAME, HeaderChannelRegistry.class);
}

Example 3 with MessageProducer

use of org.springframework.integration.core.MessageProducer in project spring-cloud-stream by spring-cloud.

the class AbstractMessageChannelBinder method doBindConsumer.

/**
 * Binds an inbound channel to a given destination. The implementation delegates to
 * {@link ProvisioningProvider#provisionConsumerDestination(String, String, ConsumerProperties)}
 * and
 * {@link #createConsumerEndpoint(ConsumerDestination, String, ConsumerProperties)}
 * for handling middleware-specific logic. If the returned consumer endpoint is an
 * {@link InitializingBean} then {@link InitializingBean#afterPropertiesSet()} will be
 * called on it. Similarly, if the returned consumer endpoint is a {@link Lifecycle},
 * then {@link Lifecycle#start()} will be called on it.
 *
 * @param name the name of the destination
 * @param group the consumer group
 * @param inputChannel the channel to be bound
 * @param properties the {@link ConsumerProperties} of the binding
 * @return the Binding for the channel
 * @throws BinderException on internal errors during binding
 */
@Override
public final Binding<MessageChannel> doBindConsumer(String name, String group, MessageChannel inputChannel, final C properties) throws BinderException {
    MessageProducer consumerEndpoint = null;
    try {
        ConsumerDestination destination = this.provisioningProvider.provisionConsumerDestination(name, group, properties);
        if (HeaderMode.embeddedHeaders.equals(properties.getHeaderMode())) {
            enhanceMessageChannel(inputChannel);
        }
        consumerEndpoint = createConsumerEndpoint(destination, group, properties);
        consumerEndpoint.setOutputChannel(inputChannel);
        if (consumerEndpoint instanceof InitializingBean) {
            ((InitializingBean) consumerEndpoint).afterPropertiesSet();
        }
        if (consumerEndpoint instanceof Lifecycle) {
            ((Lifecycle) consumerEndpoint).start();
        }
        Binding<MessageChannel> binding = new DefaultBinding<MessageChannel>(name, group, inputChannel, consumerEndpoint instanceof Lifecycle ? (Lifecycle) consumerEndpoint : null) {

            @Override
            public Map<String, Object> getExtendedInfo() {
                return doGetExtendedInfo(destination, properties);
            }

            @Override
            protected void afterUnbind() {
                try {
                    if (getEndpoint() instanceof DisposableBean) {
                        ((DisposableBean) getEndpoint()).destroy();
                    }
                } catch (Exception e) {
                    AbstractMessageChannelBinder.this.logger.error("Exception thrown while unbinding " + toString(), e);
                }
                afterUnbindConsumer(destination, this.group, properties);
                destroyErrorInfrastructure(destination, group, properties);
            }
        };
        doPublishEvent(new BindingCreatedEvent(binding));
        return binding;
    } catch (Exception e) {
        if (consumerEndpoint instanceof Lifecycle) {
            ((Lifecycle) consumerEndpoint).stop();
        }
        if (e instanceof BinderException) {
            throw (BinderException) e;
        } else if (e instanceof ProvisioningException) {
            throw (ProvisioningException) e;
        } else {
            throw new BinderException("Exception thrown while starting consumer: ", e);
        }
    }
}

Example 4 with MessageProducer

use of org.springframework.integration.core.MessageProducer in project spring-cloud-stream by spring-cloud.

the class AbstractMessageChannelBinderTests method testEndpointLifecycle.

@Test
@SuppressWarnings({ "rawtypes", "unchecked" })
public void testEndpointLifecycle() throws Exception {
    AbstractMessageChannelBinder<ConsumerProperties, ProducerProperties, ProvisioningProvider<ConsumerProperties, ProducerProperties>> binder = context.getBean(AbstractMessageChannelBinder.class);
    ConsumerProperties consumerProperties = new ConsumerProperties();
    // to force error infrastructure creation
    consumerProperties.setMaxAttempts(1);
    Binding<MessageChannel> consumerBinding = binder.bindConsumer("foo", "fooGroup", new DirectChannel(), consumerProperties);
    DirectFieldAccessor consumerBindingAccessor = new DirectFieldAccessor(consumerBinding);
    MessageProducer messageProducer = (MessageProducer) consumerBindingAccessor.getPropertyValue("lifecycle");
    assertTrue(((Lifecycle) messageProducer).isRunning());
    assertNotNull(messageProducer.getOutputChannel());
    SubscribableChannel errorChannel = (SubscribableChannel) consumerBindingAccessor.getPropertyValue("lifecycle.errorChannel");
    assertThat(errorChannel).isNotNull();
    Set<MessageHandler> handlers = TestUtils.getPropertyValue(errorChannel, "dispatcher.handlers", Set.class);
    assertThat(handlers.size()).isEqualTo(2);
    Iterator<MessageHandler> iterator = handlers.iterator();
    assertThat(iterator.next()).isInstanceOf(BridgeHandler.class);
    assertThat(iterator.next()).isInstanceOf(LastSubscriberMessageHandler.class);
    assertThat(context.containsBean("foo.fooGroup.errors")).isTrue();
    assertThat(context.containsBean("foo.fooGroup.errors.recoverer")).isTrue();
    assertThat(context.containsBean("foo.fooGroup.errors.handler")).isTrue();
    assertThat(context.containsBean("foo.fooGroup.errors.bridge")).isTrue();
    consumerBinding.unbind();
    assertThat(context.containsBean("foo.fooGroup.errors")).isFalse();
    assertThat(context.containsBean("foo.fooGroup.errors.recoverer")).isFalse();
    assertThat(context.containsBean("foo.fooGroup.errors.handler")).isFalse();
    assertThat(context.containsBean("foo.fooGroup.errors.bridge")).isFalse();
    assertFalse(((Lifecycle) messageProducer).isRunning());
    ProducerProperties producerProps = new ProducerProperties();
    producerProps.setErrorChannelEnabled(true);
    Binding<MessageChannel> producerBinding = binder.bindProducer("bar", new DirectChannel(), producerProps);
    assertThat(context.containsBean("bar.errors")).isTrue();
    assertThat(context.containsBean("bar.errors.bridge")).isTrue();
    producerBinding.unbind();
    assertThat(context.containsBean("bar.errors")).isFalse();
    assertThat(context.containsBean("bar.errors.bridge")).isFalse();
}

Example 5 with MessageProducer

use of org.springframework.integration.core.MessageProducer in project spring-integration by spring-projects.

the class MessageHandlerChain method configureChain.

private void configureChain() {
    Assert.isTrue(this.handlers.size() == new HashSet<MessageHandler>(this.handlers).size(), "duplicate handlers are not allowed in a chain");
    for (int i = 0; i < this.handlers.size(); i++) {
        MessageHandler handler = this.handlers.get(i);
        if (i < this.handlers.size() - 1) {
            // not the last handler
            Assert.isInstanceOf(MessageProducer.class, handler, "All handlers except for " + "the last one in the chain must implement the MessageProducer interface.");
            MessageHandler nextHandler = this.handlers.get(i + 1);
            MessageChannel nextChannel = (message, timeout) -> {
                nextHandler.handleMessage(message);
                return true;
            };
            ((MessageProducer) handler).setOutputChannel(nextChannel);
            // to 'force' re-init it for check its configuration in conjunction with current MessageHandlerChain.
            if (handler instanceof MessageHandlerChain) {
                ((MessageHandlerChain) handler).initialized = false;
                ((MessageHandlerChain) handler).afterPropertiesSet();
            }
        } else if (handler instanceof MessageProducer) {
            MessageChannel replyChannel = new ReplyForwardingMessageChannel();
            ((MessageProducer) handler).setOutputChannel(replyChannel);
        } else {
            Assert.isNull(getOutputChannel(), "An output channel was provided, but the final handler in " + "the chain does not implement the MessageProducer interface.");
        }
    }
}