Understanding the three HTTP timeout types—connect, write, and read—helps engineers pinpoint failures, while detailed examples of causes and observable symptoms guide troubleshooting, and step-by-step Chaos Mesh simulations demonstrate how to inject and monitor these faults to validate system resilience.
This article explains common HTTP status codes, demonstrates step‑by‑step API testing using Postman—including basic requests, exception handling, token management, test assertions, and collection runs—shows how to import Postman collections into Eolinker, compares the two tools, and adds practical tips and code examples.
This comprehensive guide explains domain name concepts, structures, and registration, introduces web page fundamentals and HTML basics—including tags, syntax, and HTML5 features—then covers HTTP protocol essentials, request/response formats, version evolution, and HTTPS security, providing a solid foundation for modern web development.
This guide explains how to configure custom HTTP request headers in Locust for GET, POST, and shared header scenarios, providing code examples, best practices for security, dynamic updates, and error handling to ensure effective load testing of APIs.
The article examines the new Streamable HTTP transport layer introduced in the Model Context Protocol (MCP), comparing it with the traditional HTTP+SSE approach and demonstrating its superior stability, performance, and client simplicity through architectural analysis, session management details, and extensive benchmark results.
This article explains how to use PHP's get_headers() function to fetch HTTP response headers from a URL, describes its syntax and parameters, provides code examples for retrieving and printing headers, and outlines common use cases such as file information, existence checks, and web crawling.
This article explains how to extend an open‑source smart production management system with MCP support by creating SSE/HTTP endpoints, a token‑based MAP, and a McpService that scans, executes, and pushes results, and demonstrates client configuration using CherryStudio.
This article provides a comprehensive overview of the HTTP protocol, covering its fundamental concepts, the complete request lifecycle—including DNS resolution, TCP handshake, request headers, methods, cookies, and tokens—and detailed server response structures with practical Spring Boot examples.
This article introduces the fundamentals of the HTTP protocol, explains its request and response structures, and provides a comprehensive guide to using Python's requests library for sending GET, POST, PUT, DELETE requests, handling headers, parameters, JSON responses, timeouts, and exceptions.
This article explains the fundamental differences between HTTP and HTTPS, how internet messages travel through DNS and routers, the roles of IP and MAC addresses, port conventions, request/response structures, encryption methods, digital certificates, and compares cookies with server‑side sessions for state management.
This article explains how TCP connection setup, slow‑start, delayed acknowledgments, the Nagle algorithm, TIME_WAIT and file‑descriptor limits affect HTTP performance, and shows how to tune Nginx and Linux keep‑alive settings to achieve faster, more reliable web traffic.
This article narrates the messy history of API design, illustrating early AJAX conventions, the misuse of HTTP status codes, the challenges of maintaining Restful standards, ad‑hoc extensions, and the eventual abandonment of Restful in favor of a simplified POST‑centric approach, while highlighting practical lessons for backend developers.
This article explains the fundamentals of HTTP and HTTPS, detailing how web requests travel across the internet, the roles of IP and MAC addresses, port numbers, request and response structures, encryption methods, digital certificates, and the differences between cookies and sessions.
The article reviews Alova.JS, a lightweight, declarative HTTP request library, comparing its features, size, performance, and ecosystem against the widely used Axios, and provides step‑by‑step guidance on installation, configuration, and usage in modern frontend projects.
This article explains the fundamental differences between HTTP and HTTPS, how internet messages travel through DNS and routers, the roles of ports, request and response structures, encryption methods, digital certificates, and compares cookies with sessions for state management.
This article walks through the complete lifecycle of an HTTP API call initiated with Postman, covering DNS resolution, TCP/IP connection, Nginx reverse proxy and load balancing, Spring Boot request handling, service layer processing, JSON serialization, and the final response delivery back to Postman.
This article introduces the fundamentals of RESTful APIs and demonstrates how to install the Python requests library, send GET, POST, PUT, and DELETE requests, set custom headers, handle responses, manage sessions, and apply best‑practice tips for reliable API testing.
This guide explains why request headers are needed, shows how to set them using Python's requests library—including basic headers and authentication tokens—and demonstrates how to view both request and response headers along with common header usage tips.
This tutorial explains the Python requests library, covering its core modules, HTTP methods (GET, POST, PUT, DELETE), key parameters, session management, and exception handling with practical code examples for API interaction and best practices.
This article explains how Spring's ResponseBodyEmitter, introduced in Spring 4.2, enables lightweight asynchronous HTTP streaming for use cases like real-time logs, progress updates, chat, and AI responses, and provides a complete code example with best-practice guidelines.
This article explains the purpose and usage of PHP's curl_multi_getcontent() function, demonstrates how to combine it with curl_multi_init() and curl_multi_exec() for concurrent requests, and provides a complete example showing initialization, execution, content retrieval, and cleanup of multiple cURL handles.
This article explains the core components of HTTP requests and responses in API testing, including request headers, request body formats, and response status codes with practical examples.
This article explains the purpose, common fields, and examples of HTTP request headers, request bodies, and response status codes, and shows how to parse and validate them in automated API testing to ensure correct and stable interfaces.
This article explains the fundamental components of an HTTP request—including URL, methods, headers, and body—details the request‑response workflow with TCP connections, outlines common request methods and their characteristics, and categorizes response status codes for effective web development and testing.
An extensive Spring Boot 3 case collection featuring over 100 practical examples is now available, accompanied by a detailed tutorial that demonstrates how RestTemplateAdapter and RestClientAdapter simplify HTTP request handling, improve code readability, and ensure seamless integration with third‑party APIs, with a commitment to permanent updates.
This article introduces Spring Framework's ResponseBodyEmitter, explains its advantages over SSE for asynchronous HTTP responses, demonstrates practical usage with a real‑time log‑streaming example, outlines core methods, working principles, best‑practice considerations, and compares it with traditional Streaming and Server‑Sent Events.
The article provides a comprehensive technical overview of HTTP's history, the design and advantages of the QUIC protocol—including connection establishment, migration, head‑of‑line blocking mitigation, congestion control, ACK handling, and stream/connection flow control—while contrasting it with TCP and HTTP/2 mechanisms.
This article introduces native Node.js HTTP server creation, explains request and response concepts, and then demonstrates how to use the Koa framework—including installation, middleware, routing, body parsing, and the onion model—to build clean, maintainable backend services.
This article provides a collection of practical Python snippets demonstrating how to send GET and POST requests, validate status codes, response bodies, JSON schemas, handle headers, query parameters, file uploads, redirects, timeouts, sessions, authentication, rate limiting, and parameterized testing using the requests library and pytest framework.
This guide explains how to use Locust to add query parameters to GET requests and send JSON or form‑encoded data in POST requests, including combined examples with custom headers for comprehensive HTTP request configuration.
This article introduces UniHttp, a declarative Java HTTP client framework that simplifies third‑party API integration by using annotations to generate request metadata, supports various parameter types, lifecycle hooks, custom processors, and provides practical enterprise‑level examples with full code snippets.
This guide explains how to integrate multiple custom clients in Locust, covering the definition of client classes for HTTP and WebSocket, their use within a user class, configuration of run parameters, and important considerations such as resource management and exception handling.
This article explains the PHP get_headers() function, its syntax and parameters, provides code examples for fetching and printing HTTP response headers, and discusses common use cases such as checking remote file existence, obtaining file metadata, and supporting web crawlers.
This article explores practical HTTP retry solutions for offline store applications, covering a basic loop retry, the built‑in retry mechanism of Apache HttpClient with custom handlers, and an asynchronous retry approach using message queues to achieve higher reliability and eventual consistency.
This article explains how the PHP curl_multi_getcontent() function retrieves the response of each cURL handle created with curl_multi_init() and executed via curl_multi_exec(), provides a complete example with code, and highlights important usage considerations for concurrent API requests.
This article explains the complete network communication process for HTTP, covering the OSI and TCP/IP models, DNS lookup, protocol stack handling, TCP handshakes, IP routing, MAC addressing, switches, routers, Ethernet transmission, and server-side packet de‑encapsulation.
This guide explains the fundamentals of CORS, walks through typical misconfigurations such as HeaderDisallowedByPreflightResponse, Nginx header ordering, and Origin‑Credentials conflicts, and provides complete Nginx examples to reliably enable cross‑origin requests.
This article explains the PHP curl_init() function, covering its syntax, optional URL parameter, return values, and provides a complete example demonstrating initialization, option setting, execution, error handling, and response processing for HTTP API requests.
This tutorial walks you through installing the Python requests library, using GET, POST, and PUT methods, handling query parameters, setting custom headers to bypass anti‑scraping measures, and saving both HTML content and images to local files, complete with runnable code examples.
This article provides a detailed tutorial on cURL, covering its basic usage, key options for HTTP and HTTPS requests, file upload and download techniques, and common troubleshooting tips to help developers efficiently interact with web services from the command line.
This article explains why traditional HTTP cannot let servers initiate messages, compares periodic HTTP polling and long polling as workarounds, and introduces the full‑duplex WebSocket protocol—including its handshake, frame format, and typical use cases such as web games and real‑time chat.
A high‑concurrency data collection service quickly saturated a 100 Mbps uplink because each GET request incurred a 1.27 KB TLS handshake, prompting a switch to plain HTTP and keep‑alive to cut bandwidth usage by 70% and lower server load.
This article explains how TCP, the reliable transport‑layer protocol, differs from HTTP, the application‑layer web protocol in terms of purpose, connection handling, and data formatting, helping readers understand why TCP underpins HTTP while each serves distinct roles on the Internet.
This article provides a comprehensive overview of common HTTP request and response headers, explaining their purposes, typical usage, and example syntax, helping developers prepare for interviews and deepen their understanding of web communication fundamentals.
A high‑concurrency service quickly maxed out a 100 Mbps uplink because each HTTPS GET request incurred a 1.68 KB payload dominated by a 1.27 KB TLS handshake, prompting a switch to plain HTTP or keep‑alive to dramatically cut bandwidth and CPU usage.
The article explains the newly proposed HTTP QUERY method, detailing its definition, idempotent and safe characteristics, usage scenarios for large payloads, caching behavior, the Accept-Query response header, and provides multiple concrete request‑response examples with code snippets.
UniHttp is a declarative HTTP interface integration framework that simplifies third‑party API calls in Java projects by generating proxy beans, supporting rich annotations for request parameters, lifecycle hooks, custom processors, and seamless Spring integration, thereby improving code cohesion and maintainability.
This article explains the fundamental differences between HTTP and HTTPS, covering security vulnerabilities, authentication mechanisms, encryption methods, default ports, and performance impacts, helping developers understand why HTTPS is essential for protecting sensitive data on the web.
Alova.JS is a lightweight HTTP request library that supports multiple adapters, cross‑framework usage, and TypeScript, offering a smaller bundle size (≈30% of axios), a concise API, and high‑performance request strategies, making it a compelling replacement for axios in modern web projects.
After discovering that a simple GET request consumes 1.68 KB due to the TLS handshake, the article explains the handshake’s components, calculates the resulting bandwidth demand, and demonstrates how switching to HTTP or enabling Keep‑Alive can dramatically reduce traffic and server load in high‑concurrency scenarios.
This article examines the shortcomings of Volcengine's Python TTS SDK, proposes a cleaner design using request interceptors or Auth objects, demonstrates refactored code examples with the Tetos library, and explains how to integrate signing logic into standard HTTP clients for more maintainable backend development.
Spring WebClient, the reactive replacement for the deprecated RestTemplate in Spring 5+, offers non‑blocking I/O, functional style, streaming support, and improved error handling; this article explains its benefits, demonstrates synchronous and asynchronous request patterns, timeout configuration, and comprehensive error processing with code examples.
This article explains why RestTemplate is deprecated in Spring Framework 5+, outlines the advantages of the reactive WebClient such as non‑blocking I/O, functional style, streaming and improved error handling, and provides complete Java code examples for creating, configuring, and using WebClient synchronously and asynchronously, including timeout and error management.
A high‑concurrency data‑collection service quickly filled a 100 Mbps uplink because each GET request incurred a 1.68 KB TLS handshake, consuming over 260 Mbps, but switching to plain HTTP or using keep‑alive can dramatically cut bandwidth and server load.
This article reviews the evolution of HTTP from its early versions to HTTP/3, explains the QUIC protocol and its advantages over TCP, and discusses connection establishment, migration, head‑of‑line blocking, congestion control, and flow control mechanisms that improve modern web performance.
This article explains the PHP get_headers() function, its syntax, parameters, and usage examples, demonstrates how to retrieve and display HTTP response headers from a URL, and discusses common application scenarios such as checking remote file existence, obtaining file metadata, and supporting web crawling or monitoring.
This article explains the fundamentals of the browser same‑origin policy, details how CORS and preflight requests work, and discusses related security considerations, while also promoting a ChatGPT community and related services for developers.
This article introduces UniHttp, a declarative Java HTTP client framework that lets developers define third‑party HTTP APIs as annotated interfaces, provides quick‑start instructions, detailed annotation usage, lifecycle hooks, custom client configuration, and an enterprise integration example with full code snippets.
The article explains why network protocols use layered design, details TCP's reliability and congestion‑control mechanisms, outlines HTTP status‑code categories, reviews MySQL lock scopes from global to row‑level, provides a C++ breadth‑first binary‑tree traversal example, and describes a three‑step weighing puzzle to find an odd ball.
The article explains how to use PHP’s curl_multi_select() function to wait for active cURL transfers in a multi‑handle scenario, detailing its definition, parameters, behavior, and providing a complete example that demonstrates efficient concurrent HTTP requests handling.
This article demonstrates how to use Python's asyncio library together with the aiohttp package to perform asynchronous HTTP requests, covering installation, concurrent request execution, GET and POST examples, error handling, timeouts, SSL verification, and proxy usage, with complete code snippets.
Cloudflare replaced NGINX with its self‑developed Rust proxy Pingora, detailing why the legacy architecture fell short, the design decisions behind building a new internal proxy, and how Pingora delivers significantly higher performance, efficiency, and security for trillions of daily requests.
This article continues the open‑source design series by detailing the remaining design points of the Lantu Pay SDK, including the end‑to‑end request chain, the Post method with retry support, the use of strategy and template method patterns, and a custom @Require annotation for mandatory parameter validation.
This article examines the design goals, typical use cases, and performance differences between the browser‑oriented fetch API and the high‑throughput Undici library for Node.js, including a simple benchmark that shows Undici completing the same workload roughly twice as fast as fetch.
The article explains the HTTP QUERY method, a safe and idempotent request type that carries payloads in the request body, addressing GET's URL length limits and POST's lack of idempotency, and provides detailed usage examples and header specifications.
This article explains the two ways to call Axios—using a configuration object or shortcut methods—then walks through building a minimal Axios clone, detailing its constructor, prototype methods, and the clever instance creation that lets the library behave both as a function and an object.
This article explains the fundamental differences between long-lived and short-lived network connections, covering their operation processes, resource consumption, typical use cases, and impact on stability and fault tolerance, helping developers choose the right approach for their applications.
This article explains the fundamentals of the same‑origin policy, the security risks it mitigates, and how CORS and preflight requests work in browsers, illustrating the concepts with diagrams, header details, and a complete request flow chart.
This article explains how the PHP curl_multi_getcontent() function retrieves the response content of each handle in a multi‑cURL session, demonstrates its usage with a complete example, and highlights important considerations for concurrent API requests.
This tutorial demonstrates how to build a reusable Python HTTP client by defining a base HttpRequest class with standard methods, extending it with a RestApiRequest subclass that adds authentication handling, and provides a complete code example showing GET and POST requests.
This article explains the purpose and syntax of the PHP curl_close() function, demonstrates how to use it with curl_init() and curl_setopt() in a complete example, and highlights the resource, performance, and memory benefits of closing cURL sessions promptly.
This article walks through the design and implementation of a Spring Boot Starter for the Lantu Pay SDK that supports personal sign‑up, covering project structure, configuration classes, HTTP layer abstraction using strategy and template patterns, and request/response model design with concrete code examples.
This article explains why Spring Cloud uses HTTP instead of RPC for remote calls, compares HTTP and RPC protocols, describes how to implement a simple HTTP server in Java, outlines the principles of RESTful architecture, and discusses the advantages, disadvantages, and future trends of both approaches.
The article introduces the open‑source Java utility library Hutool, compares it with Guava, lists its modules, shows how to install it via Maven, and provides concrete code examples for HTTP requests, random codes, date handling, string manipulation, number operations, map utilities, encryption, captcha generation, and data desensitization, demonstrating how it can reduce boiler‑plate and speed up development.
This article traces the evolution of HTTP from its 1991 origins through HTTP/2 and HTTP/3, explains how QUIC leverages UDP to reduce latency, and details QUIC's connection establishment, migration, head‑of‑line blocking mitigation, congestion control, and flow‑control mechanisms.
This article provides a comprehensive guide to using Spring Boot’s @RequestMapping annotation, covering path definitions, HTTP methods, headers, produces/consumes, path variables, parameters, fallback handling, and advanced options, with practical curl commands and code snippets for each scenario.
This article explains why Spring Cloud prefers HTTP over RPC for remote calls, covering the embedded Tomcat architecture, JSON data exchange, the fundamentals of RPC over TCP, and compares their advantages, disadvantages, and suitability for microservice development.
The Cool Request plugin for IntelliJ IDEA now adds a Trace feature that automatically measures method execution time, visualizes call counts, highlights slow calls, supports Mybatis tracing, and lets you script environment variables, making HTTP debugging and performance analysis in Java projects far easier.
This article explains the fundamentals of the HTTP protocol, illustrates its vulnerability to man‑in‑the‑middle attacks, demonstrates why plain HTTP is insecure, and shows how HTTPS, TLS/SSL, asymmetric encryption, and certificate authorities together protect communications from interception and tampering.
The article compares Spring Cloud’s HTTP‑based, Tomcat‑served JSON services with TCP‑based RPC, highlighting HTTP’s cross‑platform flexibility and ease of use versus RPC’s faster, binary‑serialized calls that mimic local methods, and advises choosing HTTP for microservice, loosely‑coupled architectures despite RPC’s speed advantage.
The article explains how TLS handshakes significantly increase request size and upstream bandwidth consumption in high‑concurrency services, demonstrates the bandwidth calculations, and proposes using plain HTTP or Keep‑Alive connections to reduce overhead and server load.
This article explains why Spring Cloud prefers HTTP over RPC for remote calls, detailing the underlying Tomcat-based web service, the differences between HTTP and RPC protocols, their advantages and disadvantages, and provides guidance on choosing the appropriate approach for microservice architectures.
This article explains the fundamentals of the Same-Origin Policy, its security implications for DOM, data, and network access, and provides a detailed walkthrough of CORS, including simple requests, preflight requests, and handling of credentials to protect web applications.
Learn step-by-step how to activate gzip compression in Nginx, configure compression level, buffer size, minimum file size, and proxy settings, and understand the impact of each directive on bandwidth reduction and page load speed for both static and dynamic content.
The article shares a graduate's interview experience and provides a comprehensive technical guide covering HTTP/1.x vs HTTP/2 differences, Java socket and HTTP server code, OS I/O buffering vs direct I/O, database concurrency control, Bloom filter principles, Java reflection, annotation usage, and synchronized locking semantics.
This article traces the evolution of HTTP from its 1991 inception through HTTP/1.1, HTTP/2, and HTTP/3, explains the QUIC protocol’s design and advantages, and details connection establishment, congestion control, flow control, and head‑of‑line blocking mitigation techniques used in modern web transport.
This article explains in detail how an HTTP request moves from a user’s device through Wi‑Fi, routers, modems, ISP NAT devices, and finally reaches the application server, illustrating each OSI layer and the transformations that occur along the way.
This article traces the evolution from HTTP/1.1 to HTTP/3, explains how QUIC built on UDP to reduce connection latency, avoid head‑of‑line blocking, support seamless connection migration, and introduce advanced congestion and flow‑control mechanisms that give HTTP/3 a performance edge over its predecessors.
This article explains the complete browser navigation flow from URL entry to page rendering and provides practical optimization strategies for DNS resolution, HTTP protocols, CDN usage, and front‑end resources such as HTML, CSS, JavaScript, images, and fonts to improve performance and user experience.
This article explains the complete browser navigation process—from URL entry, DNS resolution, TCP and HTTP communication, to resource loading and page rendering—and presents practical optimization techniques such as DNS prefetch, HTTP/2, CDN usage, and HTML, CSS, JavaScript, and image improvements to boost frontend performance.
This article explains the PHP header() function, its syntax, parameters, and common use cases such as page redirection, setting HTTP response headers, status codes, preventing caching, and enabling file downloads, with clear code examples for each scenario.
Learn how to use Go's net package for low‑level socket programming—including TCP, UDP, and ICMP connections with the Dial function—and build HTTP clients with net/http, covering basic requests, POST forms, custom headers, and practical code examples.
This article explains the origins of REST, why modern developers must follow RESTful conventions, and provides a step‑by‑step guide—including domain naming, versioning, endpoint design, HTTP verbs, filtering, status codes, error handling, hypermedia links, and data formats—illustrated with concrete code snippets.
This article explains the fundamentals of the HTTP protocol, demonstrates how man‑in‑the‑middle attacks exploit its plaintext nature, discusses symmetric and asymmetric encryption attempts to mitigate these risks, and describes how HTTPS (TLS) and the CA trust model provide robust protection against such attacks.
A RESTful API is an HTTP‑based design that treats each resource as a URI, uses standard verbs (GET, POST, PUT, PATCH, DELETE) for CRUD operations, returns appropriate status codes, supports content negotiation, versioned secure endpoints, clear noun‑based naming, pagination, filtering, HATEOAS links, and avoids embedding actions or verbs in URLs.
This article examines the need for reliable HTTP retries in offline store applications, evaluates simple loop retries, explores Apache HttpClient's built‑in retry mechanism, and proposes a hybrid solution that combines customized HttpClient retry handling with asynchronous message‑queue retries to achieve high availability and eventual consistency.
This guide explains why random User-Agent headers improve API automation testing, introduces the Python fake_useragent library, shows how to install it, and provides comprehensive example code for generating, validating, and persisting random User-Agent strings.
This article explains the PHP curl_init() function, covering its syntax, optional URL parameter, return values, and provides a complete example that demonstrates initializing a cURL session, setting options, executing a request, handling errors, and processing JSON responses.