Java Spring Interview Questions

Singleton (one instance application-wide), Prototype (new per injection), Request (per HTTP request), Session (per user session), Application (application scope).

A Bean in Spring is a managed object created and maintained by the Spring IoC container with lifecycle methods and dependency injection capabilities.

Spring Bean lifecycle: instantiation → property injection → BeanNameAware/BeanFactoryAware callbacks → BeanPostProcessor.postProcessBeforeInitialization → @PostConstruct/InitializingBean.afterPropertiesSet → BeanPostProcessor.postProcessAfterInitialization → ready for use → @PreDestroy/DisposableBean.destroy on shutdown.

Spring context (ApplicationContext) is a container that manages bean lifecycle, dependency injection, and provides access to beans and resources defined in configuration.

Singleton (one instance per container), Prototype (new instance each time), Request, Session, Application, and WebSocket scopes.

Dependency Injection is the mechanism of providing dependencies; Inversion of Control is the broader principle where the framework controls object creation and lifecycle.

Spring provides declarative transaction management, AOP, dependency injection, and reduces boilerplate, enabling loose coupling and easier testing.

A Bean is a reusable Java component following JavaBean conventions; Spring manages Bean lifecycle, dependency injection, and configuration through its IoC container.

Constructor injection, setter injection, and field injection (@Autowired) are the main options for dependency injection in Spring.

Dependency Injection is a design pattern where Spring automatically provides object dependencies rather than objects creating them themselves, promoting loose coupling.

Spring Boot is a framework that simplifies Spring application setup with auto-configuration and embedded servers; main advantage is reduced boilerplate and faster development.

Singleton (one per container), Prototype (new instance per request), Request (one per HTTP request), Session (one per session), and Application (one per ServletContext).

Scope in Spring defines the lifecycle and visibility of beans,where they're created and when they're destroyed within the application context.

Spring Boot provides rapid development with auto-configuration, embedded servers, and opinionated defaults, eliminating manual XML configuration and setup overhead.

Spring MVC is a web framework for building RESTful and traditional web applications using the Model-View-Controller pattern with servlet-based request handling and routing.

DI provides loose coupling, testability, and maintainability by injecting dependencies rather than hardcoding them, allowing easier mocking and configuration management.

IoC is the broader principle where the framework controls object lifecycle; Dependency Injection is a specific IoC implementation where dependencies are provided to objects.

Spring MVC can return String (view name), ModelAndView, ResponseEntity, Map, @ResponseBody annotated objects (JSON/XML), and void with direct response writing.

Yes, if you use @Service or @Repository without any HTTP mapping annotations, or if you use purely backend services like data processors, schedulers, or message consumers.

To use Spring MVC you need DispatcherServlet configured, at least one @Controller or @RestController bean, handler mappings, and a servlet container like Tomcat.

Scope defines the lifecycle of a bean: Singleton (one per context), Prototype (new per request), Request (per HTTP request), Session (per user session), Application (per ServletContext).

Context is the Spring ApplicationContext container that holds all bean definitions, manages their lifecycle, performs dependency injection, and provides access to configured beans.

Spring Bean dependency injection is applied via @Autowired constructor injection (preferred), setter injection with @Autowired, or field injection, resolved by type and qualified with @Qualifier if needed.

HTTP types (methods) include GET (retrieve), POST (create), PUT (replace), PATCH (partial update), DELETE (remove), and OPTIONS (describe communication options).

DispatcherServlet uses RequestMappingHandlerMapping to match incoming HTTP requests to controller methods based on @RequestMapping annotations, HTTP method, and URL patterns.

The client understands server response through HTTP headers (Content-Type, Content-Length) and the response body containing HTML, JSON, or XML parsed by the browser or client library.

REST provides a stateless, scalable architecture for building distributed systems using standard HTTP methods, making APIs simple, cacheable, and language-agnostic.

