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

List of usage examples for org.springframework.beans.factory BeanFactory containsBean

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.beans.factory.*
  5. BeanFactory
  6. containsBean

Introduction

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

Prototype

boolean containsBean(String name);

Source Link

Document

Does this bean factory contain a bean definition or externally registered singleton instance with the given name?

Usage

From source file:org.toobsframework.pres.doit.DoItRunner.java

/**
 *  Called upon receipt of a validation error.  Iterates over all the
 *  actions for this DoIt, retrieving an object of appropriate type out
 *  of the posted request.  All such objects are put in the response parameter
 *  mapping under the "ValidationErrorObjects" key.
 *///from  ww w  .  j a  v a  2 s  . c o m
@SuppressWarnings("unchecked")
private void pullErrorObjectsIntoRequest(IRequest request, DoIt doIt, Map<String, Object> paramMap,
        Map<String, Object> responseMap, String multipleActionsKey, String[] multipleActionsAry,
        ValidationException ve) throws Exception {
    if (log.isDebugEnabled()) {
        log.debug("ENTER pullErrorObjectsIntoRequest");
    }
    Action thisAction = null;
    Collection globalErrorObjects = new ArrayList();
    Collection<String> globalErrorMessages = new ArrayList<String>();
    BeanFactory beanFactory = BeanMonkey.getBeanFactoryInstance();

    if (doIt.getActions() != null) {
        paramMap.remove("guid");
        //Actions actionsObj = doIt.getActions();

        for (int i = 0; i < multipleActionsAry.length; i++) {
            HashMap actionParams = new HashMap(paramMap);
            responseMap.clear();
            actionParams.put(multipleActionsKey, multipleActionsAry[i]);
            actionParams.put(PlatformConstants.MULTI_ACTION_INSTANCE, new Integer(i));
            Collection instanceErrorObjects = new ArrayList();
            Collection instanceErrorMessages = new ArrayList();

            if (ve != null) {
                Iterator errIter = ve.getErrors().iterator();
                while (errIter.hasNext()) {
                    Errors err = (Errors) errIter.next();
                    instanceErrorMessages.addAll(err.getAllErrors());
                }
            }
            // iterate over the create and update actions
            Enumeration actions = doIt.getActions().enumerateAction();
            while (actions.hasMoreElements()) {
                // for each, retrieve the object of appropriate type
                thisAction = (Action) actions.nextElement();

                // get parameters from action object
                String actionStr = thisAction.getAction();
                // for now, only do error object handling for creates and updates..
                if (!actionStr.startsWith("create") && !actionStr.startsWith("update")) {
                    continue;
                }

                //retrieve the input object for this action
                Object inputObject = constructInputObjectFromAction(request, thisAction, actionParams);

                //if there's an input object 
                if (inputObject != null || actionStr.endsWith("Collection")) {
                    if (thisAction.getNamespace() != null && !"".equals(thisAction.getNamespace())) {
                        actionParams.put("namespace", thisAction.getNamespace());
                    }
                    // before calling the getSafeBean method, have to 
                    // stick this action's returnObjectType in the paramMap
                    String objectReturnType = ((String[]) ParameterUtil.resolveParam(request,
                            thisAction.getReturnObjectType(), actionParams))[0];
                    actionParams.put("returnObjectType", objectReturnType);

                    // use the bean monkey to populate that object
                    // (pass false in as last arg to block validation)
                    boolean collection = false;
                    String className = null;
                    if (actionStr.endsWith("Collection")) {
                        String beanClazz = ((String[]) ParameterUtil.resolveParam(request,
                                thisAction.getInputObjectType(), actionParams))[0];
                        inputObject = BeanMonkey.populateCollection(beanClazz, thisAction.getIndexParam(),
                                actionParams, false, thisAction.getValidationErrorMode(),
                                instanceErrorMessages);
                        collection = true;
                        className = beanClazz.substring(beanClazz.lastIndexOf(".") + 1);
                    } else {
                        try {
                            BeanMonkey.populate(inputObject, actionParams, instanceErrorMessages);
                        } catch (ValidationException e) {
                            Iterator errIter = e.getErrors().iterator();
                            while (errIter.hasNext()) {
                                Errors err = (Errors) errIter.next();
                                instanceErrorMessages.addAll(err.getAllErrors());
                            }
                        }
                        className = inputObject.getClass().getName();
                    }
                    // If there are no error messages for the object don't produce an error object
                    //if (instanceErrorMessages.size() == 0) continue;

                    // and get the validator for the input object
                    IValidator v = null;
                    className = className.substring(className.lastIndexOf(".") + 1);
                    String validatorName = className + "Validator";
                    if (beanFactory.containsBean(validatorName)) {
                        v = (IValidator) beanFactory.getBean(validatorName);
                    } else {
                        log.warn("No validator " + validatorName + " for " + className);
                    }

                    // if there's no validator, then just continue...
                    if (v == null)
                        continue;

                    // call the validator's prepare method,
                    // pipe the populated bean through the validator's getSafeBean method
                    // and, finally dump the populated object into the error objects map
                    actionParams.put("doit.validation.error.mode", new Boolean(true));
                    v.prepare(inputObject, actionParams);
                    if (collection && inputObject != null && inputObject instanceof Collection) {
                        Iterator iter = ((Collection) inputObject).iterator();
                        while (iter.hasNext()) {
                            instanceErrorObjects.add(v.getSafeBean(iter.next(), actionParams));
                        }
                    } else {
                        instanceErrorObjects.add(v.getSafeBean(inputObject, actionParams));
                    }
                }

                continue;
            }
            globalErrorMessages.addAll(instanceErrorMessages);
            globalErrorObjects.addAll(instanceErrorObjects);
        }
        // put the populated error objs in the request scope.
        responseMap.put(ForwardStrategy.VALIDATION_ERROR_OBJECTS, globalErrorObjects);
        responseMap.put(ForwardStrategy.VALIDATION_ERROR_MESSAGES, globalErrorMessages);

    }

    if (log.isDebugEnabled()) {
        log.debug("EXIT pullErrorObjectsIntoRequest");
    }
}

