Java Programming - MCQ Practice Questions

Singleton beans are instantiated once per Spring container and reused for the application's lifetime, making them memory-efficient for stateless objects.

@Component is a generic stereotype, while @Service is a specialized annotation indicating the class contains business logic, improving code readability.

@SpringBootApplication is a convenience annotation that combines three key annotations for configuration, component scanning, and auto-configuration.

Both @Primary (default choice) and @Qualifier (explicit selection by name) can resolve bean ambiguity. @Qualifier is more explicit and takes precedence over @Primary.

@PropertySource allows loading properties from external files (like .properties or .yml) into the Spring Environment for use throughout the application.

@Repository marks a class as a data access component and enables Spring to translate persistence-specific exceptions into Spring's DataAccessException hierarchy.

DI reduces tight coupling between classes, making code more maintainable, testable, and flexible for changes or mock implementations during testing.

Spring can resolve circular dependencies when at least one injection is done via setter method rather than constructor, allowing lazy initialization.

BeanFactory is the core interface for accessing beans, providing lazy initialization. ApplicationContext extends BeanFactory with additional enterprise features.

A Join Point is a candidate point in program execution (method call, exception throw) where advice can be applied. Pointcuts select specific Join Points.

@Transactional delegates transaction management to Spring, automatically committing on success and rolling back on exceptions, following ACID principles.

@Conditional provides fine-grained control, @Profile handles environment-specific beans, and factory beans offer explicit creation logic. Choice depends on use case requirements.

@ConfigurationProperties enables binding of external properties (from application.properties/yml) to POJO classes, providing type safety and validation.

Spring AOP with a custom aspect provides centralized, reusable cross-cutting concern implementation without code duplication in individual methods.

Spring raises NoUniqueBeanDefinitionException when ambiguity exists. Use @Primary or @Qualifier to resolve the ambiguity.

FactoryBean allows creating beans with sophisticated initialization logic through getObject() method, useful for complex object creation.

@EnableCaching activates Spring's caching infrastructure, allowing method-level caching through annotations like @Cacheable to store and retrieve results.

Request-scoped beans are instantiated per HTTP request and destroyed after request completion, ideal for storing user-specific or request-specific information.

Constructor injection enforces required dependencies and creates immutable objects; setter injection allows optional dependencies and partial initialization.

@Component, @Service, @Repository, and @Controller are all stereotype annotations that mark classes as Spring Beans. @Bean is used for method-level bean definition.