Example usage for org.springframework.beans.factory.config ConfigurableListableBeanFactory getBean

List of usage examples for org.springframework.beans.factory.config ConfigurableListableBeanFactory getBean

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.beans.factory.config.*
  5. ConfigurableListableBeanFactory
  6. getBean

Introduction

In this page you can find the example usage for org.springframework.beans.factory.config ConfigurableListableBeanFactory getBean.

Prototype

Object getBean(String name) throws BeansException;

Source Link

Document

Return an instance, which may be shared or independent, of the specified bean.

Usage

From source file:org.seedstack.spring.internal.SpringModule.java

@SuppressWarnings("unchecked")
private void bindFromApplicationContext() {
    boolean debugEnabled = LOGGER.isDebugEnabled();

    ConfigurableListableBeanFactory currentBeanFactory = this.beanFactory;
    do {//from w w w  .ja  v  a2s  .c o  m
        for (String beanName : currentBeanFactory.getBeanDefinitionNames()) {
            BeanDefinition beanDefinition = currentBeanFactory.getMergedBeanDefinition(beanName);
            if (!beanDefinition.isAbstract()) {
                Class<?> beanClass;
                try {
                    beanClass = Class.forName(beanDefinition.getBeanClassName());
                } catch (ClassNotFoundException e) {
                    LOGGER.warn("Cannot bind spring bean " + beanName + " because its class "
                            + beanDefinition.getBeanClassName() + " failed to load", e);
                    continue;
                }

                // FactoryBean special case: retrieve it and query for the object type it creates
                if (FactoryBean.class.isAssignableFrom(beanClass)) {
                    beanClass = ((FactoryBean) currentBeanFactory.getBean('&' + beanName)).getObjectType();
                    if (beanClass == null) {
                        LOGGER.warn("Cannot bind spring bean " + beanName
                                + " because its factory bean cannot determine its class");
                        continue;
                    }
                }

                SpringBeanDefinition springBeanDefinition = new SpringBeanDefinition(beanName,
                        currentBeanFactory);

                // Adding bean with its base type
                addBeanDefinition(beanClass, springBeanDefinition);

                // Adding bean with its parent type if enabled
                Class<?> parentClass = beanClass.getSuperclass();
                if (parentClass != null && parentClass != Object.class) {
                    addBeanDefinition(parentClass, springBeanDefinition);
                }

                // Adding bean with its immediate interfaces if enabled
                for (Class<?> i : beanClass.getInterfaces()) {
                    addBeanDefinition(i, springBeanDefinition);
                }
            }
        }
        BeanFactory factory = currentBeanFactory.getParentBeanFactory();
        if (factory != null) {
            if (factory instanceof ConfigurableListableBeanFactory) {
                currentBeanFactory = (ConfigurableListableBeanFactory) factory;
            } else {
                LOGGER.info(
                        "Cannot go up further in the bean factory hierarchy, parent bean factory doesn't implement ConfigurableListableBeanFactory");
                currentBeanFactory = null;
            }
        } else {
            currentBeanFactory = null;
        }
    } while (currentBeanFactory != null);

    for (Map.Entry<Class<?>, Map<String, SpringBeanDefinition>> entry : this.beanDefinitions.entrySet()) {
        Class<?> type = entry.getKey();
        Map<String, SpringBeanDefinition> definitions = entry.getValue();

        // Bind by name for each bean of this type and by type if there is no ambiguity
        for (SpringBeanDefinition candidate : definitions.values()) {
            if (debugEnabled) {
                LOGGER.info("Binding spring bean " + candidate.getName() + " by name and type "
                        + type.getCanonicalName());
            }

            bind(type).annotatedWith(Names.named(candidate.getName()))
                    .toProvider(new SpringBeanProvider(type, candidate.getName(), candidate.getBeanFactory()));
        }
    }
}

From source file:ome.client.utests.Preferences3Test.java

