HTTP Cache‑Control defines how browsers, proxies, and origin servers coordinate caching through directives like public, private, max‑age, no‑store, and revalidation, enabling developers to control freshness, reduce server load, save bandwidth, and improve user experience while avoiding stale‑content issues.
Node.js v17.5 introduces experimental support for the familiar fetch API—originally a browser‑side HTTP client—by leveraging the Undici library, allowing developers to use a lightweight, standards‑compliant request method without external modules, though it still requires the --experimental-fetch flag to activate.
This article explains the concept of middleware, demonstrates how to implement it in Go using the net/http Handler interface and the Negroni library, and provides complete code examples for logging and authentication middleware chains.
cURL author Daniel Stenberg announced plans to add native JSON handling, explaining its importance for REST APIs, the common pain points developers face, and introducing two new command‑line options that simplify sending JSON payloads and headers.
This article explains why the default JSON request format fails for file uploads, introduces the FormData API, demonstrates how to construct and manipulate FormData objects—including append versus set methods—and provides practical code examples for sending multipart/form-data requests in modern frontend development.
This article presents a concise Nginx cheat sheet covering common configuration blocks such as listening ports, access logs, server names, static file serving, redirects, reverse proxy, load balancing, and SSL settings, providing ready-to-use code snippets to help developers quickly set up and optimize their web servers.
This comprehensive guide explains the origins and definitions of REST and RESTful, outlines core architectural constraints, compares terminology, presents best‑practice API design patterns—including URI conventions, HTTP methods, error handling, filtering, pagination, versioning, and health checks—while evaluating the future role of REST versus GraphQL.
This article demonstrates how to use a Python script to perform a brute‑force attack against the DVWA login page by sending HTTP GET requests with custom headers and payloads, iterating over username and password dictionaries, recording response status, content length, and saving results to CSV or TXT files.
This article explains how WKWebView leverages various WebKit cache types—including disk, memory, and page caches—detailing their structures, sizing strategies, eviction policies, and the exact source‑code logic that governs HTTP caching, cleanup, and validation on iOS.
This article introduces core networking concepts for developers, covering the OSI layers, the roles of IP, TCP, and HTTP, the TCP three‑way handshake, step‑by‑step socket connection setup, HTTP connection traits, and key differences between TCP and UDP.
This article explains why RESTful API versioning is needed, presents four common versioning strategies (URI, request parameter, custom header, and media type), and provides complete Spring Boot code examples for each method along with factors to consider when choosing a strategy.
The article examines why certain companies mandate POST for every API, comparing GET and POST characteristics, discussing RESTful principles, ROI considerations, and the practical trade‑offs of such a uniform approach, while offering guidance on when each method is appropriate.
Most companies favor POST requests because they are more secure, can handle larger and more complex payloads, avoid URL length limits, and are suited for modifying data, while GET is better for retrieving static resources or simple queries, reflecting industry best practices for API design.
This article traces the evolution of HTTP from its early TCP‑based origins through HTTP/1.0, 1.1, SPDY, HTTP/2, and finally to HTTP/3, explaining how QUIC over UDP addresses latency, head‑of‑line blocking, and security challenges of previous versions.
The article presents a detailed performance comparison of three HTTP client implementations—Java FunTester, Go's net/http, and the high‑performance fasthttp library—across multiple thread counts and artificial latency settings, reporting CPU usage, memory consumption, and QPS to determine the most efficient choice.
This article introduces Spring's RestTemplate as a simple and convenient HTTP client, compares it with java.net.URLConnection, shows how to add the required dependency, configure the bean, and demonstrates GET and POST request usage with complete code samples and explanations.
This guide explains why and how to change HTTP request headers during Selenium WebDriver automation, covering three practical approaches—using REST‑Assured, employing a BrowserMob proxy, and configuring a Firefox extension—complete with code examples and step‑by‑step instructions.
This article explains how to use APIPOST to send HTTP requests, configure header, query, and body parameters, switch between form-data, x-www-form-urlencoded, and raw modes, view responses, and efficiently import parameter descriptions, providing a practical guide for backend developers.
This article explains the fundamentals and strategies of client‑side caching, covering HTTP cache mechanisms (strong and negotiated caching), cache‑control directives, cookie storage, localStorage, sessionStorage, and IndexedDB, and provides practical guidelines for optimizing web performance and reducing network load.
This comprehensive guide explains the OSI seven‑layer model, the TCP/IP four‑layer architecture, core networking protocols such as HTTP, HTTPS, TCP, UDP, IP, MAC, DNS and ARP, and covers essential concepts like network devices, address resolution, flow and congestion control, as well as common security mechanisms and attack mitigations.
This article explains the historical development of the HTTP protocol—from the simple HTTP/0.9 version through HTTP/1.0, 1.1, the binary‑based HTTP/2, and the emerging HTTP/3—highlighting each version's features, limitations, and the motivations behind their upgrades.
This article provides a detailed tutorial on Spring's RestTemplate class, covering its overview, setup, and extensive examples of GET, POST, file download, header handling, dynamic URL parameters, and integration with HttpClient and OkHttp, along with complete code snippets and best‑practice recommendations for backend Java development.
The article explains the PHP function apache_response_headers, which returns an array of all Apache HTTP response headers or FALSE on failure, lists its parameterless signature, describes its return values, and provides a sample code snippet demonstrating its usage.
The apache_lookup_uri function, available when PHP runs as an Apache module, performs a partial request on a given URI, returning an object with detailed request and file information such as status, method, headers, and timestamps.
This article explains the fundamentals of the HTTP protocol, illustrates how plain‑text communication enables man‑in‑the‑middle attacks, and describes how symmetric and asymmetric encryption, SSL/TLS handshakes, and CA certificate chains are used in HTTPS to secure web traffic.
This article walks through the design and implementation of a Java open‑platform SDK, covering a lightweight HTTP client, flexible serialization adapters for JSON and XML, and a simple API client, while sharing practical code examples and best‑practice tips for building maintainable backend integrations.
This article walks through creating a reusable Go HTTP client wrapper, demonstrates its use in a test script, shows console output, and integrates a mock server with Moco to enable quick API testing while applying a learning‑by‑doing approach.
This guide walks Java developers through installing Groovy, using its .groovy files, manipulating lists, maps, conditionals, loops, and leveraging built‑in JsonBuilder and HTTPBuilder for JSON handling and HTTP requests, all with clear code examples.
This comprehensive guide answers 19 core networking interview questions, covering the TCP/IP five‑layer model, HTTP fundamentals, GET vs POST, ping, status codes, differences among HTTP/1.0, 1.1, 2, 3, HTTPS, TCP connection handshake and teardown, sliding windows, flow control, half‑ and full‑connection queues, packet framing, and the browser request lifecycle.
The article explains how front‑end developers can prevent duplicate or stale HTTP calls by identifying identical requests with a unique key, then canceling them using Axios’s CancelToken or Fetch’s AbortController—integrated via React hooks, Axios interceptors, and route‑change cleanup.
Java’s URL class lets you represent and fetch resources identified by a URL, while URLConnection (and its HttpURLConnection subclass) provides detailed control over HTTP requests such as setting methods, headers, and handling input/output streams, with custom handlers enabling protocol‑specific behavior.
This article explains why HTTP is a stateless protocol and how authentication and authorization are achieved using cookies, sessions, and token-based mechanisms such as JWT, detailing their characteristics, workflows, and security considerations for modern web applications.
This article explains how to scrape tens of thousands of images from Sogou by analyzing the request URLs, extracting image URLs from JSON responses, and implementing a multithreaded Java downloader that stores the pictures locally.
This guide walks you through creating a JMeter thread group, adding HTTP samplers, configuring listeners, using the JSON Extractor to capture response data, and handling multiple variables, enabling you to chain API calls and validate responses efficiently.
This tutorial explains HTTP fundamentals, shows how to install and configure the Jenkins Generic Webhook Trigger plugin, and demonstrates parsing GET, POST, and header parameters using curl, Postman, and Jenkinsfile Groovy scripts for automated CI/CD pipelines.
This article provides a step‑by‑step guide for implementing a Java‑based SMS verification system, covering random code generation, API request construction, session handling, and includes full Java code for utility classes, configuration, and sending the verification message via a third‑party service.
This article shares practical experiences and lessons learned while integrating with Jira's REST API, covering the absence of Chinese documentation, handling of HTTP status codes, inconsistent and overly nested JSON responses, demo errors, mixed language fields, and the differences between POST and PUT methods.
This comprehensive guide walks you through installing Postman, navigating its interface, sending your first request, and mastering basic, convenient, and advanced features such as collections, batch runs, logging, assertions, variables, pre‑request scripts, and request chaining for efficient API testing.
This tutorial explains how to crawl thousands of images from Sogou using Java, detailing the request URL analysis, parameter extraction, multithreaded downloading logic, and providing complete source code for the image processor, pipeline, and HTTP utility classes.
This article provides a comprehensive overview of TCP networking fundamentals, covering the OSI seven‑layer model, TCP header fields, the three‑way handshake and four‑way termination, connection limits, packet fragmentation and reassembly, flow‑control mechanisms, HTTP/HTTPS differences, encryption methods and useful analysis tools.
This article provides a comprehensive analysis of Axios, covering its core directory structure, internal request/response flow, interceptor mechanism, data transformation, adapter handling, and ways to customize or replace default behavior, illustrated with extensive source code excerpts.
This article explains the fundamentals and advanced aspects of cookies and sessions, covering their definitions, use cases, key differences, handling when cookies are disabled, session management in distributed systems, same‑origin policy, cross‑origin requests, and security considerations for interview preparation.
An in‑depth look at the relationship between TCP and HTTP explains how many HTTP requests a single TCP connection can carry, covering keep‑alive, HTTP/1.0 vs 1.1 behavior, pipelining, HTTP/2 multiplexing, browser connection limits, and practical keep‑alive trade‑offs.
This article provides a thorough overview of the HTTP protocol, covering its basic format, workflow, request and response message structures, common methods, status codes, and URL composition, complete with examples and code snippets to help developers understand and use HTTP effectively.
This guide explains how to analyze Sogou's image search XHR request, extract image URLs from the JSON response, and use Java with multithreaded HTTP requests to download thousands of pictures efficiently, including full source code and execution tips.
This article presents six practical Go techniques—including loop labels for prime number generation, IP address conversion, octal UTF‑8 decoding, a lightweight HTTP utility library, a concise debug logging helper, and a Go‑based httpbin replacement—complete with code examples, usage notes, and visual results.
This article explains how Java NIO's non‑blocking I/O can accelerate HTTP interface testing by offloading response handling to separate threads, presents a simple request‑time model, and provides concrete async HttpClient code examples with logging and JSON parsing.
This article compares RPC and HTTP services by explaining their protocol foundations, the OSI network layers, RPC architecture components, synchronous versus asynchronous calls, and popular frameworks such as gRPC, Thrift, and Dubbo, while also outlining when each approach is appropriate for enterprise development.
The article explains the key differences between HTTP and HTTPS—including transmission security, connection methods, port numbers, and certificate requirements—and describes how HTTPS uses SSL/TLS, public‑key cryptography, and session keys to guarantee secure data exchange.
An extensive compilation of 50 essential computer networking interview questions covering HTTP status codes, request methods, network architecture, DNS resolution, TCP/UDP protocols, security concepts like CSRF and XSS, and detailed explanations of TCP handshakes, congestion control, and encryption mechanisms.
This article explains what middleware is, why it’s used in Go projects, and demonstrates various implementations—including logging, authentication, method checks, and chaining—through clear code examples for both the standard net/http package and the Gin framework, helping developers enhance their backend services.
This article explores the origin, technical meaning, and cultural myths of the HTTP 404 “Page Not Found” error, tracing its development from early web protocols to urban legends and even unrelated aviation incidents, while clarifying common misconceptions about its naming.
The article explores the origins and cultural impact of the HTTP 404 status code, debunks the CERN room‑404 myth, links the number to real‑world flight disasters, and explains why this ubiquitous error continues to intrigue both technologists and the public.
This tutorial explains how to install the Python requests library and use it to perform GET and POST HTTP requests, detailing required parameters, headers, and providing complete code examples for calling remote APIs and handling responses.
The article explores the origins of the HTTP 404 status code, debunks the legend of CERN's Room 404, recounts mysterious flights named 404, and ties these stories together to explain why the error has become a cultural symbol of missing content.
This article uses ten vivid real‑life analogies to clarify essential interview topics such as HTTP statelessness, serialization, rate limiting, TCP handshakes, thread‑pool mechanics, flow‑control windows, BIO/NIO/AIO differences, deadlocks, and the select versus epoll model, helping readers grasp complex computing concepts through familiar scenarios.
This tutorial explains why RESTful API versioning is needed, presents four versioning strategies (URI, request parameter, custom header, and media type), provides Spring Boot code examples for each, and discusses factors to consider when choosing a versioning approach.
This article provides a concise yet comprehensive guide to HTTP and its response status codes, explaining each class of codes (1xx‑5xx) and highlighting the most common codes developers encounter when building web applications.
This article introduces a Java OkHttp3 utility class that simplifies HTTP requests for backend developers, covering Maven dependency setup, code implementation with builder pattern, synchronous and asynchronous request methods, header and parameter handling, and usage examples.
This article explains why Spring Boot developers should return a ResponseEntity instead of a plain business object, covering its structure, custom status codes, headers, body handling, and a practical example of serving file downloads with proper content disposition.
This article explains how to configure Nginx as a reverse proxy to maintain long‑lived HTTP/1.1 keep‑alive connections between client and Nginx and between Nginx and upstream servers, covering required directives, upstream and location settings, performance implications for high QPS workloads, and advanced WebSocket handling.
This article explains the Richardson Maturity Model for REST, illustrates each level with a hospital appointment example—including HTTP request/response code snippets and HATEOAS links—and then outlines practical REST API design guidelines such as using nouns, proper HTTP verbs, pagination, versioning, and comprehensive status‑code handling.
This article explains the fundamental differences between RPC and HTTP services, covering the OSI model, RPC architecture, synchronous vs asynchronous calls, and popular open‑source RPC frameworks such as gRPC, Thrift, and Dubbo, to help developers choose the right approach for large‑scale systems.
This article explains how to configure Nginx as a reverse proxy to maintain long‑lived client and server connections, optimize keep‑alive parameters, and avoid connection churn in high‑QPS scenarios, providing practical code examples and advanced tuning tips.
This article traces the development of the HTTP protocol from its earliest 0.9 version through HTTP/1.1, HTTP/2, and finally HTTP/3 built on QUIC, highlighting how each iteration improved speed, efficiency, and mitigated head‑of‑line blocking while introducing new challenges.
This article presents an interview‑style walkthrough of HTTP request methods, detailing the eight methods defined by HTTP/1.1, focusing on GET and POST, their functional differences, URL length limits, parameter formatting, security considerations, and packet behavior.
This article explains how using Netty for HTTP handling—covering codec setup, HEAD request support, ByteBuf reference management, connection pooling, and full asynchronous processing—delivers superior performance, lower GC pressure, and better scalability compared to traditional servlet containers.
This article explains how Nginx runs as a daemon with a master process and multiple worker processes, why it prefers a multi‑process asynchronous non‑blocking architecture over threads, and details the key internal data structures such as connections, requests, arrays, queues, lists, strings, memory pools, hash tables, and red‑black trees that enable its high‑performance HTTP handling.
This guide introduces Axel, a lightweight command‑line download accelerator for Linux, covering installation across major distributions, key configuration options, and performance comparisons with wget that demonstrate significantly faster FTP and HTTP downloads using multiple simultaneous connections.
This article explains the fundamental differences between RPC and HTTP services, reviews the OSI network model, describes RPC architecture and sync/async calls, compares popular RPC frameworks such as gRPC, Thrift, and Dubbo with traditional RESTful HTTP, and offers guidance on choosing the right approach for a project.
This article compares Python's built‑in urllib library with the third‑party requests library, demonstrating their usage through code examples, highlighting differences in request construction, response handling, and practical considerations for web scraping, and concludes with recommendations for choosing the more convenient tool.
This article examines common RESTful API design mistakes—such as using verbs in URIs, embedding version numbers, and inconsistent case—provides corrected examples, discusses versioning strategies, and outlines best‑practice guidelines for building clean, resource‑oriented backend services.
This article explains the complete process from entering a URL to rendering a web page, covering URL parsing, DNS resolution, TCP three‑way handshake and four‑way teardown, HTTP request/response structure, and browser rendering, while also clarifying TIME_WAIT and related socket states.
This article explains the structure and meaning of HTTP status codes, detailing each of the five response classes (1xx informational, 2xx success, 3xx redirection, 4xx client error, 5xx server error) and providing concise descriptions for the most common codes within each class.
This article explains the fundamental differences between RPC and HTTP services, covering the OSI network model, RPC architecture components, synchronous and asynchronous calls, and introduces popular open‑source RPC frameworks such as gRPC, Thrift, and Dubbo, before comparing their suitability for various enterprise scenarios.
An in‑depth guide to computer network architecture covers layered models, the OSI reference model versus TCP/IP, protocol functions from the physical to application layer, TCP three‑way handshake and four‑way termination, HTTP basics, encryption methods, and common interview questions for network engineers.
This guide demonstrates how to use Python's requests library for sending GET, POST, and HTTPS requests, handling file uploads and downloads, managing timeouts, performing authentication, session and token handling, generating signatures, and organizing a complete API test automation framework.
This article walks through the complete journey of a web request—from entering a URL, checking browser, OS, router, and ISP DNS caches, performing DNS queries, resolving MAC addresses via ARP, establishing a TCP three‑way handshake, sending an HTTP request, to finally rendering the HTML page in the browser.
This article provides an extensive overview of the HTTP protocol, covering its layered network architecture, request/response processes, detailed header fields, caching directives, status codes, message bodies, as well as related components such as cookies, proxies, and servers.
This whimsical diary narrates the evolution of the HTTP protocol—from its humble GET request origins to the sophisticated features of HTTP/2—using a client‑server love story to illustrate methods, headers, pipelining, chunked transfer, and server push in an engaging, educational way.
This article explains how to extract song information from KuGou by inspecting network requests, simplifying URLs, generating required MD5 signatures, constructing authenticated API calls, and using Python to download the resulting audio files to a local directory.
This comprehensive guide walks you through Postman's core capabilities—including installation, interface navigation, sending requests, handling query parameters, forms, JSON and file uploads, response analysis, collection management, batch execution, logging, assertions, variables, pre‑request scripts, and request chaining—empowering developers and testers to automate and streamline API testing workflows.
This article explains the fundamental differences between RPC and HTTP services, covering the OSI model, RPC architecture, synchronous vs. asynchronous calls, popular RPC frameworks, and when to choose RPC over HTTP for enterprise versus small‑scale applications.
This article provides a comprehensive overview of the HTTP protocol, covering its definition, stateless nature, connection handling, key characteristics, request/response workflow, header fields, status codes, caching mechanisms, and practical applications such as resumable downloads, multithreaded downloading, proxy servers and virtual hosting.
This article explains the fundamental differences between RPC and HTTP services, outlines the OSI model, describes RPC architecture, synchronous and asynchronous calls, compares popular RPC frameworks such as gRPC, Thrift, and Dubbo, and discusses when to choose each approach for backend development.
This article explains the inherent insecurity of plain HTTP, illustrates man‑in‑the‑middle attacks, shows why simple symmetric encryption is insufficient, and details how HTTPS (SSL/TLS) with asymmetric key exchange and CA verification protects data transmission.
This article reviews the fundamentals of the HTTP protocol, explains why its plaintext transmission makes it vulnerable to man‑in‑the‑middle attacks, and details how HTTPS—through SSL/TLS, asymmetric key exchange, and CA certificate verification—protects data integrity and confidentiality.
An in‑depth guide covering Java reflection fundamentals, three methods to obtain Class objects, and practical code examples, followed by a comprehensive overview of computer networking layers, protocols, TCP/IP versus OSI models, transport protocols, HTTP/HTTPS differences, status codes, GET/POST, cookies, sessions, tokens, and servlet lifecycle.
This article explains the fundamental differences between RPC and HTTP services, reviews the OSI network model, describes RPC architecture, synchronous and asynchronous calls, compares popular RPC frameworks such as gRPC, Thrift, and Dubbo, and discusses when to choose each approach for enterprise applications.
This article explains why caching is essential for web performance, describes the two main HTTP cache types (strong and negotiated), compares Expires and Cache‑Control headers, and details ETag generation, validation, and best‑practice considerations in server implementations such as Nginx.
This article explains HTTP’s key characteristics, compares short‑lived and persistent connections, and explores related concepts such as head‑of‑line blocking, concurrency, and domain sharding, providing readers with a comprehensive understanding of how HTTP manages connections and performance.
This article walks through the complete process of how a browser accesses a web resource, from parsing a URL and generating an HTTP request, through DNS name resolution, the construction of MAC, IP, TCP, and application headers, to the TCP three‑way handshake, data transmission, and the four‑step connection termination.
The article shares three interview scenarios—a puzzling HTTP GET failure, a rate‑limiting challenge solved with token‑bucket logic, and a deep dive into Java ThreadPoolExecutor behavior—each followed by personal insights on problem‑solving, algorithm application, and understanding underlying principles.
This article explains how to build a high‑performance large‑file HTTP upload service with resumable support by using a C‑based server, client‑side hash generation, cookie‑based browser IDs, AJAX queries for upload progress, and JavaScript code that slices files and tracks upload speed and progress.
This article provides a comprehensive overview of HTTP caching mechanisms, covering cache‑related header fields, legacy directives like Pragma and Expires, modern Cache‑Control directives, validation headers such as Last‑Modified and ETag, practical simulation with Fiddler, and best‑practice recommendations for both client and server side caching.
This article details the design evolution, architectural choices, performance tuning, monitoring, and future plans of Ximalaya's high‑traffic HTTP gateway, covering its migration from Tomcat NIO to a fully asynchronous Netty implementation and the associated engineering challenges and solutions.
This article provides a comprehensive overview of HTTP caching mechanisms, detailing cache‑related header fields, browser behaviors, legacy and modern directives, validation techniques, and practical tips for configuring efficient cache strategies in web applications.
This article introduces the Forest HTTP client framework, showing how it abstracts diverse third‑party API differences through configuration and annotations, provides easy Spring Boot integration, and offers powerful features like template expressions, HTTPS support, and extensive request customization.
This article explains how to transform a Java HttpRequestBase object into an equivalent curl command, enabling rapid request replay across servers and detailed timing analysis, and demonstrates the process with step‑by‑step code examples and a functional test using the FunTester framework.
This article explains how misconfigured HTTP Host headers can be abused for attacks such as cache poisoning, SSRF, password‑reset poisoning and other server‑side exploits, and provides practical detection methods and defensive recommendations for developers and security engineers.
