ConfigurableListableBeanFactory

ConfigurableListableBeanFactory is the full interface of the bean container: besides handing out beans, it lets code change bean definitions and the container's setup before any bean is created.

Why

Most applications never need it. Beans are declared with annotations, and the generator registers them. It is for code that adjusts the container itself:

• a BeanFactoryPostProcessor that makes some beans lazy or checks that a bean exists;
• code that registers an object that is not a bean, such as one built in main, so beans can inject it;
• code that registers a custom scope or adds a bean post-processor;
• a test or tool that uses a container without a context.

You get it in two places: as the argument of BeanFactoryPostProcessor.postProcessBeanFactory, and as context.beanFactory. The latter is available before refresh().

DefaultListableBeanFactory is its implementation. Every application context owns one. Create one yourself for a small container without a context: a command-line tool, a test, a library that wires a few objects. Without a context there is no environment, no event delivery, no detection of post-processor beans and no lifecycle management.

The interfaces it combines

DefaultListableBeanFactory also implements BeanDefinitionRegistry (registerBeanDefinition, removeBeanDefinition, ...).

Example

In a post-processor:

import 'package:spring_core_dart/spring_core_dart.dart';

// The slow `reports` bean starts on first use; `auditLog` must exist.
@Component()
class AdjustBeans implements BeanFactoryPostProcessor {
  @override
  void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    beanFactory.getBeanDefinition('reports').lazy = true;
    if (!beanFactory.containsBeanDefinition('auditLog')) {
      throw StateError('An auditLog bean is required');
    }
  }
}

Before the context starts:

abstract interface class Clock {
  DateTime now();
}

class SystemClock implements Clock {
  @override
  DateTime now() => DateTime.now();
}

void main() {
  final context = AnnotationConfigApplicationContext([appBeans]);
  context.beanFactory
    // An object built here, injectable as a Clock.
    ..registerSingleton(
      'clock',
      SystemClock(),
      types: const [SystemClock, Clock],
    )
    // A library expects 'primaryDb'; the application named it 'dataSource'.
    ..registerAlias('dataSource', 'primaryDb')
    ..registerScope('screen', SimpleMapScope());
  context.refresh();
}

A container without a context:

class Repo {}

class Service {
  Service(this.repo);
  final Repo repo;
}

void main() {
  final factory = DefaultListableBeanFactory()
    ..registerBeanDefinition(
      BeanDefinition<Repo>(name: 'repo', create: (_) => Repo()),
    )
    ..registerBeanDefinition(
      BeanDefinition<Service>(
        name: 'service',
        dependencies: const [Dependency(Repo)],
        create: (r) => Service(r.dependency<Repo>()),
      ),
    )
    ..validateBeanGraph()
    ..preInstantiateSingletons();

  final service = factory.getBean<Service>();
  factory.destroySingletons();
}

Members

Specific to ConfigurableListableBeanFactory:

From ConfigurableBeanFactory:

From SingletonBeanRegistry: registerSingleton(name, singleton, {types}) registers a ready-made object. It is found by its name and by the listed types (its runtime type by default). No injection, init or destroy callback runs for it.

On DefaultListableBeanFactory only: the constructor takes an optional parentBeanFactory, and allowBeanDefinitionOverriding (false by default) lets a definition replace another with the same name.

In Spring (Java)

@Component
class AdjustBeans implements BeanFactoryPostProcessor {
  @Override
  public void postProcessBeanFactory(ConfigurableListableBeanFactory factory) {
    factory.getBeanDefinition("reports").setLazyInit(true);
  }
}

ConfigurableListableBeanFactory factory = context.getBeanFactory();
factory.registerSingleton("clock", new SystemClock());
factory.registerScope("screen", new SimpleThreadScope());

Differences that matter:

• Definitions carry closures and their lookup types instead of class names. There is no reflection.
• registerSingleton must list every type the object should be found by. Spring finds the supertypes by reflection.
• validateBeanGraph() has no Spring counterpart. Spring finds missing beans and cycles only while creating beans.
• Circular references are always an error. There are no early singleton references.
• getBean<T>({qualifier}) and getBeanByName(name) replace the overloads of getBean.

See also

• BeanFactoryPostProcessor
• BeanPostProcessor
• ApplicationContext (beanFactory)
• ObjectProvider
• FactoryBean
• @Scope
• @Configurable