Back to interview questions

100+ Spring Framework Interview Questions and Answers

100+ Spring Framework Interview Questions and Answers

Explore 120 Spring Framework interview questions and answers on bean lifecycle, container extensions, AOP, JDBC, transactions, MVC, resources and testing.

Explore 120 Spring Framework interview questions and answers on bean lifecycle, container extensions, AOP, JDBC, transactions, MVC, resources and testing.

By

Team Sherlock.sh

Add Sherlock as a preferred source on Google

Spring Framework interviews should reveal whether candidates understand how the container and its infrastructure actually behave. Recruiters need more than annotation recognition: lifecycle timing, proxy boundaries, resource ownership and transaction participation determine whether an application behaves correctly. A service that starts successfully can still bypass advice, leak resources or expose an unintended request-binding path.

These 100+ Spring Framework Interview Questions and Answers provide 120 questions across beginner, intermediate and experienced levels. The focus is the Framework itself: bean metadata and lifecycle, extension points, events, resources, AOP, JDBC, MVC strategies and testing. Spring Boot setup, starters and auto-configuration are separate concerns and are not the organizing structure of this guide.

How can recruiters test framework understanding beyond a list of familiar annotations?

Ask candidates to trace a bean from definition to exposed instance, or a request from mapping to response conversion. Then introduce a failure: an early-created dependency, a callback that loses its resource or a transaction test that never commits. Strong candidates identify the boundary involved and propose a focused test instead of adding another annotation without explaining its effect.

Sherlock AI helps hiring teams assess signals of potential AI cheating, deepfakes, impersonation and unauthorized assistance during remote interviews. Pair those signals with small code walkthroughs, lifecycle diagrams and follow-up questions about failure behavior. Review them alongside demonstrated reasoning rather than treating a single signal as conclusive proof of misconduct.

Spring Framework Interview Questions

Choose questions appropriate to application development or framework-integration work. Ask candidates to identify the Spring version and whether a behavior comes from the Framework, Spring Boot or another Spring project. The complete bank appears before its matching numbered answers.

Spring Framework Interview Questions for Beginners

Establish the distinction between definitions, managed instances, lifecycle stages and framework services. Look for concrete ownership and execution boundaries rather than annotation recitation.

  1. What responsibilities belong to the Spring Framework's application container?

  2. How does a BeanDefinition differ from a bean instance?

  3. How does ApplicationContext extend the basic BeanFactory contract?

  4. What does refreshing an application context accomplish?

  5. Why should a standalone application close its context?

  6. How do bean names and aliases relate to object identity?

  7. What is a FactoryBean used for?

  8. How does an instance factory method differ from a constructor definition?

  9. What does registering an existing singleton object omit?

  10. How do parent and child application contexts resolve dependencies?

  11. What is the difference between bean-definition inheritance and Java inheritance?

  12. When is an optional dependency appropriate?

  13. What does injecting a collection of beans express?

  14. How can generic type information help dependency resolution?

  15. What does lazy initialization change about failure timing?

  16. What is the purpose of depends-on metadata?

  17. What are initialization callbacks for?

  18. What are destruction callbacks for?

  19. How does Lifecycle differ from SmartLifecycle?

  20. What is a BeanPostProcessor allowed to influence?

  21. How does a BeanFactoryPostProcessor differ from a BeanPostProcessor?

  22. What is a BeanDefinitionRegistryPostProcessor used for?

  23. How does a Resource abstract a location?

  24. How does ResourceLoader differ from ResourcePatternResolver?

  25. What is MessageSource used for?

  26. What does the Environment abstraction expose?

  27. How does a property placeholder differ from a SpEL expression?

  28. What is ConversionService responsible for?

  29. How does a Formatter differ from a Converter?

  30. What is Spring's Validator interface for?

  31. What does DataBinder do?

  32. How do field errors differ from object errors?

  33. What is an application event in Spring?

  34. Are Spring application listeners always asynchronous?

  35. What does an event listener's type filter accomplish?

  36. What is the purpose of Spring AOP?

  37. How do a pointcut and advice differ?

  38. How do before, after-returning and after-throwing advice differ?

  39. What additional control does around advice provide?

  40. Why is the exposed bean type important when AOP is enabled?

Spring Framework Interview Questions for Intermediate

Explore custom container processing, AOP chains, JDBC callbacks and MVC strategies. Ask how the candidate would verify both intended behavior and a plausible negative case.

  1. How would you inspect a bean without accidentally creating it?

  2. Why should a definition post-processor avoid ordinary application dependencies?

  3. Why can a static BeanFactoryPostProcessor factory method be useful?

  4. How should a custom BeanPostProcessor decide which beans to wrap?

  5. How do processor ordering and bean dependency ordering differ?

  6. How would you implement a FactoryBean with predictable type discovery?

  7. How should prototype objects that own resources be cleaned up?

  8. What does a scoped proxy do for a longer-lived consumer?

  9. How can a custom scope leak objects?

  10. How do you diagnose duplicate initialization callbacks?

  11. What must SmartLifecycle.stop(Runnable) do with its callback?

  12. How do you test resource loading across development and packaged execution?

  13. How should a resource loader treat untrusted locations?

  14. How can a custom converter create surprising application behavior?

  15. How do you validate nested objects without losing useful error paths?

  16. Why is unrestricted SpEL evaluation unsafe for user-defined rules?

  17. How does event ordering differ from transactional ordering?

  18. What happens when a synchronous event listener throws an exception?

  19. How can a parent-child context hierarchy affect event delivery?

  20. How do JDK proxies and class-based proxies constrain advice?

  21. What does advice ordering mean for nested interceptors?

  22. How should an around advice preserve exceptions?

  23. How do pointcut parameter bindings improve an advice?

  24. When would programmatic ProxyFactory be useful?

  25. What work does JdbcTemplate perform around a query?

  26. How does RowMapper differ from ResultSetExtractor?

  27. When is RowCallbackHandler useful?

  28. What does NamedParameterJdbcTemplate change about SQL parameters?

  29. How should generated keys be retrieved safely?

  30. How do JDBC batch update results need to be interpreted?

  31. Why does Spring translate SQLExceptions?

  32. How does JdbcTemplate participate in a Spring-managed transaction?

  33. What is TransactionTemplate useful for beyond annotations?

  34. How should TransactionTemplate results and failures be handled?

  35. What is DispatcherServlet's relationship to HandlerMapping and HandlerAdapter?

  36. What does a HandlerMethodArgumentResolver do?

  37. What does a HandlerMethodReturnValueHandler do?

  38. How does content negotiation interact with message conversion?

  39. How does a servlet Filter differ from a HandlerInterceptor?

  40. What should a custom ViewResolver return when it cannot resolve a view?

Spring Framework Interview Questions for Experienced

Explore integration design, transaction completion, reactive resource handling and test boundaries. Look for evidence that the candidate can reason about behavior across lifecycle and execution contexts.

  1. How would you design a reusable container extension without creating hidden beans?

  2. How can early bean references complicate proxy correctness?

  3. How should a library handle bean-name collisions across modules?

  4. What makes dynamic bean registration after startup difficult?

  5. How do you make a parent-child context boundary testable?

  6. How should a plugin system unload a child context?

  7. How do you validate lifecycle phase relationships in a complex application?

  8. How do you keep initialization failures from leaking resources?

  9. How can a custom annotation compose framework behavior safely?

  10. What should an AOP contract test assert beyond advice execution?

  11. How do you distinguish proxy AOP from AspectJ weaving when debugging interception?

  12. How can advice that changes arguments violate a service contract?

  13. How do you choose a transaction manager in a multi-resource application?

  14. How do transaction synchronization callbacks differ from durable work scheduling?

  15. Why can database work in an after-commit callback be surprising?

  16. What limits the portability of NESTED transaction propagation?

  17. What does a read-only transaction declaration actually guarantee?

  18. How do transaction timeouts interact with slow external calls?

  19. How does queryForObject distinguish result cardinality from a SQL NULL value?

  20. How does reactive transaction scope differ from imperative transaction scope?

  21. Why can an internal subscribe call break a reactive transaction design?

  22. How should reactive cancellation be tested around resource use?

  23. How do you choose between DataSourceTransactionManager and JdbcTransactionManager?

  24. How do you prevent JDBC callbacks from escaping their resource lifetime?

  25. How do you test SQL null handling in custom row mapping?

  26. What should a streaming JDBC export do when the output sink fails?

  27. How do you validate custom MVC argument-resolution precedence?

  28. How can custom message converters break an existing API?

  29. What is the difference between configuring and extending MVC defaults?

  30. How do servlet asynchronous requests complicate interceptor cleanup?

  31. How do WebFlux codecs differ from MVC message converters?

  32. How do you handle pooled data buffers in a custom reactive integration?

  33. What does the TestContext framework contribute without Spring Boot?

  34. How should custom TestExecutionListeners coexist with defaults?

  35. How can preemptive test timeouts invalidate transactional-test assumptions?

  36. When should TestTransaction be used?

  37. How do you test transaction behavior that only appears at commit?

  38. How should SQL test fixtures interact with transaction boundaries?

  39. How do you assess compatibility when upgrading the Spring Framework itself?

  40. How would you review a custom Spring integration before accepting it into production?

Spring Framework Interview Questions and Answers