public void xxxtestPreferencesAreUpdated() {

    log.info("CONTEXT");
    ConfigurableApplicationContext applicationContext = OmeroContext.getClientContext();

    // A)//from  www.  j ava 2  s .  c o m
    // PropertyPlaceholderConfigurer ppc =(PropertyPlaceholderConfigurer)
    // applicationContext.getBean("placeholderConfig");
    // ppc.setProperties( props );
    // 1
    // ppc.postProcessBeanFactory( applicationContext.getBeanFactory() );
    // 2
    // applicationContext.refresh();
    // applicationContext.getBeanFactory().
    // 3
    // ConfigurableListableBeanFactory bf =
    // applicationContext.getBeanFactory();
    // ppc.postProcessBeanFactory( bf );
    // while (bf.getParentBeanFactory() != null)
    // {
    // bf = (ConfigurableListableBeanFactory) bf.getParentBeanFactory();
    // ppc.postProcessBeanFactory( bf );
    // }
    // 4

    // B)
    log.info("OWN BFPP");
    BeanFactoryPostProcessor bfpp = new BeanFactoryPostProcessor() {
        public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
            PropertyPlaceholderConfigurer ppc = (PropertyPlaceholderConfigurer) beanFactory
                    .getBean("placeholderConfig");
            ppc.setProperties(props);
        }
    };
    log.info("ADDING BFPP");
    applicationContext.addBeanFactoryPostProcessor(bfpp);

    log.info("GETTING PRINCIPAL");
    Principal principal = (Principal) applicationContext.getBean("principal");

    assertTrue(principal.getName(), "bar".equals(principal.getName()));
}

From source file:org.apache.james.container.spring.bean.factorypostprocessor.ConfigurationBeanFactoryPostProcessor.java

/**
 * Parse the configuration file and depending on it register the beans
 *//*from  w  w w .  j a  va 2 s  .c  o m*/
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {

    ConfigurationProvider confProvider = beanFactory.getBean(ConfigurationProvider.class);

    // loop over the beans
    for (String name : beans.keySet()) {

        try {

            HierarchicalConfiguration config = confProvider.getConfiguration(name);

            // Get the configuration for the class
            String repClass = config.getString("[@class]");

            // Create the definition and register it
            BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
            BeanDefinition def = BeanDefinitionBuilder.genericBeanDefinition(repClass).getBeanDefinition();
            registry.registerBeanDefinition(name, def);

            String aliases = beans.get(name);
            String[] aliasArray = aliases.split(",");

            // check if we need to register some aliases for this bean
            if (aliasArray != null) {
                for (String anAliasArray : aliasArray) {
                    String alias = anAliasArray.trim();
                    if (alias.length() > 0) {
                        registry.registerAlias(name, anAliasArray);
                    }
                }
            }

        } catch (ConfigurationException e) {
            throw new FatalBeanException("Unable to parse configuration for bean " + name, e);
        }
    }

}

From source file:org.apache.james.container.spring.bean.factorypostprocessor.EventsConfigurationBeanFactoryPostProcessor.java

@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
    ConfigurationProvider confProvider = beanFactory.getBean(ConfigurationProvider.class);
    try {//from   w w  w  . j a  va2  s .c o  m
        HierarchicalConfiguration config = confProvider.getConfiguration("events");
        String type = config.getString("type", "default");
        String serialization = config.getString("serialization", "json");
        String publisher = config.getString("publisher", "kafka");
        String registration = config.getString("registration", "cassandra");
        String delivery = config.getString("delivery", "synchronous");
        String delegatingListenerAlias = getDelegatingListenerAlias(type);
        String serializationAlias = getSerializationAlias(serialization);
        String registrationAlias = getRegistrationAlias(registration);
        String deliveryAlias = getDeliveryString(delivery);
        String publisherAlias = null;
        String consumerAlias = null;

        if (publisher.equals("kafka")) {
            publisherAlias = "kafka-publisher";
            consumerAlias = "kafka-consumer";
        }

        detectInvalidValue(delegatingListenerAlias, "Delegating listener type " + type + " not supported!");
        detectInvalidValue(deliveryAlias, "Event delivery " + delivery + " not supported");
        beanFactory.registerAlias(delegatingListenerAlias, "delegating-listener");
        beanFactory.registerAlias(deliveryAlias, "event-delivery");
        if (!delegatingListenerAlias.equals("default")) {
            detectInvalidValue(serializationAlias,
                    "Serialization system type " + serialization + " not supported!");
            detectInvalidValue(publisherAlias, "Publisher system type " + publisher + " not supported!");
            beanFactory.registerAlias(serializationAlias, "event-serializer");
            beanFactory.registerAlias(publisherAlias, "publisher");
            beanFactory.registerAlias(consumerAlias, "consumer");
            if (delegatingListenerAlias.equals("registered")) {
                detectInvalidValue(registrationAlias,
                        "Registration system type " + registration + " not supported!");
                beanFactory.registerAlias(registrationAlias, "distant-mailbox-path-register-mapper");
            }
        }

    } catch (ConfigurationException e) {
        throw new FatalBeanException("Unable to config the mailboxmanager", e);
    }
}

