Example usage for org.springframework.beans.factory.config BeanDefinition getScope

List of usage examples for org.springframework.beans.factory.config BeanDefinition getScope

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.beans.factory.config.*
  5. BeanDefinition
  6. getScope

Introduction

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

Prototype

@Nullable
String getScope();

Source Link

Document

Return the name of the current target scope for this bean, or null if not known yet.

Usage

From source file:org.echocat.jomon.spring.BeanFactoryUtils.java

@Nullable
public static String findScopeOfBeanDefinition(@Nonnull ConfigurableListableBeanFactory beanFactory,
        @Nonnull String beanName) throws NoSuchBeanDefinitionException {
    final BeanDefinition definition = beanFactory.getBeanDefinition(beanName);
    if (definition == null) {
        throw new NoSuchBeanDefinitionException("Could not find a bean named '" + beanName + "'.");
    }/*  w  w  w.  j a  va  2 s  .  c  om*/
    return definition.getScope();
}

From source file:com.helpinput.spring.BeanRegister.java

public static boolean removeBean(DefaultListableBeanFactory dlbf, BeanInfo beanInfo, String beanName) {
    BeanDefinition bd = null;
    if (!Utils.hasLength(beanName))
        if (beanInfo != null)
            beanName = beanInfo.beanName;
    if (!Utils.hasLength(beanName))
        return false;

    try {/*  w  ww.j  a v  a2s  .co  m*/
        bd = dlbf.getBeanDefinition(beanName);
        if (bd != null) {
            //?bean? relativePath?, ??
            //               BeanRegister.runOnUnregisger(beanName, dlbf);
            String scope = bd.getScope();
            /**
             * bean?application,singletonbeansession?view? flash?
             * requestbean,
             * session,view,flash,requestbeanapplicationbean
             * application,singletonbean
             * scopebeanbeanbean
             */
            if (application_scope.equals(scope))
                dlbf.destroyScopedBean(beanName);
            else if (singleton_scope.equals(scope))
                dlbf.destroySingleton(beanName);

            dlbf.removeBeanDefinition(beanName);
            if (beanInfo != null && beanInfo.beanClass != null
                    && PropertyEditor.class.isAssignableFrom(beanInfo.beanClass)) {
                ContextHolder.refreshers.remover(beanName);
            }

            List<BeanRegistInterceptor> interceptors = ContextHolder.beanRegistIntercpterHolder.getList();
            if (Utils.hasLength(interceptors)) {
                for (BeanRegistInterceptor beanRegistInterceptor : interceptors) {
                    if (beanRegistInterceptor.afterRemove(beanInfo.beanClass, beanName, scope, dlbf))
                        break;
                }
            }

            logRegist(Info.Removed, (String) bd.getAttribute(relativePath), beanInfo.beanName, scope);
            return true;
        }
    } catch (NoSuchBeanDefinitionException e) {
        //? BeanDefinition,????beanInfo,
        return true;
    }
    return false;
}

From source file:me.springframework.di.spring.SpringConfigurationLoader.java

/**
 * Loads a {@link MutableInstance} from one of the {@link BeanDefinition}s
 * provided by the {@link BeanDefinitionRegistry} passed in.
 * //from ww w . j  a  v a2s  .  c o  m
 * @param instance
 *            A {@link MutableInstance} to be populated.
 * @param definition
 *            A {@link BeanDefinition}, providing the meta data.
 */
