Examples with InitializingBean org.springframework.beans.factory.InitializingBean used on opensource projects

Example 11 with InitializingBean

use of org.springframework.beans.factory.InitializingBean in project cuba by cuba-platform.

the class ActionsImpl method autowireContext.

protected void autowireContext(Action instance) {
    AutowireCapableBeanFactory autowireBeanFactory = applicationContext.getAutowireCapableBeanFactory();
    autowireBeanFactory.autowireBean(instance);
    if (instance instanceof ApplicationContextAware) {
        ((ApplicationContextAware) instance).setApplicationContext(applicationContext);
    }
    if (instance instanceof InitializingBean) {
        try {
            ((InitializingBean) instance).afterPropertiesSet();
        } catch (Exception e) {
            throw new RuntimeException("Unable to initialize UI Component - calling afterPropertiesSet for " + instance.getClass(), e);
        }
    }
}

Example 12 with InitializingBean

use of org.springframework.beans.factory.InitializingBean in project cuba by cuba-platform.

the class WebFacets method autowireContext.

protected void autowireContext(Facet instance) {
    AutowireCapableBeanFactory autowireBeanFactory = applicationContext.getAutowireCapableBeanFactory();
    autowireBeanFactory.autowireBean(instance);
    if (instance instanceof ApplicationContextAware) {
        ((ApplicationContextAware) instance).setApplicationContext(applicationContext);
    }
    if (instance instanceof InitializingBean) {
        try {
            ((InitializingBean) instance).afterPropertiesSet();
        } catch (Exception e) {
            throw new RuntimeException("Unable to initialize UI Component - calling afterPropertiesSet for " + instance.getClass(), e);
        }
    }
}

Example 13 with InitializingBean

use of org.springframework.beans.factory.InitializingBean in project spring-cloud-stream by spring-cloud.

the class FunctionBindingTestUtils method bind.

@SuppressWarnings("rawtypes")
public static void bind(ConfigurableApplicationContext applicationContext, Object function) {
    try {
        Object targetFunction = function;
        if (function instanceof FunctionRegistration) {
            targetFunction = ((FunctionRegistration) function).getTarget();
        }
        String functionName = targetFunction instanceof Function ? "function" : (targetFunction instanceof Consumer ? "consumer" : "supplier");
        System.setProperty("spring.cloud.function.definition", functionName);
        applicationContext.getBeanFactory().registerSingleton(functionName, function);
        Object actualFunction = ((FunctionInvocationWrapper) applicationContext.getBean(FunctionCatalog.class).lookup(functionName)).getTarget();
        InitializingBean functionBindingRegistrar = applicationContext.getBean("functionBindingRegistrar", InitializingBean.class);
        functionBindingRegistrar.afterPropertiesSet();
        BindableProxyFactory bindingProxy = applicationContext.getBean("&" + functionName + "_binding", BindableProxyFactory.class);
        bindingProxy.afterPropertiesSet();
        InitializingBean functionBinder = applicationContext.getBean("functionInitializer", InitializingBean.class);
        functionBinder.afterPropertiesSet();
        BindingServiceProperties bindingProperties = applicationContext.getBean(BindingServiceProperties.class);
        String inputBindingName = functionName + "-in-0";
        String outputBindingName = functionName + "-out-0";
        Map<String, BindingProperties> bindings = bindingProperties.getBindings();
        BindingProperties inputProperties = bindings.get(inputBindingName);
        BindingProperties outputProperties = bindings.get(outputBindingName);
        ConsumerProperties consumerProperties = inputProperties.getConsumer();
        ProducerProperties producerProperties = outputProperties.getProducer();
        TestChannelBinder binder = applicationContext.getBean(TestChannelBinder.class);
        if (actualFunction instanceof Supplier || actualFunction instanceof Function) {
            Binding<MessageChannel> bindProducer = binder.bindProducer(outputProperties.getDestination(), applicationContext.getBean(outputBindingName, MessageChannel.class), producerProperties == null ? new ProducerProperties() : producerProperties);
            bindProducer.start();
        }
        if (actualFunction instanceof Consumer || actualFunction instanceof Function) {
            Binding<MessageChannel> bindConsumer = binder.bindConsumer(inputProperties.getDestination(), null, applicationContext.getBean(inputBindingName, MessageChannel.class), consumerProperties == null ? new ConsumerProperties() : consumerProperties);
            bindConsumer.start();
        }
    } catch (Exception e) {
        throw new IllegalStateException("Failed to bind function", e);
    } finally {
        System.clearProperty("spring.cloud.function.definition");
    }
}

Example 14 with InitializingBean

use of org.springframework.beans.factory.InitializingBean in project spring-cloud-stream by spring-cloud.

the class AbstractMessageChannelBinder method doBindProducer.

