Features

Features

The complete Explyt Spring feature list. For the headline summary, see the README; for the differentiator, see Native Context Mode. Visual gallery: Screenshots · Videos.

Contents

• Tool windows
• Bean detection & context analysis
• Spring Core & Boot enhancements
• Spring Web enhancements
• HTTP client
• Spring Debugger
• Spring Data support
• Spring AOP enhancements
• Inlay hints & Code Vision
• Code generation
• Spring Initializr
• Docker Compose & Kubernetes
• Quarkus support
• Spring AI
• MCP Server tools
• Kotlin support
• Additional inspections & features

---

Tool windows

• Explyt Spring — load real bean metadata, browse contexts, navigate beans, view aspects, and open Bean Analyzer. Entry point for native context mode.
• Explyt Endpoints — view and navigate endpoints for MVC/WebFlux, router functions, message brokers (Kafka/RabbitMQ listeners) and Spring Boot Actuator.

Walkthroughs and demos: Usage · Videos.

Bean detection & context analysis

• Detects beans via annotations, factory methods, and conditional logic (@Conditional, profiles, complex scans).
• Follows a scan into a dependency module: when scanBasePackageClasses (or a scan root) reaches a configuration in a module the application depends on, the components that configuration's own @ComponentScan adds are part of the application — for the autowiring inspection, the bean gutters, Search Everywhere and the MCP bean tools. Only scans of configurations the application itself reaches count; a library's own @SpringBootApplication root stays with that other application.
• Applications — a class annotated with @SpringBootApplication or with @EnableAutoConfiguration, directly or through a meta-annotation, is an application; an @EnableAutoConfiguration class scans its package only when it also carries @ComponentScan.
• Profiles — the values of @Profile({"a", "b"}) are alternatives, as in Spring: a bean is active when any value matches, also across a direct @Profile and one from a meta-annotation, and an empty @Profile({}) keeps the bean. A value is read by its constant value, so @Profile(Profiles.DEV) works; a value that cannot be evaluated keeps the bean rather than hiding it. Profiles added by spring.profiles.group.<name> are active whenever their group is.
• @ConditionalOnProperty is evaluated the way Spring Boot evaluates it: every repeated annotation and every listed name must match, havingValue is compared ignoring case, false does not match without havingValue, matchIfMissing applies only to a missing key, and @ConditionalOnBooleanProperty is evaluated too. The value comes from the configuration files — an active profile file over the default one, a multi-document file by its spring.config.activate.on-profile sections, ${VAR:default} by its default — and a value the IDE cannot resolve keeps the bean.
• Class conditions — Kotlin @ConditionalOnClass class literals and @ConditionalOnMissingClass names are read from source like Java; a bean guarded by @ConditionalOnClass(Missing::class) is excluded when that class cannot resolve.
• Bean names — @Bean(name = "x") names the bean x (the first of several names is the bean name, the rest are aliases), so @Qualifier("x") finds it; a @Bean method overridden in a subclass is one bean, not two. A composed @Bean annotation can name the bean through @AliasFor(annotation = Bean.class, attribute = "name") (or "value"): an explicit alias wins, and an empty alias falls back to the method name. Convention mapping of a same-named name attribute applies only before Spring Framework 7 and only without an explicit alias; an unknown spring-core version uses explicit aliases only.
• Abstract components — an abstract class without a @Lookup method and a non-static inner class are not beans, even when annotated as components; a component interface still is a candidate. An abstract component gets its own gutter icon listing the beans implementing it and the injection points of its type, and the usages gutter of a bean also lists injection points declared in its abstract base classes.
• Native context mode eliminates many false positives by using real Spring logic.
• Supports projects with multiple application contexts.
• Autowiring/inspections also consider library beans (from dependencies), not only project sources.

See Native Context Mode for how this works.

Spring Core & Boot enhancements

Inspections & quick fixes

• Property key validations — unused properties, duplicate keys, and kebab-case convention checks.
• @ConfigurationProperties support — navigate, complete, and validate; nullable-parameter checks; empty/duplicate/invalid prefix detection; registration verification; smarter quick-fixes.
• Bean autowiring checks — no candidate found, ambiguous candidates, invalid @Autowired usage.
• Proxy method usage — warns about incorrect proxy-method use when proxyBeanMethods = false.
• Resource reference validation — file/classpath references in annotations like @Value.
• AOP self-invocation — alerts when AOP-advised methods are called within the same class.
• Meta-annotation retention — a custom annotation used as a Spring meta-annotation must be retained at runtime, or Spring never sees it ("Spring meta-annotation retention policy"). A Kotlin annotation class counts as runtime-retained with @Retention(AnnotationRetention.RUNTIME) or with no @Retention at all, the Kotlin default; one meta-annotated by another Kotlin annotation is checked through it, as in Java.

Completion & navigation

