Spring Interview Questions and Answers

Spring interview questions are commonly asked to evaluate your understanding of the Spring Framework, dependency injection, IoC, Spring MVC, Spring Boot, Spring Data JPA, and Spring Security. This collection covers the most important questions to help you prepare for coding and technical interviews.

• Covers the most frequently asked Spring interview questions with concise answers.
• Suitable for both freshers and experienced professionals preparing for technical interviews.

Spring Framework Interview Question For a Beginner

These beginner-level questions help you build a strong foundation in Spring Framework concepts commonly asked in interviews.

1. What is Spring Framework

Spring Framework is an open-source Java framework used to build scalable, robust, and enterprise-level applications. It simplifies application development by providing a comprehensive programming and configuration model.

• Provides features such as Dependency Injection (DI), Inversion of Control (IoC), AOP, transaction management, and security.
• Offers a modular architecture with seamless integration for web applications, databases, REST APIs, and other enterprise technologies.

2. What are the key-features of Spring framework

Spring Framework provides several features that simplify Java application development and make applications more modular, scalable, and maintainable. Some of the key features are:

• Dependency Injection (DI): Automatically injects required dependencies into objects.
• Inversion of Control (IoC): Delegates object creation and lifecycle management to the Spring IoC Container.
• Aspect-Oriented Programming (AOP): Separates cross-cutting concerns like logging and security from business logic.
• Spring Security: Provides authentication, authorization, and protection against common security threats.

3. What are the Advantages of Spring framework

Spring Framework offers several advantages that make Java application development faster, easier, and more efficient. Some of the major advantages are:

• Loose Coupling: Reduces dependency between classes using Dependency Injection.
• Lightweight Framework: Allows using only the required Spring modules.
• Simplified Development: Reduces boilerplate code through automatic configuration and dependency management.
• Easy Integration: Integrates seamlessly with databases, ORM frameworks, messaging systems, and third-party libraries.

4. Inversion of Control(IoC)

Inversion of Control (IoC) is a design principle in which the control of creating and managing objects is transferred from the application to the Spring IoC Container.

• The Spring IoC Container creates and manages objects (beans).
• Automatically injects the required dependencies into beans.

5. Explain the Types of IoC Container

Spring provides two types of IoC Containers that are responsible for creating, configuring, and managing beans. Both containers implement the IoC principle, but they differ in terms of features and capabilities.

• BeanFactory - The basic IoC container that provides lazy initialization and is suitable for simple applications with minimal resource usage.
• ApplicationContext - An advanced IoC container that extends BeanFactory and provides additional features such as event handling, internationalization (i18n), annotation support, and automatic bean initialization.

6. Why IoC is called Inversion of Control?

Inversion of Control (IoC) is called "Inversion of Control" because the control of creating and managing objects is transferred from the application code to the Spring IoC Container. Instead of the application creating objects using new, Spring creates, configures, and manages them.

• Reduces tight coupling between classes.
• Improves maintainability and testability.

7. What is Dependency Injection(DI)

Dependency Injection is a design pattern in which the Spring IoC Container automatically provides the required dependencies (objects) to a class instead of the class creating them itself.

Types of Dependency Injection

• Constructor Injection: Dependencies are provided through the class constructor (recommended approach).
• Setter Injection: Dependencies are injected using setter methods after object creation.
• Field Injection: Dependencies are injected directly into class fields using @Autowired.

8. What are the different ways of Dependency Injection ?

Spring provides Two ways to perform Dependency Injection:

• Constructor Injection: Dependencies are injected through the class constructor.
• Setter Injection: Dependencies are injected using setter methods.

Note: Field Injection (@Autowired on fields) is a commonly used autowiring approach, but it is not considered an official type of Dependency Injection.

9. What is the difference between IoC and DI ?

10. Explain Spring Application Configuration

Spring Application Configuration is the process of defining and configuring beans, dependencies, and application settings so that the Spring IoC Container can manage them.

Ways to Configure Spring Applications

• Java-based Configuration using @Configuration and @Bean.
• Annotation-based Configuration using annotations like @Component, @Service, @Repository, and @Autowired.
• XML-based Configuration using applicationContext.xml (legacy approach).

Benefits

• Centralized bean configuration.
• Simplifies dependency management.
• Supports loose coupling.
• Easier maintenance and testing.

11. What are the different ways to configure a Spring application

There are three common ways to configure a Spring (core) application are:

• XML-based Configuration : Configures beans and their dependencies using XML configuration files.
• Annotation-based Configuration : Uses annotations such as @Component, @Service, and @Autowired to automatically configure and manage beans.
• Java-based Configuration (@Configuration + @Bean) : Uses Java configuration classes and methods to define and configure beans programmatically.