The official reference consulted for this guide identifies Spring Framework 7.0.10. The Java examples are instructional fragments or explicitly labeled skeletons with stated dependencies; no Java runtime was available for compilation or execution during preparation. Verify them in the selected application, framework version, database and test environment before use.

Spring Framework Interview Questions and Answers for Beginners

These answers explain core contracts and show how apparently simple choices affect initialization, resource access and method interception.

1. What responsibilities belong to the Spring Framework's application container?

The container creates and connects managed objects using configuration metadata, applies supported lifecycle processing and makes those objects available to collaborators. It supplies infrastructure for composition; it does not discover business requirements or make arbitrary objects managed merely because Spring is on the classpath.

For example, a command-line application can build an application context without Spring Boot and obtain a configured service. An object constructed separately with ordinary Java code does not automatically receive the same post-processing. I would distinguish container ownership from the simple presence of framework annotations when explaining an application's behavior.

2. How does a BeanDefinition differ from a bean instance?

A BeanDefinition is metadata describing how the container should create and manage an object, including its type, scope and configuration. A bean instance is the actual object produced from that metadata. Some definitions may not produce an instance until they are requested.

This distinction explains why a definition-level extension can change configuration before ordinary objects exist. Reading or changing metadata is different from calling a live service. I would avoid invoking application behavior while analyzing definitions because doing so can force early creation and alter the initialization sequence being investigated.

3. How does ApplicationContext extend the basic BeanFactory contract?

BeanFactory provides fundamental lookup and dependency-management capabilities. ApplicationContext adds application-oriented facilities such as resource loading, events and message resolution, and coordinates automatic discovery of supported infrastructure processors during refresh.

A bare bean factory can be useful for low-level container work, but it does not reproduce every application-context lifecycle behavior simply by registering the same classes. I would normally use an appropriate application context for an application and choose a lower-level factory only when the missing orchestration is understood and deliberately supplied.

4. What does refreshing an application context accomplish?

Refresh initializes the context's bean-factory configuration, applies container extension processing, establishes infrastructure and creates eligible non-lazy singletons before completing startup. It is a lifecycle operation, not a request to reinject every changed property into an already running object.

With an explicitly constructed annotation context, configuration can be registered before refresh. Whether repeated refresh is supported depends on the context implementation. I would not use refresh as a generic live-reconfiguration mechanism; resources, object references and state need a deliberate replacement strategy.

5. Why should a standalone application close its context?

Closing a configurable application context triggers appropriate shutdown and destruction processing for managed resources. Without it, executors, connections or other resources may remain active until process termination, and expected cleanup may not run.

A small command-line program can use try-with-resources around its context. Closing the context does not guarantee completion of arbitrary unmanaged threads or cleanup of every object the application created itself. I would identify resource ownership and configure shutdown behavior instead of assuming garbage collection performs operational cleanup.

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

// AppConfig and ReportService are application-defined types.
try (var context = new AnnotationConfigApplicationContext(AppConfig.class)) {
    context.getBean(ReportService.class).runReport();
}
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

// AppConfig and ReportService are application-defined types.
try (var context = new AnnotationConfigApplicationContext(AppConfig.class)) {
    context.getBean(ReportService.class).runReport();
}
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

// AppConfig and ReportService are application-defined types.
try (var context = new AnnotationConfigApplicationContext(AppConfig.class)) {
    context.getBean(ReportService.class).runReport();
}

This is a method-body fragment. It assumes AppConfig registers a ReportService with a runReport() method; it is not a complete standalone program.

6. How do bean names and aliases relate to object identity?

A bean name identifies a definition or registered object in the container, while an alias is another name resolving to the same target name. An alias does not ordinarily create an additional instance or an independent lifecycle.

Two separate definitions of the same class can still produce different objects, even when their configuration looks identical. I would inspect definitions and aliases before diagnosing unexpected duplicates. Names are useful for explicit lookup and wiring, but type-based application dependencies often make ordinary service code less coupled to container naming conventions.

7. What is a FactoryBean used for?

A FactoryBean is a container-managed factory whose product can be exposed through ordinary bean lookup. It is useful when constructing an object requires integration-specific logic that does not fit a simple constructor or factory method.

The factory object and its product are distinct. A lookup with the factory-dereference prefix can obtain the factory itself rather than the product. I would check product type and singleton semantics when debugging injection, because the factory's own scope does not by itself explain every detail of the product's lifecycle.

// clientFactory is a registered FactoryBean that produces Client objects.
Client product = context.getBean("clientFactory", Client.class);
Object factory = context.getBean("&clientFactory");
// clientFactory is a registered FactoryBean that produces Client objects.
Client product = context.getBean("clientFactory", Client.class);
Object factory = context.getBean("&clientFactory");
// clientFactory is a registered FactoryBean that produces Client objects.
Client product = context.getBean("clientFactory", Client.class);
Object factory = context.getBean("&clientFactory");

The fragment assumes a configured context and an application-defined Client type. The ampersand selects the factory object; it is not part of the ordinary product name.

8. How does an instance factory method differ from a constructor definition?

A constructor definition asks the container to instantiate a class directly, while an instance factory method asks an existing factory object to create the product. Both can participate in container-managed composition when declared appropriately.

A third-party builder or factory may be necessary to create a configured client. The factory's dependencies must exist before it can create that client, and the returned type should be clear enough for dependency resolution. I would keep construction logic focused rather than hide network work or unrelated business operations inside the factory.

9. What does registering an existing singleton object omit?

Registering a preconstructed object through a low-level singleton registry is not equivalent to asking the container to create it from a bean definition. The object may not receive the normal injection, initialization and destruction treatment that definition-based creation would provide.

This can be appropriate when another system already owns the object's lifecycle. It can also surprise a test that expects annotations to be processed automatically. I would consult the registration API's contract and make ownership explicit rather than assume that every object retrievable by getBean was built through the same pipeline.

10. How do parent and child application contexts resolve dependencies?

A child context can normally consult its parent for dependencies it does not provide locally, while the parent does not look down into its children. Local definitions can shadow parent names, so context placement affects which object a lookup resolves.

A web application may place shared services in a root context and web-specific components in a child. Putting a service only in the child will not make it available to a parent-created bean. I would map the hierarchy before treating a missing dependency as a scanning failure.

11. What is the difference between bean-definition inheritance and Java inheritance?

Bean-definition inheritance reuses configuration metadata from a parent definition. Java inheritance defines a type relationship and inherited language-level behavior. The two mechanisms can be used independently and should not be confused.

An abstract parent definition can supply common property values for several concrete definitions without being instantiated itself. That does not make their classes subclasses of a common Java implementation unless the code declares it. I would use metadata inheritance sparingly when it clarifies configuration rather than hides where important values come from.

12. When is an optional dependency appropriate?

An optional dependency is appropriate when the component has a defined, useful behavior without that collaborator. Expressing optionality does not repair an accidentally missing required service; it changes the component's contract.

A metrics adapter might be optional in a small utility, while a payment gateway is essential to a payment operation. I would test both the present and absent cases and document the fallback. If absence silently disables a required business capability, a startup failure is usually more informative than a nullable reference.

13. What does injecting a collection of beans express?

It requests the set of eligible beans matching the collection's element type and qualifiers, allowing a component to compose multiple strategies. The collection is not necessarily restricted to a single preferred candidate.

A validation pipeline might receive several rule implementations and apply them in an explicit order. I would define ordering through supported metadata or an application contract, and decide whether an empty set is valid. A plugin list whose behavior depends on incidental registration order can become unstable as the application grows.

14. How can generic type information help dependency resolution?

Spring can use retained generic type metadata to distinguish compatible dependency candidates, such as a repository for one domain type from another. The information must be available in the declared types and factory signatures to be useful.

A raw return type can erase distinctions the container needs, leaving ambiguity that a more precise declaration would avoid. I would keep configuration method signatures accurate and use explicit qualifiers when the generic distinction is not sufficient. Generic matching helps composition but does not replace Java type safety or runtime validation of external data.

15. What does lazy initialization change about failure timing?

Lazy initialization delays creation until the bean is needed, except when another eagerly created bean requires it in a way that forces resolution. This can defer resource use and startup work, but also moves construction failures into later execution.

An optional expensive report generator may benefit from delayed creation. A required core dependency that fails on the first customer request may be a worse operational outcome than a startup failure. I would assess first-use latency and failure visibility, rather than consider a shorter startup duration an unconditional improvement.

16. What is the purpose of depends-on metadata?

It declares an initialization dependency when the relationship is not represented by an ordinary injected reference. For singleton beans, the relationship can also influence destruction ordering. It is not a general mechanism for sequencing every application operation.

A legacy library may require a registration step before another component initializes. I would prefer an explicit dependency when possible because it makes the relationship visible in code. Excessive depends-on declarations can conceal a fragile startup protocol that should be redesigned as a clearer lifecycle abstraction.

17. What are initialization callbacks for?

They allow a managed object to perform setup after its dependencies have been supplied and before it is used in the normal application lifecycle. Supported mechanisms include configured methods and lifecycle interfaces or annotations when the relevant processing is active.

A component can validate configuration or prepare a local data structure at this stage. Long remote calls can make startup fragile, and calling other services during initialization can encounter partially initialized infrastructure. I would keep setup bounded and distinguish basic readiness from background work that needs separate lifecycle coordination.

18. What are destruction callbacks for?

They release resources or perform bounded cleanup when the container destroys an eligible managed object. They depend on the bean's scope and how the context is shut down; they are not guaranteed to run after an abrupt process termination.