From source file:org.apache.cocoon.core.xml.impl.AbstractJaxpParser.java

/**
 * @see org.springframework.beans.factory.BeanFactoryAware#setBeanFactory(org.springframework.beans.factory.BeanFactory)
 *///from ww w  .j a v a 2s.com
public void setBeanFactory(BeanFactory factory) throws BeansException {
    // we search for a resolver if we don't have one already 
    if (this.resolver == null && this.searchResolver) {
        if (this.getLogger().isDebugEnabled()) {
            this.getLogger().debug("Searching for entity resolver in factory: " + factory);
        }
        if (factory.containsBean(EntityResolver.class.getName())) {
            this.resolver = (EntityResolver) factory.getBean(EntityResolver.class.getName());
            if (this.getLogger().isDebugEnabled()) {
                this.getLogger().debug("Set resolver to: " + this.resolver);
            }
        }
    }
}

From source file:org.codehaus.groovy.grails.context.annotation.ClosureClassIgnoringComponentScanBeanDefinitionParser.java

@Override
protected ClassPathBeanDefinitionScanner createScanner(XmlReaderContext readerContext,
        boolean useDefaultFilters) {
    final ClassPathBeanDefinitionScanner scanner = super.createScanner(readerContext, useDefaultFilters);
    BeanDefinitionRegistry beanDefinitionRegistry = readerContext.getRegistry();

    GrailsPluginManager pluginManager = null;

    if (beanDefinitionRegistry instanceof HierarchicalBeanFactory) {
        HierarchicalBeanFactory beanFactory = (HierarchicalBeanFactory) beanDefinitionRegistry;
        BeanFactory parent = beanFactory.getParentBeanFactory();
        if (parent != null && parent.containsBean(GrailsPluginManager.BEAN_NAME)) {
            pluginManager = parent.getBean(GrailsPluginManager.BEAN_NAME, GrailsPluginManager.class);
        }//w  w  w  .  java 2s  .co m
    }

    if (pluginManager != null) {
        List<TypeFilter> typeFilters = pluginManager.getTypeFilters();
        for (TypeFilter typeFilter : typeFilters) {
            scanner.addIncludeFilter(typeFilter);
        }
    }
    return scanner;
}

