Example usage for org.springframework.beans.factory.support RootBeanDefinition setScope

List of usage examples for org.springframework.beans.factory.support RootBeanDefinition setScope

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.beans.factory.support.*
  5. RootBeanDefinition
  6. setScope

Introduction

In this page you can find the example usage for org.springframework.beans.factory.support RootBeanDefinition setScope.

Prototype

@Override
public void setScope(@Nullable String scope)

Source Link

Document

Set the name of the target scope for the bean.

Usage

From source file:com.gwtplatform.dispatch.rpc.server.spring.utils.SpringUtils.java

private static <B> RootBeanDefinition createBeanDefinition(B instance) {
    RootBeanDefinition bd = new RootBeanDefinition(instance.getClass(),
            AbstractBeanDefinition.AUTOWIRE_CONSTRUCTOR, false);
    bd.setScope(BeanDefinition.SCOPE_SINGLETON);
    return bd;/*from   w w w . ja  va2 s. c o m*/
}

From source file:com.predic8.membrane.core.DefaultConfig.java

private void defineTransformerFactory(BeanDefinitionRegistry beanDefinitionRegistry) {
    if (!beanDefinitionRegistry.containsBeanDefinition("transformerFactory")) {
        Class<?> clazz;//w w  w  .j  av a  2s  .  co m
        try {
            clazz = Class.forName("com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl");
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(
                    "Please define a bean called 'transformerFactory' which extends javax.xml.transform.TransformeFactory to specify which XSLT processor to use.",
                    e);
        }
        RootBeanDefinition def = new RootBeanDefinition(clazz);
        def.setScope("singleton");
        beanDefinitionRegistry.registerBeanDefinition("transformerFactory", def);
    }
}

From source file:com.helpinput.spring.registinerceptor.mvc.UrlInterceptorBeanRegistInterceptor.java

@Override
public BeanDefinition beforeRegist(Class<?> clz, String beanName, String scope, DefaultListableBeanFactory dlbf,
        BeanDefinitionBuilder builder) {
    if (getCondition(clz)) {
        String refDefname = beanName + "$$$$";

        RootBeanDefinition refDef = new RootBeanDefinition();
        refDef.setBeanClass(clz);//from w  ww . j a  va2 s  .  c  om
        refDef.setScope(scope);
        dlbf.registerBeanDefinition(refDefname, refDef);

        RootBeanDefinition mappedInterceptorDef = new RootBeanDefinition(MappedInterceptor.class);
        mappedInterceptorDef.setScope(scope);

        ManagedList<String> includePatterns = null;
        ManagedList<String> excludePatterns = null;
        Object interceptorBean;

        Mapping mapAnn = clz.getAnnotation(Mapping.class);
        if (mapAnn != null) {
            String[] includes = mapAnn.value();
            if (Utils.hasLength(includes)) {
                includePatterns = new ManagedList<>(includes.length);
                for (String s : includes)
                    includePatterns.add(s);
            }
        }

        MappingExclude unMapAnn = clz.getAnnotation(MappingExclude.class);
        if (unMapAnn != null) {
            String[] excludes = unMapAnn.value();
            if (Utils.hasLength(excludes)) {
                excludePatterns = new ManagedList<>(excludes.length);
                for (String s : excludes)
                    excludePatterns.add(s);
            }
        }

        interceptorBean = new RuntimeBeanReference(refDefname);
        mappedInterceptorDef.getConstructorArgumentValues().addIndexedArgumentValue(0, includePatterns);
        mappedInterceptorDef.getConstructorArgumentValues().addIndexedArgumentValue(1, excludePatterns);
        mappedInterceptorDef.getConstructorArgumentValues().addIndexedArgumentValue(2, interceptorBean);
        return mappedInterceptorDef;
    }
    return null;
}

From source file:org.seasar.dao.spring.autoregister.AbstractBeanAutoRegister.java

