🌱 Spring Boot Interview Series – Q6 💡: Dependency Injection & Bean Management Deep Dive 🚀🛠️📜
21️⃣ Difference between @Component, @Service, @Repository, and @Controller
Spring Boot uses stereotype annotations to manage beans and organize layers:
- @Component – Generic annotation for any Spring-managed bean.
- @Service – Marks service layer classes for business logic.
- @Repository – Marks DAO layer classes; enables automatic exception translation.
- @Controller – Handles HTTP requests; used with MVC or REST APIs.
💡 Real-time Example:
@Repository
public class UserRepository { ... }
@Service
public class UserService {
@Autowired
private UserRepository userRepository;
}
22️⃣ Difference between @Bean and @Component
@Component → automatic bean detection via component scanning.
@Bean → explicit bean creation inside a @Configuration class; perfect for third-party classes or custom initialization.
@Configuration
public class AppConfig {
@Bean
public PaymentService paymentService() {
return new CreditCardPaymentService();
}
}
⚠️ Common mistake: Using @Component on external library classes will not work. Use @Bean instead.
23️⃣ How does @Configuration differ from @Component
@Configuration is a special type of @Component used to declare beans via @Bean methods. Spring ensures singleton beans using CGLIB proxies.
⚠️ Common mistake:
@Component
public class AppConfig {
@Bean
public PaymentService paymentService() { ... }
}
This can break singleton guarantees.
24️⃣ What is a Bean definition in Spring Boot
A bean is any object managed by Spring IoC container.
Bean definition = metadata describing the bean: class, scope, dependencies, init/destroy methods. Spring uses this to instantiate and manage lifecycle.
25️⃣ What is bean scope in Spring Boot? Name all scopes
| Scope | Description |
|---|---|
| singleton | Default, one instance per container |
| prototype | New instance each time requested |
| request | One instance per HTTP request |
| session | One instance per HTTP session |
| application | One instance per ServletContext |
| websocket | One instance per WebSocket session |
26️⃣ Difference between singleton and prototype bean scope
Singleton beans are shared across the container; prototype beans are new per request.
Singleton → CheckoutService Prototype → ShoppingCart per user
27️⃣ What is @Primary and when is it used
@Primary resolves ambiguity when multiple beans of the same type exist. Spring injects the primary bean by default.
@Component
@Primary
public class FastPaymentService implements PaymentService {}
28️⃣ How to use @Qualifier to resolve bean conflicts
@Autowired
@Qualifier("fastPaymentService")
private PaymentService paymentService;
💡 @Primary = default; @Qualifier = explicit selection.
29️⃣ Field injection vs Setter vs Constructor injection
| Type | Pros | Cons / Real-time proof |
|---|---|---|
| Field | Quick, simple | Hard to unit test; could be null outside Spring |
| Setter | Testable, optional | Mutable; accidental reassignment possible |
| Constructor | Immutable, testable, fail-fast | More boilerplate; safest for production |
30️⃣ Why constructor injection is recommended
@Component
public class CheckoutService {
private final PaymentService paymentService;
@Autowired
public CheckoutService(PaymentService paymentService) {
this.paymentService = paymentService;
}
}
✅ Ensures immutability, fail-fast, unit-testable. ❌ Mistake: making fields public breaks safety.
31️⃣ Can Spring Boot inject values into static fields?
❌ No. Spring injects instance-level fields only.
Workarounds:
- Use @PostConstruct to assign static fields from instance fields.
- Prefer singleton beans instead of static injection.
32️⃣ How to load values from application.properties into a bean
@Component
public class AppConfig {
@Value("${app.name}")
private String appName;
}
33️⃣ What is @Value used for
Inject property values from application.properties, application.yml, or environment variables. Supports SpEL:
@Value("#{2 * 2}") // injects 4
34️⃣ How to bind a group of properties to a POJO
@Component
@ConfigurationProperties(prefix = "db")
public class DbProperties {
private String url;
private String username;
private String password;
}
💡 Supports relaxed binding: db-url → dbUrl
35️⃣ How to create a lazy-loaded bean in Spring Boot
@Component
@Lazy
public class RecommendationEngine {
public RecommendationEngine() {
System.out.println("ML model loaded!");
}
}
Real-time scenario: E-commerce recommendation engine only loads when a user opens “Recommended for You”. Saves startup time & memory.
🌈 Wrapping Up
Dependency Injection & Bean Management is the heartbeat of Spring Boot. Key takeaways:
- Master stereotypes, scopes, injection types.
- Use constructor injection with final fields for safe, testable, production-ready code.
- Use @Lazy for heavy or optional beans to optimize startup and memory.
- Understand @Primary, @Qualifier, @Value, @ConfigurationProperties for real-world apps.
💡 Interview tip: Use real-time examples like checkout/payment systems, shopping carts, or ML-based recommendations to explain DI concepts. Shows deep understanding beyond syntax!
Comments
Post a Comment