12. What are Metadata Types in Spring?

Spring metadata is the configuration information that tells the Spring IoC Container how to create, configure, and manage beans. Spring supports three types of metadata: XML metadata, Annotation metadata, and Java-based metadata.

Types of Spring Metadata

• XML Metadata: Configuration is defined in XML files such as applicationContext.xml.
• Java-based Metadata: Configuration is written in Java classes using @Configuration and @Bean annotations.
• Annotation Metadata: Configuration is provided using annotations like @Component, @Service, @Repository, @Controller, @Autowired, and @Value.

13. What is Bean Scope?

Bean Scope defines the lifecycle and visibility of a Spring bean, specifying how many instances of the bean are created and shared within the application.

Common Bean Scopes

14. What are the different types of Bean Scope?

Spring provides six bean scopes:

• Singleton: Only one instance of the bean is created per Spring IoC Container.
• Prototype: A new bean instance is created every time it is requested.
• Request: One bean instance is created for each HTTP request.
• Session: One bean instance is created for each HTTP session.
• Application: One bean instance is shared across the entire web application.
• WebSocket: One bean instance is created for each WebSocket session.

Note: Request, Session, Application, and WebSocket scopes are available only in web applications.

15. What is the Default Bean Scope in Spring?

The default bean scope in Spring is Singleton, which means the Spring IoC Container creates only one instance of a bean and shares it throughout the application.

• Improves memory usage and performance.
• Suitable for stateless beans.

16. How is a Spring Bean Created?

A Spring Bean is created and managed by the Spring IoC Container during application startup.

Bean Creation Process

• Spring reads the bean configuration.
• Creates the bean instance.
• Injects required dependencies.
• Calls initialization methods.
• Stores the bean in the IoC container for use.

17. Explain Bean LifeCycle In Spring?

The Spring Bean Lifecycle consists of bean instantiation, dependency injection, initialization, bean usage, and destruction. The Spring IoC Container manages the entire lifecycle, from creating the bean to destroying it when the application shuts down.

• Container Started : The Spring IoC Container starts and loads the application configuration.
• Bean Instantiated : Spring creates the bean object.
• Dependencies Injected : The container injects all required dependencies into the bean.
• Custom init() Method : Spring calls the initialization method before the bean is ready for use.
• Business (Utility) Method : The bean performs its business logic while the application is running.
• Custom destroy() Method : Before shutting down the container, Spring calls the destruction method to release resources.

18. What is Autowiring in Spring?

Autowiring is a feature in Spring that automatically injects required bean dependencies into another bean, eliminating the need for manual configuration.

• Supports Constructor, Setter, and Field Injection.
• Performed using the @Autowired annotation.
• Promotes loose coupling.

19. Explain different ways of Autowiring in Spring.

Spring supports three commonly used ways of autowiring dependencies

• Constructor Autowiring : Injects dependencies through the constructor and is recommended for mandatory dependencies.
• Setter Autowiring : Injects dependencies through setter methods and is mainly used for optional dependencies.
• Field Autowiring : Injects dependencies directly into class fields using @Autowired; simple but generally not recommended.

20. What are Autowiring Modes in Spring? (XML -Configuration)

In XML-based Spring configuration, autowiring modes determine how the Spring IoC Container automatically injects dependencies into beans.

Spring provides the following autowiring modes:

• no : Dependencies are configured manually. (Default mode)
• byName : Injects dependencies by matching the bean name with the property name.
• byType : Injects dependencies by matching the bean type with the property type.
• constructor : Injects dependencies through the constructor by matching constructor parameter types.

Note: These autowiring modes are used only in XML-based configuration. In modern Spring Boot applications, annotation-based autowiring using @Autowired is the preferred approach.

21. Difference between Java Object and Spring Bean?

A Java Object is created manually using the new keyword and is managed by the application, whereas a Spring Bean is created, configured, and managed by the Spring IoC Container

22. Difference between @Component and @Bean?

Both @Component and @Bean are used to register objects as Spring Beans, but they differ in how the beans are created and managed.

23. What is Spring Boot ?

Spring Boot is a Java-based framework built on top of the Spring Framework that simplifies the development of stand-alone, production-ready applications by providing auto-configuration, starter dependencies, and embedded servers.

Advantages

• Minimal configuration
• Embedded server (Tomcat)
• Starter POMs for dependencies
• Rapid development
• Cloud-friendly

24. Explain the Difference between Spring and Spring Boot