• Property files — relaxed binding and nested properties.
• Annotation attributes — e.g. package completion/navigation in @ComponentScan; keys of @ConditionalOnProperty and @ConditionalOnBooleanProperty complete, navigate and count as usages of the configuration key.
• Bean methods — navigate from usage to definition across configuration classes.
• Query languages — JPQL plus basic SQL DML out of the box (no external plugin): JdbcTemplate, @Query(nativeQuery = true), @NamedNativeQuery, inline strings, and JdbcClient parameter inspections.

Other

• XML configuration support in native context mode (no extra setup).
• Multi-context support, library beans DI, and SPI bean navigation/line markers.
• Search Everywhere Beans tab; Mark directory as Spring Application Property Folder.
• One-click converter between .properties and .yml.
• Spellchecking in configuration files — in Spring .yml and .properties files, the key segments the configuration model declares (a property, a group leading to properties, or a member reached below a list index) are not spellchecked, so spring.security.oauth2.resourceserver is not offered a "fix" that breaks the binding. Keys the application invents, and misspelled ones, still are; other YAML and properties files are untouched.
• YAML value types in configuration files — the bundled YAML check that compares the scalar types of one key across list items (enabled: true next to enabled: "${FLAG:false}") is suppressed in Spring configuration files, because Spring converts both to the declared type. Each value is still validated against its property type.

Spring Web enhancements