@RequestMapping handles all HTTP methods (GET, POST, PUT, DELETE), while @PutMapping is specifically for PUT requests; @PutMapping is more explicit and preferred for REST design.

Singleton scope is used for any application as the default in Spring; it creates one bean instance per Spring container shared across the entire application.

Request scope can be used in all Spring applications as it creates a new bean instance for each HTTP request.

Dependency Injection inverts control by allowing Spring container to automatically inject dependencies into beans through constructor, setter, or field injection based on type or qualifier.

IOC implementations include Spring IoC, PicoContainer, Guice, and CDI; Spring IoC is the most widely used for enterprise applications.

Spring IoC container manages bean lifecycle, dependency injection, and object creation; implementations include ApplicationContext and BeanFactory with ApplicationContext preferred for production.

Visibility/access areas in Spring: public (accessible everywhere), protected (same package and subclasses), package-private (same package only), private (class only).

Dependency injection types: Constructor Injection (immutable, testable), Setter Injection (flexible, circular dependency prone), Field Injection (@Autowired, harder to test), and Method Injection.

Inversion of Control transfers control of object lifecycle and dependencies from the application to a container, allowing loose coupling and easier testing.

Spring Framework is a lightweight, open-source Java framework providing IoC, AOP, transaction management, and MVC support for building enterprise applications.

Java configuration (@Configuration, @Bean) is preferred for complex logic and type-safety; XML configuration suits large teams and external configuration changes without recompilation.

Spring IOC container manages bean lifecycle and dependency injection, instantiating objects and wiring dependencies based on configuration metadata from XML, annotations, or Java classes.

Bean scopes in Spring include singleton (one instance per context), prototype (new instance per request), request, session, application, and websocket scopes.

Dependency injection types are constructor injection, setter injection, and field injection; constructor injection is preferred for mandatory dependencies.

Inversion of Control transfers control of object creation and lifecycle management from application code to a container, reducing coupling and improving testability.

Spring Framework is a lightweight, modular Java framework providing IoC, AOP, transaction management, web MVC, and data access abstractions.

Java configuration suits complex logic and type-safety; XML is better for external configuration changes without recompilation and legacy systems.

The question is unclear; if asking what configuration to remove: redundant bean definitions or unused profiles should be cleaned up.

Annotations are preferred for modern Spring apps due to cleaner code and less boilerplate; XML for external configuration in large enterprises.

Priority order: Annotation (highest) overrides Java configuration, which overrides XML (lowest); beans defined in multiple places follow this precedence.

@Autowired is optional in Spring 4.3+ because constructor injection is auto-wired by default; field/setter injection still requires explicit annotation.

Create a Spring controller using @Controller or @RestController annotation on a class with @RequestMapping or @GetMapping/@PostMapping methods.

Servlets in Spring are created as DispatcherServlet in web.xml or auto-configured via ServletRegistrationBean in Java config; Spring doesn't directly create servlets.

Spring context (ApplicationContext) loads bean definitions, manages beans, resolves dependencies, and provides access to beans via getBean() method.

Yes, you can create multiple singletons in Spring by defining multiple bean definitions with scope='singleton'; each bean name is a distinct singleton instance.

Spring supports multiple contexts: root ApplicationContext (beans shared across dispatchers) and child DispatcherServlet contexts (web-specific beans).

SCAN in Spring (via @ComponentScan or XML) automatically discovers and registers @Component, @Service, @Repository, @Controller annotated classes as beans.

Filters operate on request/response layer pre/post servlet, Interceptors wrap controller methods via AOP, Listeners react to application lifecycle events.

Both register beans in the container. @Component is generic; @Bean is explicit factory method registration offering fine-grained control.

@Component is generic; @Repository adds persistence exception translation; @Service indicates business logic layer and improves code semantics.

Bean instantiation → setter/constructor injection → @PostConstruct → ready for use → @PreDestroy → destruction.

Authentication verifies identity (who you are via credentials), Authorization checks permissions (what you can access via roles/authorities).