protected void register(final String packageName, final String shortClassName) {

    final String className = ClassUtil.concatName(packageName, shortClassName);

    final Class targetClass = ClassUtil.forName(className);
    Class enhancedClass;//from w ww .j  a v a 2s. co  m

    final AspectWeaver weaver = new AspectWeaver(targetClass, null);

    final Method[] methods = targetClass.getMethods();
    for (int i = 0; i < methods.length; ++i) {
        final Method method = methods[i];
        if (isBridgeMethod(method)) {
            continue;
        }

        final List interceptorList = new ArrayList();
        for (int j = 0; j < interceptorNames.length; j++) {
            final MethodInterceptor interceptor = (MethodInterceptor) getBeanFactory()
                    .getBean(interceptorNames[j]);
            interceptorList.add(interceptor);
        }
        if (!isApplicableAspect(method)) {
            continue;
        }
        if (interceptorList.size() == 0) {
            weaver.setInterceptors(method, new MethodInterceptor[0]);
        } else {
            weaver.setInterceptors(method, (MethodInterceptor[]) interceptorList
                    .toArray(new MethodInterceptor[interceptorList.size()]));
        }
    }
    enhancedClass = weaver.generateClass();

    final BeanDefinitionParserDelegate delegate = new BeanDefinitionParserDelegate(
            new XmlReaderContext(null, null, null, null, null, null));
    final int autowireMode = delegate.getAutowireMode(autowire);

    final RootBeanDefinition bd = new RootBeanDefinition();
    bd.setBeanClass(enhancedClass);
    bd.setAutowireMode(autowireMode);
    bd.setScope(scope);

    String beanName;
    if (autoNaming != null) {
        beanName = autoNaming.defineName(packageName, shortClassName);
    } else {
        beanName = className;
    }
    getBeanFactory().registerBeanDefinition(beanName, bd);

}

From source file:org.exoplatform.container.spring.SpringContainer.java

/**
 * {@inheritDoc}//from  www. j a  va  2s .c o  m
 */
@Override
@SuppressWarnings({ "rawtypes", "unchecked" })
public void start() {
    ConfigurationManager cm = super.getComponentInstanceOfType(ConfigurationManager.class, false);
    // We check if the component has been defined in the configuration of the current container
    // The goal is to enable the SpringContainer only if it is needed
    Component component = cm.getComponent(ApplicationContextProvider.class);
    if (component == null) {
        if (LOG.isDebugEnabled()) {
            LOG.debug(
                    "No ApplicationContextProvider has been defined, thus the SpringContainer will be disabled."
                            + " To enable the Spring Integration please define an ApplicationContextProvider");
        }
    } else {
        DefaultListableBeanFactory bf = new DefaultListableBeanFactory();
        bf.setAutowireCandidateResolver(new QualifierAnnotationAutowireCandidateResolver());
        Collection<ComponentAdapter<?>> adapters = delegate.getComponentAdapters();
        for (ComponentAdapter<?> adapter : adapters) {
            Object key = adapter.getComponentKey();
            String name = keyToBeanName(key);
            String factoryName = name + "#factory";
            RootBeanDefinition def = new RootBeanDefinition(adapter.getComponentImplementation(),
                    AbstractBeanDefinition.AUTOWIRE_NO, false);
            def.setScope(BeanDefinition.SCOPE_PROTOTYPE);
            def.setFactoryBeanName(factoryName);
            def.setFactoryMethodName("getInstance");
            def.setLazyInit(true);
            def.setTargetType(adapter.getComponentImplementation());
            if (key instanceof String) {
                def.addQualifier(new AutowireCandidateQualifier(Named.class, key));
            } else if (key instanceof Class<?> && ((Class<?>) key).isAnnotation()) {
                def.addQualifier(new AutowireCandidateQualifier((Class<?>) key));
            } else {
                def.setPrimary(true);
            }
            bf.registerBeanDefinition(name, def);
            bf.registerSingleton(factoryName, new ComponentAdapterFactoryBean(adapter));
        }
        GenericApplicationContext parentContext = new GenericApplicationContext(bf);
        parentContext.refresh();
        ApplicationContextProvider provider = super.getComponentInstanceOfType(ApplicationContextProvider.class,
                false);
        ctx = provider.getApplicationContext(parentContext);
        LOG.info("A SpringContainer has been enabled using the ApplicationContextProvider "
                + provider.getClass());
    }
    super.start();
}

From source file:eap.config.ConfigBeanDefinitionParser.java

