How to use

ConfigurableBeanFactory

in

org.springframework.beans.factory.config

/**
 * Resolve the given annotation-specified value,
 * potentially containing placeholders and expressions.
 */
private Object resolveStringValue(String value) {
  if (this.configurableBeanFactory == null) {
    return value;
  }
  String placeholdersResolved = this.configurableBeanFactory.resolveEmbeddedValue(value);
  BeanExpressionResolver exprResolver = this.configurableBeanFactory.getBeanExpressionResolver();
  if (exprResolver == null) {
    return value;
  }
  return exprResolver.evaluate(placeholdersResolved, this.expressionContext);
}

boolean alreadyInCreation = beanFactory.isCurrentlyInCreation(beanName);
try {
  if (alreadyInCreation) {
    beanFactory.setCurrentlyInCreation(beanName, false);
  if (useArgs && beanFactory.isSingleton(beanName)) {
  Object beanInstance = (useArgs ? beanFactory.getBean(beanName, beanMethodArgs) :
      beanFactory.getBean(beanName));
  if (!ClassUtils.isAssignableValue(beanMethod.getReturnType(), beanInstance)) {
          beanMethod.getReturnType().getName(), beanInstance.getClass().getName());
      try {
        BeanDefinition beanDefinition = beanFactory.getMergedBeanDefinition(beanName);
        msg += " Overriding bean of same name declared in: " + beanDefinition.getResourceDescription();
  if (currentlyInvoked != null) {
    String outerBeanName = BeanAnnotationHelper.determineBeanNameFor(currentlyInvoked);
    beanFactory.registerDependentBean(beanName, outerBeanName);
    beanFactory.setCurrentlyInCreation(beanName, true);

private void createHealthIndicatorForLimiter(ConfigurableBeanFactory beanFactory, String name, RateLimiter rateLimiter) {
  beanFactory.registerSingleton(
      name + "RateLimiterHealthIndicator",
      new RateLimiterHealthIndicator(rateLimiter)
  );
}

@Override
public void setBeanFactory(BeanFactory beanFactory) {
  this.beanFactory = beanFactory;
  if (beanFactory instanceof ConfigurableBeanFactory) {
    ConfigurableBeanFactory cbf = (ConfigurableBeanFactory) beanFactory;
    if (this.beanClassLoader == null) {
      this.beanClassLoader = cbf.getBeanClassLoader();
    }
    this.retrievalMutex = cbf.getSingletonMutex();
  }
}

/**
 * Check the BeanFactory to see whether the bean named <var>beanName</var> already
 * exists. Accounts for the fact that the requested bean may be "in creation", i.e.:
 * we're in the middle of servicing the initial request for this bean. From an enhanced
 * factory method's perspective, this means that the bean does not actually yet exist,
 * and that it is now our job to create it for the first time by executing the logic
 * in the corresponding factory method.
 * <p>Said another way, this check repurposes
 * {@link ConfigurableBeanFactory#isCurrentlyInCreation(String)} to determine whether
 * the container is calling this method or the user is calling this method.
 * @param beanName name of bean to check for
 * @return whether <var>beanName</var> already exists in the factory
 */
private boolean factoryContainsBean(ConfigurableBeanFactory beanFactory, String beanName) {
  return (beanFactory.containsBean(beanName) && !beanFactory.isCurrentlyInCreation(beanName));
}

@Nullable
public Object getObject(String key) {
  if (this.beanFactory.containsBean(key)) {
    return this.beanFactory.getBean(key);
  }
  else if (this.scope != null) {
    return this.scope.resolveContextualObject(key);
  }
  else {
    return null;
  }
}

@Override
public void copyConfigurationFrom(ConfigurableBeanFactory otherFactory) {
  Assert.notNull(otherFactory, "BeanFactory must not be null");
  setBeanClassLoader(otherFactory.getBeanClassLoader());
  setCacheBeanMetadata(otherFactory.isCacheBeanMetadata());
  setBeanExpressionResolver(otherFactory.getBeanExpressionResolver());
  setConversionService(otherFactory.getConversionService());
  if (otherFactory instanceof AbstractBeanFactory) {
    AbstractBeanFactory otherAbstractFactory = (AbstractBeanFactory) otherFactory;
    this.propertyEditorRegistrars.addAll(otherAbstractFactory.propertyEditorRegistrars);
    this.customEditors.putAll(otherAbstractFactory.customEditors);
    this.typeConverter = otherAbstractFactory.typeConverter;
    this.beanPostProcessors.addAll(otherAbstractFactory.beanPostProcessors);
    this.hasInstantiationAwareBeanPostProcessors = this.hasInstantiationAwareBeanPostProcessors ||
        otherAbstractFactory.hasInstantiationAwareBeanPostProcessors;
    this.hasDestructionAwareBeanPostProcessors = this.hasDestructionAwareBeanPostProcessors ||
        otherAbstractFactory.hasDestructionAwareBeanPostProcessors;
    this.scopes.putAll(otherAbstractFactory.scopes);
    this.securityContextProvider = otherAbstractFactory.securityContextProvider;
  }
  else {
    setTypeConverter(otherFactory.getTypeConverter());
    String[] otherScopeNames = otherFactory.getRegisteredScopeNames();
    for (String scopeName : otherScopeNames) {
      this.scopes.put(scopeName, otherFactory.getRegisteredScope(scopeName));
    }
  }
}

/**
 * Resolve the specified value if possible.
 *
 * @see ConfigurableBeanFactory#resolveEmbeddedValue
 */
private String resolve(String value) {
  if (this.beanFactory != null && this.beanFactory instanceof ConfigurableBeanFactory) {
    return ((ConfigurableBeanFactory) this.beanFactory).resolveEmbeddedValue(value);
  }
  return value;
}

/**
 * Resolve placeholder property values, e.g.
 * <br />
 * <br />
 * "${somePropertyValue}" -> "the actual property value"
 */
public Object resolvePropertyValue(ConfigurableBeanFactory beanFactory, String beanName, String placeholder) {
 // resolve string value
 String strVal = beanFactory.resolveEmbeddedValue(placeholder);
 BeanDefinition bd = (beanFactory.containsBean(beanName) ? beanFactory
   .getMergedBeanDefinition(beanName) : null);
 // resolve expressions like "#{systemProperties.myProp}"
 return evaluateBeanDefinitionString(beanFactory, strVal, bd);
}

if (factory.containsSingleton(name)) {
  log.warn("Singleton {} already exists, try unload first", name);
  return;
  log.debug("Lookup common - bean:{} local:{} singleton:{}", new Object[] { factory.containsBean("red5.common"), factory.containsLocalBean("red5.common"), factory.containsSingleton("red5.common"), });
  parentContext = (ApplicationContext) factory.getBean("red5.common");
factory.registerSingleton(name, context);

public void copyConfigurationFrom(ConfigurableBeanFactory otherFactory) {
  Assert.notNull(otherFactory, "BeanFactory must not be null");
  setBeanClassLoader(otherFactory.getBeanClassLoader());
  setCacheBeanMetadata(otherFactory.isCacheBeanMetadata());
  setBeanExpressionResolver(otherFactory.getBeanExpressionResolver());
  if (otherFactory instanceof AbstractBeanFactory) {
    AbstractBeanFactory otherAbstractFactory = (AbstractBeanFactory) otherFactory;
    this.customEditors.putAll(otherAbstractFactory.customEditors);
    this.propertyEditorRegistrars.addAll(otherAbstractFactory.propertyEditorRegistrars);
    this.beanPostProcessors.addAll(otherAbstractFactory.beanPostProcessors);
    this.hasInstantiationAwareBeanPostProcessors = this.hasInstantiationAwareBeanPostProcessors ||
        otherAbstractFactory.hasInstantiationAwareBeanPostProcessors;
    this.hasDestructionAwareBeanPostProcessors = this.hasDestructionAwareBeanPostProcessors ||
        otherAbstractFactory.hasDestructionAwareBeanPostProcessors;
    this.scopes.putAll(otherAbstractFactory.scopes);
    this.securityContextProvider = otherAbstractFactory.securityContextProvider;
  }
  else {
    setTypeConverter(otherFactory.getTypeConverter());
  }
}

@Override
public void beforeTestClass(TestContext testContext) throws Exception {
  ConfigurableBeanFactory beanFactory = (ConfigurableBeanFactory) testContext
      .getApplicationContext().getAutowireCapableBeanFactory();
  if (!beanFactory.containsBean("mockMvcClientHttpRequestFactory")) {
    this.factory = new MockMvcClientHttpRequestFactory(
        beanFactory.getBean(MockMvc.class));
    beanFactory.registerSingleton("mockMvcClientHttpRequestFactory",
        this.factory);
  }
  else {
    this.factory = beanFactory.getBean("mockMvcClientHttpRequestFactory",
        MockMvcClientHttpRequestFactory.class);
  }
}

@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
  if (beanFactory instanceof ConfigurableBeanFactory) {
    Object typeConverter = ((ConfigurableBeanFactory) beanFactory).getTypeConverter();
    if (typeConverter instanceof SimpleTypeConverter) {
      delegate = (SimpleTypeConverter) typeConverter;
    }
  }
}

public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
  // TODO: This code can never happen...
  if (converter == null && beanFactory instanceof ConfigurableBeanFactory) {
    ConfigurableBeanFactory cFB = (ConfigurableBeanFactory) beanFactory;
    ConversionService conversionService = cFB.getConversionService();
    converter = (conversionService != null ? new Converter(conversionService)
        : new Converter(cFB.getTypeConverter()));
  }
}

@Override
@Nullable
public ClassLoader getAspectClassLoader() {
  return (this.beanFactory instanceof ConfigurableBeanFactory ?
      ((ConfigurableBeanFactory) this.beanFactory).getBeanClassLoader() :
      ClassUtils.getDefaultClassLoader());
}

@Override
public Object getTargetObject() {
  return this.beanFactory.getBean(this.targetBeanName);
}

sec.addPropertyAccessor(new EnvironmentAccessor());
sec.setBeanResolver(new BeanFactoryResolver(evalContext.getBeanFactory()));
sec.setTypeLocator(new StandardTypeLocator(evalContext.getBeanFactory().getBeanClassLoader()));
ConversionService conversionService = evalContext.getBeanFactory().getConversionService();
if (conversionService != null) {
  sec.setTypeConverter(new StandardTypeConverter(conversionService));

if (beanFactory.isCurrentlyInCreation(scopedBeanName)) {
  beanName = scopedBeanName;
Object factoryBean = beanFactory.getBean(BeanFactory.FACTORY_BEAN_PREFIX + beanName);
if (factoryBean instanceof ScopedProxyFactoryBean) {

private void buildMessage(StringBuilder message, String beanName) {
  try {
    BeanDefinition definition = this.beanFactory
        .getMergedBeanDefinition(beanName);
    message.append(getDefinitionDescription(beanName, definition));
  }
  catch (NoSuchBeanDefinitionException ex) {
    message.append(String
        .format("\t- %s: a programmatically registered singleton", beanName));
  }
}

private Object evaluateBeanDefinitionString(ConfigurableBeanFactory beanFactory, String value,
  BeanDefinition beanDefinition) {
 if (beanFactory.getBeanExpressionResolver() == null) {
  return value;
 }
 Scope scope = (beanDefinition != null ? beanFactory
   .getRegisteredScope(beanDefinition.getScope()) : null);
 return beanFactory.getBeanExpressionResolver()
   .evaluate(value, new BeanExpressionContext(beanFactory, scope));
}