A managed client can close an underlying connection pool during normal shutdown. Durable business work should not rely solely on that callback because crashes bypass graceful cleanup. I would design operations to tolerate interruption and use destruction callbacks for resource management rather than as the only record of completed work.

19. How does Lifecycle differ from SmartLifecycle?

Lifecycle defines start, stop and running-state operations. SmartLifecycle adds features such as phases, automatic startup behavior and a callback-based stop contract for coordinated shutdown. These facilities support components that have an active operating state beyond simple object construction.

A message listener may need to start after its supporting infrastructure and stop before that infrastructure closes. Phase ordering can express part of that relationship. I would verify dependency rules and completion callbacks rather than assume that implementing the interface automatically makes asynchronous shutdown complete safely.

20. What is a BeanPostProcessor allowed to influence?

A BeanPostProcessor participates around initialization of bean instances and can return a wrapped or replacement object. This is a foundation for many container integrations, including proxy-based behavior.

A processor might wrap selected services with an interceptor after initialization. It should not indiscriminately instantiate unrelated beans while being created, because early dependencies can miss later processing. I would use precise matching and test the resulting exposed type, especially when callers expect an interface or a concrete implementation.

21. How does a BeanFactoryPostProcessor differ from a BeanPostProcessor?

A BeanFactoryPostProcessor works on bean-factory metadata before ordinary bean instantiation, while a BeanPostProcessor works on instances. Choosing the correct extension point depends on whether the goal is changing definitions or changing the objects produced from them.

Changing a configured property value belongs at the metadata stage; wrapping a live service belongs at the instance stage. I would avoid calling getBean from a factory post-processor unless the consequences are explicitly intended, because forcing early creation can disrupt the lifecycle ordering that makes the extension work.

Extension

Primary input

Typical purpose

BeanFactoryPostProcessor

Definition metadata

Validate or adjust configuration before ordinary creation

BeanPostProcessor

Bean instance

Apply initialization-related processing or wrapping

22. What is a BeanDefinitionRegistryPostProcessor used for?

It extends definition-level processing with the ability to register additional bean definitions before ordinary factory post-processing proceeds. This supports integrations that discover or generate definitions programmatically.

A library might translate a small configuration model into several client definitions. I would validate names, types and conflicts at this stage and avoid performing the clients' operational work. Registration should be deterministic and reviewable; discovering definitions does not require opening production connections or invoking business services.

23. How does a Resource abstract a location?

Resource provides a common interface for accessing content from supported locations, such as classpath entries, filesystem paths or URLs. It lets code request a stream without assuming that every resource is a local file.

A template packaged inside a JAR may be readable through an input stream but not representable as an ordinary filesystem File. I would code against the required capability and close streams appropriately. Treating every resource as a file often works in an IDE and fails after packaging.

import java.nio.charset.StandardCharsets;
import org.springframework.core.io.ClassPathResource;

var resource = new ClassPathResource("templates/welcome.txt");
try (var input = resource.getInputStream()) {
    String text = new String(input.readAllBytes(), StandardCharsets.UTF_8);
    System.out.println(text);
}
import java.nio.charset.StandardCharsets;
import org.springframework.core.io.ClassPathResource;

var resource = new ClassPathResource("templates/welcome.txt");
try (var input = resource.getInputStream()) {
    String text = new String(input.readAllBytes(), StandardCharsets.UTF_8);
    System.out.println(text);
}
import java.nio.charset.StandardCharsets;
import org.springframework.core.io.ClassPathResource;

var resource = new ClassPathResource("templates/welcome.txt");
try (var input = resource.getInputStream()) {
    String text = new String(input.readAllBytes(), StandardCharsets.UTF_8);
    System.out.println(text);
}

This method-body fragment assumes a small trusted UTF-8 resource packaged at the given classpath location. Reading all bytes is appropriate only when the resource size is bounded.

24. How does ResourceLoader differ from ResourcePatternResolver?

ResourceLoader resolves a location to a resource, while ResourcePatternResolver supports pattern-based resolution that can return multiple resources. Pattern behavior depends on the location scheme and runtime packaging.

A plugin system might load several metadata files from the classpath. I would define how duplicate resources and ordering are handled rather than assume the first result is authoritative. Wildcard discovery should be tested in the actual JAR or module arrangement, not only against an expanded development directory.

25. What is MessageSource used for?

MessageSource resolves message codes and arguments into localized text, often through resource bundles. It separates user-facing wording from application logic and provides a consistent place for fallback behavior.

An error code such as order.notFound can produce different text for different locales while retaining a stable machine-readable meaning. I would not use translated text as an API error identifier or database key. Missing-message behavior and argument formatting should be tested so localization failures do not obscure the original problem.

26. What does the Environment abstraction expose?

Environment provides access to property sources and active profiles for the context. It allows configuration code to query values without assuming a single physical configuration file.

A library can inspect a named property through the Environment, but it should still define defaults and validate required values. Spring Framework's abstraction does not by itself imply Spring Boot's full property-loading and precedence conventions. I would distinguish the core API from the surrounding application setup that populates it.

27. How does a property placeholder differ from a SpEL expression?

A placeholder resolves a named configuration value, while a Spring Expression Language expression evaluates an expression against an allowed context. They solve different problems even when both appear in configuration annotations.

A timeout value usually needs simple property resolution and type conversion, not a complex expression. I would keep business rules in ordinary testable code when expressions become difficult to read. Expression evaluation also has a security boundary: untrusted input must not become unrestricted executable expressions.

28. What is ConversionService responsible for?

ConversionService converts between supported source and target types through registered converters. It centralizes type-conversion behavior used by framework facilities rather than requiring each consumer to parse values independently.

A custom identifier type can have a converter from a string used during binding. The converter should reject invalid values predictably and avoid unrelated side effects such as database writes. I would distinguish syntactic conversion from business validation, because a value can be well formed while still being unacceptable for an operation.

29. How does a Formatter differ from a Converter?

A Formatter is oriented toward parsing and printing values with locale awareness, while a Converter provides general source-to-target conversion. Formatting is useful at presentation boundaries where text representation depends on the user's locale.

A date or monetary amount may have different readable forms in different locales. I would keep the underlying domain representation stable and test both parsing and printing. A locale-specific display string should not silently become the canonical format for a machine-to-machine API.

30. What is Spring's Validator interface for?

It defines a contract for checking supported object types and recording validation errors through the Errors abstraction. It can express checks beyond simple type conversion and can be used independently of annotation-based Bean Validation.

A form object may require a relationship between two fields, such as an end date after a start date. I would report meaningful field or object errors without modifying unrelated state. Validation is not an authorization check, and passing it does not prove that the caller may perform the requested operation.

31. What does DataBinder do?

DataBinder applies incoming property values to a target object and records binding or validation errors. Because binding can expose writable properties, its configuration is part of the boundary between external input and application state.

A form should generally bind to a dedicated input model with an intentional set of fields. I would constrain allowed properties where appropriate and avoid exposing a rich persistence object directly. Successful binding means values were assigned according to the rules, not that the request is authorized or semantically valid.

32. How do field errors differ from object errors?

A field error is associated with a particular property, while an object error describes a problem involving the object as a whole. Both can carry codes and arguments for consistent error presentation.

An invalid postal-code format is naturally a field error; incompatible start and end dates may be expressed as a relationship error. I would choose the location that helps the client correct the input and preserve stable codes. Returning only an exception string makes structured handling and localization unnecessarily difficult.

33. What is an application event in Spring?

An application event is an in-process notification published through the context's event mechanism to interested listeners. It can decouple components within an application, but does not inherently provide persistence, cross-process delivery or replay.

A component can publish that a local cache has been refreshed so another component updates its view. If the process crashes, an ordinary in-memory event is not a durable record. I would choose a persistent messaging or job mechanism when business correctness requires delivery after restart.

34. Are Spring application listeners always asynchronous?

No. With the ordinary default event multicaster, listeners commonly execute synchronously in the publishing thread. A configured executor or supported asynchronous listener mechanism can change execution, with different exception and context behavior.

A slow synchronous listener can delay the publisher, while an asynchronous listener can fail after the publisher has returned. I would state the configured mechanism and test failure handling instead of inferring timing from the word event. Decoupling source-code dependencies does not automatically decouple execution time.

35. What does an event listener's type filter accomplish?

It restricts which event types a listener handles, allowing publishers and listeners to communicate through a defined contract. Precise event types reduce accidental coupling to unrelated notifications.

A listener for invoice-issued events should not have to inspect every application event and guess its meaning. I would keep event payloads clear and avoid exposing mutable internal objects that listeners can alter unpredictably. Type matching is only part of the contract; timing, ordering and failure semantics must also be defined.

36. What is the purpose of Spring AOP?

Spring AOP applies cross-cutting behavior around selected method executions on managed proxy targets. It can separate concerns such as tracing or transaction interception from the business method, while retaining explicit configuration of where that behavior applies.

An interceptor can measure a service call without duplicating timing code in every implementation. The proxy boundary matters: ordinary internal method calls do not create a new external proxy invocation. I would explain the actual interception path rather than describe AOP as a mechanism that automatically intercepts every line of Java code.

37. How do a pointcut and advice differ?

A pointcut selects join points where behavior should apply, while advice defines the behavior applied there. In Spring's proxy-based AOP model, the relevant join points are method executions reached through the proxy.

