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

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

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

Introduction

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

Prototype

boolean containsBeanDefinition(String beanName);

Source Link

Document

Check if this bean factory contains a bean definition with the given name.

Usage

From source file:ro.pippo.spring.AnnotationFieldValueProvider.java

private BeanDefinition getBeanDefinition(ConfigurableListableBeanFactory beanFactory, String name) {
    if (beanFactory.containsBeanDefinition(name)) {
        return beanFactory.getBeanDefinition(name);
    }/*from w ww  .ja v  a2 s .  c o  m*/

    BeanFactory parent = beanFactory.getParentBeanFactory();
    if ((parent != null) && (parent instanceof ConfigurableListableBeanFactory)) {
        return getBeanDefinition((ConfigurableListableBeanFactory) parent, name);
    }

    return null;
}

From source file:org.solmix.runtime.support.spring.ContainerPostProcessor.java

private Object getContainerByName(String name, ConfigurableListableBeanFactory factory, boolean create,
        String cn) {/*from w ww .  j a  va2  s .c o m*/

    if (!factory.containsBeanDefinition(name) && (create || Container.DEFAULT_CONTAINER_ID.equals(name))) {
        //
        DefaultListableBeanFactory df = (DefaultListableBeanFactory) factory;
        RootBeanDefinition rbd = new RootBeanDefinition(SpringContainer.class);
        if (cn != null) {
            //  SpringContainer.setConfig
            rbd.setAttribute("config", new RuntimeBeanReference(cn));
        }
        df.registerBeanDefinition(name, rbd);
    } else if (cn != null) {
        BeanDefinition bd = factory.getBeanDefinition(name);
        bd.getPropertyValues().addPropertyValue("config", new RuntimeBeanReference(cn));
    }
    return new RuntimeBeanReference(name);
}

From source file:org.xaloon.wicket.component.inject.spring.CdiProxyFieldValueFactory.java

private BeanDefinition getBeanDefinition(ConfigurableListableBeanFactory beanFactory, String name) {
    if (beanFactory.containsBeanDefinition(name)) {
        return beanFactory.getBeanDefinition(name);
    } else {/* w  w w  . j a v  a  2 s . co  m*/
        BeanFactory parent = beanFactory.getParentBeanFactory();
        if (parent != null && parent instanceof ConfigurableListableBeanFactory) {
            return getBeanDefinition((ConfigurableListableBeanFactory) parent, name);
        } else {
            return null;
        }
    }
}

From source file:com.github.steveash.spring.WiringFactoryBeanFactoryPostProcessor.java

private void addPrototypeDef(ConfigurableListableBeanFactory beanFactory, String beanDefName,
        Class<?> protoBeanClass) {
    String beanName = getPrototypeBeanNameFromBeanClass(protoBeanClass);
    if (beanFactory.containsBeanDefinition(beanName)) {
        throw new BeanDefinitionValidationException("Trying to register a bean definition for a synthetic "
                + "prototype bean with name " + beanName + " due to the bean factory of name " + beanDefName
                + " but a bean with this name already exists!");
    }//from  w w w. j  a  v a 2  s  . com

    GenericBeanDefinition protoBean = new GenericBeanDefinition();
    protoBean.setLazyInit(true);
    protoBean.setBeanClass(protoBeanClass);
    protoBean.setScope(BeanDefinition.SCOPE_PROTOTYPE);
    protoBean.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_CONSTRUCTOR);
    protoBean.setBeanClassName(protoBeanClass.getName());

    log.debug("Dynamically adding prototype bean {} from factory {}", beanName, beanDefName);
    BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
    registry.registerBeanDefinition(beanName, protoBean);
}

From source file:com.longio.spring.LioBootstrap.java

private Connector getConnector(ConfigurableListableBeanFactory beanFactory) {

    if (beanFactory.containsBeanDefinition("longio.connector")) {

        Connector connector = (Connector) beanFactory.getBean("longio.connector", Connector.class);

        return connector;
    }// w  w w. java  2  s.  c  om
    return null;
}