private static void load(MutableInstance instance, BeanDefinition definition, MutableContext context) {
    instance.setReferencedType(definition.getBeanClassName());
    instance.setPrimitive(false);
    instance.setLazyInit(definition.isLazyInit());
    instance.setId("source" + counter++);
    instance.setFactoryMethod(definition.getFactoryMethodName());
    instance.setFactoryInstance(definition.getFactoryBeanName());
    if (ConfigurableBeanFactory.SCOPE_SINGLETON.equals(definition.getScope())) {
        instance.setScope(Scope.SINGLETON);
    }
    if (ConfigurableBeanFactory.SCOPE_PROTOTYPE.equals(definition.getScope())) {
        instance.setScope(Scope.PROTOTYPE);
    }
    if (definition instanceof AbstractBeanDefinition) {
        instance.setInitMethod(((AbstractBeanDefinition) definition).getInitMethodName());
        instance.setDestroyMethod(((AbstractBeanDefinition) definition).getDestroyMethodName());
    }
    if (!definition.getConstructorArgumentValues().isEmpty()) {
        List<MutableConstructorArgument> arguments = new ArrayList<MutableConstructorArgument>();
        for (Object object : definition.getConstructorArgumentValues().getGenericArgumentValues()) {
            MutableConstructorArgument argument = new MutableConstructorArgument(instance);
            argument.setInstance(instance);
            ValueHolder holder = (ValueHolder) object;
            argument.setSource(loadSource(context, argument, holder.getValue()));
            argument.setType(holder.getType());
            arguments.add(argument);
        }
        instance.setConstructorArguments(arguments);
    }
    Set<MutablePropertySetter> setters = new HashSet<MutablePropertySetter>();
    for (Object object : definition.getPropertyValues().getPropertyValueList()) {
        MutablePropertySetter setter = new MutablePropertySetter(instance);
        setter.setInstance(instance);
        PropertyValue value = (PropertyValue) object;
        setter.setName(value.getName());
        setter.setSource(loadSource(context, setter, value.getValue()));
        setters.add(setter);
    }
    instance.setSetters(setters);

    // added by woj
    instance.setAutowireCandidate(definition.isAutowireCandidate());
    if (definition instanceof AbstractBeanDefinition) {
        instance.setAutowireMode(((AbstractBeanDefinition) definition).getResolvedAutowireMode());
    } else {
        instance.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_NO);
    }
}

From source file:com.rosenvold.spring.SpringContextAnalyzer.java

/**
 * Checks if the value in a given field can be accessed from a singleton bean without a proxy.
 * @param singletonBean The client bean//from ww w .  j  a va  2s.co  m
 * @param field The field to check
 * @return true if the requirements are verified not to be met, false in all other cases
 */
boolean violatesProxyRequirementsForSingletonClient(Object singletonBean, Field field) {
    Object injectedBean = getFieldValue(singletonBean, field);
    if (injectedBean == null)
        return false; // Dont care
    String[] beanNamesForType = applicationContext.getBeanNamesForType(injectedBean.getClass());
    if (beanNamesForType.length != 1)
        return false;
    BeanDefinition injectedBeanDef = getBeanDefinition(beanNamesForType[0]);
    return (isWebScope(injectedBeanDef.getScope()) && !isProxy(injectedBean));
}

From source file:org.echocat.jomon.spring.BeanProvider.java

protected void validateTypeAgainstBeanConfiguration(@Nonnull String name, @Nonnull Type type) {
    if (type != undefined) {
        final BeanDefinition definition = getBeanDefinitionRegistry().getBeanDefinition(name);
        final String scope = definition.getScope();
        if (type == multiton && !SCOPE_PROTOTYPE.equals(scope)) {
            throw new IllegalArgumentException("The bean '" + name + "' was requested as " + type
                    + ". This requires the scope '" + SCOPE_PROTOTYPE + "' but was '" + scope + "'.");
        }//  ww w. j a  v  a 2s.c  om
        if (type == singleton && !SCOPE_SINGLETON.equals(scope)) {
            throw new IllegalArgumentException("The bean '" + name + "' was requested as " + type
                    + ". This requires the scope '" + SCOPE_SINGLETON + "' but was '" + scope + "'.");
        }
    }
}

From source file:com.vaadin.spring.navigator.SpringViewProvider.java

private View getViewFromApplicationContext(String viewName, String beanName) {
    View view = null;//from w  ww .  j a va2s  . c o  m
    if (isAccessGrantedToBeanName(beanName)) {
        final BeanDefinition beanDefinition = beanDefinitionRegistry.getBeanDefinition(beanName);
        if (beanDefinition.getScope().equals(ViewScopeImpl.VAADIN_VIEW_SCOPE_NAME)) {
            LOGGER.trace("View [{}] is view scoped, activating scope", viewName);
            final ViewCache viewCache = ViewScopeImpl.getViewCacheRetrievalStrategy()
                    .getViewCache(applicationContext);
            viewCache.creatingView(viewName);
            try {
                view = getViewFromApplicationContextAndCheckAccess(beanName);
            } finally {
                viewCache.viewCreated(viewName, view);
            }
        } else {
            view = getViewFromApplicationContextAndCheckAccess(beanName);
        }
    }
    if (view != null) {
        return view;
    } else {
        return getAccessDeniedView();
    }
}

From source file:org.activiti.spring.components.scope.ProcessScope.java

