Java & JVM
Java language, JVM behavior, dependencies and application diagnostics.
75 troubleshooting guides · Page 3 / 4
Why does a timed-out CompletableFuture leave the underlying request running?
Completing the promise exceptionally and stopping the work that produces it are separate mechanisms. A waiting deadline alone is not a resource-cancellation strategy.
Why does a finished Java command-line job stay alive after submitting executor tasks?
Task completion and executor lifecycle are different responsibilities. A pool owned by the command may still have worker threads after its jobs finish.
Why is a managed Maven dependency missing from compilation?
An entry in dependencyManagement is a version policy, not a request to put a library on this module’s classpath. This often surfaces when a parent knows a JSON library but its child imports unavailable classes.
Why does a provided dependency disappear when running a JAR?
Provided scope expresses an environment promise: compilation sees a dependency that the runtime is expected to supply. A plain command-line JAR does not automatically provide an application server’s APIs.
Why does source/target compile successfully but fail on an older JRE?
Syntax and class-file targets do not by themselves prove that only the older platform’s APIs were used. A newer build JDK can expose a method absent from the supported runtime.
Why does Maven report success without running my newly named test?
Test discovery has naming and engine rules. A file called `InvoiceChecks.java` may compile without matching the active Surefire inclusion configuration.
Why does selecting a Java toolchain not fix the Gradle daemon JDK?
The JVM running Gradle and the compiler toolchain can differ. Selecting Java 21 for compilation does not guarantee an old wrapper can run under the JDK launching its daemon.
Why does JAVA_HOME differ from the compiler used by a Gradle task?
A task with an explicit toolchain can use a compiler other than the shell’s JDK. That separation is useful, but makes `java -version` an incomplete diagnostic.
Why is @Transactional ignored by a same-bean method call?
In normal proxy-based transaction advice, a direct call through `this` does not re-enter the Spring proxy. An annotation can therefore exist while the expected boundary is absent.
Why does a checked exception leave my Spring transaction committed?
Rollback rules are policy, not simply the presence of an exception. With standard declarative defaults, a checked business exception may not trigger the rollback expected; applications can customize those defaults.
How do I resolve two PaymentGateway beans without parameter-name assumptions?
Two implementations create an ambiguous dependency unless a selection policy narrows candidates. Renaming a constructor parameter is a fragile expression of a business choice.
Why is a sibling-package Spring service not discovered?
Default component scanning starts in the application class’s package. A service outside that tree can be valid Java code yet absent from the context.
Why does editing application.properties not change a deployed setting?
Configuration has precedence. A launch argument, environment variable or external file may override the packaged value. Editing a lower-priority file then appears ineffective.
How do I reject an invalid timeout configuration before serving requests?
A value can bind successfully yet be operationally invalid, such as a negative connection timeout. Scattered string parsing delays failure until an unlucky request.
Why does a prototype dependency act like a singleton inside my service?
A prototype injected once into a singleton is resolved at that injection point. The containing service does not receive a fresh instance on every method call automatically.
Why do concurrent requests overwrite a Spring service field?
A singleton service is shared across requests. Storing the current invoice in an instance field shares that state even when controller invocations look independent.
Why does @Async still execute on the caller thread?
Async annotations require enabled infrastructure and an intercepted call. A same-object call can bypass the proxy; a manually created object is not a managed async bean.
Why does a scheduled import overlap its previous execution?
Schedule semantics, executor capacity and multiple application instances are separate factors. A larger timer interval does not create a distributed exclusion guarantee.
Why is advice absent from a final method on a class-based proxy?
A class-based proxy must override an intercepted method. A final method blocks that override; an annotation cannot make this proxy rewrite it.
Why is the wrong Spring profile active only in production?
Profile activation can originate in deployment rather than the package. A stale launch variable may keep an unexpected profile active after a file is edited.
Why does @Transactional not cover work launched on another thread?
For ordinary imperative transaction management, transaction context belongs to execution on the calling thread. Launching a worker does not automatically carry its database transaction.
Why is transactional initialization unreliable in @PostConstruct?
Initialization occurs while a bean is being created, before ordinary use through its completed proxy boundary. Self-invoked transactional initialization mixes lifecycle and interception assumptions.
Why does @Primary fix one injection but change unrelated services?
Primary supplies a default preference for type-based selection, not a local instruction to one constructor. A newly primary implementation can redirect other unqualified dependencies.
Why does an overridden configuration list replace rather than extend entries?
Binding merge behavior depends on property shape. Treating a higher-priority list as individual patches to the lower-priority list can remove rules or change order unexpectedly.
Ask your own question · Sign in to post questions and answers.