A pointcut may select methods in a service package, and advice may record duration around those calls. I would test both matching and nonmatching methods because an overly broad expression can affect infrastructure unexpectedly. A correctly implemented advice still produces the wrong result if its selection rule targets the wrong operations.

Concept

Question it answers

Example

Pointcut

Where does behavior apply?

Selected service methods

Advice

What additional behavior runs?

Measure invocation duration

Proxy

How is the call intercepted?

Caller invokes exposed service interface

38. How do before, after-returning and after-throwing advice differ?

Before advice runs before the target invocation, after-returning advice runs when it completes normally, and after-throwing advice runs when a matching exception escapes. Their timing and access to outcomes differ.

A success counter belongs on normal completion rather than before invocation, while failure recording needs the exception path. I would avoid treating a method's entry as proof that its business effect succeeded. Advice should preserve the intended exception and return-value contract unless changing that contract is an explicit design decision.

39. What additional control does around advice provide?

Around advice can decide whether and when to proceed with the invocation, inspect or replace the result and handle failures. That flexibility makes it powerful but also easier to misuse than advice with a narrower timing role.

A timing interceptor should usually call proceed exactly once and record duration in a finally block. Calling it twice can duplicate a business effect, while never calling it can silently suppress the operation. I would use around advice only when the required control justifies that responsibility.

40. Why is the exposed bean type important when AOP is enabled?

A proxy may expose interfaces or a generated subclass rather than the target's exact runtime class. Code that assumes a concrete implementation type can therefore fail even though the service contract is available.

I would inject an appropriate interface when it represents the intended abstraction and avoid casting merely to bypass interception. Reflection-based integrations should use framework-aware type inspection when necessary. The proxy is part of the application's behavior, so obtaining the raw target to make a cast work can also remove required advice.

Spring Framework Interview Questions and Answers for Intermediate

These answers connect framework extension mechanisms to practical mistakes and explain the assumptions behind each instructional code fragment.

41. How would you inspect a bean without accidentally creating it?

Use definition and type metadata where the relevant API permits non-eager inspection, and understand whether a query can initialize a FactoryBean or resolve a lazy object. A method that appears to ask only about types can still have lifecycle consequences in some contexts.

For a diagnostic tool, I would separate definition enumeration from explicit instance lookup and document any eager-resolution option. Calling every bean merely to print its class can open connections or trigger failures that otherwise would occur later. Inspection should preserve the state it is intended to explain.

42. Why should a definition post-processor avoid ordinary application dependencies?

Definition post-processors run before normal bean creation is complete. Injecting application services into them can force those services into existence before all relevant instance processors are registered, producing objects with incomplete expected behavior.

A processor that needs a simple configuration value should read appropriate metadata rather than call a business service. I would keep its dependencies minimal and examine early-instantiation warnings. The issue is lifecycle timing, not merely whether the dependency graph has a visible circular reference.

43. Why can a static BeanFactoryPostProcessor factory method be useful?

A static factory method can create the post-processor without first instantiating its enclosing configuration class. This helps avoid prematurely constructing configuration objects and their dependencies during an early container phase.

I would still keep the method's dependencies appropriate to that phase; static does not make arbitrary application-service injection safe. The return type should also expose the processor contract so the container can identify it early. This is an infrastructure configuration technique, not a reason to make ordinary business factories static by default.

import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration(proxyBeanMethods = false)
class DefinitionChecks {
    @Bean
    static BeanFactoryPostProcessor requireGatewayDefinition() {
        return factory -> {
            if (!factory.containsBeanDefinition("gateway")) {
                throw new IllegalStateException("Missing local gateway definition");
            }
        };
    }
}
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration(proxyBeanMethods = false)
class DefinitionChecks {
    @Bean
    static BeanFactoryPostProcessor requireGatewayDefinition() {
        return factory -> {
            if (!factory.containsBeanDefinition("gateway")) {
                throw new IllegalStateException("Missing local gateway definition");
            }
        };
    }
}
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration(proxyBeanMethods = false)
class DefinitionChecks {
    @Bean
    static BeanFactoryPostProcessor requireGatewayDefinition() {
        return factory -> {
            if (!factory.containsBeanDefinition("gateway")) {
                throw new IllegalStateException("Missing local gateway definition");
            }
        };
    }
}

The example intentionally requires a local definition named gateway; it does not accept a parent-context bean or a manually registered singleton. That narrow rule is part of the example contract, not a general recommendation for dependency validation.

44. How should a custom BeanPostProcessor decide which beans to wrap?

Use a precise type, annotation or other stable contract and preserve the expected service interface and lifecycle behavior. Broad name patterns can accidentally match framework infrastructure or unrelated application objects.

I would test a target bean, a non-target bean and a bean already wrapped by another processor. If wrapping changes assignability or creates duplicate advice, callers may fail in ways far from startup. The processor should also avoid retaining unnecessary references that prevent scoped objects from being released.

45. How do processor ordering and bean dependency ordering differ?

Processor ordering controls the sequence in which eligible infrastructure processors act, while dependency ordering determines which objects must be available to create others. They are related during startup but are not interchangeable mechanisms.

An ordering annotation on a service does not generally mean that every singleton will initialize in that order. I would use explicit dependencies or lifecycle contracts for startup relationships and supported processor-order contracts for extensions. Tests should assert the required behavior rather than rely on an observed incidental sequence.

46. How would you implement a FactoryBean with predictable type discovery?

Return accurate product-type information when possible, define whether the product is a singleton and keep construction behavior consistent with that declaration. Type discovery should not require expensive or side-effecting product creation if it can be avoided.

A factory for a typed client can report the client interface before opening a connection. I would test ordinary product lookup and factory-dereference lookup separately. Returning an unknown type unnecessarily can interfere with autowiring or early type-based processing, while reporting the wrong type creates misleading configuration failures.

47. How should prototype objects that own resources be cleaned up?

The consumer must arrange cleanup because the container does not automatically track and destroy every prototype instance after handing it out. Initialization and destruction responsibilities are therefore asymmetric for this scope.

A per-operation object that opens a stream should expose a clear close contract and be used within a bounded ownership scope. I would consider whether a plain local object is simpler than a managed prototype. Changing scope without changing resource ownership can turn a lifecycle misunderstanding into a leak.

48. What does a scoped proxy do for a longer-lived consumer?

It exposes a stable proxy that resolves the actual target according to the active scope when invoked. This lets a longer-lived bean depend on a shorter-lived scoped object without capturing one target permanently during construction.

A singleton web service can reference request-scoped state through a supported proxy. Invoking it outside an active request can still fail; the proxy does not manufacture a meaningful request context. I would avoid passing such references to arbitrary background work and instead pass the required immutable values explicitly.

49. How can a custom scope leak objects?

A scope must define storage, lookup, removal and destruction behavior for its contextual lifetime. If its backing storage outlives the intended context or destruction callbacks are never invoked, scoped objects and their resources can accumulate.

For a workflow scope, I would test successful completion, cancellation and exceptional termination. Thread-local storage alone is unsafe if pooled threads are reused without cleanup. The scope contract needs an explicit owner of lifetime boundaries rather than assuming that threads and logical operations end together.

50. How do you diagnose duplicate initialization callbacks?

Inspect whether the same callback was configured through multiple mechanisms, whether multiple bean definitions exist, and whether several contexts create separate instances. Log stable instance identities and lifecycle phases rather than only the class name.

Two similar log lines may represent two legitimate objects, not one object initialized twice. I would first establish which definition and context owns each instance. Removing a callback without understanding the duplication can hide a configuration error or leave one instance uninitialized.

51. What must SmartLifecycle.stop(Runnable) do with its callback?

It must invoke the supplied callback when the component has completed its asynchronous stopping work, so the lifecycle coordinator can proceed. Returning from the method alone is not sufficient when shutdown continues elsewhere.

A listener container can stop accepting messages, finish bounded in-flight work and then call the callback. I would test failure and timeout paths so a cleanup exception does not prevent completion signaling indefinitely. The callback contract does not excuse unbounded shutdown or guarantee that externally submitted work will finish.

52. How do you test resource loading across development and packaged execution?

Exercise the same access path from an expanded classpath and from the actual packaged artifact. Use stream-oriented access when the content may be inside an archive, and avoid assuming a filesystem path exists.

A test that calls getFile on a classpath template can pass locally and fail from a JAR. I would include a packaged smoke test and verify encoding and missing-resource errors. Resource discovery order and duplicate names also deserve tests when multiple dependencies contribute files.

53. How should a resource loader treat untrusted locations?

Validate allowed schemes and locations before resolving them, and avoid giving arbitrary user input unrestricted access to local files or remote URLs. The resource abstraction provides convenience, not an authorization boundary.

An endpoint that accepts a template location should usually select from known identifiers rather than load any supplied path. I would test traversal, unsupported schemes and unexpected network destinations. Restricting the application-level contract is clearer than trying to make every possible Resource implementation safe for untrusted input.

54. How can a custom converter create surprising application behavior?

A broadly registered converter can affect many binding or configuration paths, including ones its author did not anticipate. Ambiguous parsing, side effects or overly permissive defaults can make invalid input look valid.

I would keep conversion deterministic, narrow the source and target types and reject malformed values with meaningful errors. A converter that looks up remote data during every conversion can introduce hidden latency into request binding. Business enrichment belongs in an explicit application step where failure and authorization can be managed.