Spring is a Java framework for building applications, while Spring Boot is an extension of Spring framework that simplifies development with auto-configuration, starter dependencies, and embedded servers

25. What problems does Spring Boot solve?

Spring Boot simplifies Spring application development by reducing manual configuration and setup. It helps developers build, run, and deploy applications quickly so they can focus more on business logic than infrastructure.

Problems Solved by Spring Boot:

• Reduces Boilerplate Configuration: Eliminates most manual configuration using annotations and auto-configuration.
• Dependency Management: Manages required dependencies automatically through starter dependencies.
• Embedded Web Server: Provides a built-in server like Tomcat, so no external server is needed.
• Faster Development: Reduces setup time, enabling faster application development.

Spring Interview Question For Intermediate Level

Spring Interview Questions for Intermediate Level cover core Spring concepts such as Spring Boot, Spring MVC, annotations, REST APIs, and application configuration commonly asked in developer interviews

26. What is the flow of a Spring Boot application?

The Spring Boot application flow starts when the application is launched and ends when the response is returned to the client.

• Application Starts: main() method calls SpringApplication.run().
• IoC Container Creation: Spring creates the ApplicationContext.
• Auto-Configuration: Configures the application automatically.
• Component Scanning: Detects Spring Beans (@Controller, @Service, @Repository, etc.).
• Bean Creation: Creates beans and injects dependencies.
• Embedded Server Starts: Tomcat/Jetty/Undertow starts.
• Client Request: Client sends an HTTP request.
• Request Processing: DispatcherServlet -> Controller -> Service -> Repository -> Database.

Key Features

• Auto-Configuration.
• Starter Dependencies.
• Embedded Servers (Tomcat, Jetty, Undertow).
• Production-ready features with Actuator.
• Rapid application development.

27. What is the role of the @SpringBootApplication annotation?

It is the main annotation in a Spring Boot application. It combines with @Configuration, @EnableAutoConfiguration, and @ComponentScan to simplify application configuration and startup.

Components of @SpringBootApplication

• @Configuration: Marks the class as a configuration class for defining Spring beans.
• @EnableAutoConfiguration: Automatically configures the application based on project dependencies.
• @ComponentScan: Scans the package and sub-packages for Spring components like @Controller, @Service, @Repository, and @Component.

28. What are Spring Boot Starters?

Spring Boot Starters are pre-configured dependency packages that bundle all the required libraries for a specific feature or functionality. They simplify dependency management by eliminating the need to add and manage individual dependencies manually.

Common Spring Boot Starters

• spring-boot-starter-web: Used to build web and RESTful applications
• spring-boot-starter-data-jpa: Used for database access with JPA and Hibernate.
• spring-boot-starter-security: Provides authentication, authorization, and other security features.
• spring-boot-starter-test: Includes testing libraries such as JUnit, Mockito, and Spring Test.

29. What is Spring Boot Starter Parent?

Spring Boot Starter Parent is a parent POM that provides default dependency versions, plugin configurations, and build settings, simplifying Maven project configuration.

• Manages compatible dependency versions.
• Reduces Maven configuration.
• Configures common plugins automatically.
• Ensures consistent project builds.

30. What is Auto-Configuration in Spring Boot?

Auto-Configuration is a feature of Spring Boot that automatically configures Spring beans based on the dependencies available in the classpath and the application's configuration, reducing the need for manual setup.

Advantages

• Reduces manual configuration.
• Automatically creates required beans.
• Speeds up application development.
• Works with Starter Dependencies.

31. What is the use of application.properties file?

The application.properties file is the central configuration file in Spring Boot. It is used to configure application settings such as the server port, database connection, logging, security, and custom properties without changing the source code.

32. Explain Profiles in Spring Boot

Profiles in Spring Boot are used to maintain different configurations for different environments such as Development, Testing, and Production. By activating a profile, Spring Boot loads the configuration specific to that environment.

Why do we use Profiles?

• Separate environment-specific configurations (Dev, Test, Prod).
• Avoid changing configuration manually when moving between environments.
• Improve security by keeping production settings separate from development settings.

33. What are Stereotype Annotations in Spring?

Stereotype annotations are special Spring annotations that mark a class as a Spring-managed component (Bean). They help Spring identify and automatically register classes in the IoC container during component scanning.

Common Stereotype Annotations

34. Difference between @Component, @Service, @Repository, and @Controller Annotations

All four are Spring stereotype annotations used to register classes as Spring Beans in the IoC container. The main difference is their purpose and the layer in which they are used.

35. Difference between @PathVariable and @RequestParam?