• Endpoints tool window for Spring MVC, WebFlux, router functions, Kotlin coRouter, message brokers (@KafkaListener, @RabbitListener) and Spring Boot Actuator — the project's @Endpoint classes and the built-in health, info, metrics and the rest, once per Spring Boot application. The annotated controllers of a WebFlux application are grouped under WebFlux; a classpath with both stacks runs, and is shown as, Spring MVC. An Actuator controller endpoint (@RestControllerEndpoint) lists each mapping method with its verbs, a project @EndpointWebExtension adds its operations to the endpoint it extends, and an Actuator endpoint without operations is not listed, since Boot does not serve it. A route that answers any HTTP method — a controller's bare @RequestMapping, a Kotlin path("/x", handler) route — is one ALL row that every verb filter keeps; a verbless OpenFeign method is listed as GET. An Actuator endpoint that management.endpoints.web.exposure does not publish is still listed, in grey with not exposed over HTTP, and so is one the configuration grants no access to, with access none. Its search accepts a path or a URL pasted from a browser, a log line or a curl: /api/stores/42/orders finds /api/stores/{storeId}/orders, and the scheme, host, query, the declared base path and — failing that — a leading prefix only the deployment knows are ignored.
• Resolved mapping paths — a property placeholder in a Spring MVC or OpenFeign mapping (@RequestMapping("${shop.receipts-path:/r}")) is resolved from the module's configuration, else from its default, for the tool window, Swagger UI, the generated OpenAPI and the MCP tools, and for URL navigation to controllers. JAX-RS @Path and @HttpExchange paths are shown as written, because Spring does not resolve them either without extra configuration.
• Mappings declared on an interface — a @Controller implementing an interface (or extending a class) whose methods carry the request mappings serves them from its own override: the endpoint, its class-level prefix, the inherited parameter annotations (@PathVariable, @RequestParam, @RequestHeader, @RequestBody) and consumes/produces are read as Spring reads them, and the Swagger and endpoint gutters sit on the override. A JAX-RS resource implementing an annotated interface, also one declared in another module, is listed under the resource class.
• Functional route prefixes — Kotlin router DSLs and Java builders use one predicate rule: literal path("/a"), string receivers, verb predicates, and composed and predicates contribute prefixes; path-free accept, contentType, headers, method/methods, all, param/queryParam and Spring 7 version keep the inner path. An undecidable variable, helper, or, negate or unresolved condition hides only that nest, siblings remain listed, and one-argument verb predicates are not routes. Kotlin two-argument path("/x", handler) routes are listed for all HTTP methods, with nest prefixes applied; Java builder nested routes have no route in the MCP trace.
• Inspections — duplicate endpoint detection; controller checks (missing @PathVariable, unsupported signatures); OpenAPI validation (JSON/YAML, $ref navigation, version compatibility). Generate OpenAPI documentation reads and writes JSON and YAML, merges only missing operations into an existing path, preserves specification parameter names when template names differ, and leaves flow-style YAML or non-object paths untouched. It is not offered for endpoints without an HTTP method. Controller bean name looks like a request path reports @RestController("/app"): the value is the bean name, so no prefix is added to the mappings, and on Spring MVC a request to exactly /app fails with HTTP 500. Its quick fixes move the value to a class-level @RequestMapping, or only remove the bean name when the class hierarchy already declares a type-level mapping.
• Completion & navigation — WebClient/WebTestClient, Router Functions (RouterFunctions, coRouter), MockMvc multipart handling. A URL string in a MockMvc, WebClient or WebTestClient call navigates to its handler — a controller, a functional route or an Actuator endpoint — when it is relative, absolute against this machine (http://localhost:8080/api/orders) or written under the base path the application declares; a URL naming another host belongs to another service and stays unresolved. URL completion labels a route that answers any HTTP method [ALL] — a bare @RequestMapping or a Kotlin two-argument path("/x", handler) — and offers and resolves it inside any verb-specific call, such as MockMvc get("/x"), post("/x") or request(HttpMethod.PUT, "/x"), a WebClient or WebTestClient request, or an OpenAPI operation key such as get:; a route that lists its verbs is still matched by the exact verb, compared case-insensitively, so post("/x") never reaches a @GetMapping("/x"). Navigate To Endpoint Usage on an endpoint's gutter lists the tests that call it: MockMvc requests to any host, and WebTestClient, java.net.http, RestTemplate, TestRestTemplate and RestClient requests to this machine, with URLs built from templates, concatenation, URI.create(…) or a UriBuilder lambda (uri { it.path("/api/orders").build() }) — see test requests.
• Line markers for controller methods and router functions, and on the @ReadOperation/@WriteOperation/@DeleteOperation methods of a project @Endpoint, listing the test requests to that operation.

HTTP client

Two ways to test requests — Swagger UI from Spring annotations (Spring Web & OpenAPI REST client) and .http/.rest runners (Rest Client RFC 7230).

Spring Debugger

Spring context data, active transactions, and runtime property values right in the debugger. Full page: Spring Debugger.

Spring Data support

• Repository method-name validation and autocomplete (prefixes like findBy/countBy/existsBy, operators like Between/Like/In, sorting/limits like OrderBy…Asc/Top/Distinct).
• Return type and parameter checks; JPQL & SQL language injection; repository bean recognition.
• Generate equals/hashCode for JPA entities — proxy-safe Hibernate approach (final, type check, non-null @Id). See Code Generations.
• Spring Data 4.0 AOT navigation — jump from repository methods to AOT-generated artifacts and back.

Spring AOP enhancements

• Line markers for aspects, pointcuts, and advice methods.
• Inspection for self-invocation of AOP-advised methods (@Transactional, @Async).

Inlay hints & Code Vision

• @Profile inlay hints show the computed result of profile expressions (e.g. "prod & !cloud" → true/false).
• @Scheduled cron completion + readable hints (including the zone attribute).
• Runtime property value Code Vision during Explyt debug sessions (see Spring Debugger).

Code generation

From Code → Generate (Alt+Insert / ⌘N): Spring Web Method from URL/cURL, standalone java.net.http.HttpClient method, JPA equals/hashCode, OpenAPI generation, and Properties ↔ YAML conversion. Demos: Code Generations.

Spring Initializr

Create Spring Boot projects (Java/Kotlin) directly from IDEA Community with improved templates from start.spring.io, always up to date.

Docker Compose & Kubernetes

• Completion for Spring properties as environment variables in docker-compose.yml (environment:) and Kubernetes manifests (env.name:).
• Converts keys to ENVIRONMENT_VARIABLE_FORM (e.g. server.port → SERVER_PORT).
• Go-to-declaration jumps into application.properties / application.yml.

Quarkus support

• CDI/DI — detect and navigate @Inject, qualifiers, scopes, and producers (@Produces) both ways.
• AOP — interceptors and decorators with gutter markers and navigation.
• Web (JAX-RS) — Endpoints tool window for REST resources, navigation to handlers, duplicate-path checks, and a Swagger UI–based HTTP client.
• Works by static analysis — most features are available just by opening a Quarkus project, no app run required.

Spring AI

Optional integration with the Explyt AI platform for Spring tasks inside the IDE. AI-augmented actions (when the Explyt AI plugin is installed): DB schema → JPA entity, entity ↔ DTO, controller ↔ OpenAPI round-trips, Spring config generators (Kafka/Security), curl/Postman → .http, and Properties ↔ YAML. Works with OpenAI-compatible providers or local models; requires IntelliJ Platform 2025.1+. Full page: Explyt AI Actions.

MCP Server tools

8 Spring-aware MCP tools for agentic AI clients on the bundled JetBrains MCP Server (IDEA 2025.2+). Full reference: MCP Tools.

Kotlin support

• Spring-specific handling of the internal modifier and constructor validations.
• Warns against using an object as a Spring @Component (with a convert-to-class quick-fix).
• Alerts when internal bean methods need explicit bean names (JVM name mangling).
• Kotlin coRouter / Router Function endpoints and Kotlin code generation.
• Kotlin suspend handlers are read through their declaration — the declared response type instead of Object, no coroutine continuation among the parameters — in the gutter, Swagger UI, the generated OpenAPI and the MCP tools (details).

Additional inspections & features

• Configuration metadata — completion/validation in additional-spring-configuration-metadata.json and schema support.
• Profile validation — checks @Profile for errors, empty profiles, and operator misuse.
• Async return type — @Async methods must return void or a Future inheritor.
• Cache annotations — reports incorrect usage on interfaces; suggests classes/methods.
• Dependency Analyzer — analyze and navigate bean relationships.
• Experimental Scala support — create and develop projects using Scala.

See also: Native Context Mode · Spring Debugger · MCP Tools · Usage