This article explains the limitations of traditional REST APIs, introduces GraphQL as a flexible alternative, details its core concepts such as schema, types, queries, mutations and subscriptions, and outlines various deployment architectures and implementation considerations for backend development.
This guide shows how to retrieve the Kubernetes API endpoint, generate an authentication token, deploy a Python script, configure Zabbix host and external check, and manually trigger the monitoring to collect cluster metrics via Zabbix Sender.
This article explains the evolution and limitations of REST APIs, introduces GraphQL as a more flexible, declarative alternative, details its core concepts such as schema and type system, compares execution models, and outlines various backend integration architectures for adopting GraphQL.
This article walks through using Socket.IO to test whiteboard pixel data transmission, presenting a Java test script, sample console logs, and an explanation of the joinRoom interface that pushes full board state to connected clients.
This article compares the four major API architectural styles—RPC, SOAP, REST, and GraphQL—detailing their mechanisms, strengths, weaknesses, and typical use cases, and provides guidance on selecting the most suitable style for a given project.
This article explains ZooKeeper's purpose, core features, and design goals, showing how it simplifies distributed application development by providing high‑performance, highly available coordination services such as naming, locks, leader election, and configuration management while hiding low‑level complexities.
This article explains how to design a unified API response format in a Spring backend by defining a JSON result structure, using standardized status codes, creating a @ResponseResult annotation, and implementing interceptors and ResponseBodyAdvice to automatically wrap controller outputs for cleaner, more maintainable code.
This article explains how to modify a Java search API and write custom performance‑testing scripts that embed unique request marks, enabling precise measurement of each request's response time when header‑based marking is unavailable.
Explore comprehensive API lifecycle management, covering lightweight gateway design, object‑driven API modeling, automatic interface generation, rule processing, service composition, orchestration, source code export, and microservice packaging, illustrating how to build, test, document, and deploy robust backend services efficiently.
This article explains how to protect front‑end/back‑end separated interfaces by designing an API signature scheme that includes appId, appSecret, timestamp, nonce and signature, detailing the generation process, request validation, anti‑replay measures and implementation using a custom filter in Java.
This article explains how to test GraphQL APIs by illustrating request/response examples, outlining testing approaches, reviewing the official sgqlc Python client, and presenting a self‑developed GraphQL testing framework called graphy with its design and usage details.
Facing the challenge of building an open API platform, the author evaluates several open‑source documentation generators—GitBook, smart‑doc, Redoc, Knife4j, YAPI, apidoc, and ShowDoc—detailing their licenses, language, stars, features, pros, cons, and suitability for real‑time online docs.
The article explains microservices as small, single‑purpose services delivered via APIs, describes how they operate and scale with Kubernetes, provides real‑world examples such as Uber, and outlines how APIs enable communication and deployment across cloud‑native architectures.
This compilation presents Qunar's 2020 technical articles covering domain‑driven design, API standardization, backend services, Linux I/O, Redis distributed locks, GraphQL, JVM internals, and performance optimizations, offering detailed insights and practical guidance for engineers seeking to improve system architecture and operational efficiency.
This article examines four major API architectural styles—RPC, SOAP, REST, and GraphQL—detailing their mechanisms, advantages, disadvantages, and typical use cases, and provides guidance on selecting the most suitable style based on project requirements and constraints.
This article explains why REST APIs have become cumbersome, introduces GraphQL as a more flexible alternative, describes its core concepts such as schema, types and modifiers, and outlines various server‑side and client‑side integration patterns and tooling options.
This article explains how to design a consistent JSON response structure for Spring-based micro‑service APIs, introduces a Result wrapper class, demonstrates annotation‑driven response handling, and shows controller, interceptor, and advice implementations to produce clean, maintainable backend responses.
This tutorial walks you through using Python's requests library and Zabbix Sender to retrieve Kubernetes API metrics, covering API endpoint discovery, token generation, script deployment, host configuration, and manual trigger of checks to visualize the data.
Idempotency ensures that repeated API calls produce the same effect as a single call, preventing duplicate submissions, token misuse, and inconsistent data; this guide explains the concept, its importance, HTTP definitions, impact on systems, and presents four practical implementation methods—unique keys, optimistic locking, token‑based guards, and sequence numbers—with full SpringBoot and Redis code examples.
This article explains how to standardize backend API responses by defining a JSON result structure, categorizing status codes, and using a custom @ResponseResult annotation with Spring's ResponseBodyAdvice to automatically wrap controller outputs, improving readability and error handling for front‑end developers.
This tutorial shows how to install the Python requests library and use it to perform GET and POST HTTP requests, covering required parameters, headers, and example code for handling responses.
This guide shows how to install the Python requests library and use it to perform GET and POST HTTP requests, explaining required parameters, headers, and providing complete code examples for calling remote APIs.
This guide demonstrates how to retrieve a list of WeChat public account articles by constructing the appropriate API URL, examining its query parameters, viewing the JSON response, and using a Python script to parse the data and generate a markdown file of titles and links.
This article introduces the ThinkPHP PHP framework, explains its MVC three‑layer architecture, describes the built‑in single‑letter helper functions, and outlines a step‑by‑step workflow for creating backend APIs using ThinkPHP’s model and controller layers.
This article outlines seven practical rules for designing clear, consistent, and consumer-friendly REST API URIs, covering topics such as avoiding trailing slashes, using hierarchical separators, preferring hyphens over underscores, lower‑case paths, omitting file extensions, and choosing plural resource names.
This article introduces BiliBiliTool, an open‑source utility that automates daily Bilibili actions such as watching, sharing, and coin‑throwing to earn experience, quickly upgrade account levels, and collect rewards, while providing step‑by‑step instructions for setup and execution.
This tutorial shows how to add query parameters to an API request using Python's requests library, retrieve JSON data about ISS passes over a location, extract timestamps, and convert them into readable dates.
This article explains the challenges of returning large result sets in APIs, compares traditional offset‑based pagination with cursor‑based approaches, shows performance differences through SQL examples, and discusses why cursor pagination is more efficient for deep paging and concurrent data modifications.
This article describes Qunar's comprehensive API standardization effort, detailing the evolution of their API tools, the motivations behind adopting DDD and API governance, the theoretical foundations, the QDoc annotation framework, implementation steps, challenges faced, achieved outcomes, and future plans for continuous improvement.
This article introduces GraphQL as a modern API definition model, explains how to design schemas and queries, outlines its key characteristics such as precise field selection, single‑request data retrieval, front‑back end decoupling, and compares its advantages and drawbacks with traditional RESTful interfaces.
This article presents a step‑by‑step tutorial for PHP beginners on building a simple product‑detail API with ThinkPHP 6.x, covering front‑end HTML form, request‑side controller using cURL, and API controller that queries a database and returns JSON data.
This guide shows how to create a Python 3.7 Socket.IO client script for testing socket interfaces, including installation of the python‑socketio package, handling authentication tokens with tools like Postman, and a complete example script with repository links for reference.
This article explores various techniques to achieve API idempotency in high‑concurrency environments, including token mechanisms, deduplication tables, Redis SETNX keys, state‑machine checks, and both optimistic and pessimistic locking, highlighting their workflows, advantages, and trade‑offs.
This article explains how to avoid JavaScript precision loss when returning Snowflake IDs from a Laravel API by converting unsigned bigint IDs to strings using a custom Resource class, discusses a failed accessor attempt, and outlines performance and front‑end considerations.
This tutorial explains how to build an SMS verification feature in a ThinkPHP application by generating codes, storing them, sending them via Yunpian's API, and validating user input, including required API parameters and controller method implementations.
This article demonstrates how to replace repetitive Java backend code for constructing fixed‑length API request strings by defining POJOs, custom annotations, and a reflection‑based utility that formats parameters, pads strings, handles numeric and monetary fields, and appends an MD5 signature, thereby improving maintainability and reducing bugs.
The article presents a systematic, automated platform that captures, replays, and compares API requests using intelligent sampling and vertical/horizontal privilege checks to detect authorization flaws, dramatically reducing manual testing effort, uncovering over twenty issues monthly, and outlining future CI integration and AI‑enhanced detection.
This tutorial explains how to use WeChat's template message API together with the iciba daily‑sentence service, set up a Python script on an Alibaba Cloud Linux server, configure the template in the public platform, and schedule automatic delivery via a daily cron job.
This article walks you through creating a Python‑based voice synthesis tool using Baidu's AI platform, covering account setup, SDK installation, essential parameters, GUI design with Tkinter, code implementation, error handling, and generating audio files from custom text.
This article outlines essential RESTful API design principles, covering URL structuring, proper use of HTTP verbs, precise status codes, JSON payload conventions, error handling, and HATEOAS linking, providing practical code examples for backend developers to create clear and maintainable web services.
This article explains the difference between APIs and Java SPI, describes how SPI enables plug‑in development through ServiceLoader, and illustrates its practical use with JDBC driver loading and Flink table factories, providing code snippets and implementation steps for backend developers.
This article offers a concise, scenario‑driven introduction to GraphQL, explaining what it is, how it differs from REST, its data‑graph approach, and illustrating usage with sample schema and queries, helping developers quickly grasp its core concepts without diving into detailed implementation.
This article provides a comprehensive guide to Java 8 Stream API, covering its core characteristics, creation methods, essential interfaces, and common operations such as filtering, mapping, reducing, collecting, grouping, and sorting, with clear code examples for each concept.
This guide walks you through installing Nacos via source compilation or Docker, starting it in standalone mode, and using its core OpenAPI endpoints to register, heartbeat, query, and deregister service instances, complete with code snippets and visual screenshots.
This guide explains RESTful concepts, compares Casbin keyMatch functions, demonstrates Postman testing of CRUD endpoints, and shows how to integrate authentication middleware in ThinkPHP5.1, providing complete code snippets and configuration details for secure API development.
This article introduces Java 8's new date‑time API, explains why it replaces the mutable java.util.Date and non‑thread‑safe SimpleDateFormat, and provides a series of clear code examples demonstrating how to obtain current dates, manipulate specific dates, compare dates, handle time zones, work with periods, and format dates using the modern java.time classes.
This guide walks you through using the Python httpx library to perform various HTTP methods—including GET, POST, PUT, DELETE, HEAD, and OPTIONS—handle query parameters, decode responses, work with JSON, custom headers, form data, file uploads, streaming, cookies, redirects, and authentication, all with clear code examples.
This article explains the concept of API idempotency, presents common solutions such as unique indexes, token mechanisms, and distributed locks, and provides a complete Spring Boot implementation using Redis to generate, store, and validate tokens via custom annotations, interceptors, and service classes, including testing and performance verification.
The 2020 China API Ecosystem and Developer Survey Report, jointly released by Huawei Cloud, InfoQ Research Institute and partners, analyzes API adoption, developer demographics, tooling preferences, lifecycle management practices, and future trends, offering actionable insights for enterprises shaping their API strategies.
This article explains the concept of open platforms, the evolution of OAuth 2.0, its core token‑based authorization mechanism, real‑world analogies, and the step‑by‑step Authorization Code grant flow that lets third‑party apps securely access protected resources.
The article examines the emergence of open banking as a platform‑based model reshaping the banking industry, outlines its rapid global adoption and China’s fast‑track development, and discusses security, connectivity, and business continuity challenges while highlighting the driving role of cloud, big data, AI, and blockchain technologies.
This tutorial walks you through setting up a Python environment, installing required dependencies, and using AssemblyAI’s high‑accuracy speech‑to‑text Web API to upload audio files, start transcription, and retrieve the transcribed text, including tips for handling API keys and checking transcription status.
This article explains the concept of API idempotency, reviews common solutions, and provides a complete Spring Boot implementation using a Redis‑based token mechanism, custom @ApiIdempotent annotation, interceptor, and supporting services, along with testing and important concurrency considerations.
This article explains how webhooks differ from traditional APIs, using GitHub as an example to illustrate automatic data delivery versus manual request retrieval, and discusses the advantages, automation benefits, and compatibility drawbacks of webhooks in backend integration.
This article explains Java's thread lifecycle, detailing its six states—New, Runnable, Blocked, Waiting, Timed_waiting, and Terminated—and describes eleven commonly used thread APIs such as join(), wait(), notify(), yield(), sleep(), currentThread(), getName(), getId(), getPriority(), setPriority() and stop().
This article walks through the design, parameterization, and Java implementation of load‑testing scripts for two related APIs—one that creates a resource and another that deletes it—covering special handling of duplicate IDs, method encapsulation with default arguments, concurrent execution, and visual result analysis.
This guide walks through building a Java SMS verification service, covering code generation, API integration, session handling, and a reusable HTTP utility with full source examples, including Maven dependency setup, configuration file preparation, and step‑by‑step execution.
This tutorial shows how to use Python's urllib and json libraries to call the Kuaidi100 API, retrieve real‑time logistics data for various Chinese courier companies, and display the tracking timeline, while explaining how to discover the correct request URL via browser dev tools.
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 introduces a Spring Boot API project seed that combines MyBatis, a generic Mapper plugin, and PageHelper, offering ready‑made project structure, unified response handling, exception processing, code generation utilities, signature authentication, and integration guides to accelerate backend development.
This article analyzes how Kubernetes’ API‑first design, inspired by cloud‑computing principles of programmable and declarative infrastructure, creates a universal control plane that transcends container orchestration and reshapes software management across clouds.
A new developer refactored a Play‑based API to Spring Boot, encountered severe throughput loss due to implicit suffix path matching, profiled the bottleneck with jvisualvm and wrk, and restored performance by declaring request‑mapping suffixes explicitly, boosting QPS from under 1k to over 9k.
This tutorial explains how to configure a certified WeChat public account, construct the OAuth authorization URL, exchange the returned code for an access token, retrieve the user's basic profile—including nickname—and redirect back to the H5 page, while covering required parameters and token refresh details.
This article details the development of a multi‑platform mini‑program using the Taro framework, covering project background, architecture, technology selection, TypeScript practices, MobX state management, API service encapsulation, image scaling, and canvas‑based poster sharing, with code examples and implementation insights.
This article provides a thorough tutorial on Spring Validation, covering basic usage with requestBody and requestParam, dependency setup, group, nested, collection and custom validations, programmatic validation, fail‑fast mode, differences between @Valid and @Validated, as well as the underlying implementation mechanisms in Spring MVC and method‑level AOP validation.
Faced with tens of thousands of dirty records and no bulk‑delete API, the author iteratively optimized a deletion script—starting with simple serial requests, then adding asynchronous HTTP calls, and finally employing multithreading—to achieve rapid, reliable removal of hundreds of entries per second.
The article describes how a news‑list page became sluggish due to large base64‑encoded images stored in the database, details the investigation using Chrome dev tools and SQL queries, and presents a step‑by‑step solution that moves images to a FastDFS file server and updates the content references.
This article explains how to achieve API idempotency in a Spring Boot application by generating unique tokens, storing them in Redis, and using a custom @ApiIdempotent annotation with an interceptor to prevent duplicate requests, including code examples, configuration, and testing procedures.
This tutorial introduces Python's Requests library, covering installation, basic GET and POST requests, adding headers and parameters, handling proxies, cookies, sessions, and disabling SSL verification, with clear code examples for each feature.
This article explains the limitations of traditional REST APIs, introduces GraphQL as a more flexible alternative, compares their advantages, and provides a detailed guide on GraphQL concepts, schema design, server‑client architecture, supported operations, and popular tools for implementation.
This article clarifies that APIs are not limited to REST, outlines the broader API toolbox—including streaming, gRPC, and event‑driven architectures—and advises developers to choose the most suitable API style for their projects.
This tutorial explains how to use Baidu AI's Portrait Anime API with Python, covering token acquisition, API key setup, request formation, and code examples for generating both plain anime portraits and masked versions, complete with sample images and usage limits.
The article presents a Digital Transformation Framework (DTF) that helps asset‑management firms model, evaluate, and implement disruptive digital strategies across front, middle, and back‑office functions, emphasizing composable enterprises, cultural change, BPaaS, API‑driven architectures, and value‑based prioritization to achieve sustainable competitive advantage.
After an intern’s suggestion to replace a VM with Huawei’s Elastic Cloud Server, the author shares a concise three‑step guide—complete with API request examples and response parsing—to efficiently query server details, limits, and pagination, illustrating practical cloud‑computing techniques.
This article compiles a comprehensive collection of free, unlimited-use API interfaces covering diverse data services such as phone number lookup, weather forecasts, stock information, jokes, and many others, providing direct URLs for each service to help developers quickly integrate external data sources into their applications.
This tutorial introduces Python’s Requests library, covering installation, core methods like GET, POST, PUT, PATCH, DELETE, detailed parameters, session handling, exception management, header customization, proxy usage, and practical code examples to empower effective web scraping.
The article outlines Alibaba‑inspired design principles and concrete specifications for service error codes—defining a 13‑character, domain‑structured format for log‑oriented codes and a concise 5‑character scheme for external APIs—emphasizing quick source tracing, memorability, standard communication, and practical guidelines such as avoiding enums.
This article explains the MySQL Memcached API, its evolution from MySQL 5.6 to 8.0, demonstrates how to install the plugin, configure tables, and perform batch and range key retrievals with code examples, highlighting suitable use cases and performance benefits.
This guide demonstrates how to create a Laravel 5.4 API project, covering Composer project creation, database and users table setup, model and controller generation, route definition, and API testing, with complete code examples for each step.
This article shares a developer's journey from using local virtual machines to mastering Huawei Cloud's elastic server deployment, providing a detailed step‑by‑step guide—including API calls, request/response examples, and code snippets—for creating, configuring, and verifying cloud servers via the Huawei Cloud API.
Google’s fingerprint API, introduced in Android 6.0, can be integrated via the legacy FingerprintManager or the newer BiometricPrompt, using a wrapper that abstracts version differences, handling permissions, hardware checks, authentication callbacks, and optional reflection to retrieve fingerprint IDs and enrolled fingerprint lists for advanced login scenarios.
This guide outlines why manual testing can’t fully replace automation, then walks you through seven concrete steps—including data preparation, API testing, and web UI automation using tools like MySQL, Redis, SOAP UI, Postman, and Selenium with Java or Python—to become a proficient automation test engineer.
This guide explains how to integrate WeChat OAuth2.0 login into Android and iOS mobile applications, covering preparation, authorization flow, API calls for access tokens and user info, phone‑number binding, re‑login handling, and test case recommendations.
This tutorial walks through a complete Golang implementation of a food‑recommendation API using Domain‑Driven Design (DDD), covering the four DDD layers, entity and repository definitions, persistence setup with Gorm, application services, HTTP interfaces, middleware, and how to run the service.
This article describes how to discover Bilibili's comment XML APIs, decode the embedded CRC32‑hashed user IDs, choose an appropriate database schema, and implement a Python‑PHP tool that retrieves, filters, and displays comments based on video CID and keyword.
This article walks through a complete Go implementation of a food recommendation API using Domain-Driven Design, covering project setup, layer separation, entity and repository definitions, infrastructure configuration, application services, HTTP interfaces, authentication, and how to run the application.
This tutorial shows how to register an Alibaba Cloud account, configure access keys, meet PHP requirements, install Laravel 5.6 via Composer, add the mrgoon/aliyun‑sms package, set up configuration files, write an API route and controller to send verification codes, cache them, and test the endpoint with Postman.
This article explains what GraphQL is, why it was created, how it differs from RESTful APIs, and the advantages of its schema‑driven, flexible data fetching model for modern mobile and web applications.
Laravel 7 builds on the 6.x release with a host of backend enhancements such as Laravel Sanctum (Airlock), faster route matching, custom Eloquent casts, Blade component tags, improved string helpers, a native HTTP client, CORS support, route‑model binding upgrades, queue and mail driver improvements, plus new artisan commands and various bug fixes.
This guide walks through installing the tymon/jwt-auth package, configuring Laravel, creating middleware for CORS and JWT verification, defining API routes, building an authentication controller, and testing the registration and login endpoints using tools like Postman or AJAX.
After months of trial and error, I share my step‑by‑step journey of creating a Python web scraper that collects Zhihu and Weibo hot‑list data, exposing it via a Django REST API, and integrating the results into a functional WeChat mini‑program, while outlining the challenges and future improvements.
This article introduces a Python-based WeRead assistant that uses xlrd/xlwt for Excel handling, PyQt for a GUI, and WeChat Read APIs to fetch bookshelf data and export notes, providing step‑by‑step code explanations and usage instructions for developers.
This article explains how to generate and customize Laravel resource and resource collection classes, use them to convert Eloquent models and collections into JSON, handle pagination, conditional attributes, relationships, and add metadata to API responses.
This article demonstrates how to create a custom Python SDK for Pinduoduo's order-related APIs, covering request signing, parameter assembly, URL encoding, and example calls to retrieve order lists, details, status, and incremental updates, complete with sample code and usage screenshots.
This article explains the REST architectural style, its fundamental concepts, the most important HTTP methods, response‑code categories, the Richardson maturity model, description languages, popular server frameworks and client tools, while providing concrete examples and RFC references for building robust web APIs.
This article compiles a comprehensive list of resources—including tools, scripts, and tutorials—for conducting interface performance testing on Linux and other platforms, covering topics such as netdata localization, timewatch utility, load testing strategies, JVM heap dumps, and visualizing test data.
This article demystifies cloud‑native infrastructure by clarifying common misconceptions, defining its core principles—API‑controlled, software‑managed resources aimed at running applications with minimal human intervention—and outlining its benefits, implementation steps, and the mindset shift required for modern operations.
This article guides Java developers on creating a comprehensive interface testing project using the FunRequest framework, covering reusable utilities, request/response handling, and detailed code examples for HTTP GET and POST operations, while also providing links to related tutorial videos.
This article introduces FastAPI, a modern high‑performance Python web framework, walks through installation, basic routing, async handling, query and path parameters, data modeling with Pydantic, template rendering with Jinja2, and compares its speed to Flask, providing complete code examples and screenshots.
This article provides a comprehensive guide to Java's reflection mechanism, covering its definition, core capabilities, practical code examples, common API usage, and considerations such as performance and security, enabling developers to understand and apply reflection effectively in real-world projects.
