Skip to content

Features

Jump to bottom
Ilya Muromtsev edited this page Jun 16, 2026 · 2 revisions

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

  • 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, and message brokers (Kafka/RabbitMQ listeners).

Walkthroughs and demos: Usage · Videos.

Bean detection & context analysis

  • Detects beans via annotations, factory methods, and conditional logic (@Conditional, profiles, complex scans).
  • 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 checks — ensures custom meta-annotations have correct settings.

Completion & navigation

  • Property files — relaxed binding and nested properties.
  • Annotation attributes — e.g. package completion/navigation in @ComponentScan.
  • 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.

Spring Web enhancements

  • Endpoints tool window for Spring MVC, WebFlux, router functions, Kotlin coRouter, and message brokers (@KafkaListener, @RabbitListener).
  • Inspections — duplicate endpoint detection; controller checks (missing @PathVariable, unsupported signatures); OpenAPI validation (JSON/YAML, $ref navigation, version compatibility).
  • Completion & navigation — WebClient/WebTestClient, Router Functions (RouterFunctions, coRouter), MockMvc multipart handling.
  • Line markers for controller methods and router functions.

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

7 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.

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

Home · Features · Installation · Usage · Marketplace · Issues · Telegram (EN)

Explyt Spring Plugin — free for commercial and non-commercial use under the Apache License 2.0.

Explyt Spring Wiki

Getting started

Features

Gallery

Links

Clone this wiki locally