/**
 * Binds an outbound channel to a given destination. The implementation delegates to
 * {@link ProvisioningProvider#provisionProducerDestination(String, ProducerProperties)}
 * and
 * {@link #createProducerMessageHandler(ProducerDestination, ProducerProperties, MessageChannel)}
 * for handling the middleware specific logic. If the returned producer message
 * handler is an {@link InitializingBean} then
 * {@link InitializingBean#afterPropertiesSet()} will be called on it. Similarly, if
 * the returned producer message handler endpoint is a {@link Lifecycle}, then
 * {@link Lifecycle#start()} will be called on it.
 * @param destination the name of the destination
 * @param outputChannel the channel to be bound
 * @param producerProperties the {@link ProducerProperties} of the binding
 * @return the Binding for the channel
 * @throws BinderException on internal errors during binding
 */
@Override
public final Binding<MessageChannel> doBindProducer(final String destination, MessageChannel outputChannel, final P producerProperties) throws BinderException {
    final MessageHandler producerMessageHandler;
    final ProducerDestination producerDestination;
    try {
        producerDestination = this.provisioningProvider.provisionProducerDestination(destination, producerProperties);
        SubscribableChannel errorChannel = producerProperties.isErrorChannelEnabled() ? registerErrorInfrastructure(producerDestination) : null;
        producerMessageHandler = createProducerMessageHandler(producerDestination, producerProperties, outputChannel, errorChannel);
        customizeProducerMessageHandler(producerMessageHandler, producerDestination.getName());
        if (producerMessageHandler instanceof InitializingBean) {
            ((InitializingBean) producerMessageHandler).afterPropertiesSet();
        }
    } catch (Exception e) {
        if (e instanceof BinderException) {
            throw (BinderException) e;
        } else if (e instanceof ProvisioningException) {
            throw (ProvisioningException) e;
        } else {
            throw new BinderException("Exception thrown while building outbound endpoint", e);
        }
    }
    if (producerProperties.isAutoStartup() && producerMessageHandler instanceof Lifecycle) {
        ((Lifecycle) producerMessageHandler).start();
    }
    this.postProcessOutputChannel(outputChannel, producerProperties);
    AtomicReference<ReactiveStreamsConsumer> reactiveStreamsConsumerRef = new AtomicReference<>();
    if (outputChannel instanceof SubscribableChannel) {
        ((SubscribableChannel) outputChannel).subscribe(new SendingHandler(producerMessageHandler, HeaderMode.embeddedHeaders.equals(producerProperties.getHeaderMode()), this.headersToEmbed, useNativeEncoding(producerProperties)));
    } else if (outputChannel instanceof FluxMessageChannel) {
        final ReactiveStreamsConsumer reactiveStreamsConsumer = new ReactiveStreamsConsumer(outputChannel, producerMessageHandler);
        reactiveStreamsConsumerRef.set(reactiveStreamsConsumer);
        reactiveStreamsConsumer.start();
    } else {
        throw new IllegalStateException("No capable binding targets found.");
    }
    Binding<MessageChannel> binding = new DefaultBinding<MessageChannel>(destination, outputChannel, producerMessageHandler instanceof Lifecycle ? (Lifecycle) producerMessageHandler : null) {

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

        @Override
        public boolean isInput() {
            return false;
        }

        @Override
        public void afterUnbind() {
            try {
                destroyErrorInfrastructure(producerDestination);
                final ReactiveStreamsConsumer rsc = reactiveStreamsConsumerRef.get();
                if (rsc != null && rsc.isRunning()) {
                    rsc.destroy();
                }
                if (producerMessageHandler instanceof DisposableBean) {
                    ((DisposableBean) producerMessageHandler).destroy();
                }
            } catch (Exception e) {
                AbstractMessageChannelBinder.this.logger.error("Exception thrown while unbinding " + toString(), e);
            }
            afterUnbindProducer(producerDestination, producerProperties);
        }
    };
    Lifecycle companion = null;
    String companionLifecycleName = destination + "_spca";
    if (this.getApplicationContext().containsBean(companionLifecycleName)) {
        companion = this.getApplicationContext().getBean(companionLifecycleName, Lifecycle.class);
    }
    ((DefaultBinding<?>) binding).setCompanion(companion);
    doPublishEvent(new BindingCreatedEvent(binding));
    return binding;
}

Example 15 with InitializingBean

use of org.springframework.beans.factory.InitializingBean in project spring-cloud-stream by spring-cloud.

the class FunctionConfiguration method supplierInitializer.

/*
	 * Binding initializer responsible only for Suppliers
	 */