55. How do you validate nested objects without losing useful error paths?

Traverse the nested structure through an appropriate validation mechanism and preserve the field path when recording errors. For a custom Spring Validator, nested-path handling must be balanced so later errors are not assigned to the wrong property.

An address error should identify the relevant address and field rather than appear as an unrelated top-level failure. I would test collections, null nested values and multiple errors. Validation code should restore contextual state even when a nested check fails, especially when using shared error-collection infrastructure.

56. Why is unrestricted SpEL evaluation unsafe for user-defined rules?

A powerful evaluation context can expose properties, methods, types or other capabilities beyond simple arithmetic. Treating untrusted text as an unrestricted expression can cross the boundary from data into executable behavior.

I would define a constrained rule language or a deliberately restricted evaluation context with explicit allowed operations and resource limits. A read-only intent is not enough if method access remains available. Test both capability restrictions and expensive expressions rather than assume that the absence of a shell command makes evaluation harmless.

57. How does event ordering differ from transactional ordering?

Listener ordering controls which eligible listener is invoked first within the configured event mechanism. It does not automatically establish database commit order, durable delivery or a transaction spanning independent listeners.

A synchronous listener may run before the publisher's transaction commits and see behavior tied to that transaction. An asynchronous listener may run elsewhere with different context. I would specify when the event represents a committed fact and choose a mechanism that provides the required timing, rather than infer transactional guarantees from an ordering annotation.

58. What happens when a synchronous event listener throws an exception?

With ordinary synchronous event delivery, an uncaught listener failure can propagate through publication according to the multicaster's error-handling configuration. It can interrupt the publisher's flow and may prevent later work from proceeding.

I would decide whether the listener is essential to the operation or a best-effort observer, then configure handling accordingly. Silently swallowing every error can hide broken business behavior, while allowing an optional metric listener to abort a transaction may be equally inappropriate. Test the actual configured path and document the contract.

59. How can a parent-child context hierarchy affect event delivery?

Events published in a child context can propagate to parent listeners. Bean lookup can also proceed upward, but it is a fallback search for a dependency rather than event delivery to listeners at multiple levels. A parent-published event does not automatically broadcast down to its child contexts.

A listener registered in multiple contexts may process the same logical occurrence through separate instances or paths. I would inspect event source and context ownership and test hierarchy behavior explicitly. Moving a listener to a shared parent should be a deliberate design choice, not an accidental result of broad scanning.

60. How do JDK proxies and class-based proxies constrain advice?

JDK proxies expose interface methods, while class-based proxies subclass the target type and therefore cannot override final methods or extend final classes. Private methods are not ordinary overridable proxy entry points.

I would select a service contract and proxy strategy compatible with the methods that need advice. A method annotation alone does not overcome Java's proxying constraints. Tests should call the exposed managed bean, because directly constructing the target can make an otherwise valid advice configuration appear absent.

61. What does advice ordering mean for nested interceptors?

Ordered interceptors form a call chain, so an outer interceptor runs its entry behavior before inner ones and its exit behavior after they unwind. The order changes what each concern observes and which resources are active.

For timing and transaction advice, the timer may include transaction setup depending on its position. A retry interceptor outside a transaction can create a fresh transaction per attempt, while a different order can reuse unsuitable state. I would document the intended nesting and test both success and failure paths rather than rely on annotation appearance order.

62. How should an around advice preserve exceptions?

It should rethrow the intended exception unless its contract explicitly translates or handles it, and ensure that cleanup does not replace the original failure accidentally. Broad catch-and-return behavior can convert failure into a misleading success value.

A timing advice can use a finally block to record elapsed time without changing the target's result. If the recorder itself fails, the design should decide whether that failure may override the business exception. I would test thrown exceptions and cleanup failures, not just the normal return path.

// Method-body fragment in an org.aopalliance.intercept.MethodInterceptor.
long started = System.nanoTime();
try {
    return invocation.proceed();
} finally {
    long elapsedNanos = System.nanoTime() - started;
    // Record elapsedNanos through a bounded, failure-safe observation path.
}
// Method-body fragment in an org.aopalliance.intercept.MethodInterceptor.
long started = System.nanoTime();
try {
    return invocation.proceed();
} finally {
    long elapsedNanos = System.nanoTime() - started;
    // Record elapsedNanos through a bounded, failure-safe observation path.
}
// Method-body fragment in an org.aopalliance.intercept.MethodInterceptor.
long started = System.nanoTime();
try {
    return invocation.proceed();
} finally {
    long elapsedNanos = System.nanoTime() - started;
    // Record elapsedNanos through a bounded, failure-safe observation path.
}

The enclosing invoke method must accept a MethodInvocation named invocation and declare throws Throwable. The placeholder comment is deliberate: an actual recording implementation needs its own failure policy.

63. How do pointcut parameter bindings improve an advice?

They expose relevant method arguments or annotations through a declared contract rather than requiring fragile manual indexing of an argument array. The pointcut and advice signature must agree on what is bound.

An advice can inspect a designated operation identifier without assuming it is always argument zero across every method. I would keep matching rules narrow and test overloaded methods and interface declarations. Parameter binding improves clarity but does not authorize logging sensitive argument values or changing them unexpectedly.

64. When would programmatic ProxyFactory be useful?

It can create a proxy with explicit target, interfaces and advice when an integration or test needs controlled proxy construction outside ordinary auto-proxy discovery. It is useful for learning and specialized infrastructure, not necessarily for routine application wiring.

A focused test can create one service proxy and verify interceptor order without starting a full context. I would still test container registration separately if production relies on it. A correct manually created proxy does not prove that component scanning or auto-proxy matching will expose the same behavior in the application.

65. What work does JdbcTemplate perform around a query?

It coordinates standard JDBC resource handling, statement execution and exception translation while application code supplies SQL, parameters and result mapping. It reduces repeated plumbing but does not choose efficient SQL or establish every business transaction automatically.

I would use parameter binding for values and a mapper suited to the result shape. The template's cleanup contract should be respected rather than closing its shared resources arbitrarily inside a callback. Query plans, indexes and transaction boundaries remain application and database concerns.

66. How does RowMapper differ from ResultSetExtractor?

A RowMapper maps one current row to an object, while a ResultSetExtractor processes the result set as a whole. The extractor can assemble relationships or aggregate several rows into one structure.

A flat customer list fits a row mapper; a joined result that builds one order with many line items may need an extractor or deliberate grouping. I would not advance the cursor inside an ordinary RowMapper because the template manages iteration. Choosing the wrong callback can skip rows or duplicate parent objects.

// jdbc is a configured JdbcTemplate; Customer is an application record.
var customers = jdbc.query(
    "select id, name from customer where active = ?",
    (rs, rowNum) -> new Customer(rs.getLong("id"), rs.getString("name")),
    true
);
// jdbc is a configured JdbcTemplate; Customer is an application record.
var customers = jdbc.query(
    "select id, name from customer where active = ?",
    (rs, rowNum) -> new Customer(rs.getLong("id"), rs.getString("name")),
    true
);
// jdbc is a configured JdbcTemplate; Customer is an application record.
var customers = jdbc.query(
    "select id, name from customer where active = ?",
    (rs, rowNum) -> new Customer(rs.getLong("id"), rs.getString("name")),
    true
);

This fragment assumes non-null id values, a compatible boolean parameter and a Customer(long, String) constructor. The row mapper reads the current row without calling next().

Callback

Iteration ownership

Suitable result

RowMapper

Template advances the cursor

One object per row

ResultSetExtractor

Extractor processes the result set

Aggregate or related-object structure

RowCallbackHandler

Template advances the cursor

Per-row processing without a returned list

67. When is RowCallbackHandler useful?

It processes rows for side effects or accumulation without requiring the template to build a list of mapped results. This can suit exports or streaming-style processing, subject to the driver's actual fetch and buffering behavior.

Writing rows to a controlled output sink may reduce application-level list allocation. It does not guarantee that the JDBC driver streams everything or that a long query holds no resources. I would configure and measure fetch behavior, handle output failures and bound the transaction and connection lifetime.

68. What does NamedParameterJdbcTemplate change about SQL parameters?

It lets SQL refer to named value parameters and translates them into the underlying JDBC parameter form. This improves readability for statements with many values and reduces mistakes caused by positional reordering.

A query can use customerId and status names rather than remembering several numeric positions. Parameter binding applies to values, not arbitrary SQL identifiers such as table names or sort expressions. I would whitelist those structural choices separately and define empty-collection behavior before generating an IN condition.

// namedJdbc is a configured NamedParameterJdbcTemplate.
var parameters = java.util.Map.of("status", "OPEN");
Integer count = namedJdbc.queryForObject(
    "select count(*) from ticket where status = :status",
    parameters,
    Integer.class
);
// namedJdbc is a configured NamedParameterJdbcTemplate.
var parameters = java.util.Map.of("status", "OPEN");
Integer count = namedJdbc.queryForObject(
    "select count(*) from ticket where status = :status",
    parameters,
    Integer.class
);
// namedJdbc is a configured NamedParameterJdbcTemplate.
var parameters = java.util.Map.of("status", "OPEN");
Integer count = namedJdbc.queryForObject(
    "select count(*) from ticket where status = :status",
    parameters,
    Integer.class
);

This fragment assumes a compatible schema and a count that fits the selected Java type. The named parameter represents a value; it cannot safely substitute for a table name or arbitrary SQL clause.