public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {

    beanFactory.registerScope(ProcessScope.PROCESS_SCOPE_NAME, this);

    Assert.isInstanceOf(BeanDefinitionRegistry.class, beanFactory,
            "BeanFactory was not a BeanDefinitionRegistry, so ProcessScope cannot be used.");

    BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;

    for (String beanName : beanFactory.getBeanDefinitionNames()) {
        BeanDefinition definition = beanFactory.getBeanDefinition(beanName);
        // Replace this or any of its inner beans with scoped proxy if it has this scope
        boolean scoped = PROCESS_SCOPE_NAME.equals(definition.getScope());
        Scopifier scopifier = new Scopifier(registry, PROCESS_SCOPE_NAME, proxyTargetClass, scoped);
        scopifier.visitBeanDefinition(definition);
        if (scoped) {
            Scopifier.createScopedProxy(beanName, definition, registry, proxyTargetClass);
        }/*  ww  w .jav a2s  . c o m*/
    }

    beanFactory.registerSingleton(ProcessScope.PROCESS_SCOPE_PROCESS_VARIABLES_SINGLETON,
            this.processVariablesMap);
    beanFactory.registerResolvableDependency(ProcessInstance.class, createSharedProcessInstance());
}

From source file:org.os890.ds.addon.spring.impl.SpringBridgeExtension.java

private <T> Bean<T> createBeanAdapter(Class<T> beanClass, String beanName, BeanDefinition beanDefinition,
        ConfigurableApplicationContext applicationContext, BeanManager bm, AfterBeanDiscovery abd) {
    String beanScope = beanDefinition.getScope();
    ContextualLifecycle lifecycleAdapter = new SpringAwareBeanLifecycle(applicationContext, beanName,
            beanScope);/*from   ww  w.j a  v a2s  .c o m*/

    List<Annotation> cdiQualifiers = tryToMapToCdiQualifier(beanName, beanDefinition, abd);

    //we don't need to handle (remove) interceptor annotations, because BeanBuilder >won't< add them (not supported)
    BeanBuilder<T> beanBuilder = new BeanBuilder<T>(bm)
            .readFromType(new AnnotatedTypeBuilder<T>().readFromType(beanClass).create()).name(beanName)
            .beanLifecycle(lifecycleAdapter).injectionPoints(Collections.<InjectionPoint>emptySet())
            .scope(Dependent.class) //the instance (or proxy) returned by spring shouldn't bootContainer proxied
            .passivationCapable(true).alternative(false).nullable(true);

    if (!cdiQualifiers.isEmpty()) {
        beanBuilder.addQualifiers(cdiQualifiers);
    }

    boolean typeObjectFound = false;
    for (Type type : beanBuilder.getTypes()) {
        if (Object.class.equals(type)) {
            typeObjectFound = true;
        }
    }

    if (!typeObjectFound) {
        beanBuilder.addType(Object.class); //java.lang.Object needs to be present (as type) in any case
    }

    return beanBuilder.create();
}

From source file:com.github.persapiens.jsfboot.annotations.JsfCdiToSpringBeanNameGenerator.java

@Override
public String generateBeanName(BeanDefinition definition, BeanDefinitionRegistry registry) {
    String result = super.generateBeanName(definition, registry);

    if (definition instanceof AnnotatedBeanDefinition) {
        AnnotatedBeanDefinition annDef = (AnnotatedBeanDefinition) definition;

        String scopeName = JsfCdiToSpring.scopeName(annDef.getMetadata().getAnnotationTypes());
        if (scopeName != null) {
            definition.setScope(scopeName);

            logger.debug(// w w  w .  j  a  v a  2 s  .c o m
                    definition.getBeanClassName() + " - Scope(" + definition.getScope().toUpperCase() + ")");
        }
    }

    return result;
}

From source file:org.activiti.spring.components.aop.util.Scopifier.java

@Override
protected Object resolveValue(Object value) {

    BeanDefinition definition = null;
    String beanName = null;/*from  www.  j a  v a 2 s  .  co  m*/
    if (value instanceof BeanDefinition) {
        definition = (BeanDefinition) value;
        beanName = BeanDefinitionReaderUtils.generateBeanName(definition, registry);
    } else if (value instanceof BeanDefinitionHolder) {
        BeanDefinitionHolder holder = (BeanDefinitionHolder) value;
        definition = holder.getBeanDefinition();
        beanName = holder.getBeanName();
    }

    if (definition != null) {
        boolean nestedScoped = scope.equals(definition.getScope());
        boolean scopeChangeRequiresProxy = !scoped && nestedScoped;
        if (scopeChangeRequiresProxy) {
            // Exit here so that nested inner bean definitions are not
            // analysed
            return createScopedProxy(beanName, definition, registry, proxyTargetClass);
        }
    }

    // Nested inner bean definitions are recursively analysed here
    value = super.resolveValue(value);
    return value;
}