คอนเทนเนอร์ Spring IoC

Inversion of Control (IoC) means your objects no longer create their own collaborators. Instead, a container constructs them and hands over (injects) their dependencies.

This flips the traditional flow: rather than calling new everywhere, you declare what you need and let the framework wire it up.

Spring’s IoC container is the ApplicationContext. It reads bean definitions, instantiates them, resolves dependencies, and manages their lifecycle from creation to shutdown.

In Spring Boot, SpringApplication.run builds this context for you and keeps it running.

A bean is simply an object that the container creates and manages. The context knows how to build it, what it depends on, and when to destroy it.

Beans are typically singletons living for the life of the application, though other scopes exist.

Annotate a class with @Component and component scanning will register it. Specializations like @Service, @Repository, and @Controller are @Component with added semantics.

@SpringBootApplication includes @ComponentScan, which searches the main class’s package and sub-packages for stereotype annotations. Keep your classes under that root package so they are discovered.

For types you do not own or want to configure manually, define a factory method annotated @Bean inside a @Configuration class. The return value becomes a managed bean.

Both create beans, but differ in control:

• @Component — you own the class and let scanning register it
• @Bean — explicit factory method, ideal for third-party classes or conditional construction

The container reads a bean’s constructor parameters and supplies matching beans. Here OrderService receives a fully built OrderRepository automatically.

Spring injects by type. If exactly one bean matches the parameter type, it is wired in. The bean’s concrete class can implement an interface, and you inject the interface.

When several beans match a type, disambiguate with @Primary on the default, or @Qualifier at the injection point to name the exact one.

Delegating wiring to the container brings real benefits:

• Testability — inject mocks instead of real collaborators
• Loose coupling — depend on interfaces, not constructors
• Centralized lifecycle — one place manages creation and shutdown

The IoC container wires your application together.

• IoC means the container, not your code, creates and injects collaborators
• The ApplicationContext manages beans
• @Component + scanning registers your classes; @Bean handles others
• Injection resolves by type, disambiguated with @Primary/@Qualifier