69. How should generated keys be retrieved safely?

Use the database and driver's supported generated-key mechanism and verify the expected columns and row cardinality. Do not infer a new identifier by querying the current maximum value, which races with concurrent inserts.

JdbcTemplate supports key-holder patterns for compatible operations, but details vary by database and statement. I would test the exact schema and driver, including batch behavior if used. A successful insert does not guarantee that every driver returns generated keys in the same shape or order.

70. How do JDBC batch update results need to be interpreted?

A batch can return per-operation counts or special status values according to JDBC and driver behavior. Failures may include partial results, so an array of counts should not be assumed to mean every statement affected exactly one row.

I would define whether partial completion is acceptable and place the batch in an appropriate transaction when all-or-nothing behavior is required. Check the driver's handling of failures and generated keys. Batching reduces round trips, but transaction duration and memory consumption still need limits for large inputs.

71. Why does Spring translate SQLExceptions?

Translation maps database-specific failures into a more consistent data-access exception hierarchy, allowing application code to distinguish broad failure categories without depending entirely on vendor codes. The original cause remains important for diagnosis.

A duplicate-key conflict and a transient connection failure require different responses. I would avoid retrying every DataAccessException indiscriminately or returning raw database details to clients. Translation improves the abstraction, but the chosen database's semantics and the application's idempotency still determine whether a retry is safe.

72. How does JdbcTemplate participate in a Spring-managed transaction?

When configured with the appropriate DataSource and transaction infrastructure, it obtains connections through Spring's resource-management mechanisms so operations can participate in the current transaction. Using an unrelated connection source can escape that boundary.

I would verify that the transaction manager and template refer to the intended resource, particularly in applications with multiple databases. A transaction annotation on a service cannot make arbitrary independently opened connections join automatically. An integration test should provoke failure and inspect committed state outside the transaction under test.

73. What is TransactionTemplate useful for beyond annotations?

It makes a transaction boundary explicit around a block of imperative code and exposes status for decisions such as marking rollback-only. This can be clearer when only part of a method should be transactional or when boundaries are determined by the control flow.

A service can prepare input before entering the transaction and perform the short database operation inside the callback. I would avoid placing slow remote calls inside that boundary unnecessarily. Programmatic control couples code to Spring's transaction API, so the clarity gained should justify that coupling.

// transactionTemplate and jdbc use the same intended DataSource.
Integer changed = transactionTemplate.execute(status ->
    jdbc.update("update inventory set reserved = reserved + ? where id = ?",
                1, 42L)
);
// transactionTemplate and jdbc use the same intended DataSource.
Integer changed = transactionTemplate.execute(status ->
    jdbc.update("update inventory set reserved = reserved + ? where id = ?",
                1, 42L)
);
// transactionTemplate and jdbc use the same intended DataSource.
Integer changed = transactionTemplate.execute(status ->
    jdbc.update("update inventory set reserved = reserved + ? where id = ?",
                1, 42L)
);

This fragment demonstrates a boundary, not a complete reservation algorithm. A real invariant may require a conditional update, concurrency control and checking the affected-row count.

74. How should TransactionTemplate results and failures be handled?

Return the callback's intended result through the template and let failure behavior reflect the operation's contract. Marking rollback-only can roll back work without necessarily throwing the same exception a declarative path would produce, so callers need a clear success/failure representation.

I would not return a success DTO after deliberately marking rollback-only unless it accurately describes a no-commit outcome. For checked failures, use an explicit design consistent with the template API rather than silently swallowing them. Test both returned values and database state, because either alone can conceal a contract mismatch.

75. What is DispatcherServlet's relationship to HandlerMapping and HandlerAdapter?

DispatcherServlet coordinates request processing. HandlerMapping identifies a suitable handler and associated execution chain, while HandlerAdapter knows how to invoke that handler type. The separation allows different handler models to share the dispatcher.

A request that fails to map needs a different investigation from a mapped handler that cannot be invoked correctly. I would inspect mappings, supported handler types and configuration rather than treat every 404 or invocation error as a controller bug. These are framework strategies, not features that require Spring Boot.

Strategy

Responsibility

Common diagnostic question

HandlerMapping

Select handler and execution chain

Did this request match the intended handler?

HandlerAdapter

Invoke the handler model

Can this adapter invoke the selected handler?

Message converter

Read or write supported representations

Is the body type and media type supported?

76. What does a HandlerMethodArgumentResolver do?

It turns request context into a supported controller method argument. Custom resolvers can centralize a narrowly defined binding contract, but should have precise support rules so they do not intercept unrelated parameters.

A resolver might construct an application-specific request context from already validated information. I would not treat a caller-provided header as trusted identity merely because a resolver wrapped it in an object. Test missing, malformed and ambiguous input as well as interaction with built-in resolvers.

77. What does a HandlerMethodReturnValueHandler do?

It interprets supported controller return values and coordinates their contribution to the response or model. It is distinct from an HTTP message converter, which encodes or decodes a representation for supported types and media types.

A custom return wrapper may need special handling before serialization. I would avoid overlapping support rules that unexpectedly replace standard behavior and test status, headers and body together. Returning a Java object does not determine the complete HTTP response without the surrounding handler and conversion infrastructure.

78. How does content negotiation interact with message conversion?

Negotiation identifies an acceptable response representation using the configured request and application rules, while a compatible converter must be able to write the selected body type and media type. Either step can prevent a response from being produced.

A client requesting an unsupported representation may receive an appropriate negotiation error even when the controller returned a valid object. I would test Accept and Content-Type separately because they describe different directions. Adding a converter should not silently override the public API's representation contract.

79. How does a servlet Filter differ from a HandlerInterceptor?

A Filter operates in the servlet chain and can wrap requests or responses before MVC dispatch. A HandlerInterceptor participates in the MVC handler execution process and has access to handler-related context at its defined stages.

A filter can address concerns spanning servlet endpoints, while an interceptor can observe mapped MVC handlers. I would choose based on the required boundary and account for asynchronous dispatch behavior. Neither should casually duplicate a dedicated security framework's authorization logic, and interceptor coverage should not be assumed to include every request path.

80. What should a custom ViewResolver return when it cannot resolve a view?

A resolver should return null from resolveViewName when the requested view is not defined in it and it supports chaining. This allows another resolver to try. The contract also permits resolvers that always attempt to construct a view because they cannot determine existence in advance; such resolvers need careful ordering.

An overly broad resolver can prevent a later resolver from handling a valid view. I would test known views, unknown views and overlapping names with the actual chain, including view-creation exceptions. A catch-all resolver generally belongs after more selective ones. View resolution renders a model; it is distinct from response-body serialization through message converters.

Spring Framework Interview Questions and Answers for Experienced

The experienced answers focus on contracts that can fail despite successful startup or compilation. They distinguish local observations from verified framework and infrastructure behavior.

81. How would you design a reusable container extension without creating hidden beans?

Define the extension's registration contract, names, types and conditions explicitly, and provide a way to inspect the resulting definitions. Infrastructure should be deterministic across equivalent configurations rather than depend on unrelated scan order or runtime side effects.

I would test minimal contexts with the extension enabled, disabled and configured alongside user definitions. Conflicts should produce a clear failure or documented override behavior. The extension's purpose is to make composition predictable; silently adding unrelated resources makes applications harder to reason about and operate.

82. How can early bean references complicate proxy correctness?

Some container paths involving circular dependencies can expose references before normal initialization finishes. If the eventual exposed object is a proxy but a collaborator holds an earlier raw reference, calls may bypass expected behavior or trigger lifecycle errors.

I would first remove the dependency cycle or clarify its construction boundary rather than depend on incidental early-reference handling. Infrastructure that customizes early references must coordinate with later wrapping carefully. A test should compare the actual injected references and observed advice, not merely confirm that the context starts.

83. How should a library handle bean-name collisions across modules?

Use a deliberate naming and registration policy and fail clearly when two incompatible definitions claim the same role. Whether overriding is allowed depends on container configuration and should not be assumed from one application's defaults.

I would avoid generic names for internal infrastructure and expose intentional extension points separately. Tests should combine realistic modules, because each may work alone while failing together. Renaming a bean can also affect explicit references, so collision fixes need compatibility review rather than a random generated suffix.

84. What makes dynamic bean registration after startup difficult?

Already created objects retain their dependencies, and framework caches or discovery steps may not automatically reconsider new definitions. Runtime registration therefore does not imply that all consumers, proxies and handlers adopt the change consistently.

I would prefer a stable, explicit registry or strategy abstraction for genuinely dynamic application behavior. If container mutation is necessary, define synchronization, lifecycle and removal semantics and test concurrent access. Treating a running context like an unrestricted mutable map overlooks the initialization work that has already occurred.

85. How do you make a parent-child context boundary testable?

Specify which services are owned by each level and verify dependency resolution, shadowing and event behavior in a small hierarchy test. The boundary should correspond to an actual isolation or reuse requirement.

I would create two children sharing one parent and assert which instances are shared and which are distinct. Closing one child should not unexpectedly destroy parent-owned resources. This exercise can reveal accidental duplicate scanning or dependencies that point in the wrong direction before the hierarchy is embedded in a larger application.

86. How should a plugin system unload a child context?

Stop accepting new plugin work, drain or cancel in-flight operations, close the child context and release external references to its objects and classloader. Context closure alone cannot reclaim objects still held by global registries, threads or static caches.