@Bean
InitializingBean supplierInitializer(FunctionCatalog functionCatalog, StreamFunctionProperties functionProperties, GenericApplicationContext context, BindingServiceProperties serviceProperties, @Nullable List<BindableFunctionProxyFactory> proxyFactories, StreamBridge streamBridge, TaskScheduler taskScheduler) {
    if (CollectionUtils.isEmpty(proxyFactories)) {
        return null;
    }
    return new InitializingBean() {

        @SuppressWarnings("rawtypes")
        @Override
        public void afterPropertiesSet() throws Exception {
            for (BindableFunctionProxyFactory proxyFactory : proxyFactories) {
                FunctionInvocationWrapper functionWrapper = functionCatalog.lookup(proxyFactory.getFunctionDefinition());
                if (functionWrapper != null && functionWrapper.isSupplier()) {
                    // gather output content types
                    List<String> contentTypes = new ArrayList<String>();
                    if (proxyFactory.getOutputs().size() == 0) {
                        return;
                    }
                    Assert.isTrue(proxyFactory.getOutputs().size() == 1, "Supplier with multiple outputs is not supported at the moment.");
                    String outputName = proxyFactory.getOutputs().iterator().next();
                    BindingProperties bindingProperties = serviceProperties.getBindingProperties(outputName);
                    ProducerProperties producerProperties = bindingProperties.getProducer();
                    if (!(bindingProperties.getProducer() != null && producerProperties.isUseNativeEncoding())) {
                        contentTypes.add(bindingProperties.getContentType());
                    }
                    // see https://github.com/spring-cloud/spring-cloud-stream/issues/2027
                    String functionDefinition = proxyFactory.getFunctionDefinition();
                    String[] functionNames = StringUtils.delimitedListToStringArray(functionDefinition.replaceAll(",", "|").trim(), "|");
                    Function supplier = null;
                    Function function = null;
                    if (!ObjectUtils.isEmpty(functionNames) && functionNames.length > 1) {
                        String supplierName = functionNames[0];
                        String remainingFunctionDefinition = StringUtils.arrayToCommaDelimitedString(Arrays.copyOfRange(functionNames, 1, functionNames.length));
                        supplier = functionCatalog.lookup(supplierName);
                        function = functionCatalog.lookup(remainingFunctionDefinition, contentTypes.toArray(new String[0]));
                        if (!((FunctionInvocationWrapper) supplier).isOutputTypePublisher() && ((FunctionInvocationWrapper) function).isInputTypePublisher()) {
                            functionWrapper = null;
                        } else {
                            functionWrapper = functionCatalog.lookup(proxyFactory.getFunctionDefinition(), contentTypes.toArray(new String[0]));
                        }
                    } else {
                        functionWrapper = functionCatalog.lookup(proxyFactory.getFunctionDefinition(), contentTypes.toArray(new String[0]));
                    }
                    Publisher<Object> beginPublishingTrigger = setupBindingTrigger(context);
                    if (!functionProperties.isComposeFrom() && !functionProperties.isComposeTo()) {
                        String integrationFlowName = proxyFactory.getFunctionDefinition() + "_integrationflow";
                        PollableBean pollable = extractPollableAnnotation(functionProperties, context, proxyFactory);
                        if (functionWrapper != null) {
                            // Type functionType = functionWrapper.getFunctionType();
                            IntegrationFlow integrationFlow = integrationFlowFromProvidedSupplier(new PartitionAwareFunctionWrapper(functionWrapper, context, producerProperties), beginPublishingTrigger, pollable, context, taskScheduler, producerProperties, outputName).route(Message.class, message -> {
                                if (message.getHeaders().get("spring.cloud.stream.sendto.destination") != null) {
                                    String destinationName = (String) message.getHeaders().get("spring.cloud.stream.sendto.destination");
                                    return streamBridge.resolveDestination(destinationName, producerProperties, null);
                                }
                                return outputName;
                            }).get();
                            IntegrationFlow postProcessedFlow = (IntegrationFlow) context.getAutowireCapableBeanFactory().applyBeanPostProcessorsBeforeInitialization(integrationFlow, integrationFlowName);
                            context.registerBean(integrationFlowName, IntegrationFlow.class, () -> postProcessedFlow);
                        } else {
                            // Type functionType = ((FunctionInvocationWrapper) supplier).getFunctionType();
                            IntegrationFlow integrationFlow = integrationFlowFromProvidedSupplier(new PartitionAwareFunctionWrapper(supplier, context, producerProperties), beginPublishingTrigger, pollable, context, taskScheduler, producerProperties, outputName).channel(c -> c.direct()).fluxTransform((Function<? super Flux<Message<Object>>, ? extends Publisher<Object>>) function).route(Message.class, message -> {
                                if (message.getHeaders().get("spring.cloud.stream.sendto.destination") != null) {
                                    String destinationName = (String) message.getHeaders().get("spring.cloud.stream.sendto.destination");
                                    return streamBridge.resolveDestination(destinationName, producerProperties, null);
                                }
                                return outputName;
                            }).get();
                            IntegrationFlow postProcessedFlow = (IntegrationFlow) context.getAutowireCapableBeanFactory().applyBeanPostProcessorsBeforeInitialization(integrationFlow, integrationFlowName);
                            context.registerBean(integrationFlowName, IntegrationFlow.class, () -> postProcessedFlow);
                        }
                    }
                }
            }
        }
    };
}