This tutorial shows how to use the Java‑based magic‑api framework to generate Spring Boot HTTP endpoints directly from a UI, covering dependency setup, datasource configuration, database preparation, CRUD scripts, validation, result mapping, transaction handling, and Swagger integration.
This guide walks through installing magic-api in a SpringBoot project, configuring data sources, creating CRUD endpoints with magic-script, adding validation, transaction handling, and integrating Swagger for API documentation, complete with code snippets and configuration examples.
This guide shows how to use the Java‑based magic‑api framework to generate CRUD REST endpoints directly from a UI, covering Maven setup, datasource configuration, script‑based request handling, validation, result mapping, transactions, and Swagger integration.
A Spring Boot channel service showed an unexpected 100 ms latency; by systematically checking network, using curl, and employing Arthas to trace Spring MVC and Tomcat internals, the author discovered a Tomcat‑embed bug that repeatedly loads Swagger‑UI JAR resources, which is resolved by upgrading Tomcat.
This article explores Go's built-in documentation philosophy, explains how godoc, README, and Example sections each serve distinct roles, contrasts them with Swagger for API consumers, and provides a concrete, step-by-step guideline for establishing maintainable, evolution-ready documentation practices in real-world Go projects.
This article demonstrates how to eliminate manual route definitions in a Go Gin service by using a JSON configuration to dynamically register endpoints, map parameters, rewrite response bodies, and automatically generate Swagger documentation, while also offering enhancements like validation, caching, and hot-reloading.
This step‑by‑step guide shows how to create a high‑performance OCR service that recognizes Chinese and English, using a Go Gin backend with OpenCV preprocessing and Tesseract, a Vue3 frontend, Docker multi‑stage builds, and Swagger UI for API testing.
This guide shows how to integrate springdoc‑openapi 2.7.0 with Spring Boot 3.5.6 to generate an online Swagger UI, covering Maven dependencies, configuration class, annotation usage, response wrapper, version compatibility notes, and the URL to access the generated documentation.
This guide walks you through adding the appropriate SpringDoc OpenAPI dependencies for Spring Boot 2.x or 3.x, configuring the library, creating sample controllers with OpenAPI annotations, customizing documentation metadata, and using advanced features like API grouping, hidden endpoints, and offline generation.
This article walks through why SpringDoc replaces SpringFox, shows step‑by‑step minimal configuration, dependency setup, controller annotations, API grouping (both programmatic and declarative), and necessary adjustments for WebMvcConfigurer and Spring Security to generate OpenAPI 3 documentation in a Spring Boot project.
This guide introduces SpringDoc as a fully supported Swagger replacement for Spring Boot 3, covering its features, integration steps, configuration examples, comparison with SpringFox, usage with Spring Security, testing procedures, and links to the source repositories.
This tutorial introduces the magic‑api Java framework, shows how to integrate it with Spring Boot, configure data sources, create the necessary MySQL tables, and implement full CRUD operations, parameter validation, result transformation, transaction handling, and Swagger documentation using concise scripts.
Learn how to eliminate manual API documentation in Go gRPC projects by automatically generating Swagger docs from Proto annotations, syncing with code changes, and enabling interactive testing, using tools like Buf, grpc-gateway, and Swagger UI in a concise three‑step workflow.
This tutorial shows how Java developers can use the magic‑api framework to rapidly create Spring Boot CRUD APIs without writing Controllers, Services, or DAOs, covering Maven setup, configuration, database schema, code‑free endpoint design, validation, transactions, Swagger integration, and deployment.
Learn how to create fast, modern Python APIs using FastAPI, automatically generate interactive Swagger documentation, and enhance your endpoints with validation, metadata, and a full-featured to‑do list project, all illustrated with clear code examples and step‑by‑step deployment instructions.
This tutorial walks you through API protocol types, Swagger/OpenAPI documentation setup, advanced configuration, environment‑specific activation, UI enhancement with Knife4j, and practical versioning strategies to efficiently manage and evolve your backend APIs.
This article explains why Swagger falls short for API debugging in production, outlines the recurring issues developers face, and shows how Apifox’s import, environment variables, global parameters, pre‑ and post‑scripts, mock data, and cURL import features streamline API development and testing.
This guide walks through initializing a Spring Boot project, handling IDE setup challenges, managing version compatibility between Spring Cloud, Spring Boot, and Kafka, and provides practical code examples for global exception handling, logging, CORS configuration, Swagger integration, and useful development tools.
This article explains the main types of API documentation—Swagger, Word, Excel, and PDF—describing their features, suitable scenarios, and how to convert between formats to improve API development and testing efficiency.
This article analyzes the shortcomings of separating Swagger2.0 documentation from parameter handling in a Go backend, proposes a unified parameter definition and routing adapter for the GF framework, and demonstrates the resulting automatic OpenAPI generation with detailed code flow and visual examples.
The article details a step‑by‑step investigation of an unexpected ~100 ms latency in a Spring Boot‑based channel system, covering network checks, curl measurements, Arthas trace and watch commands, identification of TomcatJarInputStream’s repeated jar‑resource loading caused by Swagger dependencies, and the final fix by upgrading the embedded Tomcat version.
This article explains how Apache Dubbo 3.3.3 natively supports OpenAPI 3, allowing developers to automatically generate API documentation, export Proto files, integrate with Swagger UI and Apifox, and customize the output via annotations, all without extra dependencies or complex configuration.
This guide walks you through the pain points of environment setup, shows step‑by‑step creation of a Spring Boot project, explains version compatibility between Spring Cloud, Spring Boot and Kafka, and provides ready‑to‑use Maven configurations, global exception handling, logging, CORS, Swagger, and a curated list of useful development tools.
This article compares Google’s Protocol Buffers and the Swagger/OpenAPI framework, detailing their features, data formats, use cases, flexibility, development workflows, and why Google created protobuf, helping developers choose the right tool for high‑performance data serialization or comprehensive API documentation.
The article presents a TypeScript automation tool that parses Swagger v2/v3 specifications to automatically generate API function bodies, interfaces, and mock files—supporting custom templates, case conversion, and header tweaks—enabling front‑end teams to reduce manual coding, cut onboarding time, and boost development efficiency across complex B‑side projects.
This guide introduces Insomnia, an open‑source, cross‑platform API client that supports GraphQL, REST, WebSockets, and gRPC, walks through its simple installation, demonstrates how to import and test the SpringBoot‑based mall project via Swagger, and highlights useful configuration tips for efficient backend debugging.
This article details how a hidden 100 ms delay in a Spring Boot channel system was traced to Tomcat‑embed’s handling of Swagger‑UI resources, diagnosed with Arthas, and resolved by upgrading the embedded Tomcat version.
This guide explains what Swagger is, why it’s useful for RESTful APIs, and provides step‑by‑step instructions for integrating Swagger 3.0 with Spring Boot 2.7, handling version conflicts, customizing documentation, adding security, and using annotations to enrich API metadata.
This article explains what Swagger is, why it is useful for RESTful API documentation, and provides a step‑by‑step guide for integrating Swagger 3.0 with Spring Boot 2.7.6, handling version conflicts, customizing Docket settings, securing the UI, and applying advanced annotations to enrich the generated documentation.
This tutorial explains what Swagger is, why it is useful for RESTful API documentation, and provides step‑by‑step instructions for integrating Swagger 3.0 into a Spring Boot 2.7.6 project, including Maven dependencies, configuration classes, handling startup errors, customizing the UI, security settings, and annotation usage.
This guide shows how to eliminate manual Controller code by automatically exposing CommandService and QueryService as web endpoints, integrating with Swagger for dynamic API documentation, and explains the underlying unified controller architecture and extension points.
This article walks through building a low‑code platform that automatically creates Spring Boot REST endpoints from plain SQL definitions, covering datasource configuration, dynamic request mapping, SQL execution, and optional Swagger documentation generation.
This article explains why @RequestBody conflicts with Swagger in Spring Boot, outlines two common but cumbersome work‑arounds, describes a Swagger API timeout caused by Groovy's MetaClass, and provides a concise configuration fix that eliminates both the timeout and the compatibility issue.
This article provides a comprehensive guide to upgrading Spring Boot to version 2.7, detailing common issues such as missing dependencies, logging conflicts, circular bean references, Swagger configuration changes, Flyway compatibility, JUnit version mismatches, and JSON Long precision loss, along with concrete code‑based solutions.
This article compares Java Swagger libraries SpringFox and SpringDoc, explains when to choose each, and demonstrates how to integrate SpringDoc with Knife4j for enhanced API documentation, JSON validation, data folding, and a microservice aggregation solution.
This guide shows how to install Go‑Swagger, annotate Go code with Swagger comments, generate a swagger.json file, serve it via Nginx, and configure Yapi to automatically import the spec, creating a seamless, always‑up‑to‑date API documentation pipeline for front‑end and back‑end teams.
After upgrading to Spring Boot 2.6, a NullPointerException occurs when integrating Swagger due to the new PathPatternParser, and the issue can be resolved by changing the path‑matching strategy to ant_path_matcher or adding a custom WebMvcEndpointHandlerMapping bean.
Swagger’s poor JSON handling can hinder API testing, but two sleek visualization tools—JsonHero and JsonVisio—offer formatting, editing, tree views, and easy installation, enabling developers to efficiently view and manipulate JSON data directly from Swagger or standalone.
After SpringFox became outdated and incompatible with Spring Boot 2.6, this article introduces SpringDoc as a modern OpenAPI 3‑based alternative, explains its advantages, shows how to integrate it, migrate annotations, configure security, and provides sample code and screenshots for a seamless transition.
This article walks through upgrading a Spring Boot project to version 2.6.x, explains why circular bean dependencies and Swagger failures occur after the upgrade, and provides step‑by‑step configuration changes—including allowing circular references, using @Lazy, and adjusting MVC path‑matching—to resolve the problems.
An extensive SpringBoot guide covering its definition, benefits, core configuration files and formats, main annotations, activation methods, container independence, run options, auto‑configuration mechanics, new 2.x features, pagination, security, ActiveMQ, YAML, Actuator, Swagger, exception handling, request mapping nuances, legacy compatibility, protection strategies, executable jar differences, and task scheduling.
This article explains why and how to aggregate Swagger API documentation across multiple Spring Cloud microservices by creating a reusable swagger‑starter, configuring each service, and implementing a GatewaySwaggerResourcesProvider to expose a unified documentation entry point.
This article explains why Swagger can become cumbersome as API counts grow, introduces Knife4j as a powerful Swagger enhancement, and provides step‑by‑step instructions with code examples to integrate Knife4j into a Spring Boot project, highlighting its key features such as JSON folding, search, and global parameters.
This article explains how to replace the default Swagger‑UI with Knife4j, outlines the problems of using Swagger in a microservice environment, and presents two documentation aggregation patterns—gateway aggregation and a centralized registration mode—detailing the architecture, database schema, and Spring Boot starter implementation for a reusable Swagger registration server.
This guide explains how to keep Swagger annotations in sync with Yapi by generating a swagger.json file, exposing it via Nginx, and configuring Yapi’s automatic import, so that API documentation updates automatically after each code change without manual effort.
This article introduces think-swagger-ui-vuele, a custom Swagger UI built on think‑vuele that simplifies API documentation by parsing Swagger JSON, offers fast loading for large APIs, supports mock data, customizable request headers, and provides both npm and Maven integration with usage instructions and code examples.
A Spring Boot channel service suffered an unexplained 100 ms extra latency, which was traced using Arthas to Tomcat’s handling of META‑INF resources from Swagger’s JAR, and the issue was resolved by upgrading the embedded Tomcat version.
This article introduces Knife4j, a lightweight Java MVC Swagger enhancement, explains its core features and UI improvements, and provides a step‑by‑step guide with Maven dependencies, configuration classes, model definitions, and controller code to quickly set up interactive API documentation in a Spring Boot project.
Learn how to set up the enterprise‑grade Torna API documentation platform, integrate it with Swagger, and run it on Windows, Linux, or Docker, covering project structure, installation steps, configuration, and advanced features like permission control, mock data, and interface testing.
This article walks through integrating Swagger into a SpringBoot project, covering dependency setup, configuration, handling common issues like ResponseBodyAdvice conflicts, enhancing UI with Knife4j, and leveraging Swagger’s grouping feature for parameter validation, providing complete code snippets and troubleshooting tips for seamless API documentation.
This article explains how to import Swagger API documentation into a testing platform database, perform version control and diff using zjsonpatch, and seamlessly connect the documented APIs with automated test cases to improve efficiency for front‑end, back‑end, and QA teams.
Knife4j is a lightweight, feature‑rich solution that enhances Swagger UI for Java MVC frameworks, offering customizable configurations, offline document export, and seamless integration with Spring Boot and Spring Cloud micro‑service architectures, while providing open‑source repositories and clear usage instructions.
This article presents a comprehensive GitHub collection of Spring Boot vulnerabilities, explains how to identify information‑leakage and remote‑code‑execution flaws via exposed Swagger and Actuator endpoints, and provides step‑by‑step verification commands for security testing.
This article explains the history, recent updates, and step‑by‑step usage of the Spring Boot Swagger starter, including dependency setup, detailed configuration options, grouping, JSR‑303 validation support, custom response messages, UI tweaks, ignored parameter types, and authorization settings.
Knife4j is a lightweight, feature‑rich enhancement for Swagger that integrates seamlessly with Java MVC frameworks, offering customizable UI, advanced functionalities like interface sorting and export options, and easy Maven integration for both monolithic Spring Boot and Spring Cloud microservice architectures.
This article explains why Swagger‑Dubbo is needed, introduces Swagger, describes the Swagger‑Dubbo tool, provides step‑by‑step integration instructions with Maven dependencies and Java configuration code, demonstrates how to launch and test the generated API docs, and outlines additional integrations with Knife4j and YApi.
This article describes how a hidden 100 ms latency in a Spring Boot channel service was traced with Arthas, revealing a Tomcat‑embed bug caused by repeated loading of Swagger UI resources, and explains how upgrading Tomcat or Spring Boot eliminates the delay.
The article introduces the DCS_FunTester framework, explains its naming, provides Swagger API access, details local deployment steps, describes a header‑based authentication change, outlines asynchronous test execution, multi‑request handling, progress tracking, and includes relevant Java code snippets for building and running the system.
This tutorial demonstrates how to integrate the open‑source Swagger‑Bootstrap‑UI (now renamed Knife4j) into a Spring Boot application, covering Maven dependencies, configuration class setup, project launch, common annotations, sample controller code, and troubleshooting tips.
magic-api is a Java-based rapid API development framework that eliminates the need for traditional Controllers, Services, DAOs, and XML files by providing a UI for defining endpoints, supporting Spring Boot integration, CRUD operations, validation, transactions, result mapping, and Swagger integration, with detailed configuration examples.
This article provides a step‑by‑step tutorial on building a Spring Boot project and configuring essential features such as starters, configuration properties, profiles, global exception handling, CORS, MVC interceptors, AOP, MyBatis‑Druid integration, Redis caching, email sending, and Swagger API documentation, complete with code examples and best‑practice tips.
This article explains how to integrate Swagger using Springfox 3.0.0 into a Spring Boot project, covering required dependencies, configuration files, annotations, new features, compatibility requirements, and provides a complete example with code snippets for generating interactive OpenAPI documentation.
This tutorial explains how to replace the default Swagger UI with Swagger‑Bootstrap‑UI (now called Knife4j) in a Spring Boot application, covering Maven dependencies, configuration classes, common annotations, a sample controller, launch steps, and troubleshooting tips.
This guide explains how to integrate Dubbo‑Api‑Docs into a Dubbo project, providing Swagger‑style interface documentation and testing via Dubbo‑Admin, covering annotation setup, Maven dependencies, example projects, and deployment steps.
This tutorial walks you through installing YApi, configuring its environment, importing Swagger definitions, managing interfaces, leveraging mock data, enabling automatic sync, and handling permission management, providing a powerful, secure API documentation solution for backend developers.
The article explains the challenges of keeping interface model definitions synchronized between development and testing, compares code‑first and doc‑first approaches, introduces the Go‑based GinDoc library for generating Swagger documentation and client code from annotated routes, and provides step‑by‑step usage examples and integration tips.
This article compares several open‑source API documentation generators—GitBook, smart‑doc, Redoc, Knife4j, YAPI, apidoc, and ShowDoc—evaluating their licenses, popularity, language support, features, pros, cons, and suitability for real‑time online documentation, search, and debugging.
This guide shows how to import Swagger-generated API definitions into Postman, configure environment variables, handle authentication tokens, and use Postman for efficient API debugging, while noting the limitations of documentation display compared to Swagger.
This article introduces Midway's lightweight, dependency‑free Swagger component that leverages the framework’s own decorators to generate Swagger‑compatible JSON, explains its advantages and limitations, showcases code examples for multi‑scenario service injection, details recent configuration refactoring that speeds up local development, and highlights new request‑parameter decorators for richer API documentation.
This article provides a comprehensive guide on using Swagger for REST API documentation in Spring Boot projects, covering Swagger fundamentals, Springfox introduction, the features of Springfox 3.0.0, compatibility requirements, Maven integration, configuration classes, common annotations, and a complete example with code snippets.
This article walks through the complete process of integrating Swagger 3.0 into a Spring Boot 2.3.5 application, covering dependency setup, the role of springfox‑boot‑starter, custom OpenAPI configuration, API grouping, security schemes, and global request parameters with concrete code examples.
This tutorial walks through installing swagger-php 2.0, downloading swagger-ui, integrating it into a ThinkPHP project, generating a swagger.json file via annotations, and provides code snippets and configuration details to help developers set up API documentation in a PHP backend environment.
This guide shows how to replace the old springfox-swagger jars with the new Springfox 3.0.0 starter, configure Swagger UI in a Spring Boot project, compare version differences, and integrate Swagger with Spring Security for protected API endpoints.
This article introduces a self‑implemented Swagger UI built on think‑vuele, explains its architecture and dependencies, provides step‑by‑step usage instructions and Maven integration, and details performance optimizations such as API summary loading, mock data generation, and customizable request headers.
This article outlines the latest upgrades to the open‑source Mall project, including migration to SpringBoot 2.3.0, support for Elasticsearch 7.6.2, enhanced ELK log collection, unified Swagger and Redis configurations, and updated deployment guides for Windows and Linux environments.
Learn to unify API documentation across multiple Spring Cloud microservices by configuring Nacos, Spring Cloud Gateway, and Knife4j, covering prerequisite setup, service definitions, detailed implementation steps, Swagger resource aggregation, UI switching, and complete code examples for user, order, and gateway services.
This article introduces SpringFox 3.0.0, highlights its new features such as Spring 5 WebFlux support, OpenAPI 3 compatibility, and zero‑configuration starter, then provides a step‑by‑step guide with Maven dependencies, annotations, controller examples, and notes on updated Swagger UI endpoints.
This article walks readers through building a high‑efficiency API testing workflow using Swagger’s automated documentation and Springfox integration, covering setup, configuration, mock services, code coverage, keyword‑driven automation, and practical deployment examples with Maven dependencies and live Swagger UI demonstrations.
This article explains how to use Swagger and Springfox to automate API documentation and testing in Java SpringBoot projects, covering the benefits of Swagger, integration steps, Maven dependencies, configuration examples, and how to access the generated interactive UI for faster, more reliable interface validation.
This tutorial shows how to integrate Spring Security into a Spring Boot project that already uses Swagger2, configuring dependencies, application properties, Swagger and security classes so that the generated API documentation is protected by a login page without affecting other business endpoints.
This article explains what Swagger is, why it benefits backend and frontend teams, and provides a step‑by‑step guide to integrate Swagger 2.7.0 into a Spring Boot project, including dependencies, configuration, annotations, controller examples, testing tips, and deployment considerations.
This tutorial explains how to integrate MyBatis into a Spring Boot project, covering the framework's basics, Maven dependencies, annotation‑based CRUD operations, XML‑based mappings, entity definitions, controller implementations, Swagger testing, and Druid monitoring, with complete code examples and download links.
This tutorial explains how to integrate JDBC into a Spring Boot project, covering Maven dependencies, MySQL driver setup, application.yml datasource configuration, Spring Boot's auto‑configuration mechanism, JdbcTemplate usage, Swagger documentation, CRUD endpoint implementation, and solutions to typical connection errors.
This guide explains how to integrate JDBC into a Spring Boot project, covering Maven dependencies, datasource configuration, Spring Boot's auto‑configuration mechanism, JdbcTemplate usage, Swagger setup for API testing, CRUD examples on a MySQL department table, and solutions to typical connection errors.
This article outlines essential API design principles and best practices, covering simple, understandable, consistent, stable, and secure APIs, then delves into RPC mechanisms, Protobuf serialization, RESTful conventions, Swagger documentation, Spring Boot integration, HTTP/2 performance improvements, and the powerful combination of HTTP/2 with Protobuf in gRPC.
This article explains the motivation behind building ITest, a unified API testing platform, details its architecture, key features such as Swagger import, parameterization, assertions, signing, and CI/CD integration, and summarizes the benefits it brings to development and testing teams.
This article introduces the ATP automated testing platform, outlines its four-step interface testing workflow, explains three methods for recording transaction formats, and demonstrates how integrating ATP with Swagger streamlines format capture, case design, and execution to improve testing efficiency and quality.
This article explains how to control the organization, grouping, and ordering of API documentation in Swagger for Spring Boot projects, covering controller-based tags, custom tag names, merging groups, fine‑grained operation tags, and sorting of tags, operations, and parameters.
This tutorial explains why server‑side request parameter validation is essential, introduces the JSR‑303 Bean Validation standard and its Hibernate Validator implementation, and provides step‑by‑step code examples, Swagger integration tips, and dependency guidance for building robust Spring Boot REST APIs.
This guide walks you through the challenges of manual API documentation, introduces Swagger as a powerful solution, and provides a step‑by‑step tutorial for integrating Swagger with Go projects using the Swag tool, Gin framework, and custom UI enhancements.
This article explains how to parse a Swagger JSON document and automatically generate maintainable Java test code for each API endpoint, detailing the handling of GET query parameters, POST form‑data, RESTful path variables, and header conventions.
This tutorial walks through building a Spring Boot backend with user registration, login, JWT token generation, Swagger UI configuration, and method-level permission annotations, providing complete code examples and step‑by‑step instructions for secure authentication and authorization.
This tutorial shows how to integrate Spring Security and JWT into a Spring Boot backend to implement user login and authorization, configure Swagger‑UI to automatically include the token, and provides all necessary code snippets, configuration files, and utility classes for a complete authentication solution.
This tutorial walks through integrating Swagger‑UI into the mall‑tiny Spring Boot project, covering Maven dependencies, Java configuration, adding Swagger annotations to controllers, customizing MyBatis Generator to emit @ApiModelProperty, regenerating model code, and finally viewing and testing the generated API docs via the Swagger‑UI interface.
This article explains the challenges of manual mock data creation in fast‑paced front‑end projects, compares existing solutions, and presents SMock—a Swagger‑driven tool that automatically generates mock data, starts a local service, aggregates API paths, validates requests, and boosts development efficiency.
This guide explains how to use the Swagger @ApiModelProperty annotation's allowableValues attribute to define fixed lists, numeric ranges, or open-ended limits for API parameters, with clear Java code examples and the resulting documentation output.
This article describes the pain points of manual API test script writing, proposes a workflow that parses interface documentation, automatically generates both interface classes and robust test cases using Python and Swagger, and demonstrates significant efficiency gains and future improvement directions.
This tutorial explains how to use the open‑source Swagger2Markup library to transform Swagger/OpenAPI specifications into Markdown or Confluence markup by adjusting a single Java configuration, includes code examples, output structure, single‑file options, and deployment tips for static sites and Confluence.
This guide explains how to use Swagger2Markup to convert Swagger JSON from a Spring Boot project into AsciiDoc and then into static HTML, covering Maven dependencies, a JUnit test for document generation, and the Asciidoctor plugin configuration for final deployment.
This article introduces the Spring Boot Swagger starter version 1.3.0.RELEASE, highlighting new host configuration and JSR‑303 annotation support, and provides step‑by‑step instructions, Maven dependency snippets, Java code, detailed property settings, grouping examples, and resource links for seamless API documentation integration.
