This article introduces StopCoding, an IntelliJ IDEA plugin that forces developers to take regular breaks by displaying an unclosable dialog with a countdown timer, and provides step‑by‑step installation, usage instructions, and a complete walkthrough of its Java‑based Swing and Timer implementation.
This article demonstrates how to use IntelliJ IDEA's diagram feature to view, clean up, and explore the inheritance and interface implementation relationships of Java Servlet classes, including tips for customizing the view, inspecting members, and navigating to source code.
This guide shows how to configure IntelliJ IDEA so you can create a single workspace that contains multiple projects or modules, covering step‑by‑step creation, adding new modules, importing existing sources, and repeating the process for seamless multi‑project debugging.
This article introduces a collection of practical IntelliJ IDEA tricks—including Presentation Mode, Inject Language, splitter movement, smart code completion, navigation bar toggling, symbol search, directory lookup, automatic null checks, and structural template searches—each explained with step‑by‑step shortcuts to boost Java developers' efficiency.
This article details a systematic experiment that compares default, modest, balanced, and aggressive JVM memory configurations for IntelliJ IDEA, measuring startup time, project load speed, and garbage‑collection behavior on a large monolith and micro‑service projects, and concludes with practical tuning recommendations.
Discover how IntelliJ IDEA 2020.3 enhances productivity with machine‑learning code suggestions, automatic quoting, an integrated calculator, exception breakpoint hints, and powerful postfix completions that let you write common code patterns faster and with fewer errors.
After changing a project's JDK in IntelliJ IDEA, imports of your own classes may appear in red despite the code compiling, but you can eliminate these false errors by invalidating caches and restarting the IDE, as detailed in this step‑by‑step guide.
This article investigates how different IntelliJ IDEA memory configurations affect IDE speed and responsiveness by testing default, large, balanced, and sophisticated settings on a MacBook Pro with a monolithic Java project and microservices, measuring startup times, project loading, and JVM garbage collection using jstat.
IntelliJ IDEA 2020.3 introduces a revamped welcome window, reader mode, easier window splitting, refined refactoring, enhanced debugging, AI‑powered code completion, Search Everywhere upgrades, Java 15 support, and various other tweaks such as MongoDB SQL queries and built‑in Lombok, all aimed at smoother developer experience.
This guide walks Java developers through high‑efficiency IntelliJ IDEA configurations, essential daily shortcuts, powerful live templates, advanced debugging techniques, and a curated set of plugins to dramatically improve coding speed and code quality.
IntelliJ IDEA 2020.3 introduces a revamped welcome screen, reader mode, easier window splitting, enhanced refactoring, upgraded debugging tools, AI‑powered code completion, Search Everywhere improvements, Java 15 support, built‑in database tools, Lombok integration, and a refined VCS menu, all aimed at boosting developer productivity.
This guide walks through downloading the RuoYi source, importing its SQL schema into MySQL, configuring the datasource in IntelliJ IDEA, running the SpringBoot application, and accessing the permission‑management UI at http://localhost:8000/, with links to advanced versions.
This guide reviews seven popular IntelliJ IDEA themes—both dark and light—ranked by user adoption, offering ratings, key visual features, and screenshots to help Java developers choose the most comfortable and aesthetically pleasing UI for coding.
This guide walks Java developers through high‑efficiency IntelliJ IDEA configurations, indispensable keyboard shortcuts, code‑template tricks, powerful debugging features, and a curated set of plugins, helping newcomers and seasoned programmers alike to work faster and smarter with the IDE.
This article explains how to enable Chinese language support in IntelliJ IDEA by installing the official Simplified Chinese language pack plugin, provides step‑by‑step instructions with screenshots, notes on partial localization, and highlights the benefits for new developers.
This article explains how to install IntelliJ IDEA plugins—both online and offline—and provides detailed introductions to over a dozen useful plugins for Java development, including Lombok, RestfulTool, MyBatis helpers, code quality tools, and UI enhancements, helping developers boost productivity.
This article introduces a curated list of essential IntelliJ IDEA plugins for Java developers, explaining how each tool—such as Key Promoter X, String Manipulation, Background Image Plus, and others—enhances coding efficiency, improves code readability, and streamlines everyday development tasks.
This tutorial walks through preparing the environment, configuring Docker remote access, creating a Spring Boot project in IntelliJ IDEA, setting up Maven and Docker files, building the image, and running the container, demonstrating a complete end‑to‑end Java microservice deployment with Docker.
Discover a comprehensive guide to the most useful IntelliJ IDEA configurations, covering 26 essential settings—from appearance and keymaps to editor, build, and project structure—complete with visual examples and step‑by‑step instructions to help Java developers optimize their development environment.
This article explains how to leverage IntelliJ IDEA's Live Templates feature—including basic usage, custom template creation, variable functions, and advanced Groovy scripts—to quickly generate repetitive Java code such as loops, loggers, beans, and context‑aware logging statements, thereby boosting development productivity.
This article explains how IntelliJ IDEA's Scratch files and Scratch buffers let developers create temporary, runnable code snippets outside the project, avoid accidental Git commits, and quickly test Java or SQL without switching applications, enhancing focus and productivity.
This article explains how to install and configure JRebel for both local and remote hot deployment in Spring Boot projects, compares it with Spring DevTools, provides step‑by‑step setup instructions, and addresses multi‑module deployment pitfalls.
This article provides a detailed tutorial on using IntelliJ IDEA's Debug mode, covering interface components, basic operations and shortcuts, variable inspection, expression evaluation, smart step‑into, conditional breakpoints, multithreaded debugging, frame dropping, and force return techniques to efficiently trace and troubleshoot Java applications.
This guide explains how to add Tomcat support to IntelliJ IDEA Community Edition by installing a compatible plugin, configuring the server and web project, handling download issues, and deploying your web application without needing the paid Ultimate edition.
This guide explains why IntelliJ IDEA's default VM settings are low, shows how to view memory usage, and provides recommended VM option configurations for machines with 8 GB or 16 GB RAM to improve startup speed and overall IDE responsiveness.
This guide explains how to use IntelliJ IDEA's diagram feature to view, clean up, and explore the inheritance and interface implementation relationships of Java Servlet classes, including removing irrelevant nodes, inspecting class members, adding related classes, and navigating to source code.
This article explains how to leverage IntelliJ IDEA's Live Templates feature—including built‑in snippets, custom templates, variable functions, and advanced Groovy scripts—to quickly generate repetitive Java code such as loops, fields, loggers, beans, and context‑aware logging statements.
This guide walks you through every configurable element of IntelliJ IDEA's Project Structure—Modules, SDKs, language level, compiler output, libraries, facets, and artifacts—so you can fine‑tune Spring Boot projects, avoid common pitfalls, and streamline multi‑module development.
This guide shows how to quickly reformat code without opening settings, generate UML class diagrams, view and test Spring Boot endpoint mappings, navigate debugging execution points, and rename methods using IntelliJ IDEA Ultimate shortcuts, enhancing productivity for Java developers.
This tutorial demonstrates how to use IntelliJ IDEA’s powerful features—including string highlighting with regex validation, batch replacement shortcuts, interactive Java Streams debugging, enhanced auto‑completion for stream APIs, and document block rendering—to boost productivity when developing Java applications.
This comprehensive guide details IntelliJ IDEA configuration and productivity tips, covering Maven setup, code line width, case‑insensitive completion, forced Maven dependency refresh, file‑type exclusions, shortcut customizations, plugin installation, memory settings, JSON injection, presentation mode, and numerous other settings to streamline Java development.
This guide walks you through configuring Maven, customizing code style, enabling case‑insensitive completion, forcing Maven dependency updates, managing hidden files, remapping shortcuts, adjusting memory and encoding settings, using live templates, and leveraging presentation and inject‑language modes in IntelliJ IDEA to boost productivity.
This guide explains what PlantUML is, why it’s useful for fast diagram creation, how to install the required Graphviz engine, set up the PlantUML plugin in IntelliJ IDEA, create UML files, and includes sample code for sequence diagrams and role definitions.
This guide explains step‑by‑step how to disable the yellow background warnings that appear in MyBatis XML files within IntelliJ IDEA by adjusting the IDE's inspection and injected language settings.
This guide provides a comprehensive collection of IntelliJ IDEA tips covering Maven configuration, code‑style settings, key shortcuts, plugin installation, SVN handling, memory tuning, live templates, presentation mode, and many other practical adjustments to streamline Java development.
This guide explains why IntelliJ IDEA often misreports Groovy syntax, shows the three ways to access object properties, demonstrates generic method definitions, and clarifies the behavior of the 'it' keyword in nested loops, providing concrete code examples and practical work‑arounds.
This tutorial explains how to use IntelliJ IDEA's built‑in Diagram plugin to automatically generate UML class diagrams for Java classes, covering configuration steps, shortcut keys, example screenshots, and the tool's limitations for software design documentation.
This tutorial walks through creating a Netty HelloWorld server in IntelliJ IDEA using Gradle, adding the Netty dependency, implementing the server bootstrap, event loop groups, initializer and handler classes, and verifying the service with a curl request.
This guide walks through downloading Gradle 6.6.1, setting GRADLE_HOME and PATH on Windows, configuring a custom GRADLE_USER_HOME for dependency jars, and adjusting IntelliJ IDEA settings to use the installed Gradle distribution and a specific JDK.
This guide shows how to use IntelliJ IDEA's diagram feature to clearly display inheritance and interface relationships of Java Servlet classes, remove irrelevant nodes, explore class members, add additional classes, and quickly navigate to source code, making backend code comprehension much easier.
This comprehensive guide details how to configure Maven, adjust code style settings, manage case‑sensitive completion, force Maven dependency updates, customize environment paths, hide files, modify keymaps, resolve CPU spikes, enable plugins, adjust memory, use presentation mode, inject language fragments, and resolve shortcut conflicts in IntelliJ IDEA, providing step‑by‑step instructions for each feature.
Explore essential IntelliJ IDEA techniques—including string highlighting with regex validation, batch replacement via Alt+J, interactive Java Streams debugging, enhanced auto‑completion for Stream APIs, and document block rendering—to boost your Java development productivity and streamline code editing workflows.
This tutorial walks you through downloading RuoYi-Vue 3.1, creating a MySQL database, importing required SQL files, configuring Redis and application settings, and then launching the Spring Boot back‑end and Vue front‑end so you can access the admin console at http://localhost:81/.
This article provides a detailed walkthrough of using IntelliJ IDEA’s Debug mode, covering interface elements, basic shortcuts, variable inspection, expression evaluation, smart step‑into, conditional breakpoints, multithreaded debugging, frame rollback, and force return techniques for efficient Java development.
This guide shows how to use IntelliJ IDEA’s diagram feature to visualize Java Servlet inheritance and interface relationships, remove irrelevant classes, display detailed members, zoom the view, add additional classes, and quickly jump to source code, making backend code exploration much easier.
This comprehensive guide explains how to use IntelliJ IDEA's Debug mode—including launching the debugger, managing breakpoints, inspecting variables, evaluating expressions, employing smart step‑into, configuring conditional breakpoints, handling multithreaded debugging, and using drop‑frame and force‑return features—to efficiently trace and troubleshoot Java applications.
This article explains why recent IntelliJ IDEA versions stopped supporting the Lombok plugin, details the communication between the plugin author and JetBrains, describes the bug in the plugin platform, and provides the steps to obtain the fixed plugin version.
This article introduces five essential IntelliJ IDEA plugins—Key Promoter X, Lombok, Rainbow Brackets, Codota, and String Manipulation—explaining their features, installation steps, and how they can significantly improve Java developers' coding efficiency and productivity.
This article presents a comprehensive guide to the most useful IntelliJ IDEA configuration options—including case‑sensitive code completion, automatic imports, code folding, split‑screen layout, key‑map adjustments, memory allocation, project opening behavior, line numbering, serialVersionUID generation, and default browser settings—to help developers streamline their Java workflow and improve productivity.
The article explains why excessively long classes with many responsibilities hinder readability and extensibility, outlines the problems of redundant code and SRP violations, and provides practical refactoring techniques—such as extracting methods, moving members, and creating new classes—using IntelliJ IDEA.
This article introduces ten practical IntelliJ IDEA plugins for Java developers, explaining their core features, shortcuts, and visual cues, so you can streamline code generation, dependency management, JSON conversion, decompilation, and more while avoiding common pitfalls.
This guide explains how to install and use a curated list of IntelliJ IDEA plugins—including Lombok, RestfulTool, MyBatis helpers, and productivity enhancers—detailing both online and offline installation methods, configuration tips, and practical examples for Java development.
This guide walks you through connecting IntelliJ IDEA to a database, using its built‑in POJO generators, adding JPA modules, and creating custom Groovy scripts to produce fully annotated JPA entity classes, complete with getters, setters, and utility methods.
IntelliJ IDEA 2020.2 brings full Java 15 support, richer editor tools, integrated GitHub Pull Request handling, advanced profiling, terminal shortcuts, improved database editors, and secure Docker connections, offering developers a comprehensive set of productivity enhancements in a single release.
The article provides a step‑by‑step tutorial on configuring database connections in IntelliJ IDEA, using its built‑in tools to generate simple POJOs or JPA‑annotated entities, and creating a custom Groovy script to produce fully annotated Java entity classes directly from a database schema.
Discover a collection of powerful IntelliJ IDEA shortcuts—including navigation, history view, auto‑completion, variable extraction, renaming, and a serialVersionUID generator plugin—that streamline coding, reduce keystrokes, and boost productivity for developers working on Java projects.
This article explains how to streamline Java 8 Stream operations by creating IntelliJ IDEA live templates for common collectors like toList, toSet, joining, and groupingBy, reducing repetitive code and improving developer productivity.
This article introduces a curated list of IntelliJ IDEA plugins compatible with version 2020.1, including code formatters, translation tools, shortcut helpers, coding guideline checkers, algorithm practice editors, RESTful URL explorers, bytecode viewers, case converters, hot-reload utilities, string manipulators, MyBatis helpers, sequence diagram generators, setter generators, Chinese language packs, rainbow brackets, and QA assistants, each with a brief description and usage shortcuts.
IntelliJ IDEA 2020.2 EAP5 introduces Java 15 support, related‑problems warnings, intention previews, enhanced Java intention actions, and flexible structural search‑replace inspections, offering developers a richer, more efficient coding experience in the latest IDE preview.
This article introduces EvoSuite, an open‑source tool for automatically generating JUnit test suites, explains how to configure it with Maven (including the required pom.xml entries), describes essential command‑line options, and provides step‑by‑step instructions for installing and using the EvoSuite plugin in IntelliJ IDEA, supplemented by practical examples and coverage analysis.
This article provides a comprehensive step‑by‑step guide to configuring IntelliJ IDEA, covering Maven setup, code‑style settings, case‑sensitive completion, forced Maven dependency refresh, default configuration locations, plugin installation, shortcut customizations, presentation mode, inject‑language feature, and various other useful IDE tricks for Java developers.
This article provides a comprehensive collection of IntelliJ IDEA configuration steps, shortcuts, and productivity tips—including Maven setup, code‑style adjustments, keymap changes, plugin installation, presentation mode, inject‑language usage, and common troubleshooting—to help developers work more efficiently in Java projects.
After a decade of using Eclipse, the author shares a candid comparison with IntelliJ IDEA, highlighting usability improvements, shortcut differences, and practical tips that convinced seasoned Java developers to make the switch for a more efficient coding experience.
This guide explains how to integrate SonarLint into IntelliJ IDEA to perform pre‑commit code quality checks, covering the tool’s objectives, the seven quality dimensions it assesses, required prerequisites, plugin installation steps, and detailed project and server configuration procedures.
This guide explains how to set up SonarLint in IntelliJ IDEA, covering the seven quality dimensions Sonar checks, required prerequisites, plugin installation, server configuration, project selection, and visual verification of the integration within the IDE.
This article introduces sixteen IntelliJ IDEA plugins that have been personally tested to work with version 2020.1, covering code formatting, translation, shortcut hints, coding standards, LeetCode integration, RESTful URL search, bytecode viewing, string case conversion, hot‑reload, string manipulation, MyBatis navigation, sequence diagram generation, setter generation, Chinese language support, rainbow brackets, and bug‑finding, each with a brief description and usage shortcut.
This guide shows how to add a custom SpringBoot startup banner via a banner.txt file, lists online ASCII art generators for creating text banners, and provides step‑by‑step instructions to install and activate the JetBrains agent in IntelliJ IDEA for license management.
This article reports a systematic experiment that compares four IntelliJ IDEA memory configurations on a large Java monolith and two micro‑services, measuring startup, project loading times and JVM garbage‑collection metrics with jstat to identify the most efficient setting.
This article reports a systematic experiment that compares four IntelliJ IDEA memory configurations on a MacBook Pro, measuring startup time, project loading speed, and garbage‑collection behavior with jstat, and concludes that allocating more heap (2‑4 GB) significantly improves IDE responsiveness for large codebases.
This article provides a detailed cheat sheet of the most useful IntelliJ IDEA keyboard shortcuts, covering navigation, code editing, refactoring, and project management commands to boost developer productivity across various programming tasks.
Discover twelve essential IntelliJ IDEA plugins—ranging from Lombok and MyBatis helpers to Vue.js support—that streamline Java backend development and frontend work, complete with usage tips, code examples, and screenshots to dramatically improve your productivity.
This tutorial walks through installing the EasyCode and Lombok plugins, creating a MySQL table, configuring IDEA database connections, generating entity, DAO, service, controller, and mapper code for a Spring Boot project, and setting up the required Maven dependencies and application.yml configuration.
This tutorial demonstrates how to leverage IntelliJ IDEA's diagram feature to view, clean up, and enrich the inheritance and interface implementation hierarchy of Java Servlet classes, including removing irrelevant nodes, inspecting class members, adding new classes, and jumping to source code.
This article introduces ten essential IntelliJ IDEA plugins—including FindBugs, Translation, Grep Console, GsonFormat, Free MyBatis Plugin, CodeGlance, Maven Helper, Background Image Plus+, MyBatis Log Plugin, and RestfulToolkit—that help Java developers improve code quality, debugging, navigation, and overall workflow efficiency.
This article explains why debugging is a core skill for developers, walks through essential IntelliJ IDEA debugging features, introduces command‑line debugging with jdb, and demystifies remote debugging by exploring the JPDA architecture and its underlying protocols.
This article introduces ten essential IntelliJ IDEA plugins—ranging from static analysis and translation tools to console filtering, JSON formatting, MyBatis assistance, Maven dependency visualization, and UI enhancements—that can significantly improve Java developers' productivity and code quality.
This guide compiles 33 practical IntelliJ IDEA configurations and shortcuts—from Maven setup and code‑style settings to presentation mode and inject‑language features—helping developers streamline their workflow, avoid common pitfalls, and enhance coding efficiency across Java projects.
This article walks through the release of IntelliJ IDEA 2020.1 stable version, highlighting major UI changes, improved Javadoc browsing, the new default JetBrains Mono font, smarter inspections, enhanced debugging, a revamped version‑control commit interface, and a crucial Lombok compatibility warning, all illustrated with screenshots.
This guide walks you through the new Chinese localization in IntelliJ IDEA 2020.1, showing the visual changes, explaining why the language pack isn’t enabled by default, and providing step‑by‑step instructions to install and activate the Chinese plugin for a smoother development experience.
This article introduces essential Java debugging skills, covering IntelliJ IDEA’s powerful debugging features, command‑line debugging with jdb, remote debugging setup, and the underlying JPDA architecture, providing developers with both practical tips and a deeper understanding of how Java debuggers work.
IntelliJ IDEA 2020.1 introduces a suite of enhancements—including data‑flow‑aware debugging, property pinning, IPv6 remote debugging, refined performance profiling, memory‑snapshot analysis, a revamped commit UI, LightEdit mode, intention previews, and Zen mode—to streamline Java development and boost productivity.
IntelliJ IDEA 2020.1 introduces a suite of debugging enhancements—including data‑flow analysis, pinned variables, IPv6 remote debugging, refined CPU profiling options, hprof memory‑snapshot support, a revamped commit UI, LightEdit mode, intention previews, and a distraction‑free Zen mode—helping Java developers diagnose and optimize code more efficiently.
This article introduces the most useful IntelliJ IDEA plugins for Java developers, explaining how each tool—ranging from shortcut reminders and Maven helpers to mind‑mapping, code mini‑maps, naming converters, MyBatis utilities, JavaDoc generators, Git commit templates, and icon enhancers—can improve productivity and streamline development workflows.
This article compiles a comprehensive collection of IntelliJ IDEA keyboard shortcuts for Windows, covering code generation, navigation, refactoring, debugging, and miscellaneous productivity tricks, enabling Java developers to work more efficiently and reduce reliance on the mouse.
This guide introduces ten essential IntelliJ IDEA plugins—including JRebel, Codota, Lombok, and MyBatis—that streamline Java development, enhance code quality, and accelerate productivity through features like hot deployment, AI code completion, automatic boilerplate generation, and convenient project navigation.
This guide provides a comprehensive collection of essential Mac keyboard shortcuts for IntelliJ IDEA, covering editing, searching, navigation, compiling, debugging, version control, live templates, and general IDE actions to help developers work faster and more efficiently.
This guide explains what Maven dependency conflicts are, why they matter, and provides step‑by‑step methods—including exclusion tags, the Maven Helper IntelliJ plugin, and IDEA’s dependency diagram—to identify and eliminate conflicting JAR versions in Java projects.
This guide shows how to add Spring Boot DevTools, configure Maven and IntelliJ IDEA, and use both manual and automatic hot‑deployment techniques—including registry tweaks and template cache settings—to achieve instant code changes without restarting the application.
This article introduces Git as a distributed version control system, explains its core workflow and branch model, and provides step‑by‑step instructions for configuring, cloning, checking out, committing, pushing, and using Git commands within IntelliJ IDEA, including useful screenshots.
This tutorial walks you through setting up the development environment, configuring the IntelliJ Platform SDK, creating a simple plugin project, adding a custom Action, and running the plugin, providing all necessary code snippets and screenshots for building IntelliJ IDEA plugins.
This guide walks you through installing the EasyCode plugin in IntelliJ IDEA, setting up a MySQL database, configuring Spring Boot dependencies, and using EasyCode to automatically generate entity, controller, service, DAO, and mapper classes, complete with Maven and application.yml settings.
This article presents a collection of useful IntelliJ IDEA shortcuts and features—including Presentation Mode, language injection, navigation shortcuts, batch editing, structural search, and template-based code generation—to help developers work faster and more comfortably within the IDE.
During remote work, the author discovers how IntelliJ IDEA’s integrated HTTP Client can replace external tools like Postman, offering in‑IDE request creation, environment variables, response scripts, and plugin extensions to streamline API development, testing, and collaboration across multiple product lines.
This tutorial explains how to install the EasyCode plugin, set up a MySQL database, configure IDEA, generate entity, controller, service, DAO, and mapper code for a Spring Boot project, and adjust Maven and YAML settings to run the application successfully.
The IntelliJ IDEA 2020.1 early‑access release introduces dataflow analysis assistance for the debugger, recursive‑call folding, a revamped Commit tool window, Zen Mode for distraction‑free coding, and LightEdit for quick file edits, all aimed at boosting developer productivity.
This tutorial explains how Java developers can use IntelliJ IDEA Live Templates to automatically generate repetitive code such as private fields, loggers, and Spring beans, covering basic usage, custom templates, advanced functions, and practical examples that dramatically improve coding efficiency.
IntelliJ IDEA 2020.1’s second early‑access build introduces data‑flow analysis for debugging, recursive‑call collapsing, a revamped Commit tool window, Zen Mode for distraction‑free coding, and LightEdit for quick file edits, all aimed at enhancing developer productivity.
This guide explains how to use IntelliJ IDEA's built‑in TODO feature, customize TODO patterns, filter and group tasks, and leverage live templates to efficiently track and manage code annotations across large projects.
This article presents a comprehensive guide to IntelliJ IDEA, covering high‑efficiency configurations, essential shortcuts, code templates, debugging techniques, and recommended plugins, aiming to help both newcomers and experienced developers boost productivity and fully leverage the IDE’s powerful features.
This guide compiles the most useful IntelliJ IDEA keyboard shortcuts—including code generation, navigation, refactoring, debugging, SVN operations, and miscellaneous productivity tricks—organized by function so developers can boost efficiency and reduce reliance on the mouse while coding in Java.