JWT encodes user identity and claims in a signed token, enabling stateless authentication and authorization without server-side session storage.

@DeleteMapping on controller method triggers service delete logic, which calls repository delete, executed as SQL DELETE statement.

SOAP uses XML over HTTP with strict contracts and WS-* standards; REST uses JSON/HTTP verbs (GET/POST/PUT/DELETE) for stateless, cacheable operations.

Use Spring Boot with Spring Web starter, define @RestController endpoints, inject @Service beans, configure application.properties, deploy as JAR or WAR.

Spring provides IoC container for dependency injection, declarative transaction management, AOP for cross-cutting concerns, and reduces boilerplate code compared to plain Java.

@Bean annotation registers a method's return value as a Spring bean in the application context; typically used in @Configuration classes.

@RestController returns JSON/XML directly (combines @Controller + @ResponseBody); @Controller returns view names for template rendering.

Use Spring Boot with @RestController, @GetMapping/@PostMapping annotations, and Spring Data JPA for entities,minimal configuration produces a working REST service.

Spring provides dependency injection, aspect-oriented programming, and declarative transaction management, reducing boilerplate and improving modularity.

@Bean annotation indicates a method produces a bean object managed by Spring container, typically used in @Configuration classes.

RestController combines @Controller and @ResponseBody, returning JSON/XML directly; Controller returns view names for template rendering.

Use @SpringBootApplication with @RestController and @GetMapping/@PostMapping annotations on methods returning JSON; Spring auto-configures and exposes REST endpoints via embedded Tomcat.

@Service marks business logic layer, @Repository handles data access and Spring translates DB exceptions, @Controller returns views while @RestController returns JSON/XML data.

JDK proxies (interface-based), CGLIB proxies (subclass-based), and AspectJ proxies; Spring uses JDK by default, falls back to CGLIB if no interface.

Use @Bean with @Scope("singleton") or @Component with default scope; Spring creates single instance per ApplicationContext.

Proxies in Spring include JDK dynamic proxies for interfaces and CGLib proxies for classes; used for AOP, transactions, and cross-cutting concerns.

Create singleton in Spring using @Bean with default scope (singleton) in @Configuration class, or use @Component/@Service with default singleton scope.

I developed REST APIs with Spring Boot, banking transaction systems using Spring Data JPA, and microservices with Spring Cloud for deployment.

Collection interface hierarchy: Collection (List, Set, Queue), Map. List (ArrayList, LinkedList), Set (HashSet, TreeSet), Queue (PriorityQueue, Deque).

XML configuration, Java annotations (@Configuration, @Bean), properties files, and YAML for Spring Boot applications.

@Bean marks methods returning Spring-managed objects; @Component, @Service, @Repository, @Controller are stereotype annotations for class-level bean registration.

@RestController returns JSON/XML directly; @Controller returns view names with model data for template rendering.

@Repository (DAO pattern), @Component (generic bean), @Controller (web layer), @Service (business logic layer) - semantically equivalent but contextually meaningful.

Prototype scope in Spring creates a new instance per request; used when you need stateful, non-shared objects or when multiple concurrent clients need isolated instances.

The default scope in Spring is Singleton, meaning one instance per application context.

Spring Framework Collection consists of core containers (Core, Beans, Context) and supporting modules (AOP, Data, Web, Security) organized in a layered architecture.

Spring applications can be configured via XML files (bean definitions), Java annotations (@Component, @Bean), or Java-based configuration classes (@Configuration).

@Bean marks methods that produce Spring-managed beans; used in @Configuration classes to instantiate and configure objects with fine-grained control.

@RestController combines @Controller + @ResponseBody, auto-serializing return values to JSON; @Controller requires explicit response serialization.

@Repository marks data access layer with exception translation; @Component is generic stereotype; @Controller for web handlers; @Service for business logic.

Prototype scope in Spring creates new bean instance for each request; used for stateful beans requiring fresh instances.