From source file:io.neba.core.selftests.SelftestRegistrar.java

public void registerSelftests(ConfigurableListableBeanFactory factory, Bundle bundle) {
    String[] beanNames = BeanFactoryUtils.beanNamesIncludingAncestors(factory);
    for (String beanName : beanNames) {
        if (factory.containsBeanDefinition(beanName) && !isInternal(beanName)) {
            findSelftests(factory, beanName, bundle);
        }/*from  w  ww  .  j  a v a  2s. c  o m*/
    }
}

From source file:org.solmix.runtime.support.spring.ContainerPostProcessor.java

@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
    Object inject = container;/*from w w  w  .  j av  a 2  s .c  om*/
    if (inject == null) {
        inject = getContainerByName(Container.DEFAULT_CONTAINER_ID, beanFactory, true, null);
    } else {
        if (!beanFactory.containsBeanDefinition(Container.DEFAULT_CONTAINER_ID)
                && !beanFactory.containsSingleton(Container.DEFAULT_CONTAINER_ID)) {
            beanFactory.registerSingleton(Container.DEFAULT_CONTAINER_ID, container);
        }
    }
    for (String beanName : beanFactory.getBeanDefinitionNames()) {
        BeanDefinition beanDefinition = beanFactory.getBeanDefinition(beanName);
        Object p = beanDefinition.getAttribute(AbstractBeanDefinitionParser.WIRE_CONTAINER_ATTRIBUTE);
        if (p == null)
            continue;
        String name = (String) beanDefinition.getAttribute(AbstractBeanDefinitionParser.WIRE_CONTAINER_NAME);
        String create = (String) beanDefinition
                .getAttribute(AbstractBeanDefinitionParser.WIRE_CONTAINER_CREATE);
        Object inj = inject;
        if (name != null) {
            if (container != null) {
                continue;
            }
            inj = getContainerByName(name, beanFactory, create != null, create);
        }
        beanDefinition.removeAttribute(AbstractBeanDefinitionParser.WIRE_CONTAINER_NAME);
        beanDefinition.removeAttribute(AbstractBeanDefinitionParser.WIRE_CONTAINER_ATTRIBUTE);
        beanDefinition.removeAttribute(AbstractBeanDefinitionParser.WIRE_CONTAINER_CREATE);
        if (create == null) {
            if (Boolean.valueOf(p.toString())) {
                beanDefinition.getPropertyValues().addPropertyValue("container", inj);
            } else {
                ConstructorArgumentValues constructorArgs = beanDefinition.getConstructorArgumentValues();
                insertConstructorArg(constructorArgs, inj);
            }
        }
    } //end loop bean.

}

From source file:uk.org.ponder.rsac.support.BeanDefUtil.java