From source file:org.apache.james.container.spring.bean.factorypostprocessor.IndexerConfigurationBeanFactoryPostProcessor.java

/**
 * @see org.springframework.beans.factory.config.BeanFactoryPostProcessor#postProcessBeanFactory
 * (org.springframework.beans.factory.config.ConfigurableListableBeanFactory)
 *//*from www . j  a v a 2 s  . c  o m*/
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
    ConfigurationProvider confProvider = beanFactory.getBean(ConfigurationProvider.class);
    try {
        HierarchicalConfiguration config = confProvider.getConfiguration("indexer");
        String provider = config.getString("provider", "lazyIndex");

        BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
        String indexer = null;
        String reIndexer = null;
        if (provider.equalsIgnoreCase("lazyIndex")) {
            indexer = "lazyIndex";
            reIndexer = "fake-reindexer";
        } else if (provider.equalsIgnoreCase("elasticsearch")) {
            indexer = "elasticsearch-listener";
            reIndexer = "reindexer-impl";
        }

        if (indexer == null)
            throw new ConfigurationException("Indexer provider " + provider + " not supported!");
        registry.registerAlias(indexer, "indexer");
        registry.registerAlias(reIndexer, "reindexer");

    } catch (ConfigurationException e) {
        throw new FatalBeanException("Unable to config the indexer", e);
    }

}

From source file:org.apache.james.container.spring.bean.factorypostprocessor.MailboxConfigurationBeanFactoryPostProcessor.java

/**
 * @see org.springframework.beans.factory.config.BeanFactoryPostProcessor#postProcessBeanFactory
 * (org.springframework.beans.factory.config.ConfigurableListableBeanFactory)
 *//* ww w. j a v  a2s.c om*/
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
    ConfigurationProvider confProvider = beanFactory.getBean(ConfigurationProvider.class);
    try {
        HierarchicalConfiguration config = confProvider.getConfiguration("mailbox");
        String provider = config.getString("provider", "jpa");

        BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
        String mailbox = null;
        String subscription = null;
        String messageMapperFactory = null;
        String mailboxIdDeserializer = null;
        if (provider.equalsIgnoreCase("jpa")) {
            mailbox = "jpa-mailboxmanager";
            subscription = "jpa-subscriptionManager";
            messageMapperFactory = "jpa-sessionMapperFactory";
            mailboxIdDeserializer = "jpa-mailbox-id-deserializer";
        } else if (provider.equalsIgnoreCase("memory")) {
            mailbox = "memory-mailboxmanager";
            subscription = "memory-subscriptionManager";
            messageMapperFactory = "memory-sessionMapperFactory";
            mailboxIdDeserializer = "memory-mailbox-id-deserializer";
        } else if (provider.equalsIgnoreCase("jcr")) {
            mailbox = "jcr-mailboxmanager";
            subscription = "jcr-subscriptionManager";
            messageMapperFactory = "jcr-sessionMapperFactory";
            mailboxIdDeserializer = "jcr-mailbox-id-deserializer";
        } else if (provider.equalsIgnoreCase("maildir")) {
            mailbox = "maildir-mailboxmanager";
            subscription = "maildir-subscriptionManager";
            messageMapperFactory = "maildir-sessionMapperFactory";
            mailboxIdDeserializer = "maildir-mailbox-id-deserializer";
        } else if (provider.equalsIgnoreCase("hbase")) {
            mailbox = "hbase-mailboxmanager";
            subscription = "hbase-subscriptionManager";
            messageMapperFactory = "hbase-sessionMapperFactory";
            mailboxIdDeserializer = "hbase-mailbox-id-deserializer";
        } else if (provider.equalsIgnoreCase("cassandra")) {
            mailbox = "cassandra-mailboxmanager";
            subscription = "cassandra-subscriptionManager";
            messageMapperFactory = "cassandra-sessionMapperFactory";
            mailboxIdDeserializer = "cassandra-mailbox-id-deserializer";
        }

        if (mailbox == null)
            throw new ConfigurationException("Mailboxmanager provider " + provider + " not supported!");
        registry.registerAlias(mailbox, "mailboxmanager");
        registry.registerAlias(subscription, "subscriptionManager");
        registry.registerAlias(messageMapperFactory, "messageMapperFactory");
        registry.registerAlias(mailboxIdDeserializer, "mailbox-id-deserializer");

    } catch (ConfigurationException e) {
        throw new FatalBeanException("Unable to config the mailboxmanager", e);
    }

}