The main difference is that @PathVariable extracts values from the URL path, whereas @RequestParam extracts values from query parameters.

36. Difference between @RequestBody and @ModelAttribute?

The main difference is that @RequestBody binds data from the HTTP request body (typically JSON/XML), whereas @ModelAttribute binds data from form fields and request parameters to a Java object.

37. Difference between @RestController and @Controller?

The main difference is that @Controller is used to return views (such as JSP or Thymeleaf pages), whereas @RestController is used to build REST APIs and returns data directly in JSON or XML format.

38. What is Spring Boot Actuator?

Spring Boot Actuator is a production-ready feature that provides endpoints to monitor, manage, and inspect the health and performance of a Spring Boot application. It helps developers and administrators monitor applications without writing additional code.

uses:

• Monitor application health and availability.
• Collect application metrics such as memory and CPU usage.
• Inspect application information like environment variables and configuration.
• Manage and troubleshoot applications in production.

39. Spring AOP vs AspectJ AOP

40. Advantages of AOP and its implementation

AOP helps to maintain, modify, and understand code easily.

• Modularization: separation of concerns like logging, security, etc from core business logic, to increase maintainability.
• Reusability: Bundles concerns in reusable aspects, improving code reusability.
• Interception: Allows interception and modification of method calls, enabling features like logging, security, and caching.

41. Explain Spring JDBC API and its classes.

Spring provides a simple way in the form of a JDBC abstraction layer to establish a bridge between database and application. It reduces boilerplate code and configurations.

Key classes:

• JdbcTemplate: Provides simple methods for executing SQL statements and working with data exchange for applications.
• DataSource: Establish the connection(bridge) of data exchange from database.
• SimpleJdbcCall: method present in Spring JDBC API, used for interacting with database-stored procedures.

42. Advantages of JdbcTemplate in Spring

• Reduces boilerplate code: no need to write raw JDBC codes, also bundles common operations.
• Exception handling: auto handling and conversion of SQLExceptions into Spring's DataAccessException.
• Prepared statements: Uses prepared statements to prevent SQL injection attacks.
• Data binding: instead of SQL statements it uses prepared statements, which have better security and performance.

43. Fetching records using Spring JdbcTemplate?

Use the query method of JdbcTemplate with the appropriate SQL query and result extractor.

List<User> users = jdbcTemplate.query("SELECT * FROM users", new BeanPropertyRowMapper<>(User.class));

44. Spring MVC and its components

Spring MVC (Model-View-Controller) is a web framework of the Spring Framework used to build web applications and REST APIs. It follows the MVC design pattern by separating the application into three layers: Model, View, and Controller, making the application easier to develop, maintain, and test.

Components:

• DispatcherServlet: Front controller handling requests
• Model: Data passed between controller and view
• View: UI layer
• Controller: Processes requests and returns responses

45. Explain DispatcherServlet and Request Flow in Spring MVC?

DispatcherServlet is the Front Controller of Spring MVC. It receives every incoming HTTP request, routes it to the appropriate controller, coordinates request processing, and returns the final response to the client.

Request Flow:

• The client sends a request to the DispatcherServlet.
• DispatcherServlet identifies the appropriate controller based on request mapping.
• The controller processes the request, interacts with the model, and returns a model object.
• DispatcherServlet selects the appropriate view based on the returned view name.
• View renders the model data into the final response and sends it back to the client.

46. What are Interceptors in Spring MVC?

An Interceptor in Spring MVC is a component that intercepts HTTP requests before they reach the controller and after the controller has processed them. It is mainly used for tasks such as authentication, authorization, logging, request tracking, and performance monitoring.

47. Why do we use Interceptors?

• Authentication: Verify whether the user is logged in.
• Authorization: Check whether the user has permission to access a resource.
• Logging: Log request and response details.
• Performance Monitoring: Measure request processing time.
• Request Tracking: Track incoming requests for auditing.

48. Design Patterns used in Spring MVC

• MVC Pattern: Separates the application into Presentation, Business, and Data Access layers.
• Template Method Pattern: Uses view templates to render the response consistently.
• Strategy Pattern: Allows different view resolvers (e.g., JSP or Thymeleaf) to be selected dynamically.
• Front Controller Pattern: DispatcherServlet acts as a single entry point and forwards requests to the appropriate controller.

49. Importance of session scope

Session scope plays an important role in maintaining beans for a specific duration which stores crucial information like login credentials, etc.

• Avoiding Data Repetition
• Application Security
• Reduced Database Access

50. Data validation

Spring provides various ways to validate data:

• Bean Validation API: Annotations like @NotNull and @Size can be used to validate bean properties.
• DataBinder: Binds request parameters to bean properties and performs validation based on annotations.
• Validator interface: Custom validation logic can be implemented using the Validator interface.

51. Exception Handling in Spring MVC

Spring MVC provides various mechanisms for handling exceptions:

• @ExceptionHandler annotation: Defines methods to handle specific exceptions.
• Global exception handler: Handles all uncaught exceptions.
• Error pages: Customized error pages can be displayed for different HTTP error codes.

Spring Interview Questions for Experienced Developers

Spring Interview Questions for Experienced Developers cover advanced Spring concepts, architecture, performance optimization, and production-ready application development.

52. What are Interceptors in Spring MVC?

An Interceptor in Spring MVC is a component that intercepts HTTP requests before they reach the controller and after the controller has processed them. It is mainly used for tasks such as authentication, authorization, logging, request tracking, and performance monitoring.

53. Spring WebFlux and its types

It is a reactive web framework introduced in Spring 5 for building asynchronous and non-blocking web applications. It is designed to handle a large number of concurrent requests efficiently with fewer threads.

Types of Spring WebFlux:

• Annotation-based Programming Model: Uses annotations like @RestController, @GetMapping, and @PostMapping to build reactive applications.
• Functional Programming Model: Uses RouterFunction and HandlerFunction with lambda expressions instead of annotations for lightweight request handling

54. What is Spring Reactive Web?

Reactive programming is used for developing high scalability and responsive web applications for handling asynchronous and non-blocking operations efficiently, to provide these features Spring WebFlux provides a sub-framework Spring Reactive Web.

Components:

• WebClient: Non-blocking HTTP requests
• Server-Sent Events (SSE): Real-time server-client communication
• WebSocket: Interactive apps like chat

55. Exception handling in Spring Webflux

Spring WebFlux provides various ways to handle exceptions:

• GlobalExceptionHandler: Handles all uncaught exceptions in the application.
• WebExceptionHandler: Handles exceptions specific to web requests.
• ReactiveExceptionHandler: Handles exceptions specific to reactive streams.

56. Explain the differences between Spring MVC and Spring WebFlux.

Spring MVC is a synchronous, blocking web framework, whereas Spring WebFlux is an asynchronous, non-blocking reactive framework. Spring MVC is best suited for traditional web applications, while WebFlux is designed for highly concurrent and scalable applications.

• Spring MVC: Uses the Servlet API and follows a thread-per-request model.
• Spring WebFlux: Uses Reactive Streams and handles many concurrent requests with fewer threads.

57. When should you choose Spring MVC over Spring WebFlux?

Choose Spring MVC when building traditional web applications or REST APIs with moderate traffic and blocking database operations. It is simpler to develop, easier to debug, and widely adopted in enterprise applications.

• Use Spring MVC for CRUD applications, monolithic systems, and standard REST APIs.
• Use Spring WebFlux only when your application requires non-blocking I/O and high concurrency.

58. How does Spring Boot Auto-Configuration work internally?

Spring Boot Auto-Configuration automatically creates and configures Spring beans based on the project's dependencies and application properties. It uses conditional annotations to enable only the required configurations.

• Reads dependencies available on the classpath and applies suitable configurations automatically.
• Uses annotations like @ConditionalOnClass, @ConditionalOnBean, and @ConditionalOnMissingBean to decide which beans to create.

59. Explain the internal request flow in Spring MVC.

In Spring MVC, every client request is first received by the DispatcherServlet, which forwards it to the appropriate controller. The controller processes the request, interacts with the service layer, and returns a response to the client.

• Request Flow: Client → DispatcherServlet → Controller → Service → Repository → Database.
• The processed result is returned through the DispatcherServlet as a view or JSON response.

60. How would you optimize the performance of a Spring Boot application?

Spring Boot application performance can be improved by reducing unnecessary processing, optimizing database access, and efficiently utilizing system resources. Caching and connection pooling significantly improve application response time.

• Use caching, connection pooling, lazy initialization, and optimized database queries.
• Monitor the application using Spring Boot Actuator, profiling tools, and JVM metrics to identify bottlenecks.

61. How would you design a scalable Spring Boot application for production?

A scalable Spring Boot application should follow a layered architecture with stateless services, externalized configuration, and proper monitoring. It should be designed to handle increasing traffic while maintaining performance and reliability.

• Use microservices, load balancing, caching, database optimization, and asynchronous processing for better scalability.
• Deploy with Docker, Kubernetes, centralized logging, monitoring, and CI/CD pipelines for production readiness.