Spring Boot Interview Questions and Answers

1. Explain Inversion of Control (IoC) in Spring.

Inversion of Control is a design principle in which the control of an object is created and lifecycle management is given to the container. Spring achieves IoC through Dependency Injection (DI).

2. How do you configure a Spring Bean?

The steps to be followed in configuring a spring bean are:

XML Configuration: Define beans in an XML file.
Annotation-based: Use @Component, @Bean, or other annotations.
Java-based: Use @Configuration and @Bean annotations in Java classes.

3. Explain the Spring Bean Lifecycle.

Life Cycle of Spring Bean

Bean Instantiation
Dependency Injection
@PostConstruct or InitializingBean.afterPropertiesSet()
Bean is Ready to Use
@PreDestroy or DisposableBean.destroy()

4. What are the different scopes of a Spring Bean?

Scope of a Spring bean

Singleton
Prototype
Request (Web-specific)
Session (Web-specific)
Application (Web-specific)

5. What are Spring’s key modules?

The key modules of spring are:

Core Container (Beans, Core, Context, Expression Language)
AOP and Instrumentation
Data Access/Integration (JDBC, ORM, JMS, Transactions)
Web (Web, WebSocket, Web MVC)

6. How does Spring manage transactions and handle exceptions?

Spring manages transactions through the PlatformTransactionManager interface using programmatic or declarative transaction management. To perform centralized exception handling in web applications, it provides @ControllerAdvice and @ExceptionHandler annotations.

7. What is the DispatcherServlet in Spring MVC?

DispatcherServlet is the central controller in Spring MVC. It routes requests to the appropriate controllers and views.

8. What is the difference between @RequestMapping and @GetMapping?

@RequestMapping: General-purpose annotation to map HTTP methods and URLs.

@GetMapping: A shortcut for @RequestMapping(method = RequestMethod.GET).

9. What is the difference between @Autowired and @Qualifier?

@Autowired: Automatically injects a bean by type.

@Qualifier: Specifies the exact bean to inject when there are multiple candidates.

10. If you have two beans of the same type, Spring throws an error during autowiring. How do you resolve this?

Spring fails to autowire when multiple beans of the same type exist, as it cannot decide which one to inject.

To resolve this:

Use @Qualifier to specify the exact bean.

Example:

@Component(“beanOne”) public class BeanOne implements MyInterface {} @Component(“beanTwo”) public class BeanTwo implements MyInterface {} @Service public class MyService { @Autowired @Qualifier(“beanOne”) private MyInterface myBean; }

11. What are Profiles and Spring Actuators in Spring?

Profiles allow you to define separate configurations for different environments like development, testing, production using the @Profile annotation. Spring Actuator provides monitoring and management features like health checks, metrics, and environment information for Spring Boot applications.

12. What are the different types of Dependency Injection in Spring?

Constructor Injection
Setter Injection

Constructor Injection: Dependency injection where required dependencies are provided to a class via its constructor.

Setter Injection: Definition: Dependency injection where dependencies are provided via public setter methods.

13. What is AOP in Spring?

Aspect-Oriented Programming (AOP) is a paradigm in Spring that provides the ability to modularize cross-cutting concerns like logging, security, and transaction management using aspects.

14. What is the difference between BeanFactory and ApplicationContext?

BeanFactory: basic IoC container with lazy loading.

ApplicationContext: more advanced container with features like event propagation and internationalization.

15. What is Spring Cloud?

Spring Cloud provides tools for building distributed systems that includes:

Configuration management,
service discovery,
circuit breakers.

16. What is field injection?

Field Injection

Dependencies are injected directly into fields using the @Autowired annotation.

Advantages:

Simplifies code by eliminating boilerplate.
Suitable for small applications.

Example:

@Component public class Service { @Autowired private Repository repository; }

17. How can you use different database configurations for development and production environments in a Spring Boot application?

Use Spring Profiles.
Define separate configuration files or properties for each environment.

e.g., application-dev.properties and application-prod.properties.

Activate the profile using:

Command-line: –spring.profiles.active=dev

Programmatically:

18. Consider two beans in your application dependent on each other, resulting in a circular dependency. How do you fix it?

To break the circular dependency:

Use @Lazy: Delays bean initialization until needed.

@Component public class BeanA { @Autowired @Lazy private BeanB beanB; } @Component public class BeanB { @Autowired private BeanA beanA;

Refactor: Extract the common logic into a third bean.

19. How to implement securing a REST API endpoint (/admin) so that only users with the ADMIN role can access it.

Use Spring Security with role-based access control:

1. Add Spring Security dependency:

xml Copy code <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependency>

2. Configure security rules:

@Configuration @EnableWebSecurity public class SecurityConfig extends WebSecurityConfigurerAdapter { @Override protected void configure(HttpSecurity http) throws Exception { http.authorizeRequests() .antMatchers(“/admin”).hasRole(“ADMIN”) .antMatchers(“/public”).permitAll() .and() .formLogin(); } }

20. Why are dependencies manually injected without IoC?

Dependencies are manually instantiated and provided to the dependent class without using an IoC container to get full control over the dependency lifecycle. It is useful for lightweight applications or testing.

21. How dependencies are created programmatically?

Dependencies are created and injected programmatically at runtime using a factory or builder pattern.

Advantages:

High flexibility for runtime dependency determination.
Useful in complex applications requiring conditional dependency injection.

22. Why Dependency Injection is important?

Importance:

Promotes loose coupling between components.
Enhances testability by allowing dependencies to be mocked or replaced.
Simplifies configuration and maintenance.

23. Write a program to fetch data using Spring Data JPA.

public interface ProductRepository extends JpaRepository<Product, Long> { List<Product> findByName(String name); } @Service public class ProductService { @Autowired private ProductRepository productRepository; public List<Product> getProductsByName(String name) { return productRepository.findByName(name); } } @RestController @RequestMapping(“/products”) public class ProductController { @Autowired private ProductService productService; @GetMapping(“/search”) public List<Product> searchProducts(@RequestParam String name) { return productService.getProductsByName(name); } }

24. How to implement a global exception handler in Spring Boot?

Answer:

@ControllerAdvice public class GlobalExceptionHandler { @ExceptionHandler(ResourceNotFoundException.class) public ResponseEntity<String> handleResourceNotFound(ResourceNotFoundException ex) { return new ResponseEntity<>(ex.getMessage(), HttpStatus.NOT_FOUND); } @ExceptionHandler(Exception.class) public ResponseEntity<String> handleGenericException(Exception ex) { return new ResponseEntity<>(“An error occurred: ” + ex.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR); } }

25. How are profiles used in Spring Boot, and how are they used?

Profiles in Spring Boot allow you to define environment-specific configurations.

Use Case: Separate configurations for development, testing, and production environments.

Implementation:

1. Create environment-specific property files:

application-dev.properties application-prod.properties

2. Activate a profile in application.properties:

spring.profiles.active=dev

3. Use @Profile annotation:

@Service @Profile(“dev”) public class DevService { // Development-specific implementation } @Service @Profile(“prod”) public class ProdService { // Production-specific implementation }

Request more information

Spring Boot Interview Questions and Answers