Example usage for org.springframework.beans.factory BeanFactory FACTORY_BEAN

Introduction

In this page you can find the example usage for org.springframework.beans.factory BeanFactory FACTORY_BEAN_PREFIX.

Prototype

String FACTORY_BEAN_PREFIX

To view the source code for org.springframework.beans.factory BeanFactory FACTORY_BEAN_PREFIX.

Click Source Link

Document

Used to dereference a FactoryBean instance and distinguish it from beans created by the FactoryBean.

Usage

From source file:org.apache.mina.springrpc.example.gettingstarted.config.SpringHelloServiceClientTest.java

@Test
public void test() throws Exception {
    ApplicationContext context = new ClassPathXmlApplicationContext("hello-service-client.xml", getClass());
    String beanName = "helloService";
    HelloService service = (HelloService) context.getBean(beanName);
    invokeService(service);/*from   w w  w  . j  a va2s .  c  om*/
    ((DisposableBean) context.getBean(BeanFactory.FACTORY_BEAN_PREFIX + beanName)).destroy();
}

From source file:com.alibaba.druid.support.ibatis.SpringIbatisBeanTypeAutoProxyCreator.java

/**
 * Identify as bean to proxy if the bean name is in the configured list of names.
 *//*from  www  . j  a  v a  2 s  . co m*/
@SuppressWarnings("rawtypes")
protected Object[] getAdvicesAndAdvisorsForBean(Class beanClass, String beanName, TargetSource targetSource) {
    for (String mappedName : this.beanNames) {
        if (FactoryBean.class.isAssignableFrom(beanClass)) {
            if (!mappedName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {
                continue;
            }
            mappedName = mappedName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());
        }
        if (isMatch(beanName, mappedName)) {
            return PROXY_WITHOUT_ADDITIONAL_INTERCEPTORS;
        }
    }
    return DO_NOT_PROXY;
}

From source file:org.cloudfoundry.reconfiguration.util.StandardPropertyAugmenter.java

private BeanDefinition getBeanDefinition(ConfigurableListableBeanFactory beanFactory, String beanName) {
    String canonicalBeanName;//from www .j a  v  a2  s  .c  o  m
    if (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {
        canonicalBeanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());
    } else {
        canonicalBeanName = beanName;
    }

    return beanFactory.getBeanDefinition(canonicalBeanName);
}

From source file:org.cloudfoundry.reconfiguration.util.StandardPropertyAugmenterTest.java

@Test
public void factoryBean() {
    when(this.beanFactory.getBeanNamesForType(this.beanClass, true, false))
            .thenReturn(new String[] { String.format("%s%s", BeanFactory.FACTORY_BEAN_PREFIX, this.beanName) });

    this.propertyAugmenter.augment(this.beanFactory, this.beanClass, this.key, this.additionalProperties);

    assertTrue(this.propertyValues.contains(this.key));
}

From source file:com.wavemaker.runtime.data.cloudfoundry.CloudFoundryDataServiceBeanFactoryPostProcessor.java

private BeanDefinition getBeanDefinition(DefaultListableBeanFactory beanFactory, String beanName) {
    if (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {
        beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());
    }/*from   w w  w  .  ja  v  a 2s  .  com*/
    return beanFactory.getBeanDefinition(beanName);
}

From source file:org.okj.commons.annotations.ServiceReferenceInjectionBeanPostProcessor.java

/**
 * process FactoryBean created objects, since these will not have had
 * services injected.//  ww  w. j  av  a  2  s.c  o  m
 * 
 * @param bean
 * @param beanName
 */
public Object postProcessAfterInitialization(final Object bean, final String beanName) throws BeansException {
    if (logger.isDebugEnabled())
        logger.debug("processing [" + bean.getClass().getName() + ", " + beanName + "]");
    // Catch FactoryBean created instances.
    if (!(bean instanceof FactoryBean)
            && beanFactory.containsBean(BeanFactory.FACTORY_BEAN_PREFIX + beanName)) {
        injectServices(bean, beanName);
    }
    return bean;
}

From source file:org.apache.james.container.spring.lifecycle.osgi.AbstractOSGIAnnotationBeanPostProcessor.java