From source file:org.apache.james.container.spring.bean.factorypostprocessor.QuotaBeanFactoryPostProcessor.java

@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
    ConfigurationProvider confProvider = beanFactory.getBean(ConfigurationProvider.class);
    try {/*from   w  w w . j  av a2  s .c  o m*/
        HierarchicalConfiguration config = confProvider.getConfiguration("quota");

        String quotaRootResolver = config.configurationAt(QUOTA_ROOT_RESOLVER).getString(PROVIDER, DEFAULT);
        String currentQuotaManager = config.configurationAt(CURRENT_QUOTA_MANAGER).getString(PROVIDER, "none");
        String maxQuotaManager = config.configurationAt(MAX_QUOTA_MANAGER).getString(PROVIDER, FAKE);
        String quotaManager = config.configurationAt(QUOTA_MANAGER).getString(PROVIDER, FAKE);
        String quotaUpdater = config.configurationAt(UPDATES).getString(PROVIDER, FAKE);

        BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;

        registerAliasForQuotaRootResolver(quotaRootResolver, registry);
        registerAliasForCurrentQuotaManager(currentQuotaManager, registry);
        registerAliasForMaxQuotaManager(maxQuotaManager, registry);
        registerAliasForQuotaManager(quotaManager, registry);
        registerAliasForQuotaUpdater(quotaUpdater, registry);
    } catch (ConfigurationException e) {
        throw new FatalBeanException("Unable to configure Quota system", e);
    }
}

From source file:org.metaeffekt.dcc.commons.spring.xml.ProfileValidationBeanFactoryPostProcessor.java