Request scope is default in Spring; beans are created per HTTP request and destroyed after response, though Singleton scope is default for ApplicationContext beans.

Prototype scope in Spring creates new bean instance for each injection point; used when stateful beans are needed, unlike Singleton which shares single instance across application.

Getting the same bean from ApplicationContext returns the same singleton instance by default; if scope is 'prototype', a new instance is created each time.

Getting the same bean from ApplicationContext returns the same instance if it's a singleton scope (default), ensuring consistency across the application.

Prototype scope is used when you need a new instance created each time the bean is requested, useful for stateful beans or thread-safe objects.

The default scope in Spring is Singleton, which creates one instance per Spring container and reuses it throughout the application lifecycle.

Prototype scope is used for stateful beans, request-scoped data objects, and scenarios requiring thread isolation or independent object instances.

Component is a generic stereotype; Service marks business logic beans; Repository marks data access layer beans; Controller marks web request handlers,semantically identical but convey intent.

RestController combines @Controller and @ResponseBody, automatically serializing return values to JSON/XML; Controller requires explicit @ResponseBody or view resolution.

@Bean is used on methods in @Configuration classes to explicitly define and configure beans with complex initialization logic.

Spring applications can be configured via XML files, Java classes with @Configuration, or annotations with component scanning and @SpringBootApplication.

Spring Collection framework structure: Collection (List, Set, Queue) and Map interfaces with implementations like ArrayList, HashSet, HashMap, providing different performance characteristics.

I developed a multi-tenant SaaS platform with Spring Boot, microservices, JPA/Hibernate, Redis caching, and REST APIs serving 10k+ concurrent users.

Create a singleton by using the default Singleton scope in Spring or by implementing eager initialization with @Bean or @PostConstruct in ApplicationContext startup.

Spring uses JDK dynamic proxies (for interfaces) and CGLIB proxies (for classes) for AOP, aspect weaving, and cross-cutting concerns like transactions.

Service, Repository, and Controller are semantically equivalent @Component stereotypes; Service indicates business logic, Repository indicates data access, Controller indicates web request handling.

Create a REST service quickly using @SpringBootApplication, @RestController with @RequestMapping methods, @Autowired dependencies, and run SpringApplication.run() to auto-configure embedded Tomcat.

@RestController combines @Controller and @ResponseBody, automatically serializing returned objects to JSON/XML without needing explicit view resolution.

@Bean is a method-level annotation that defines a Spring-managed bean; the method's return value is registered as a bean in the application context.

Spring provides dependency injection, aspect-oriented programming, transaction management, and declarative security, reducing boilerplate and improving maintainability.

Use @SpringBootApplication on main class, define @RestController endpoints with @GetMapping/@PostMapping methods, configure application.properties, and run the Spring Boot app.

SOAP is XML-based, protocol-agnostic, and contract-driven with WSDL; REST is resource-oriented over HTTP, uses JSON, and is stateless with simpler URLs.

Use @DeleteMapping annotation on a method that calls delete logic via repository; method returns void or ResponseEntity with appropriate HTTP status.

JWT (JSON Web Token) is a stateless authentication mechanism that encodes user claims in a signed token, allowing secure API requests without server-side sessions.

Authentication verifies who you are (login credentials), while authorization determines what resources you can access (roles/permissions).

Spring bean lifecycle: instantiation → setter injection → BeanPostProcessor.postProcessBeforeInitialization → @PostConstruct/init-method → postProcessAfterInitialization → usage → @PreDestroy/destroy-method.

@Component is generic, @Repository is for DAO/database operations, @Service is for business logic; they're semantically equivalent but indicate intent and enable specialized handling.

@Component and @Bean both create Spring beans, but @Component is class-level annotation for auto-detection via classpath scanning, while @Bean is method-level for manual configuration.

Filters operate at servlet level, Interceptors at Spring MVC level with access to request/response/handler, and Listeners react to application events; execution order differs.

@ComponentScan tells Spring where to look for @Component/@Service/@Repository annotations; it auto-registers found classes as beans in the application context.

