Useful IDEA Plugins and Dev Tools

IDEA is powerful enough on its own, but the right handful of plugins can shave real time off everyday chores like code-quality checks, dependency debugging, and style enforcement. This post rounds up the plugins and tools I use in Java development, grouped by purpose so you can grab what you need.

Static code quality management platform

Code Quality and Code Security | SonarQube

Strictly speaking, SonarQube isn't an IDEA plugin but a standalone code-quality management platform you deploy yourself. It scans code via static analysis for bugs, vulnerabilities, and code smells, and produces quantified quality reports. The typical setup is to run one instance for the team and hook it into CI so every commit or merge gets scanned automatically, catching quality issues before they land. There's also a companion IDEA plugin that connects to the server so you can see scan results locally.

Code quality inspection plugin: FindBugs

Installs directly as a plugin inside the IDEA IDE.

FindBugs™ - Find Bugs in Java Programs (sourceforge.net)

FindBugs works by analyzing compiled bytecode and matching it against known defect patterns — null-pointer dereferences, unclosed resources, equals without a matching hashCode, and so on. It complements SonarQube nicely: SonarQube leans toward team-level continuous quality management, while FindBugs is better for a quick local scan right after you finish writing code.

Translation plugin (a must if your English is shaky)

Translation lets you translate directly inside the code editor.

Select a variable name, comment, or docstring, hit the shortcut, and the translation pops up — no switching out to a browser dictionary. Especially handy when reading English source comments or naming variables.

Code style enforcement plugin

CheckStyle-IDEA checks code against rules for formatting, naming conventions, Javadoc, class design, and more, effectively nudging developers toward consistent coding standards.

Its focus differs from FindBugs: FindBugs hunts for "code that might have bugs," while CheckStyle polices "code that isn't written to standard." A team can share one rules file (say, adapted from the Alibaba or Google Java style guides) so everyone's output looks consistent, and reviews stop getting bogged down in formatting back-and-forth.

Maven dependency conflict detector

Maven Helper detects dependency conflicts across the whole project's pom.xml.

Maven dependencies are transitive, so in any sizable project it's almost inevitable that the same library gets pulled in at different versions by different dependencies. The default mvn dependency:tree output is painful to read; with Maven Helper, opening a pom.xml in IDEA adds a dependency-analysis view where conflicting dependencies are highlighted in red, and a right-click excludes the version you don't want. Extremely useful when chasing down NoSuchMethodError or ClassNotFoundException caused by version conflicts.

Code minimap plugin

CodeGlance works like the minimap in VSCode.

It shows a thumbnail of the whole file along the right edge of the editor — much more intuitive than dragging the scrollbar when jumping around long files.

Hot-reload plugin (paid)

JRebel cuts down on restarts after changing code or mapper.xml files, boosting productivity.

Cracking JRebel for IntelliJ IDEA 2020

In the traditional workflow, changing one line of Java means restarting the app, and in a big project a restart can take tens of seconds or minutes. JRebel's approach is hot class replacement at the JVM level: changes take effect without a restart, and it even covers MyBatis mapper.xml changes — broader coverage than Spring Boot's built-in devtools restart mechanism. The downside is it's commercial software, and not cheap for individual use.

JSON-to-Java class plugin

GsonFormat

When integrating a third-party API, hand-writing the Java bean for a JSON response is slow and it's easy to mistype a field. GsonFormat lets you paste the JSON string in and generates an entity class with all fields and types mapped correctly, nested structures included.

Productivity tool

Lombok is a plugin that uses annotations to simplify writing JavaBeans in Java, eliminating redundant boilerplate and keeping classes lean.

It works by generating code at compile time through an annotation processor: @Getter/@Setter generate accessors, @Builder generates a builder, @Slf4j generates the logger declaration. You won't see these methods in the source, but they're all in the compiled class files. Note that Lombok needs both ends set up — the dependency in your project and the plugin in IDEA. Miss either one and your screen fills with red.

Shortcut hint plugin (basically a must-install)

Key Promoter X is a plugin for IntelliJ-based products (IDEA, Android Studio, CLion) that helps you learn essential keyboard shortcuts while you work. When you use the mouse on a button inside the IDE, Key Promoter X shows the keyboard shortcut you should have used instead. It's an easy way to replace tedious mouse work with keystrokes and transition toward faster, mouse-free development. It currently supports toolbar buttons, menu buttons, tool windows, and the actions inside them.

Plugin page: https://plugins.jetbrains.com/plugin/9792-key-promoter-x

The nice thing about this kind of "teaching" plugin is passive learning: no need to memorize a shortcut cheat sheet. Whatever you click most with the mouse is exactly what it keeps reminding you about, so the most-used shortcuts stick on their own.

Pitfalls and caveats

1. More plugins is not better. Every plugin eats memory and slows down indexing and startup. If IDEA feels sluggish, first check whether you've installed too many, and disable the ones you rarely use.

2. For Lombok-related compile errors, first confirm both the dependency and the plugin are installed, and that Annotation Processing is enabled.

3. Quality-check plugins (FindBugs, CheckStyle) are slow on full scans of large projects; run incremental checks on just the changed modules or files instead.

4. After tracking down a conflict with Maven Helper, exclude with care — make sure the excluded version really isn't needed by another module, or you may just be deferring a compile-time problem into a runtime one.

Wrapping up

These ten tools roughly cover a few categories of daily needs: quality and standards (SonarQube, FindBugs, CheckStyle), dependency management (Maven Helper), coding efficiency (Lombok, GsonFormat, Translation, CodeGlance), and developer experience (JRebel, Key Promoter X). No need to install them all at once — pick the ones that address your project's actual pain points, get comfortable, then add more. That's the right way to use plugins.