This article explains what HTTP status codes are, categorizes them into informational, success, redirection, client error, and server error groups, and details the most common codes with examples and usage scenarios.
This article introduces Java 18’s JEP 408 Simple Web Server, explains its purpose and limitations, walks through creating an HTML page, demonstrates launching the server via command line with various options, and shows how to access and verify the served content.
This guide outlines comprehensive backend API design recommendations, covering appropriate HTTP status codes, JSON request bodies, unique resource identifiers, timestamp formats, consistent URL structures, nested relationships, error message schemas, caching, pagination, versioning, security, and clear documentation with executable examples.
This article provides a comprehensive overview of the HTTP protocol, covering its fundamental concepts, request methods, status codes, common headers, caching mechanisms, security differences with HTTPS, and the evolution of the protocol through HTTP/1.1, HTTP/2, and HTTP/3.
This article explains the mathematical and computer‑science definition of idempotency, why it is essential for reliable distributed services, how to handle timeout scenarios, and presents eight concrete design patterns—including unique IDs, database constraints, token mechanisms, optimistic/pessimistic locks, and distributed locks—along with code examples and HTTP method analysis.
Effective URL design, covering the distinctions and relationships among URI, URL, and URN, best practices for stability, readability, and longevity, as well as technical considerations such as Data URIs, hash fragments, redirects, and real‑world examples like Flickr, provides essential guidance for web architects and developers.
This article explains the concepts, differences, and hierarchical relationships of URI, URL, and URN, discusses common pitfalls and design guidelines for stable and user‑friendly web addresses, and provides practical examples such as Data URI syntax, Flickr API URL patterns, and HTTP redirection strategies.
This article demonstrates how to implement HTTP requests in Java using the built-in HttpURLConnection class, covering request creation, adding parameters, setting headers, handling timeouts, cookies, redirects, and reading responses, including error handling, with complete code examples.
This article explains how to create custom middleware for the Go Negroni framework, walks through a complete example with code, and details the internal functions such as UseHandler, Wrap, Use, build, and how Negroni ultimately runs the HTTP server.
This article explains why Dubbo’s RPC model and single‑connection design make it unsuitable for transmitting large files, compares it with HTTP streaming, and shows how Feign’s encoder still loads whole payloads into memory, recommending direct client uploads instead.
This article introduces the Python Requests library, explains how to install it, demonstrates basic HTTP methods such as GET and POST with code examples, and explores advanced use‑cases like handling JSON, binary data, custom headers, cookies, sessions, SSL verification, proxies, timeouts, and authentication.
This article explains what HTTP redirects are, why they are used, and how they affect everyday API testing with tools like JMeter and Python's requests library, providing practical examples and guidance on handling redirect behavior.
The article explains several typical situations—such as not configuring HTTPS proxies, using server IPs, non‑anonymous proxies, polluted IP pools, and lack of HTTP/2 support—that cause websites to easily detect that a request is made through a proxy, even for beginner Python scrapers.
This article explains the origins of REST, breaks down its core concepts of resources, representations, and state transfer, and provides comprehensive guidelines for designing clean, secure, and versioned RESTful APIs, including URL conventions, HTTP verbs, status codes, and authentication practices.
This article explains the origins of REST, breaks down its core concepts of resources, representations, and state transfer, and provides comprehensive guidelines for designing clean, versioned, and secure RESTful APIs, including URL conventions, HTTP verbs, status codes, and authentication.
This article provides a detailed source‑code walkthrough of Envoy's outbound request processing, explaining how the proxy receives client data, parses HTTP requests, selects routes and clusters, forwards traffic upstream, handles retries and shadowing, and finally returns responses to downstream clients.
This tutorial walks through using Spring's RestTemplate to replace complex HttpURLConnection and Apache HttpClient code, covering environment setup, bean configuration, GET/POST/PUT/DELETE operations, file upload/download, and advanced exchange usage with clear Java examples.
This article presents 22 practical best‑practice guidelines for designing consistent, secure, and user‑friendly RESTful APIs, covering URL naming conventions, HTTP methods, versioning, pagination, JSON naming, monitoring endpoints, CORS, error handling, and other essential considerations for backend developers.
This article explains how to combine Netty and Spring MVC by creating a Netty server, configuring the channel pipeline, implementing a request handler that forwards to DispatcherServlet, initializing the servlet, and providing a sample controller with troubleshooting tips for character encoding and configuration files.
This guide shares a top‑down, scenario‑driven approach to mastering computer networks, offering practical principles, curated books, videos, and visual websites to help learners study efficiently and avoid common pitfalls.
This article introduces the requests‑cache library, explains how to install it, demonstrates basic and advanced usage—including session patching, backend selection, expiration policies, request/response filtering, and cache‑control header handling—to efficiently avoid duplicate HTTP requests during Python web scraping.
This article explains how to monitor SpringBoot applications using built‑in HTTP actuator endpoints and JMX, demonstrates enabling and exposing specific endpoints, shows how to customize health, loggers, and metrics, and provides step‑by‑step code examples for creating custom monitoring endpoints and manually registering JMX MBeans.
The authors upgraded the Mahimahi record‑and‑replay framework by replacing Apache with modular Nginx, adding native HTTP/2 support and integrating a QUIC module (via quiche), enabling replay of captured traffic under modern protocols, precise network condition control and open‑sourcing the extensions for reproducible performance experiments.
This article provides a comprehensive analysis of Go's net/http library and the Gin framework, detailing request handling flow, router implementation, middleware chaining, and context management, while presenting key source code excerpts to illustrate how HTTP services are built and extended in Go.
This article presents a comprehensive performance test of Go language channels, comparing them with Java's Disruptor and LinkedBlockingQueue across various object sizes, queue lengths, and producer/consumer thread counts, and provides practical recommendations based on the benchmark results.
This article presents a comprehensive set of best‑practice guidelines for designing clean, consistent, and secure RESTful backend APIs, covering URL naming conventions, parameter styles, resource naming, versioning, pagination, authentication, error handling, and documentation tools.
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.