Spring typically has two contexts: ApplicationContext (parent, for services/repositories) and WebApplicationContext (child, for controllers/web beans).

No, Spring enforces singleton by design; you can create multiple instances only by using prototype scope with @Scope("prototype").

Spring ApplicationContext loads bean definitions from configuration sources (XML/annotations/Java config), instantiates beans, injects dependencies, and manages their lifecycle.

Create a Servlet by implementing ServletRegistrationBean or using @WebServlet annotation with Spring Boot's ServletRegistrationBean for custom servlet registration.

Use @RestController class annotation with @RequestMapping or @GetMapping/@PostMapping method annotations; Spring auto-detects and registers it as a bean.

Constructor injection is now preferred over @Autowired; Spring automatically injects dependencies via constructors without explicit annotation, improving testability and avoiding NullPointerException.

Annotation > Java Config > XML; annotations are processed first during component scanning, Java config overrides them, and XML has lowest priority if all present.

Java annotations preferred; they're cleaner, type-safe, and eliminate XML verbosity while maintaining compile-time validation.

XML configuration is largely removed in favor of annotations and Java config; Spring Boot auto-configuration makes manual bean definition obsolete.

Java config for complex conditional beans and programmatic setup; XML for large legacy projects where centralized config is preferred.

Spring Framework is a lightweight, open-source IoC container providing dependency injection, AOP, transaction management, and integrated MVC/data access layers.

IoC inverts control flow: framework manages object creation and wiring instead of the application; dependencies are pushed into objects rather than pulled.

Constructor injection (immutable, testable), setter injection (flexible, optional), and field injection (simple but less testable).

Bean scope visibility includes singleton (app-wide), prototype (new per request), request (per HTTP request), session (per user), and application (ServletContext level).

Spring IoC container instantiates, configures, and manages beans; it reads configuration metadata and handles dependency resolution and lifecycle management.

ApplicationContext and BeanFactory; ApplicationContext is the primary implementation with added features like event publishing and AOP.

Apply via constructor parameters, setter methods, or @Autowired/@Inject annotations; container resolves dependencies at runtime based on type or name.

Request scope is specific to web applications; not all Spring applications are web-based, so it's not universally applicable.

Singleton scope works in any application; it's the default and creates one instance per container for the entire application lifetime.

@RequestMapping maps HTTP requests to handler methods with flexible HTTP methods; @PutMapping is a shortcut for PUT requests only.

REST enables scalable, stateless client-server communication using HTTP standards; provides clear separation of concerns and cacheable, interoperable APIs.

Client checks HTTP response headers (Content-Type) and status codes; Content-Type indicates data format (JSON, XML), status code indicates result success/failure.

DispatcherServlet uses HandlerMapping to match request URL to controller methods, then invokes the appropriate handler via reflection based on path patterns.

HTTP methods: GET (retrieve), POST (create), PUT (update), DELETE (remove), PATCH (partial update); define operation semantics on resources.

Constructor injection (preferred), setter injection via @Autowired, field injection via @Autowired, or interface-based injection.

Context is the ApplicationContext instance that holds bean definitions, manages lifecycle, resolves dependencies, and provides access to beans in the application.

Scope defines bean lifecycle and visibility: singleton (one per container), prototype (new per request), request/session (web-specific), application (ServletContext).

Spring MVC requires DispatcherServlet configured in web.xml or via WebApplicationInitializer, controller beans in context, view resolver, and handler mappings.

No, DispatcherServlet must be present in the context as it's the central component that routes all requests in Spring MVC.

Controllers can return String (view name), ModelAndView, Model, View, ResponseEntity, @ResponseBody with any serializable object, or void.

IoC is the principle of inverting control flow where framework manages object creation; Dependency Injection is the mechanism implementing IoC by injecting dependencies.

DI promotes loose coupling, testability, reusability, and centralized configuration management, making code more maintainable and flexible.