I would test repeated load/unload cycles and inspect retained resources, not just successful initial loading. Thread context classloaders and callbacks registered with parent services are common ownership concerns. Unloading is a lifecycle protocol with the host application, rather than a single close call that guarantees memory reclamation.

87. How do you validate lifecycle phase relationships in a complex application?

Model which components must start before others and which must stop first, then translate those relationships into supported lifecycle phases and dependencies. Numeric phases should reflect documented intent rather than accumulate as unexplained constants.

A consumer should stop accepting work before its data client is destroyed. I would use a controlled test that records start and stop completion, including asynchronous callbacks and failures. The test should verify the required partial order instead of assuming every component has one globally fixed sequence.

88. How do you keep initialization failures from leaking resources?

Make resource acquisition incremental and ensure that partially acquired resources are released when later initialization fails. Do not assume a fully initialized bean's normal destruction path will cover every failed construction scenario.

A factory that creates an executor and then fails to create a client should close the executor in its failure path. I would test injected failures at each acquisition step and make ownership transfer explicit when returning the completed object. This is especially important in reusable infrastructure that may be initialized repeatedly by tests or child contexts.

89. How can a custom annotation compose framework behavior safely?

Use supported meta-annotation and attribute-aliasing mechanisms with a narrow, documented purpose. A composed annotation should make intended semantics clearer rather than hide several unrelated policies behind an attractive name.

I would test merged annotation lookup, overridden attributes and the locations where the annotation is supported. If it combines transaction or request-mapping behavior, users still need to understand those underlying boundaries. A wrapper annotation is an API: changing its defaults can alter many applications without changing their source code.

90. What should an AOP contract test assert beyond advice execution?

Assert the exposed type, matching boundaries, invocation count, result and exception preservation, and ordering relative to other relevant advice. Merely incrementing a counter proves that something ran, not that the service contract stayed correct.

I would include an unmatched method and a failing method, then test the container-created proxy used in production. A retrying advice deserves an explicit duplicate-effect test. This makes proxy behavior reviewable and protects against broad pointcuts or a later infrastructure change that rearranges the chain.

91. How do you distinguish proxy AOP from AspectJ weaving when debugging interception?

Determine how the application actually applies aspects. Proxy AOP intercepts calls through generated proxy objects, while weaving modifies behavior at supported join points in compiled or loaded classes. Their coverage and deployment requirements differ.

A same-object call that bypasses a proxy may be intercepted under an appropriately woven aspect, but that does not mean weaving is enabled because AspectJ annotations appear in source. I would inspect configuration and build/runtime tooling, then reproduce the exact invocation path. Switching mechanisms changes operational assumptions and should not be a casual workaround.

92. How can advice that changes arguments violate a service contract?

Replacing arguments can invalidate caller expectations, validation results or downstream assumptions, especially if mutable objects are shared. The advice must respect the declared types and define whether mutation is visible outside the call.

A normalization interceptor that changes a customer identifier could alter authorization meaning after a prior check. I would prefer explicit boundary normalization where possible and test interactions with validation and security. Cross-cutting implementation does not make a semantic transformation harmless or remove the need for a clear contract.

93. How do you choose a transaction manager in a multi-resource application?

Associate each transactional operation with the manager that controls its intended resource and make ambiguous selection explicit through supported configuration. Two local transaction managers do not automatically create one atomic transaction across their databases.

I would test which connection is actually enlisted and what happens if the second resource fails after the first commits. If atomic cross-resource behavior is required, choose an appropriate coordination mechanism or redesign the workflow with explicit consistency semantics. Naming two managers is not sufficient evidence of distributed atomicity.

94. How do transaction synchronization callbacks differ from durable work scheduling?

They run at defined points in a transaction's lifecycle within the process, allowing coordination with commit or completion. They do not by themselves persist a task that will be replayed after a crash.

A callback can clear local state after completion, but a crash between commit and an external action can still leave a gap. I would use durable state and a recovery process for work that must eventually occur. The callback's timing is useful, but it should not be described as an exactly-once delivery guarantee.

95. Why can database work in an after-commit callback be surprising?

The original transaction has already committed, while associated resources may still be accessible during completion processing. New work must have a deliberately defined transaction boundary; merely using the remaining resource does not mean a new commit will happen as expected.

I would keep completion callbacks focused and delegate independent writes to an appropriately configured new transaction when required. Test the actual persisted result after the callback finishes. A log showing that an insert statement ran is not proof that the intended durable transaction committed.

96. What limits the portability of NESTED transaction propagation?

Nested behavior commonly relies on savepoints within one physical transaction and depends on the transaction manager, database and resource access model. It is not a universal nested-unit feature across all persistence technologies.

I would verify savepoint support and test what state remains in any persistence context after rollback to a savepoint. A database row reverting does not automatically reconcile every in-memory object. When the business needs an independent commit, a savepoint is not equivalent to a separate physical transaction.

97. What does a read-only transaction declaration actually guarantee?

It expresses intent and can influence optimization or enforcement depending on the manager, driver and database. It should not be treated as a universal authorization mechanism that makes all writes impossible.

I would test the selected stack's behavior and use database permissions or explicit application policy where write prevention is required. A read-only hint may affect flushing or connection settings without blocking every operation. Accurate documentation should distinguish an optimization hint from an enforced security boundary.

98. How do transaction timeouts interact with slow external calls?

A transaction timeout constrains the transaction according to the participating infrastructure's enforcement behavior; it does not necessarily interrupt every arbitrary Java operation immediately. A remote call can still occupy a thread and hold resources unless its own deadlines are configured.

I would set compatible network timeouts and minimize remote work inside database transactions. After a timeout, the application must handle the resulting failure and cleanup rather than assume execution stopped at the exact deadline. Integration tests should cover the actual driver and client behavior, not just an annotation value.

99. How does queryForObject distinguish result cardinality from a SQL NULL value?

queryForObject expects exactly one result row. No rows and multiple rows are cardinality failures, commonly reported through EmptyResultDataAccessException and IncorrectResultSizeDataAccessException respectively. A single row whose selected column is SQL NULL is a different case and can produce a null value with a compatible mapping.

I would test zero rows, one non-null row, one null row and multiple rows separately. Catching every data-access exception and returning null would hide both malformed queries and infrastructure failures. If absence is valid, handle that specific outcome deliberately; if many rows are valid, use a collection query rather than weakening an exactly-one contract.

100. How does reactive transaction scope differ from imperative transaction scope?

Reactive transactions use the reactive execution context rather than an ordinary thread-bound assumption, and participation depends on the publisher chain and reactive resource infrastructure. Work must remain within the relevant subscribed pipeline.

Constructing a publisher does not necessarily execute its database operation. I would use a suitable ReactiveTransactionManager and TransactionalOperator or supported declarative arrangement, then test subscription, completion, error and cancellation behavior. Mixing unrelated imperative JDBC work into the chain does not automatically enlist it in the reactive transaction.

101. Why can an internal subscribe call break a reactive transaction design?

It creates a separate execution path whose lifetime and context may no longer be governed by the caller's composed publisher. The outer operation can finish while the internally subscribed work continues or fails independently.

I would return and compose the publisher so transaction and error handling can cover the intended work. Fire-and-forget subscription needs an explicit ownership and durability model. A method returning successfully after subscribe is called is not evidence that the database work completed or committed.

102. How should reactive cancellation be tested around resource use?

Cancel at controlled points and verify that the resource is released and the transaction outcome matches the framework and driver's contract. Cancellation is a normal execution signal, not merely an unusual exception path.

A client disconnect during a streaming response can stop downstream demand while database work is active. I would test the selected driver and transaction operator rather than infer behavior from synchronous try/finally code. Cleanup and rollback expectations need evidence for the actual reactive chain.

103. How do you choose between DataSourceTransactionManager and JdbcTransactionManager?

Both address local JDBC transaction management, while JdbcTransactionManager adds exception-translation behavior for commit and rollback failures consistent with Spring's JDBC support. The choice should align with the framework version and the application's error-handling needs.

I would review how transaction completion failures reach the caller and test representative database failures. Neither manager turns two unrelated DataSources into a distributed transaction. Selecting a more convenient exception model does not alter the fundamental resource boundary or guarantee recovery from an uncertain commit outcome.

104. How do you prevent JDBC callbacks from escaping their resource lifetime?

Convert results into application-owned values while the callback's JDBC resources are valid, or use an explicitly documented streaming API with clear closure ownership. Returning a raw ResultSet or a lazy object tied to it can fail after cleanup.

I would copy the fields needed by the caller rather than expose driver objects across service boundaries. For large exports, choose a controlled streaming path and test early termination. Resource safety depends on the lifetime contract, not only on whether the happy path eventually reads every row.

105. How do you test SQL null handling in custom row mapping?

Use nullable fixtures and verify how each JDBC getter represents SQL NULL. Primitive getters can return a default value that must be distinguished through wasNull or an appropriate typed nullable access method.

A nullable numeric column mapped to zero can silently change business meaning. I would test null, zero and nonzero values separately and choose domain types that express the distinction. A mapper that works on a dataset without nulls provides little evidence about this boundary.