From source file:org.impalaframework.spring.service.SpringServiceBeanUtils.java

/**
 * Checks that the bean with given name contained in the specified bean factory is a singleton.
 * Will return true if bean represented by a bean registered under the scope <code>singletone</code>.
 * If the bean is also a factory bean (see {@link FactoryBean}), then the {@link FactoryBean}
 * instance also needs to be a singleton.
 * /*from   w  w w.ja va 2 s  .  c  o  m*/
 * Note that in order to work properly the {@link BeanFactory} must be able to recover the {@link BeanDefinition}
 * for a particular bean name. This in particular must mean implementing {@link BeanDefinitionRegistry} or 
 * {@link BeanDefinitionExposing}. In the latter case, if null is returned, then the bean will be treated as a singleton.
 * 
 * @return true if bean is singleton registered bean and, if applicable, a singleton {@link FactoryBean}.
 */
public static boolean isSingleton(BeanFactory beanFactory, String beanName) {

    Assert.notNull(beanFactory, "beanFactory cannot be null");
    Assert.notNull(beanName, "beanName cannot be null");

    boolean singleton = true;

    boolean isBeanFactory = beanFactory.containsBean(BeanFactory.FACTORY_BEAN_PREFIX + beanName);
    if (isBeanFactory) {
        FactoryBean<?> factoryBean = (FactoryBean<?>) beanFactory
                .getBean(BeanFactory.FACTORY_BEAN_PREFIX + beanName);
        singleton = factoryBean.isSingleton();
    }

    if (singleton) {
        //ApplicationContext implements this implements this
        ListableBeanFactory registry = (ListableBeanFactory) beanFactory;

        //we're only interested in top level definitions
        //inner beans won't appear here, so 
        boolean containsBeanDefinition = registry.containsBeanDefinition(beanName);
        if (containsBeanDefinition) {
            BeanDefinition beanDefinition = getBeanDefinition(registry, beanName);

            if (beanDefinition != null) {
                singleton = beanDefinition.isSingleton();
            }
        } else {
            if (logger.isDebugEnabled()) {
                logger.debug("Cannot check whether bean definition " + beanName
                        + " is singleton as it is not available as a top level bean");
            }
        }
    }
    return singleton;
}

From source file:org.kuali.rice.test.CompositeBeanFactory.java

@Override
public boolean containsBean(String name) {
    for (BeanFactory f : factories) {
        try {/*w w  w . j  ava 2 s.  c om*/
            boolean b = f.containsBean(name);
            if (b) {
                return b;
            }
        } catch (BeansException e) {
            LOG.info("bean exception", e);
        }
    }
    return false;
}

From source file:org.springframework.beans.factory.access.el.SpringBeanELResolver.java

@Override
public Object getValue(ELContext elContext, Object base, Object property) throws ELException {
    if (base == null) {
        String beanName = property.toString();
        BeanFactory bf = getBeanFactory(elContext);
        if (bf.containsBean(beanName)) {
            if (logger.isTraceEnabled()) {
                logger.trace("Successfully resolved variable '" + beanName + "' in Spring BeanFactory");
            }/*from w  w w . j a v  a 2s  . c o  m*/
            elContext.setPropertyResolved(true);
            return bf.getBean(beanName);
        }
    }
    return null;
}

From source file:org.springframework.beans.factory.support.AbstractBeanFactory.java

public boolean containsBean(String name) {
    if (containsLocalBean(name)) {
        return true;
    }/*from   w ww .j  av  a2 s  .  c  o m*/
    // Not found -> check parent.
    BeanFactory parentBeanFactory = getParentBeanFactory();
    if (parentBeanFactory != null) {
        return parentBeanFactory.containsBean(name);
    }
    return false;
}

From source file:org.springframework.beans.factory.xml.XmlBeanFactoryTests.java

