Dependency Injection and Beans Interview Questions

Dependency injection is a design technique where an object receives the objects it needs instead of creating them itself. Spring’s container creates the dependencies and supplies them to the object.

The common types are constructor injection, setter injection, and field injection. Constructor injection is normally preferred because required dependencies are explicit and the object can be immutable.

Constructor injection makes required dependencies visible, supports final fields, prevents partially initialized objects, and makes unit testing simple because dependencies can be passed directly.

Constructor injection is best for required dependencies. Setter injection suits optional or changeable dependencies. Field injection is short but hides dependencies and makes plain unit testing harder, so it is generally avoided.

Autowiring is Spring’s process of finding a bean that matches a dependency and injecting it automatically. Spring can match by type and use @Qualifier or @Primary when more than one candidate exists.

@Autowired asks Spring to resolve and inject a dependency. Since Spring 4.3, a class with one constructor does not need @Autowired on that constructor; Spring uses it automatically.

@Autowired asks Spring to resolve and inject a dependency. Since Spring 4.3, a class with one constructor does not need @Autowired on that constructor; Spring uses it automatically.

@Primary marks the default bean when several candidates have the same type. @Qualifier selects a specific named or qualified bean at an injection point.

Spring reports an ambiguity error unless one bean is marked @Primary, the injection point uses @Qualifier, or the application injects a collection or map of all matching beans.

Common scopes are singleton, prototype, request, session, application, and websocket. Singleton is the default, meaning one bean instance is created per ApplicationContext.

Common scopes are singleton, prototype, request, session, application, and websocket. Singleton is the default, meaning one bean instance is created per ApplicationContext.

Spring creates the bean, injects dependencies, applies post-processors, calls initialization callbacks, and makes it available. During context shutdown it calls destruction callbacks for beans that support them.

@PostConstruct runs after dependency injection and is useful for initialization. @PreDestroy runs before bean destruction and is useful for releasing resources.

A circular dependency occurs when bean A needs bean B while bean B also needs bean A. Constructor cycles usually fail fast because neither object can be created first.

Prefer redesigning the classes so responsibilities are separated. If the relationship is genuinely optional, setter or lazy injection can help, but using it only to hide a design problem is not recommended.