// Method-body fragment inside a RowMapper; "quantity" is nullable.
int rawQuantity = rs.getInt("quantity");
Integer quantity = rs.wasNull() ? null : rawQuantity;
// Method-body fragment inside a RowMapper; "quantity" is nullable.
int rawQuantity = rs.getInt("quantity");
Integer quantity = rs.wasNull() ? null : rawQuantity;
// Method-body fragment inside a RowMapper; "quantity" is nullable.
int rawQuantity = rs.getInt("quantity");
Integer quantity = rs.wasNull() ? null : rawQuantity;

Call wasNull() immediately after the getter whose null status matters. Another getter can change the status being inspected. This fragment assumes a valid current JDBC row.

106. What should a streaming JDBC export do when the output sink fails?

Stop processing, propagate a meaningful failure and release database and output resources according to their ownership contracts. Continuing to read millions of rows after the destination has failed wastes capacity and can prolong transactions.

I would test a sink that fails after a few rows and verify connection release and any partial-output policy. A generated file may need a temporary name and atomic finalization so consumers do not mistake partial content for a completed export. Streaming reduces buffering but introduces lifecycle and cancellation responsibilities.

107. How do you validate custom MVC argument-resolution precedence?

Create representative handler signatures and verify which resolver accepts each one under the actual configured chain. A broad supportsParameter implementation can shadow standard conversion or another custom resolver.

I would use a dedicated annotation or type to make the contract narrow and test missing input, malformed input and unrelated parameters. The result should also preserve validation and authorization boundaries. A unit test of resolveArgument alone cannot prove that MVC selects the resolver in a real request.

108. How can custom message converters break an existing API?

Converter order and supported media/type declarations can cause a new converter to claim bodies previously handled by another one. This can change serialization, content types or error behavior without modifying controllers.

I would test existing representations as regression contracts and register the converter as narrowly as possible. A converter that claims every object for a common media type can have application-wide consequences. Successful serialization of its intended sample is insufficient evidence that unrelated endpoints remain compatible.

109. What is the difference between configuring and extending MVC defaults?

In the older list-based WebMvcConfigurer hooks, adding converters through configureMessageConverters(List) replaces the normal default registration path, while extendMessageConverters(List) customizes the already assembled list. A customization that removes defaults accidentally can break unrelated response types even if its new converter works.

Both list-based converter hooks are deprecated for removal since Spring Framework 7.0. For the 7.0.10 reference used here, consult configureMessageConverters(HttpMessageConverters.ServerBuilder) and the builder contract for supported converter customization. I would test ordinary JSON and text responses as well as the new representation. Similar hook names across framework versions do not establish identical replacement or extension semantics.

110. How do servlet asynchronous requests complicate interceptor cleanup?

Request processing can leave the original thread and resume through asynchronous dispatch, so callbacks and thread-local assumptions differ from a simple synchronous request. Cleanup must follow the supported async lifecycle rather than assume one thread executes every stage.

I would test normal completion, timeout and client cancellation with the actual servlet setup. State stored in a thread-local can leak to another request if cleanup is incomplete. The design should prefer request-associated state and explicit context propagation where needed.

111. How do WebFlux codecs differ from MVC message converters?

They serve analogous representation roles in different execution models: WebFlux uses reactive readers and writers that work with publishers and data buffers, while MVC uses servlet-oriented message conversion. Configuration and resource-lifetime assumptions are not interchangeable.

I would use the stack's intended extension points and test streaming, buffer limits and error handling. A custom codec that aggregates an unbounded body can undermine a nonblocking application's resource behavior. Reusing a domain serializer may be reasonable, but copying MVC infrastructure configuration into WebFlux does not establish equivalent behavior.

112. How do you handle pooled data buffers in a custom reactive integration?

Follow the ownership and release rules of the buffer API, especially when retaining, discarding or asynchronously processing pooled buffers. Failing to release a buffer can leak memory; releasing it too early can corrupt later access.

I would prefer supported higher-level operators when they already manage ownership correctly. Custom code needs tests for success, error, cancellation and filtered-out data. Heap metrics alone may miss pooled direct-memory pressure, so diagnostics should cover the allocator and runtime actually in use.

113. What does the TestContext framework contribute without Spring Boot?

It integrates context configuration, dependency injection into tests, lifecycle listeners and other testing facilities with supported test frameworks. A test can load a deliberately small Spring configuration without bootstrapping a Boot application.

I would use that scope to verify a container extension or transaction integration with only its required dependencies. Plain unit tests remain appropriate for ordinary domain logic. Loading a context should answer a framework-integration question, not become the default way to test every method.

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit.jupiter.SpringExtension;

@ExtendWith(SpringExtension.class)
@ContextConfiguration(classes = AppConfig.class)
class ContextSmokeTest {
    @Test
    void contextLoads() {
        // Add assertions for the specific integration contract under test.
    }
}
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit.jupiter.SpringExtension;

@ExtendWith(SpringExtension.class)
@ContextConfiguration(classes = AppConfig.class)
class ContextSmokeTest {
    @Test
    void contextLoads() {
        // Add assertions for the specific integration contract under test.
    }
}
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit.jupiter.SpringExtension;

@ExtendWith(SpringExtension.class)
@ContextConfiguration(classes = AppConfig.class)
class ContextSmokeTest {
    @Test
    void contextLoads() {
        // Add assertions for the specific integration contract under test.
    }
}

This skeleton assumes JUnit Jupiter, spring-test and an application-defined AppConfig. Context loading is only a smoke check; the comment must be replaced with assertions before this becomes a meaningful behavior test.

114. How should custom TestExecutionListeners coexist with defaults?

Configure them so required default listeners remain active unless replacement is intentional, and define ordering relative to the lifecycle tasks they depend on. Replacing the list accidentally can remove injection or transaction behavior.

A fixture listener may need to run before or after a transaction boundary depending on what it prepares. I would test the listener together with the real test configuration and inspect execution order. A listener working in isolation does not prove that it composes correctly with the framework's default sequence.

115. How can preemptive test timeouts invalidate transactional-test assumptions?

A preemptive timeout mechanism may run the test body on a different thread from the one carrying the test-managed transaction. Database work on that thread may then occur outside the transaction expected to roll back.

I would choose a timeout approach compatible with the test's transaction model and verify cleanup from outside the test transaction. A green assertion followed by polluted test data can indicate this mismatch. Thread-bound transaction behavior should be considered whenever a test framework or helper changes execution threads.

116. When should TestTransaction be used?

It allows a transactional test to control the test-managed transaction explicitly, such as ending it and starting another to inspect committed behavior. This is useful when a test needs to exercise commit-time effects rather than only work inside a transaction that always rolls back.

I would make commit or rollback intent explicit and isolate any persistent fixtures created by the test. Ending a test transaction can trigger behavior that was previously hidden, including constraints or completion listeners. The test should verify the external state and clean it deterministically rather than depend on test order.

117. How do you test transaction behavior that only appears at commit?

Ensure the test actually reaches the relevant commit or flush boundary and inspect results outside the transaction. A test that always rolls back can miss deferred constraints, commit failures or after-completion behavior.

I would use a focused integration test with a real compatible database and explicit cleanup. An in-memory substitute may not reproduce the production database's constraint timing. Successful method return inside a still-open test transaction is weaker evidence than a completed transaction with verified durable state.

118. How should SQL test fixtures interact with transaction boundaries?

Decide whether fixture setup and cleanup should participate in the test transaction or execute independently, then configure the supported SQL execution mode accordingly. The choice affects what the application sees and what remains after the test.

Fixtures for code running on another thread may need to be committed before that code reads them. I would avoid assuming rollback cleans independently committed work. Tests should use unique data or deterministic cleanup so parallel execution does not turn shared fixtures into intermittent failures.

119. How do you assess compatibility when upgrading the Spring Framework itself?

Review supported Java and Jakarta baselines, removed or changed APIs, dependency alignment and behavioral changes in the features actually used. Compile-time success is only one part of compatibility, especially for reflection, proxies and serialization integrations.

I would run focused contract tests for custom processors, MVC extensions and transaction behavior, then broader application tests. The official reference consulted for this guide identifies Framework 7.0.10, but an application's selected version governs its actual API contract. Do not mix versions casually or transfer Boot-specific migration assumptions to a framework-only application.

120. How would you review a custom Spring integration before accepting it into production?

Require a clear lifecycle and extension contract, bounded dependencies, failure handling and tests of the actual container behavior. Review what the integration changes globally and whether a simpler explicit application component would meet the need.

I would inspect startup, shutdown, proxy types, resource ownership and negative cases, including conflicting configuration. For code examples or prototypes, distinguish static review from execution against the selected framework and infrastructure. A useful integration reduces repeated complexity without making ordinary application behavior invisible to its maintainers.

  • Verify minimal-context registration and conflicting configurations.

  • Check startup failure and partial-resource cleanup.

  • Assert exposed proxy types, matching boundaries and failure behavior.

  • Exercise graceful shutdown and ownership of asynchronous work.

  • Record the actual framework version and which tests were executed.

Spring Framework Documentation and Further Reading

Use these official Spring references to verify the selected version and extension contract. Java snippets in this guide were statically reviewed, not executed; database, servlet and reactive behavior require tests against the actual runtime stack.

Team Sherlock.sh

Building fraud intelligence for live high-stake video interactions (financial discussions, hiring interviews, board meeting etc).

Catch candidate fraud before it costs you.

Sherlock AI helps you detect AI-assisted, proxy, and deepfake candidates, so every hiring decision is backed by evidence.

Ask AI about Sherlock.sh

Similar Posts