@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
    Profile profile = (Profile) beanFactory
            .getBean(DCCConfigurationBeanDefinitionParser.THE_ONE_TRUE_PROFILE_BEAN_NAME);

    if (Profile.Type.DEPLOYMENT == profile.getType()) {

        // evaluate the profile (including deployment properties)
        final PropertiesHolder propertiesHolder = profile.createPropertiesHolder(true);
        profile.evaluate(propertiesHolder);

        this.bindingRegistry = BindingRegistry.getInstance(beanFactory);

        List<String> messages = new LinkedList<>();

        for (ConfigurationUnit unit : profile.getUnits()) {
            // TODO validate if all mappings are well-formed
            validateProvidedCapabilities(unit, profile, propertiesHolder, messages);
            validateRequiredCapabilities(unit, profile, messages);
        }/*from w  ww . ja  v  a 2 s. c o m*/

        messages.addAll(checkAsserts(profile, propertiesHolder));

        // checking for unused attributes and properties (only when validation is on)
        if (Boolean.parseBoolean(
                System.getProperty(DccProperties.DCC_SYSTEM_PROPERTY_PROFILE_VALIDATION, "true"))) {

            boolean hasUnusedAttributes = false;
            for (ConfigurationUnit unit : profile.getUnits(false)) {
                for (Attribute attribute : unit.getAttributes()) {
                    String attributeId = DccUtils.deriveAttributeIdentifier(unit, attribute.getKey());
                    if (!propertiesHolder.isPropertyRelevant(attributeId)) {
                        LOG.warn("Unused attribute [{}] in unit [{}].", attribute.getKey(), unit.getId());
                        hasUnusedAttributes = true;
                    }
                }
            }
            if (hasUnusedAttributes) {
                LOG.warn(
                        "Unused attributes are not evaluated and may indicate issues within the profile definition.");
                LOG.warn("Please review the profile with id '{}'.", profile.getId());
            }

            // check on solution property usage
            checkForUnusedProperties("solution", profile.getSolutionProperties(), propertiesHolder,
                    DccProperties.DCC_SOLUTION_PROPERTIES_WHITELIST, profile.getSolutionPropertiesFile(),
                    profile);
            checkForUnusedProperties("deployment", profile.getDeploymentProperties(), propertiesHolder,
                    DccProperties.DCC_DEPLOYMENT_PROPERTIES_WHITELIST, profile.getDeploymentPropertiesFile(),
                    profile);

            checkForUnresolvedVariables(profile, propertiesHolder);
        }

        Collections.sort(messages);
        StringBuilder messageBuilder = new StringBuilder();
        int i = 1;
        for (String string : messages) {
            messageBuilder.append(System.lineSeparator());
            messageBuilder.append(System.lineSeparator());

            messageBuilder.append(i++);
            messageBuilder.append(") ");

            messageBuilder.append(string.replace("${INDENT}", INDENT));
        }
        messageBuilder.append(System.lineSeparator());

        if (messages.size() > 0) {
            String errorMessage = String.format("%d validation error(s) occurred: %s", messages.size(),
                    messageBuilder.toString());
            LOG.error(errorMessage);
            if (Boolean.parseBoolean(
                    System.getProperty(DccProperties.DCC_SYSTEM_PROPERTY_PROFILE_VALIDATION, "true"))) {
                throw new BeanDefinitionValidationException(
                        "Stopping profile evaluation due to validation errors.");
            }
        }
    }

}

From source file:org.openlegacy.support.AbstractAnnotationProccesor.java

@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
    Collection<ClassAnnotationsLoader> classAnnotationsLoaders = beanFactory
            .getBeansOfType(ClassAnnotationsLoader.class).values();
    Collection<FieldAnnotationsLoader> fieldAnnotationLoaders = beanFactory
            .getBeansOfType(FieldAnnotationsLoader.class).values();
    Collection<FieldLoader> fieldLoaders = beanFactory.getBeansOfType(FieldLoader.class).values();

    EntitiesRegistry<?, ?, ?> entitiesRegistry = getEntitiesRegistry(beanFactory);

    filterByPackage(classAnnotationsLoaders);
    filterByPackage(fieldAnnotationLoaders);
    filterByPackage(fieldLoaders);/*from   www .j a  v a2 s  .  com*/

    DefaultRegistryLoader registryLoader = (DefaultRegistryLoader) beanFactory.getBean(RegistryLoader.class);

    registryLoader.setAnnotationLoaders(classAnnotationsLoaders);
    registryLoader.setFieldAnnotationLoaders(fieldAnnotationLoaders);
    registryLoader.setFieldLoaders(fieldLoaders);
    registryLoader.setBeanFactory(beanFactory);

    registryLoader.load(entitiesRegistry);
}

From source file:org.openspaces.core.context.GigaSpaceLateContextBeanFactoryPostProcessor.java

public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
    String[] beanNames = beanFactory.getBeanDefinitionNames();
    for (String beanName : beanNames) {
        if (!beanFactory.isSingleton(beanName)) {
            continue;
        }/*from  ww  w . j av a2s . c  o  m*/
        List<AnnotatedMember> metadata = findClassMetadata(beanFactory.getType(beanName));
        if (metadata.isEmpty()) {
            continue;
        }
        Object bean = beanFactory.getBean(beanName);
        for (AnnotatedMember member : metadata) {
            member.inject(bean);
        }
    }
}