private void doTestAutowire(DefaultListableBeanFactory xbf) throws Exception {
    DependenciesBean rod1 = (DependenciesBean) xbf.getBean("rod1");
    TestBean kerry = (TestBean) xbf.getBean("spouse");
    // should have been autowired
    assertEquals(kerry, rod1.getSpouse());

    DependenciesBean rod1a = (DependenciesBean) xbf.getBean("rod1a");
    // should have been autowired
    assertEquals(kerry, rod1a.getSpouse());

    DependenciesBean rod2 = (DependenciesBean) xbf.getBean("rod2");
    // should have been autowired
    assertEquals(kerry, rod2.getSpouse());

    DependenciesBean rod2a = (DependenciesBean) xbf.getBean("rod2a");
    // should have been set explicitly
    assertEquals(kerry, rod2a.getSpouse());

    ConstructorDependenciesBean rod3 = (ConstructorDependenciesBean) xbf.getBean("rod3");
    IndexedTestBean other = (IndexedTestBean) xbf.getBean("other");
    // should have been autowired
    assertEquals(kerry, rod3.getSpouse1());
    assertEquals(kerry, rod3.getSpouse2());
    assertEquals(other, rod3.getOther());

    ConstructorDependenciesBean rod3a = (ConstructorDependenciesBean) xbf.getBean("rod3a");
    // should have been autowired
    assertEquals(kerry, rod3a.getSpouse1());
    assertEquals(kerry, rod3a.getSpouse2());
    assertEquals(other, rod3a.getOther());

    try {// ww w . j  a  va 2  s .c o  m
        xbf.getBean("rod4", ConstructorDependenciesBean.class);
        fail("Must have thrown a FatalBeanException");
    } catch (FatalBeanException expected) {
        // expected
    }

    DependenciesBean rod5 = (DependenciesBean) xbf.getBean("rod5");
    // Should not have been autowired
    assertNull(rod5.getSpouse());

    BeanFactory appCtx = (BeanFactory) xbf.getBean("childAppCtx");
    assertTrue(appCtx.containsBean("rod1"));
    assertTrue(appCtx.containsBean("jenny"));
}

From source file:org.springframework.boot.autoconfigure.AutoConfigurationPackages.java

/**
 * Determine if the auto-configuration base packages for the given bean factory are
 * available./* w w  w.  jav a2  s.  c  o m*/
 * @param beanFactory the source bean factory
 * @return true if there are auto-config packages available
 */
public static boolean has(BeanFactory beanFactory) {
    return beanFactory.containsBean(BEAN) && !get(beanFactory).isEmpty();
}

From source file:org.springframework.integration.handler.support.MessagingMethodInvokerHelper.java

private synchronized void initialize() throws Exception {
    if (!this.initialized) {
        BeanFactory beanFactory = getBeanFactory();
        if (beanFactory != null && beanFactory
                .containsBean(IntegrationContextUtils.ARGUMENT_RESOLVER_MESSAGE_CONVERTER_BEAN_NAME)) {

            try {
                MessageConverter messageConverter = beanFactory.getBean(
                        IntegrationContextUtils.ARGUMENT_RESOLVER_MESSAGE_CONVERTER_BEAN_NAME,
                        MessageConverter.class);

                this.messageHandlerMethodFactory.setMessageConverter(messageConverter);

                HandlerMethodArgumentResolversHolder handlerMethodArgumentResolversHolder = beanFactory.getBean(
                        this.canProcessMessageList ? IntegrationContextUtils.LIST_ARGUMENT_RESOLVERS_BEAN_NAME
                                : IntegrationContextUtils.ARGUMENT_RESOLVERS_BEAN_NAME,
                        HandlerMethodArgumentResolversHolder.class);

                this.messageHandlerMethodFactory
                        .setCustomArgumentResolvers(handlerMethodArgumentResolversHolder.getResolvers());
            } catch (NoSuchBeanDefinitionException e) {
                configureLocalMessageHandlerFactory();
            }//from   ww  w  . java  2s  .  c o  m
        } else {
            configureLocalMessageHandlerFactory();
        }

        this.messageHandlerMethodFactory.afterPropertiesSet();
        prepareEvaluationContext();
        this.initialized = true;
    }
}