The IoC Container

Beans, dependency injection, and the ApplicationContext — the one idea the whole framework is built on.

The problem Spring solves

Without a framework, objects create their own collaborators:

class TransferService {
  // tightly coupled: TransferService decides the exact implementation
  private AccountRepository repo = new JdbcAccountRepository();
}

Now TransferService can never use a different repository, and you can't unit-test it with a fake. It controls its own dependencies. Inversion of Control (IoC) flips that: the framework decides what to create and hands dependencies in.

class TransferService {
  private final AccountRepository repo;
  // the dependency is injected from outside — constructor injection
  TransferService(AccountRepository repo) { this.repo = repo; }
}

Beans and the container

A bean is simply an object that the Spring IoC container instantiates, assembles, and manages. You describe what beans exist and how they depend on each other (via annotations, Java @Configuration, or XML); the container reads that metadata and builds the fully-wired object graph for you.

BeanFactory vs ApplicationContext

There are two container interfaces. You will use ApplicationContext — but the exam tests that you know how they differ.

Common ApplicationContext implementations

// From @Configuration / @Component classes (the modern default)
ApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class);

// From XML on the classpath
ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");

TransferService svc = ctx.getBean(TransferService.class);

Note: DefaultListableBeanFactory is a BeanFactory, not an ApplicationContext — a favourite distractor in "which of these is an ApplicationContext?" questions.

The three ways to inject

• Constructor injection — preferred. Enables final fields, guarantees fully-built objects, trivially testable. Mandatory dependencies.
• Setter injection — for optional or reconfigurable dependencies.
• Field injection — @Autowired on a field. Discouraged: hides dependencies, can't be final, hard to instantiate in a plain unit test.

Check yourself

Exam-shaped questions. Answer before revealing — retrieval is what makes it stick.