Pick a focused question that fits your time, stack, and interview goal.
How much time do you have?
Show one-drill sessions you can finish now.
208 results across 1 active filter
Page 2 of 9
Explains path, HTTP method, parameters, headers, consumed and produced media types, specificity, and ambiguous mappings.
Improves suite speed by reusing stable application contexts and avoiding configuration variation, unnecessary dirtiness, and process forks.
Explains Spring's transactional proxy boundary and why an internal method call does not normally start independent advice.
Explains deterministic cleanup through AutoCloseable, reverse close order, suppressed exceptions, and clear ownership.
Explains how managed changes become SQL at flush and why flush is not the same as a durable commit.
Explains container ownership, dependency declarations, bean creation, and why dependency injection is a specific form of inversion of control.
Explains private, package-private, protected, and public access through design intent rather than a visibility table alone.
Explains circular lock waits, consistent ordering, reduced lock scope, timed acquisition, and thread-dump confirmation.
Applies upper and lower bounded wildcards to producer and consumer APIs while explaining their limits.
Connects identity, sequence, table, UUID, and assigned identifiers to database support, round trips, ordering, and batch inserts.
Explains mapping fetch semantics while separating them from the query-specific data shape an endpoint actually needs.
Explains dependency graphs, transitive versions, scopes or configurations, Spring Boot's BOM, and reproducible builds.
Explains one observation lifecycle feeding metrics, tracing, and context through registered handlers.
Explains first-match chain selection, rule matching inside a chain, ordering, fallback coverage, and accidental unprotected paths.
Separates compile-time overload resolution from runtime overridden-method dispatch and briefly bounds static hiding.
Explains Java primitives and references through observable language behavior without relying on an inaccurate stack-versus-heap shortcut.
Compares joining an existing transaction, suspending it for an independent transaction, and using a savepoint-backed nested scope.
Treats GrantedAuthority as the common representation while explaining role prefixes, scope mapping, and domain permission design.
Explains proxy interception, target delegation, JDK versus class proxies, method limits, and the self-invocation boundary.
Explains cache interception, keys, conditions, eviction, proxy self-invocation, and the provider boundary.
Explains cheap JVM-scheduled threads, blocking-I/O throughput, carrier pinning, ThreadLocal cost, and unchanged downstream limits.
Maps each part of the HTTP request to explicit controller arguments and distinguishes conversion, model binding, and body conversion.
Chooses a Java collection by the behavior the code needs: ordering, duplicates, membership, lookup keys, and iteration.
Selects the smallest Spring test scope that can prove the risky boundary without mocking away framework or infrastructure behavior.