This guide introduces Spring Explyt, an open‑source IntelliJ IDEA Community plugin that brings full‑featured Spring support—including precise bean detection, advanced code completion, endpoint tools, and built‑in HTTP client—to the free IDE, with installation steps, usage tips, and a feature comparison.
This guide introduces Alibaba’s free CloudToolkit IntelliJ IDEA plugin, explains how to install it, configure remote hosts, and use its built‑in terminal and deployment features to automatically package a SpringBoot application into a Docker image, upload scripts, and launch the container with one click.
This article explains how a long‑standing Java backend service was instrumented with JVM agents and JaCoCo to collect execution coverage, visualize results in an IntelliJ IDEA plugin, and systematically remove dead code, improving maintainability while minimizing impact on production performance.
The article shares the author’s struggle with inconsistent naming in front‑end Vue and back‑end Java code and introduces a self‑built AI‑driven naming tool—available as a lightweight web app and an IntelliJ IDEA plugin—that instantly generates clean, convention‑compliant identifiers.
The article describes the frustration developers face with unclear method and variable names, presents an AI‑driven naming tool with both a web app and an IntelliJ IDEA plugin, and explains how the tool quickly generates clean, convention‑compliant identifiers across front‑end and back‑end languages.
The article introduces Cool Request, an IDEA plugin that now supports a Trace feature for measuring execution time of any method, automatic MyBatis function tracing, customizable duration coloring, and script-based environment manipulation, complete with usage examples and code snippets.
The article introduces the latest Cool Request IDEA plugin update, detailing its Trace capability for method execution timing, selective MyBatis function monitoring, customizable slow‑method highlighting, and scripting support for headers and JSON parsing, all illustrated with Java code examples.
This guide explains why missing WHERE clauses can trigger dangerous full‑table updates in MySQL, shows how to enable the sql_safe_updates mode, demonstrates MyBatis‑Plus’s IllegalSQLInnerInterceptor plugin, and offers IDE and code‑review tips to safeguard database operations.
The article introduces Cool Request, a free open‑source IntelliJ IDEA plugin that streamlines Spring Boot backend API testing by providing in‑IDE request execution, method timing statistics, interceptor bypass, job triggering, Java pre/post scripts, response preview, and export to third‑party tools, complete with usage examples and code snippets.
This article introduces a lightweight IntelliJ IDEA plugin that automatically generates database‑related Java code—including entities, DTOs, controllers, and service layers—based on a simple configuration file, while also offering design‑pattern template generation to accelerate backend development.
This article introduces JarEditor, an open‑source IDEA plugin that lets Java developers modify classes and resources inside JAR files without extracting them, explains its main features, shows how to install and use it, and concludes with a brief recommendation.
This guide introduces Vim as a powerful command-line editor, explains its main modes and essential shortcuts for editing files on servers, and shows how to combine Vim functionality with IntelliJ IDEA using the IdeaVim plugin, enabling efficient coding without leaving the IDE.
The latest update of the Cool Request IDEA plugin introduces a powerful Trace function that automatically records execution times for any method—including Spring @Scheduled and xxl‑job tasks—offers customizable latency coloring, MyBatis SQL timing, call‑count indicators, and scriptable environment variables for seamless token handling and JSON parsing.
This article introduces MyBatisX, an IDEA plugin that streamlines MyBatis development with navigation, GUI‑based code generation, customizable templates, JPA‑style method hints, and icon settings, providing step‑by‑step instructions and visual examples to enhance backend productivity.
This tutorial walks through setting up a simple Spring Boot project, adding MyBatis‑Plus dependencies, configuring MybatisX in IntelliJ IDEA, generating entity, mapper, service, and controller code, and handling common connection issues, providing a complete end‑to‑end example of rapid MyBatis development.
This article introduces Cool Request, a free open‑source IntelliJ IDEA plugin that automatically extracts SpringBoot controllers, simplifies HTTP request debugging, supports multiple request bodies, pre‑ and post‑scripts, reflection calls, cURL import, Apifox export, global API search, and even provides a static resource server.
This guide explains how to install the IDEA Maven Helper plugin, use its Dependency Analyzer to detect and exclude conflicting Maven dependencies, and provides alternative methods such as IDEA Diagrams and Maven commands for managing Java project dependencies.
This guide explains why the MyBatis Log Plugin is useful for converting MyBatis console SQL logs into ready‑to‑run statements, and provides step‑by‑step instructions for installing the plugin in IntelliJ IDEA, activating it, and configuring log levels for proper operation.
This guide demonstrates how to integrate the MybatisX IDEA plugin with a Spring Boot project, covering database setup, Maven dependency configuration, plugin installation, connection testing, code generation, and sample controller implementation to accelerate MyBatis and MyBatis-Plus development.
This article examines the refactoring of an IntelliJ IDEA plugin for YAML file validation, comparing the original and improved implementations across structure, naming, readability, comments, method abstraction, conditional logic, and error handling, and demonstrates how these changes enhance maintainability and robustness.
This tutorial walks through setting up Docker's remote API, installing and configuring the IDEA Docker plugin, creating a Spring Boot Eureka project, adding the docker‑maven‑plugin, building a Docker image, and running the container with one‑click deployment for Java backend services.
This article introduces XEChat‑Idea, a Netty‑based instant messaging and game‑battle plugin for IntelliJ IDEA, detailing its project structure, required development environment, and step‑by‑step instructions for building, running, and deploying both the server and the IDEA plugin.
This article details Meituan's internal Sonic IDEA plugin, explaining hot‑deployment concepts, why they matter, the technical challenges, and Sonic's architecture—including agents, instrumentation, class reloading, Spring Bean/XML/MyBatis reloads, and real‑world deployment experience—showing how code changes can become effective in seconds instead of minutes.
The article details Meituan's internal Sonic IDEA plugin for remote and local hot deployment, explaining why hot deployment is needed, its architecture, instrumentation techniques, DCEVM integration, file‑watching, class reloading, and support for Spring Bean, Spring XML and MyBatis, along with adoption statistics and performance benefits.
This guide demonstrates how to replace traditional debugging with Arthas, covering installation of IDEA plugins, quick 5‑minute problem resolution, hot‑deployment using ArthasHotSwap, and advanced time‑tunnel commands for recording and replaying method executions.
This article introduces StopCoding, an IntelliJ IDEA plugin designed to interrupt prolonged coding sessions by showing an unclosable reminder dialog, and provides step‑by‑step installation, usage instructions, and a detailed Java‑based development tutorial including Swing UI and Timer implementation.
This article introduces the fundamentals of IntelliJ IDEA plugin development, covering plugin types, project structure, essential components, a complete development workflow with Gradle, action registration, extension points, live templates, Dubbo integration, publishing procedures, common pitfalls, and how to include local JARs.
This tutorial walks you through setting up the development environment, cloning the IDEA Community source, configuring the SDK, creating a simple plugin project, writing a custom action, registering it in plugin.xml, and running the plugin inside a new IDEA instance, all with clear code examples and screenshots.
This article provides a step‑by‑step tutorial on creating IntelliJ IDEA plugins, covering environment preparation, project creation, defining actions, updating plugin.xml, handling UI threads, launching background tasks, using ProgressManager, working with the Virtual File System and PSI, and leveraging the platform's UI components.
This article walks readers through the complete process of creating an IntelliJ IDEA plugin—from installing the SDK and setting up a project, to defining actions, handling UI threads, using background tasks, and exploring core concepts such as VFS and PSI—providing practical code examples and references for further learning.