/**
 * Creates a {@link BeanDefinition} for the {@link AspectJExpressionPointcut} class using
 * the supplied pointcut expression.//from   w  w  w. j  a  v  a 2s. com
 */
protected AbstractBeanDefinition createPointcutDefinition(String expression) {
    RootBeanDefinition beanDefinition = new RootBeanDefinition(AspectJExpressionPointcut.class);
    beanDefinition.setScope(BeanDefinition.SCOPE_PROTOTYPE);
    beanDefinition.setSynthetic(true);
    beanDefinition.getPropertyValues().add(EXPRESSION, expression);
    return beanDefinition;
}

From source file:org.hdiv.config.xml.ConfigBeanDefinitionParser.java

private RootBeanDefinition createStateCache(Element element, Object source) {
    RootBeanDefinition bean = new RootBeanDefinition(StateCache.class);
    bean.setSource(source);//from   w  ww .j  a v  a  2  s.  com
    bean.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
    bean.setScope(BeanDefinition.SCOPE_PROTOTYPE);
    bean.setInitMethodName("init");

    String maxSize = element.getAttribute("maxPagesPerSession");
    if (StringUtils.hasText(maxSize)) {
        bean.getPropertyValues().addPropertyValue("maxSize", maxSize);
    }
    return bean;
}

From source file:org.hdiv.config.xml.ConfigBeanDefinitionParser.java

private RootBeanDefinition createPageIdGenerator(Element element, Object source) {
    RootBeanDefinition bean = new RootBeanDefinition(SequentialPageIdGenerator.class);
    bean.setSource(source);/*w  w  w . jav a 2  s  .c  o m*/
    bean.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
    bean.setScope(BeanDefinition.SCOPE_PROTOTYPE);
    return bean;
}

From source file:org.rosenvold.spring.convention.ConventionBeanFactory.java

@Override
protected synchronized RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
    if (super.containsBeanDefinition(beanName)) {
        return super.getMergedLocalBeanDefinition(beanName);
    }/*w  ww .  j  a v  a 2s  .c om*/
    final Class<?> type = getResolvedType(beanName);
    if (type != null) {
        RootBeanDefinition rootBeanDefinition = mergedBeanDefinitions.get(type);
        if (rootBeanDefinition == null) {
            rootBeanDefinition = new RootBeanDefinition(type);
            rootBeanDefinition.overrideFrom(getBeanDefinition(beanName));
            // Are these next two really necessary ???
            rootBeanDefinition.setAutowireMode(AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE);
            rootBeanDefinition.setScope(getAnnotatedScope(type));
            mergedBeanDefinitions.put(type, rootBeanDefinition);
        }
        return rootBeanDefinition;
    }
    return null;
}

From source file:org.springframework.beans.factory.DefaultListableBeanFactoryTests.java

@Test
public void testStaticPrototypeFactoryMethodFoundByNonEagerTypeMatching() {
    DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
    RootBeanDefinition rbd = new RootBeanDefinition(TestBeanFactory.class);
    rbd.setScope(RootBeanDefinition.SCOPE_PROTOTYPE);
    rbd.setFactoryMethodName("createTestBean");
    lbf.registerBeanDefinition("x1", rbd);

    TestBeanFactory.initialized = false;
    String[] beanNames = lbf.getBeanNamesForType(TestBean.class, true, false);
    assertEquals(1, beanNames.length);/*  ww w  .j  ava2s.  c  o  m*/
    assertEquals("x1", beanNames[0]);
    assertFalse(lbf.containsSingleton("x1"));
    assertTrue(lbf.containsBean("x1"));
    assertFalse(lbf.containsBean("&x1"));
    assertFalse(lbf.isSingleton("x1"));
    assertFalse(lbf.isSingleton("&x1"));
    assertTrue(lbf.isPrototype("x1"));
    assertFalse(lbf.isPrototype("&x1"));
    assertTrue(lbf.isTypeMatch("x1", TestBean.class));
    assertFalse(lbf.isTypeMatch("&x1", TestBean.class));
    assertEquals(TestBean.class, lbf.getType("x1"));
    assertEquals(null, lbf.getType("&x1"));
    assertFalse(TestBeanFactory.initialized);
}