Example usage for org.springframework.context.annotation ScopedProxyMode NO

Introduction

In this page you can find the example usage for org.springframework.context.annotation ScopedProxyMode NO.

Prototype

ScopedProxyMode NO

To view the source code for org.springframework.context.annotation ScopedProxyMode NO.

Click Source Link

Document

Do not create a scoped proxy.

Usage

From source file:org.vaadin.spring.config.VaadinConfiguration.java

@Bean
@Scope(value = VaadinUIScope.VAADIN_UI_SCOPE_NAME, proxyMode = ScopedProxyMode.NO)
@Primary//from w  w w.j a  v  a  2s.  c  o m
@EventBusScope(EventScope.UI)
EventBus uiEventBus() {
    return new ScopedEventBus(EventScope.UI, sessionEventBus());
}

---

From source file:br.com.caelum.vraptor.ioc.spring.SpringRegistry.java

/**
 * From org.springframework.context.annotation.ClassPathBeanDefinitionScanner#applyScope()
 * @param definition/*from   w w w  .  j a v a 2 s  .  c o  m*/
 * @param scopeMetadata
 *
 * @return
 */
private BeanDefinitionHolder applyScopeOn(BeanDefinitionHolder definition, ScopeMetadata scopeMetadata) {
    String scope = scopeMetadata.getScopeName();
    ScopedProxyMode proxyMode = scopeMetadata.getScopedProxyMode();
    definition.getBeanDefinition().setScope(scope);
    if (BeanDefinition.SCOPE_SINGLETON.equals(scope) || BeanDefinition.SCOPE_PROTOTYPE.equals(scope)
            || proxyMode.equals(ScopedProxyMode.NO)) {
        return definition;
    } else {
        boolean proxyTargetClass = proxyMode.equals(ScopedProxyMode.TARGET_CLASS);
        return ScopedProxyUtils.createScopedProxy(definition, (BeanDefinitionRegistry) beanFactory,
                proxyTargetClass);
    }
}

---

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

private void registerBeanByResolvedType(String beanName, Class<?> resolvedType) {
    if (resolvedType == null)
        return;/*from www .  j  a  va2s  . com*/
    final BeanDefinition beanDefinition = getOrCreateBeanDefinition(beanName, resolvedType);
    BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(beanDefinition, beanName);
    ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(beanDefinition);

    ScopedProxyMode scopedProxyMode = scopeMetadata.getScopedProxyMode();
    if (!scopedProxyMode.equals(ScopedProxyMode.NO)) {
        definitionHolder = ScopedProxyUtils.createScopedProxy(definitionHolder, this,
                scopedProxyMode.equals(ScopedProxyMode.TARGET_CLASS));
    }
    registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
}

---

From source file:org.springframework.context.annotation.ConfigurationClassBeanDefinitionReader.java

/**
 * Read the given {@link BeanMethod}, registering bean definitions
 * with the BeanDefinitionRegistry based on its contents.
 *//*w  w  w .  j  a  v a2 s . c  o  m*/
private void loadBeanDefinitionsForBeanMethod(BeanMethod beanMethod) {
    ConfigurationClass configClass = beanMethod.getConfigurationClass();
    MethodMetadata metadata = beanMethod.getMetadata();
    String methodName = metadata.getMethodName();

    // Do we need to mark the bean as skipped by its condition?
    if (this.conditionEvaluator.shouldSkip(metadata, ConfigurationPhase.REGISTER_BEAN)) {
        configClass.skippedBeanMethods.add(methodName);
        return;
    }
    if (configClass.skippedBeanMethods.contains(methodName)) {
        return;
    }

    AnnotationAttributes bean = AnnotationConfigUtils.attributesFor(metadata, Bean.class);
    Assert.state(bean != null, "No @Bean annotation attributes");

    // Consider name and any aliases
    List<String> names = new ArrayList<>(Arrays.asList(bean.getStringArray("name")));
    String beanName = (!names.isEmpty() ? names.remove(0) : methodName);

    // Register aliases even when overridden
    for (String alias : names) {
        this.registry.registerAlias(beanName, alias);
    }

    // Has this effectively been overridden before (e.g. via XML)?
    if (isOverriddenByExistingDefinition(beanMethod, beanName)) {
        if (beanName.equals(beanMethod.getConfigurationClass().getBeanName())) {
            throw new BeanDefinitionStoreException(
                    beanMethod.getConfigurationClass().getResource().getDescription(), beanName,
                    "Bean name derived from @Bean method '" + beanMethod.getMetadata().getMethodName()
                            + "' clashes with bean name for containing configuration class; please make those names unique!");
        }
        return;
    }

    ConfigurationClassBeanDefinition beanDef = new ConfigurationClassBeanDefinition(configClass, metadata);
    beanDef.setResource(configClass.getResource());
    beanDef.setSource(this.sourceExtractor.extractSource(metadata, configClass.getResource()));

    if (metadata.isStatic()) {
        // static @Bean method
        beanDef.setBeanClassName(configClass.getMetadata().getClassName());
        beanDef.setFactoryMethodName(methodName);
    } else {
        // instance @Bean method
        beanDef.setFactoryBeanName(configClass.getBeanName());
        beanDef.setUniqueFactoryMethodName(methodName);
    }
    beanDef.setAutowireMode(RootBeanDefinition.AUTOWIRE_CONSTRUCTOR);
    beanDef.setAttribute(RequiredAnnotationBeanPostProcessor.SKIP_REQUIRED_CHECK_ATTRIBUTE, Boolean.TRUE);

    AnnotationConfigUtils.processCommonDefinitionAnnotations(beanDef, metadata);

    Autowire autowire = bean.getEnum("autowire");
    if (autowire.isAutowire()) {
        beanDef.setAutowireMode(autowire.value());
    }

    String initMethodName = bean.getString("initMethod");
    if (StringUtils.hasText(initMethodName)) {
        beanDef.setInitMethodName(initMethodName);
    }

    String destroyMethodName = bean.getString("destroyMethod");
    beanDef.setDestroyMethodName(destroyMethodName);

    // Consider scoping
    ScopedProxyMode proxyMode = ScopedProxyMode.NO;
    AnnotationAttributes attributes = AnnotationConfigUtils.attributesFor(metadata, Scope.class);
    if (attributes != null) {
        beanDef.setScope(attributes.getString("value"));
        proxyMode = attributes.getEnum("proxyMode");
        if (proxyMode == ScopedProxyMode.DEFAULT) {
            proxyMode = ScopedProxyMode.NO;
        }
    }

    // Replace the original bean definition with the target one, if necessary
    BeanDefinition beanDefToRegister = beanDef;
    if (proxyMode != ScopedProxyMode.NO) {
        BeanDefinitionHolder proxyDef = ScopedProxyCreator.createScopedProxy(
                new BeanDefinitionHolder(beanDef, beanName), this.registry,
                proxyMode == ScopedProxyMode.TARGET_CLASS);
        beanDefToRegister = new ConfigurationClassBeanDefinition(
                (RootBeanDefinition) proxyDef.getBeanDefinition(), configClass, metadata);
    }

    if (logger.isDebugEnabled()) {
        logger.debug(String.format("Registering bean definition for @Bean method %s.%s()",
                configClass.getMetadata().getClassName(), beanName));
    }

    this.registry.registerBeanDefinition(beanName, beanDefToRegister);
}

---

• «
• 1
• 2
• »