/**
 * process FactoryBean created objects, since these will not have had
 * services injected./*from  w w w  .ja v a2s  . c  o m*/
 * 
 * @param bean
 * @param beanName
 */
@Override
public Object postProcessAfterInitialization(final Object bean, final String beanName) throws BeansException {
    if (logger.isDebugEnabled())
        logger.debug("processing [" + bean.getClass().getName() + ", " + beanName + "]");
    // Catch FactoryBean created instances.
    if (!(bean instanceof FactoryBean)
            && beanFactory.containsBean(BeanFactory.FACTORY_BEAN_PREFIX + beanName)) {
        injectServices(bean, beanName);
    }
    return bean;
}

From source file:org.iff.infra.util.spring.script.ScriptFactoryPostProcessor.java

@Override
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
    // We only apply special treatment to ScriptFactory implementations here.
    if (!ScriptFactory.class.isAssignableFrom(beanClass)) {
        return null;
    }/*from  ww w  .jav  a 2 s. co  m*/

    BeanDefinition bd = this.beanFactory.getMergedBeanDefinition(beanName);
    String scriptFactoryBeanName = SCRIPT_FACTORY_NAME_PREFIX + beanName;
    String scriptedObjectBeanName = SCRIPTED_OBJECT_NAME_PREFIX + beanName;
    prepareScriptBeans(bd, scriptFactoryBeanName, scriptedObjectBeanName);

    ScriptFactory scriptFactory = this.scriptBeanFactory.getBean(scriptFactoryBeanName, ScriptFactory.class);
    ScriptSource scriptSource = getScriptSource(scriptFactoryBeanName, scriptFactory.getScriptSourceLocator());
    boolean isFactoryBean = false;
    try {
        Class<?> scriptedObjectType = scriptFactory.getScriptedObjectType(scriptSource);
        // Returned type may be null if the factory is unable to determine the type.
        if (scriptedObjectType != null) {
            isFactoryBean = FactoryBean.class.isAssignableFrom(scriptedObjectType);
        }
    } catch (Exception ex) {
        throw new BeanCreationException(beanName,
                "Could not determine scripted object type for " + scriptFactory, ex);
    }

    long refreshCheckDelay = resolveRefreshCheckDelay(bd);
    String language = (String) bd.getAttribute(LANGUAGE_ATTRIBUTE);//add by tylerchen
    if (refreshCheckDelay >= 0 || "groovy".equals(language)) {
        Class<?>[] interfaces = scriptFactory.getScriptInterfaces();
        RefreshableScriptTargetSource ts = new RefreshableScriptTargetSource(this.scriptBeanFactory,
                scriptedObjectBeanName, scriptFactory, scriptSource, isFactoryBean);
        boolean proxyTargetClass = resolveProxyTargetClass(bd);
        //String language = (String) bd.getAttribute(LANGUAGE_ATTRIBUTE);//remove by tylerchen
        if (proxyTargetClass && (language == null || !language.equals("groovy"))) {
            throw new BeanDefinitionValidationException(
                    "Cannot use proxyTargetClass=true with script beans where language is not 'groovy': '"
                            + language + "'");
        }
        //ts.setRefreshCheckDelay(refreshCheckDelay);//remove by tylerchen
        ts.setRefreshCheckDelay(-1);//add by tylerchen
        return createRefreshableProxy(ts, interfaces, proxyTargetClass);
    }

    if (isFactoryBean) {
        scriptedObjectBeanName = BeanFactory.FACTORY_BEAN_PREFIX + scriptedObjectBeanName;
    }
    return this.scriptBeanFactory.getBean(scriptedObjectBeanName);
}

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 ww  w  .jav a 2 s .  c om*/
        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;
}

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

private boolean isLazy(ConfigurableListableBeanFactory beanFactory, String beanName) {
    String name = (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX) ? beanName.substring(1) : beanName);
    if (beanFactory.containsBeanDefinition(name)) {
        return beanFactory.getBeanDefinition(name).isLazyInit();
    }// w ww.ja  v a  2s.  c  o  m
    return false;
}

Example usage for org.springframework.beans.factory BeanFactory FACTORY_BEAN_PREFIX

Introduction

Prototype

Document

Usage