static RSACBeanInfo convertBeanDef(BeanDefinition origdef, String beanname,
        ConfigurableListableBeanFactory factory, MethodAnalyser abdAnalyser, BeanDefConverter converter) {
    RSACBeanInfo rbi = new RSACBeanInfo();
    AbstractBeanDefinition def = getMergedBeanDefinition(factory, beanname, origdef);
    MutablePropertyValues pvs = def.getPropertyValues();
    PropertyValue[] values = pvs.getPropertyValues();
    for (int j = 0; j < values.length; ++j) {
        PropertyValue thispv = values[j];
        Object beannames = BeanDefUtil.propertyValueToBeanName(thispv.getValue(), converter);
        boolean skip = false;
        // skip recording the dependency if it was unresolvable (some
        // unrecognised
        // type) or was a single-valued type referring to a static dependency.
        // NB - we now record ALL dependencies - bean-copying strategy
        // discontinued.
        if (beannames == null
        // || beannames instanceof String
        // && !blankcontext.containsBean((String) beannames)
        ) {/*from   ww w  .  j a  va2 s  .c om*/
            skip = true;
        }
        if (!skip) {
            rbi.recordDependency(thispv.getName(), beannames);
        }
    }
    // NB - illegal cast here is unavoidable.
    // Bit of a problem here with Spring flow - apparently the bean class
    // will NOT be set for a "factory-method" bean UNTIL it has been
    // instantiated
    // via the logic in AbstractAutowireCapableBeanFactory l.376:
    // protected BeanWrapper instantiateUsingFactoryMethod(
    AbstractBeanDefinition abd = def;
    rbi.factorybean = abd.getFactoryBeanName();
    rbi.factorymethod = abd.getFactoryMethodName();
    rbi.initmethod = abd.getInitMethodName();
    rbi.destroymethod = abd.getDestroyMethodName();
    rbi.islazyinit = abd.isLazyInit();
    rbi.dependson = abd.getDependsOn();
    rbi.issingleton = abd.isSingleton();
    rbi.isabstract = abd.isAbstract();
    rbi.aliases = factory.containsBeanDefinition(beanname) ? factory.getAliases(beanname)
            : StringArrayParser.EMPTY_STRINGL;
    if (abd.hasConstructorArgumentValues()) {
        ConstructorArgumentValues cav = abd.getConstructorArgumentValues();
        boolean hasgeneric = !cav.getGenericArgumentValues().isEmpty();
        boolean hasindexed = !cav.getIndexedArgumentValues().isEmpty();
        if (hasgeneric && hasindexed) {
            throw new UnsupportedOperationException("RSAC Bean " + beanname
                    + " has both indexed and generic constructor arguments, which is not supported");
        }
        if (hasgeneric) {
            List cvalues = cav.getGenericArgumentValues();
            rbi.constructorargvals = new ConstructorArgumentValues.ValueHolder[cvalues.size()];
            for (int i = 0; i < cvalues.size(); ++i) {
                rbi.constructorargvals[i] = (ConstructorArgumentValues.ValueHolder) cvalues.get(i);
            }
        } else if (hasindexed) {
            Map cvalues = cav.getIndexedArgumentValues();
            rbi.constructorargvals = new ConstructorArgumentValues.ValueHolder[cvalues.size()];
            for (int i = 0; i < cvalues.size(); ++i) {
                rbi.constructorargvals[i] = (ConstructorArgumentValues.ValueHolder) cvalues.get(new Integer(i));
            }
        }
    }
    if (rbi.factorymethod == null) {
        // Core Spring change at 2.0M5 - ALL bean classes are now irrevocably
        // lazy!!
        // Package org.springframework.beans
        // introduced lazy loading (and lazy validation) of bean classes in
        // standard bean factories and bean definition readers
        AccessMethod bcnaccess = abdAnalyser.getAccessMethod("beanClassName");
        if (bcnaccess != null) {
            String bcn = (String) bcnaccess.getChildObject(abd);
            if (bcn != null) {
                rbi.beanclass = ClassGetter.forName(bcn);
                if (rbi.beanclass == null) {
                    throw new IllegalArgumentException("Class name " + bcn + " for bean definition with name "
                            + beanname + " cannot be resolved");
                }
            }
        } else {
            // all right then BE like that! We'll work out the class later.
            // NB - beandef.getBeanClass() was eliminated around 1.2, we must
            // use the downcast even earlier now.
            rbi.beanclass = abd.getBeanClass();
        }
    }
    return rbi;
}

From source file:org.alfresco.module.org_alfresco_module_rm.security.RMMethodSecurityPostProcessor.java

/**
 * @see org.springframework.beans.factory.config.BeanFactoryPostProcessor#postProcessBeanFactory(org.springframework.beans.factory.config.ConfigurableListableBeanFactory)
 *///from  w  w  w  .  ja  va 2 s  .  c o  m
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    for (String bean : getSecurityBeanNames(beanFactory)) {
        if (beanFactory.containsBeanDefinition(bean)) {
            if (logger.isDebugEnabled()) {
                logger.debug("Adding RM method security definitions for " + bean);
            }

            BeanDefinition beanDef = beanFactory.getBeanDefinition(bean);
            PropertyValue beanValue = beanDef.getPropertyValues()
                    .getPropertyValue(PROP_OBJECT_DEFINITION_SOURCE);
            if (beanValue != null) {
                String beanStringValue = (String) ((TypedStringValue) beanValue.getValue()).getValue();
                String mergedStringValue = merge(beanStringValue);
                beanDef.getPropertyValues().addPropertyValue(PROP_OBJECT_DEFINITION_SOURCE,
                        new TypedStringValue(mergedStringValue));
            }
        }
    }
}

