This article provides a detailed walkthrough of SpringBoot plugin development, covering the benefits of modular decoupling, common implementation approaches such as Java SPI, custom configuration, Spring factories, and practical code examples that demonstrate how to create, load, and use plugins for extensible SMS services.
This article walks you through the entire process of creating Claude Code plugins—from understanding why plugins are needed, setting up the directory structure, writing commands, agents, skills, and hooks, to testing, debugging, advanced features, and publishing—providing concrete code examples, configuration files, and best‑practice recommendations.
This guide explains how to create a lightweight Vite plugin and a Tampermonkey script that embed absolute file paths into Vue components, enabling developers to click any element in the browser and instantly locate its source file in the project.
The article chronicles the author's deep technical journey of adapting Tailwind‑Merge to work within WeChat mini‑programs, detailing the obstacles posed by illegal class‑name characters, failed compile‑time workarounds, a complete rewrite of the escape utility, and the final release of a robust, configurable merge plugin.
This step‑by‑step guide explains why you might need a custom Jenkins plugin, walks you through setting up Java 21 and Maven, generating a plugin project with the Jenkins archetype, building and locally testing it, and finally publishing it to the Jenkins Marketplace with best‑practice tips for security, CI, versioning, and community engagement.
This article explains how to develop a custom plugin that automatically captures Git metadata during build time, injects it into the bundled code, and exposes the information via a console command, with step‑by‑step guidance for both Webpack and Vite projects using Trae‑Builder.
This article walks through the Model Context Protocol (MCP) as an AI‑centric "USB‑C" for tool integration, explains its core capabilities, shows how to register and call MCP tools using the TypeScript SDK, details the end‑to‑end workflow from ZIP file handling to React code generation, and shares practical implementation tips and future improvements.
This article guides pure frontend developers with little or no Node.js experience through the fundamentals of creating Vite plugins, covering concepts such as code injection, file operations, and file routing, and provides practical examples and best‑practice tips to enhance development efficiency.
An automatically applied Babel plugin scans JavaScript AST nodes and rewrites risky property accesses and logical‑AND chains into optional‑chaining expressions, letting developers prevent TypeError crashes without modifying source code, while offering include/exclude filters, optional short‑circuit optimization, and compatibility with older browsers via downstream transforms.
The article explains how to create a custom Babel plugin that automatically transforms risky member and call expressions into optional‑chaining equivalents during bundling, using configurable include/exclude patterns and short‑circuit optimizations, thereby preventing TypeError in large JavaScript codebases while noting a modest bundle‑size increase.
This article provides a comprehensive guide to the Hvigor build tool—its core features, integration with DevEco Studio, consistent build processes, lifecycle stages, typical usage scenarios, task and product structures, as well as step‑by‑step instructions for creating custom tasks, plugins, and routing plugins using TypeScript, enabling efficient and flexible development on HarmonyOS.
Hvigor is a TypeScript‑based build orchestration tool for HarmonyOS that manages tasks, project models, and configurations, integrates with DevEco Studio for consistent command‑line and IDE builds, supports lifecycle phases, custom tasks, plugins, and routing plugins, and provides detailed development guides and code examples.
The article explains how PostCSS parses CSS into an abstract syntax tree composed of Declaration, Rule, Root, AtRule and Comment nodes, describes the rule‑ and hook‑based event listeners and depth‑first traversal used in PostCSS 8 versus the walk methods of PostCSS 7, and shows how this knowledge lets developers create custom plugins for tasks such as unit conversion, vendor prefixing, or dark‑mode generation.
AspectPro is a lightweight HarmonyOS runtime hook framework that, together with aspectProPlugin, enables comprehensive AOP capabilities such as method interception, parameter manipulation, and handling of non-writable properties, while the article details its core functions, limitations of system Aspect, and step‑by‑step implementation strategies.
This guide explains safe and efficient WordPress code modification techniques—including using child themes, avoiding direct core edits, creating plugins, and applying style changes—while emphasizing backup strategies, version control, and recovery methods to protect site stability and data.
The article explains Sermant's classloader architecture, plugin mechanism, class isolation, unified dynamic configuration, and logging capabilities, providing step‑by‑step guidance for building service‑governance plugins from basic to advanced features.
Using Adobe’s CEP platform, this tutorial shows how to set up a Photoshop extension, employ the Action Manager API to extract text layer properties such as color, font size, and shadow, and then recreate the design in HTML/CSS, streamlining marketing asset creation.
This article explains MySQL’s logical architecture, details the pluggable storage‑engine API, lists the default engines, and provides step‑by‑step guidance with code examples on how to create a custom MySQL storage engine.
This guide introduces CozeIDE, explains its main features such as code editing, dependency management, AI programming assistant, testing and publishing, and walks you through two complete plugin development examples—including a stock‑price lookup plugin—showing how to create, test, and release plugins using Node.js or Python runtimes.
This article explains how to extend the Higress cloud‑native gateway with WebAssembly plugins written in Go, C++ or Rust that call Redis for global rate limiting, token‑based AI usage control, and cookie‑based caching, including full code samples, configuration steps, and test results.
This article walks developers through Sermant’s architecture, explaining its plugin mechanism, class isolation, and how to build practical plugins with basic capabilities, unified dynamic configuration, and unified logging, while showcasing real‑world examples and tips for efficient development.
This article explores Jira's plugin ecosystem, detailing how the Forge platform lets developers create, integrate, and deploy extensions using CLI tools, UI kit or custom UI, with server‑driven rendering, sandboxed security, and a marketplace for distribution.
This article explains how to develop, package, and deploy custom Trino plugins—illustrated with an access‑control plugin—by using Java SPI, Maven dependencies, implementing the Plugin and SystemAccessControl interfaces, and configuring the plugin in Trino’s configuration files.
This article recounts the author's journey of creating a Figma plugin that transforms Markdown text into AutoLayout, detailing the challenges faced, iterative problem‑solving with AI assistance, code integration, and the final functional solution for seamless text conversion.
This guide explains how to configure a uTools plugin project, create the required plugin.json, build the settings panel with Vue3, integrate the Cheetah core module, implement search and open commands, handle platform‑specific app launching, manage cache, and submit the plugin for review.
This article presents the motivation, architecture, component selection, user authentication flow, micro‑service integration, and technical details—including custom Lua plugins and NGINX phases—of an automated operations platform built on the cloud‑native API gateway Apache APISIX.
The article examines how to boost personal efficiency by developing cross‑platform plugins for macOS productivity tools such as Alfred, Raycast, and uTools, describing their architectures, a shared core module, the use of the lightweight txiki.js runtime, and practical implementation details.
The IntelliJ platform has moved its source code to Java 17, requiring IDE 2022.3 to run on Java 17 while still supporting some modules for older Java versions, and this shift impacts plugin development, version compatibility, and build processes for developers.
IntelliJ’s source code has moved to Java 17, meaning most platform and plugin modules now target Java 17, the 2022.3 IDE release requires it, and developers can use new language features by setting plugin.xml to 223, while still supporting older versions with Java 11.
This article explains Baidu Smart Program Developer Tools 4.0, covering its design shift from Electron to VSCode, step‑by‑step migration from local VSCode environments, plugin creation and integration, and practical tips for faster mini‑program development.
This article describes how ShouQianBa standardized its API gateway stack by adopting Apache APISIX, detailing the reasons for selection, custom plugin development, logging enhancements, a bespoke management platform, version‑upgrade strategy, deployment model, and the resulting improvements in reliability and developer productivity.
This tutorial walks through building a PostgreSQL audit plugin for the SQLE platform using Go, covering project setup, minimal plugin code, adding a SELECT‑star prohibition rule, and implementing a configurable rule that limits table column counts, complete with deployment and testing instructions.
JetBrains announced the removal of Log4j from the IntelliJ platform in the 2022.1 release, explaining that the IDE’s minimal logging needs and Log4j’s complexity prompted the change, and offering plugin developers migration guidance to standard platform logging APIs, SLF4J, or java.util.logging alternatives.
This article walks through the fundamentals of Figma plugin development, explaining the architecture of main and UI threads, demonstrating core features of the lego‑quiz‑figma plugin, and providing a complete workflow from creating the manifest to publishing the plugin, complete with code examples and best‑practice tips.
This article provides a comprehensive tutorial on developing Sketch plugins using JavaScript, CocoaScript, and skpm, covering background motivation, required knowledge, quick start steps, project structure, manifest configuration, menu nesting, API usage, actions, WebView integration, debugging, hands‑on examples, and best practices for front‑end engineers seeking to bridge design and code.
This article provides a comprehensive guide to Rollup plugins, explaining why plugins are needed, detailing hook types and their execution timing, showing how to create simple plugins with example code, and exploring internal mechanisms such as PluginDriver, hook loading, and caching.
The article explains how to design and implement ESLint and StyleLint plugins for the San‑Native framework, detailing AST generation, processor creation, rule definitions for JavaScript and CSS, configuration sharing, and how these tools provide real‑time linting feedback for developers.
This article walks developers through creating the StopCoding IntelliJ IDEA plugin—a Java‑based extension that reminds you to rest, drink water, and pause coding—covering IDE fundamentals, Gradle project setup, plugin.xml configuration, action implementation, UI dialogs, and usage instructions.
StopCoding is an IntelliJ IDEA plugin designed to curb prolonged coding sessions by periodically displaying an unclosable reminder dialog with a countdown, and the article provides installation instructions, usage guide, and a detailed development tutorial covering plugin structure, Swing UI, timer implementation, and key Java code snippets.
The article introduces San CLI—a command‑line tool for the San front‑end framework—explaining its purpose, core commands for project scaffolding, development, building, and inspection, as well as how to extend it with command and service plugins for customizable, production‑ready workflows.
This guide walks you through setting up the IntelliJ IDEA development environment, cloning the Community Edition source, configuring the IntelliJ Platform SDK, creating a simple plugin project, writing a custom Action class, registering it in plugin.xml, and running the plugin to see its effect.
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.
The article walks through the complete workflow for building a Flutter plugin—using native_image_view as an example—including platform channel communication, Dart and native (iOS/Android) implementation, testing via an example app, and publishing to public or private Pub repositories.
This article introduces San CLI, explains why a command‑line interface boosts front‑end productivity, walks through project initialization, development server, production build, remote deployment, inspection, UI, and demonstrates how to extend the tool with custom command and service plugins.
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 article explains how Kubernetes' Kube‑scheduler has evolved from early Extender and multiple‑scheduler approaches to the modern Scheduling Framework, detailing its architecture, extension points, and a step‑by‑step guide to building a custom QoS plugin with code examples.
The article explains how Harbor Front‑End extends Lighthouse with a custom plugin—defining gatherers, audits, and categories—to uniformly monitor web pages and mini‑programs, illustrating setup, a sample native API‑call logger, and configuration steps that produce detailed performance reports alongside standard Lighthouse metrics.
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 tutorial shows how to use the open‑source APISIX API gateway—built on OpenResty and etcd—to create a dynamic rate‑limiting plugin in Lua, configure route matching with a radix tree, and demonstrate the feature with a test endpoint that enforces one request per second and returns HTTP 503 when exceeded.
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 article introduces Kong, a cloud‑native API gateway, outlines its key features such as high performance, plugin architecture, and traffic control, explains why it solves common microservice challenges, and provides detailed deployment, clustering, plugin development, and troubleshooting guidance with practical code examples.
This article introduces Kong, a cloud‑native API gateway, outlines its key features such as high performance, plugin architecture, and built‑in security, explains why it solves common microservice challenges like unified entry, scalability and CI/CD, and provides step‑by‑step guidance for deployment, clustering, custom plugin development, and troubleshooting.
This article explains how to develop extensible Chimee H5 video player plugins using React, covering plugin specifications, code examples, integration of React components via Context, event handling, and strategies for managing asynchronous behavior and plugin ordering.
This article details the 360 team’s decision to adopt Apache APISIX for their gateway layer, describes the production architecture, containerized deployment steps, plugin development workflow, and operational metrics, providing a practical guide for building and managing a high‑performance API gateway.
This article explains the inner workings of Babel, the JavaScript compiler, outlines what syntax it transpiles versus what requires polyfills, describes its three compilation stages, demonstrates AST generation and tokenization, and provides step‑by‑step examples of creating simple Babel plugins for code transformation.
This article explains the concept of PSI (Program Structure Interface) in IntelliJ IDEA, demonstrates how to obtain PsiFile objects, manipulate PsiJavaFile, PsiClass, PsiField, and add annotations and parameters, providing a practical guide for plugin developers.
This comprehensive guide explains what Flutter plugins are, why they are essential, the MethodChannel communication model, step‑by‑step plugin creation, common pitfalls, testing strategies, publishing to public or private repositories, and a real‑world case study of a routing plugin, providing all the code and configuration details developers need to build and distribute their own Flutter plugins.
This article details the development of Kirby, a Sketch plugin created by Ctrip's front‑end team to manage design resources, enforce design language standards, and provide a full stack of features—including design token handling, static scans, WebView GUIs, and native integrations—while explaining the underlying Sketch plugin architecture, APIs, and tooling.
This tutorial provides a comprehensive guide to developing plugins for IntelliJ IDEA, covering environment setup, project structure, actions, components, services, persistence mechanisms, dependency management, and GUI creation using the built-in designer for developers.
This article provides a comprehensive guide to developing IntelliJ IDEA plugins, covering environment configuration, project structure, component and service creation, action implementation, extension points, state persistence, GUI design, and packaging, with detailed code examples and screenshots.
This article explains Pinpoint’s architecture, its plugin system, key data structures like ServiceType and AnnotationKey, and demonstrates how to develop a custom bytecode‑injection plugin for Java applications to achieve low‑overhead distributed tracing.
This article describes the motivation, design, implementation, and deployment of an IntelliJ IDEA plugin that automatically inserts semicolons and braces, formats code, and uses a chain‑of‑responsibility pattern to decouple business logic, providing developers with a smoother coding experience.
This article explains how RePlugin maps plugin-defined custom‑process activities to host placeholder processes, retrieves component information from the plugin APK, generates static or dynamic process‑mapping tables, adjusts component process names, and orchestrates the launch and lifecycle of these activities on Android.
This article explains how RePlugin enables a host app to recognize, map, and start custom plugin processes—including static and dynamic process mapping, adjusting component process names, launching processes via injected providers, handling process reclamation, and managing activity slot allocation for seamless plugin activity execution.
This article explains how to extend a Jenkins plugin by creating a custom Action class to pass data to job pages, adding a sidebar option, and implementing a new configuration page using Jelly templates, with step‑by‑step code examples and deployment instructions.
This article explains how the two essential Gradle plugins—replugin-host-gradle and replugin-plugin-gradle—generate configuration files, inject AndroidManifest components, create built‑in plugin descriptors, and use Transform API to modify bytecode, enabling seamless plugin development and integration in Android projects.
This tutorial walks you through creating a Drone CI plugin in Node.js that sends Telegram notifications, covering environment variable handling, plugin code, Dockerfile optimization, image building, testing, secret management, and common pitfalls for seamless CI integration.
Pinpoint is a full‑stack, non‑intrusive tracing platform that visualizes service topology, active threads, request latency, and application health, and this article explains its architecture, data model, and step‑by‑step process for creating custom plugins—including ServiceLoader configuration, TraceMetadataProvider, and ProfilerPlugin implementations with code examples.
This guide explains how to set up the development environment, create a C# class‑library project, add Fiddler references, implement required interfaces, enable debugging, and build a custom Fiddler plugin that automatically decrypts encrypted SDK HTTP requests and displays them in clear text for testing.
This article provides a thorough overview of Babel, covering its core concepts, installation and configuration methods (including Webpack, fis3, command‑line, and programmatic usage), preset and plugin options, the compilation pipeline, AST fundamentals, and step‑by‑step instructions for creating and testing custom Babel plugins.
This article explores how jQuery constructs its $ objects by wrapping a simplified implementation, detailing prototype assignments, the init function, extension mechanisms, and best practices, while providing code snippets and diagrams to help developers deepen their understanding of JavaScript and frontend development.
This article provides a comprehensive tutorial on creating, configuring, and publishing an Android Studio plugin, covering environment setup, project creation, plugin.xml configuration, action implementation, packaging, and uploading to the JetBrains marketplace, with detailed screenshots and code examples.
This tutorial walks readers through setting up the development environment, generating a Jenkins plugin skeleton with Maven, understanding the project structure and Jelly view files, writing the plugin code, debugging, and finally packaging and deploying the custom plugin to a Jenkins server.
Learn how to create, customize, and extend jQuery plugins—from basic concepts and simple color-changing examples to chainable calls, avoiding $ symbol conflicts, handling parameters, and using $.extend and $.fn.extend—while understanding the underlying prototype mechanism and best practices.
This article explains how Babel parses ES6 code into an AST, traverses and modifies nodes using visitors and paths, and demonstrates a practical plugin that replaces a custom abs function with Math.abs, providing a solid foundation for building advanced JavaScript transformations.
This guide explains how to develop custom Gradle plugins by using the three supported approaches—directly in build.gradle, within the buildSrc directory, or in an independent module—covering plugin implementation in Groovy, extension creation, resource setup, and publishing to a local Maven repository for reuse in Android projects.
This article explains how WordPress uses the wp_postmeta table for flexible metadata storage and the hook (action) system for dynamic code insertion, illustrating both the benefits and trade‑offs of these extensibility techniques for plugin development.
