Inspections

Explyt Spring adds Spring-aware inspections that run as you type. Press Alt+Enter on any highlight to see the available quick fixes.

All of them live under Settings → Editor → Inspections → Explyt Spring, where you can adjust severity or disable individual checks.

Inspection accuracy improves considerably once the real bean model is loaded — see Native Context Mode. Without it, checks that depend on knowing the actual set of beans fall back to static analysis and may report problems that the running application would not have.

Beans and dependency injection

Inspection	What it catches
No candidate bean	An injection point with no bean available to satisfy it.
Ambiguous candidates	More than one candidate bean, where Spring cannot decide without a qualifier.
Invalid @Autowired usage	Autowiring applied where it does not work.
Proxy method usage	Calling a proxy method incorrectly when proxyBeanMethods is set to false.
Meta-annotation checks	Custom annotations used as meta-annotations without the required settings.
SPI beans	Recognizes and navigates beans produced through Java SPI.

Because Explyt reads the real context, these checks account for conditional beans, profile-activated beans, factory beans, and beans contributed by your dependencies — the cases where source-only analysis produces false warnings.

Configuration properties

Inspection	What it catches
Unused property keys	Keys defined in a properties file that nothing reads.
Duplicate keys	The same key defined more than once.
Naming convention	Keys that do not follow kebab-case.
Invalid prefixes	Empty, duplicate, or malformed prefixes on @ConfigurationProperties classes.
Registration check	A @ConfigurationProperties class that is not correctly registered with Spring.
Nullable parameters	Constructor parameters in a @ConfigurationProperties class that are not nullable.
Resource references	File and classpath references in annotations such as @Value that do not resolve.
Placeholder resolution	Unresolved placeholders, including keys consumed only from a dependency module.

Web endpoints

Inspection	What it catches
Duplicate endpoints	Two handlers mapped to the same path and method.
Missing path variables	A path template segment with no matching handler parameter.
Unsupported signatures	Handler method signatures Spring cannot bind.
OpenAPI validation	Structural problems in JSON and YAML specifications, unresolved references, and version incompatibilities.

AOP and async

Inspection	What it catches
Self-invocation	A method annotated with @Transactional or @Async called from within the same class, where the call bypasses the proxy and the annotation silently does nothing.
Async return type	An @Async method whose return type is neither void nor a Future subtype.
Cache annotations	Cache annotations placed on interfaces, where they should be on a class or method.

Self-invocation is worth calling out: it produces no error at runtime, the annotation simply has no effect, and it is a common source of transactions that quietly never open.

Spring Data

Inspection	What it catches
Repository method names	Derived query method names that do not match the entity's properties.
Return types and parameters	Repository methods whose signature does not match the query they describe.
Query languages	JPQL and SQL problems inside query methods, with syntax highlighting and completion.

Profiles and scheduling

Inspection	What it catches
Profile validation	Errors in @Profile expressions, empty profiles, and misused operators.
Cron expressions	Invalid @Scheduled cron expressions, with completion and a readable description of the schedule.

Kotlin-specific

Kotlin's interaction with Spring has failure modes that Java does not, mostly around JVM name mangling and singletons.

Inspection	What it catches
internal bean methods	An internal @Bean method whose JVM name is mangled by the compiler, so the bean name is not what you wrote. Quick fix adds an explicit bean name.
object as a component	A Kotlin object declared as a @Component. Quick fix converts it to a class.
Constructor validation	Kotlin-specific constructor injection problems.

Migration inspections

Explyt detects deprecated Spring Boot configuration properties, APIs, and annotations, and offers quick fixes to their modern equivalents. These help when upgrading a project across a major Spring Boot version.

Spring Boot 3. Active when the project targets Spring Boot 3 or newer.

• Renamed and removed configuration properties, with a fix to rename or remove the key.
• javax.* to jakarta.* namespace migration for imports.
• The httptrace actuator endpoint renamed to httpexchanges.
• A Spring bean injected into a @ConfigurationProperties constructor without @Autowired, which Spring Boot 3 would otherwise treat as a bound property.
• @ConstructorBinding is no longer required and is no longer reported as missing.

Spring Boot 4. Active when the project targets Spring Boot 4 or newer.

• Configuration property migration.
• @MockBean and @SpyBean migrated to @MockitoBean and @MockitoSpyBean.
• @JsonComponent and @JsonMixin migrated to @JacksonComponent and @JacksonMixin.
• Jackson 2 ObjectMapper injection flagged.
• BootstrapRegistry and BootstrapContext import migration.
• @EntityScan and TestRestTemplate package migration.
• @SpringBootTest missing Web Test Client auto-configuration.
• Actuator @Nullable migrated to JSpecify.

Availability. The migration inspections are among the newest additions and are gated to recent IntelliJ IDEA versions. Check Compatibility and the changelog to confirm they are present in the build you have installed.

Reporting a false positive

If an inspection reports a problem your application does not have, first confirm the bean model is loaded — most false positives in bean and injection checks come from analyzing without it. If the problem persists, open an issue with a minimal reproducer.

See also: Native Context Mode · Troubleshooting · Feature overview