From source file:org.eclipse.gemini.blueprint.extender.internal.dependencies.startup.MandatoryImporterDependencyFactory.java

public Collection<OsgiServiceDependency> getServiceDependencies(BundleContext bundleContext,
        ConfigurableListableBeanFactory beanFactory)
        throws BeansException, InvalidSyntaxException, BundleException {

    boolean trace = log.isTraceEnabled();

    String[] singleBeans = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(beanFactory,
            OsgiServiceProxyFactoryBean.class, true, false);

    if (trace) {//from  w w w.  j ava2 s  .  co m
        log.trace("Discovered single proxy importers " + Arrays.toString(singleBeans));
    }
    String[] collectionBeans = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(beanFactory,
            OsgiServiceCollectionProxyFactoryBean.class, true, false);

    if (trace) {
        log.trace("Discovered collection proxy importers " + Arrays.toString(collectionBeans));
    }

    String[] beans = StringUtils.concatenateStringArrays(singleBeans, collectionBeans);

    List<OsgiServiceDependency> beansCollections = new ArrayList<OsgiServiceDependency>(beans.length);

    for (int i = 0; i < beans.length; i++) {
        if (!isLazy(beanFactory, beans[i])) {
            String beanName = (beans[i].startsWith(BeanFactory.FACTORY_BEAN_PREFIX) ? beans[i]
                    : BeanFactory.FACTORY_BEAN_PREFIX + beans[i]);

            SmartFactoryBean<?> reference = beanFactory.getBean(beanName, SmartFactoryBean.class);

            OsgiServiceDependency dependency;
            if (reference instanceof OsgiServiceProxyFactoryBean) {
                OsgiServiceProxyFactoryBean importer = (OsgiServiceProxyFactoryBean) reference;

                dependency = new DefaultOsgiServiceDependency(beanName, importer.getUnifiedFilter(),
                        Availability.MANDATORY.equals(importer.getAvailability()));
            } else {
                OsgiServiceCollectionProxyFactoryBean importer = (OsgiServiceCollectionProxyFactoryBean) reference;

                dependency = new DefaultOsgiServiceDependency(beanName, importer.getUnifiedFilter(),
                        Availability.MANDATORY.equals(importer.getAvailability()));
            }

            if (trace)
                log.trace("Eager importer " + beanName + " implies dependecy " + dependency);

            beansCollections.add(dependency);
        } else {
            String name = (beans[i].startsWith(BeanFactory.FACTORY_BEAN_PREFIX) ? beans[i].substring(1)
                    : beans[i]);
            if (beanFactory.containsBeanDefinition(name)) {
                BeanDefinition def = beanFactory.getBeanDefinition(name);
                MutablePropertyValues values = def.getPropertyValues();
                // figure out if it's a mandatory bean
                PropertyValue value = values.getPropertyValue(AVAILABILITY_PROP);
                if (value != null && Availability.MANDATORY.equals(value.getValue())) {
                    String[] intfs = getInterfaces(values.getPropertyValue(INTERFACES_PROP));
                    String beanName = getString(values.getPropertyValue(SERVICE_BEAN_NAME_PROP));
                    String filterProp = getString(values.getPropertyValue(FILTER_PROP));

                    // create filter
                    Filter filter = createFilter(intfs, beanName, filterProp);
                    OsgiServiceDependency dependency;
                    dependency = new DefaultOsgiServiceDependency(name, filter, true);

                    if (trace)
                        log.trace("Lazy importer " + beanName + " implies dependecy " + dependency);

                    beansCollections.add(dependency);
                }
            } else {
                if (trace)
                    log.trace("Bean " + name
                            + " is marked as lazy but does not provide a bean definition; ignoring...");
            }
        }
    }

    return beansCollections;
}