This article provides PHP functions that wrap cURL to perform GET, POST, PUT, DELETE, and PATCH HTTP requests, automatically handling JSON encoding of data and decoding responses into associative arrays, with code examples for each request type.
This article explains the structure of HTTP request messages, compares the characteristics of GET and POST methods, and provides real-world examples to illustrate how each method works and differs in practice.
This article traces the Internet’s evolution from Cold‑War‑era research projects like ARPA and ARPANET through the birth of TCP/IP, HTTP, REST, and the rise of SDN, OpenFlow, and P4, highlighting key milestones, standards, and the ongoing push toward fully programmable networks.
An in‑depth look at the decades‑long curl vulnerability discovered by Daniel Stenberg, tracing its origins in early cookie handling, the dual‑syntax challenges of RFC 6265, the 2022 security report, and the eventual fix that finally closed a 23.9‑year‑old bug.
The article recounts the 23.9‑year‑long curl vulnerability discovered by Daniel Stenberg, detailing the early implementation of cookie handling, the challenges of dual cookie syntax, the security bug involving control‑code cookies, and the eventual fix released after nearly nine thousand days.
The Vivo Internet Operations team outlines how they cut short‑video startup latency by warming DNS caches, consolidating domains for HTTP/1.1 reuse, deploying HTTP/2 and QUIC, and optimizing CDN edge placement, achieving up to 30 ms DNS gains, 40 ms image load reductions, and lower request and first‑byte latencies.
Learn how Spring Boot 2.6.14 simplifies calling remote REST services using RestTemplate and WebClient, including automatic configuration with RestTemplateBuilder, customization options via RestTemplateCustomizer and WebClient.Builder, and detailed code examples for building, customizing, and selecting appropriate HTTP connectors.
This article introduces Javalin, a lightweight Java web framework that supports HTTP/2, WebSocket, and asynchronous requests, demonstrates a practical code example with routing, request validation, handlers, and deployment steps, and even solves a common port‑conflict issue on macOS.
This article explains the fundamental weaknesses of HTTP, demonstrates how man‑in‑the‑middle attacks exploit clear‑text communication, and shows how HTTPS—through SSL/TLS handshakes, certificate validation, and CA hierarchies—protects web traffic from interception and tampering.
This article introduces Javalin, a lightweight Java web framework that supports WebSocket, HTTP/2, and asynchronous requests, demonstrates core code examples for routing, validation, and handlers, explains deployment with an embedded Jetty server, and resolves a common macOS port conflict.
This article explains the fundamentals of HTTP, demonstrates how its plaintext nature enables man‑in‑the‑middle attacks, explores symmetric and asymmetric encryption attempts to mitigate the risk, and shows how HTTPS—through TLS handshakes, certificate validation, and a trusted CA hierarchy—provides robust protection.
An in‑depth look at HTTP’s origins, its client‑driven request‑response design, the evolution of headers, length‑ and delimiter‑based streams, and the successive enhancements from HTTP/0.9 through HTTP/1.1 to HTTP/2, SPDY, and HTTP/3, explaining the motivations behind each change.
This article walks through setting up a Starwift cloud‑native data warehouse on JD Cloud, configuring network access, installing the ClickHouse client on macOS, and demonstrates both TCP and HTTP Rust integrations with example code, while noting common dependency conflicts.
This article explores the design motivations behind HTTP, tracing its evolution from the early TCP‑based request‑response model through HTTP/0.9, 1.0, 1.1, to modern HTTP/2 and HTTP/3, highlighting key features like headers, caching, connection reuse, and protocol optimizations.
This article explains the fundamentals of HTTP caching, covering request/response structures, strong and validation cache rules, header directives like Expires and Cache-Control, and practical tips for implementing effective caching strategies in front‑end development.
This article explains the fundamental differences between RPC and HTTP services, covering OSI layers, RPC architecture, synchronous vs asynchronous calls, popular RPC frameworks, and when to choose each approach for enterprise applications.
Learn how to use Spring's RestTemplate and WebClient for calling REST endpoints, explore their core methods, initialization options, URI handling, header and body processing, multipart support, and underlying HttpMessageConverters, with practical code examples and migration guidance for modern Spring applications.
An in‑depth comparison of HTTP Keep‑Alive (application‑layer persistent connections) and TCP Keepalive (kernel‑level health checks), covering their implementation layers, usage, configuration, timeout handling, and impact on performance, with clear diagrams and code examples to help developers master both mechanisms.
This article explains the OSI seven‑layer model, compares RPC and HTTP services, details RPC architecture, synchronous vs asynchronous calls, and reviews popular RPC frameworks such as gRPC, Thrift, and Dubbo, helping developers choose the right communication approach for enterprise applications.
This article explains how browsers handle TCP connections and SSL sessions when loading pages with many images, covering connection persistence, request multiplexing, HTTP pipelining limitations, per‑host connection limits, and the advantages of HTTP/2 multiplexing for efficient resource fetching.
This article explains how MySQL stores NULL values and clarifies the distinct mechanisms of HTTP Keep‑Alive (application‑level long connections) versus TCP Keepalive (kernel‑level health checks), detailing their implementations, usage, and practical considerations.
This comprehensive guide covers computer network fundamentals, including OSI and TCP/IP models, protocol layers, DNS resolution, HTTP/HTTPS details, TCP three‑way handshake and four‑way teardown, congestion control, security threats like XSS and CSRF, and practical mitigation techniques, providing a solid foundation for networking interviews and real‑world applications.
The article surveys the evolution of web communication from HTTP/1.x through HTTPS, HTTP/2, and HTTP/3, explaining request/response structure, methods, status codes, URIs, connection handling, cookies, caching, TLS encryption, and the performance‑boosting features of header compression, multiplexing, and QUIC‑based transport.
This article explains the CORS standard, how browsers enforce same‑origin policy, the definitions of simple and preflight requests, required HTTP headers, credential handling, and typical configuration mistakes that cause CORS errors, illustrated with code examples and tables.
This article explains the fundamental differences between HTTP and RPC, covering protocol layers, communication formats, performance considerations, RPC architecture, synchronous vs asynchronous calls, popular RPC frameworks, and when to choose RPC over HTTP for backend services.
This article explains how Wireshark captures map to the TCP/IP four‑layer model, walks through Ethernet, IP, TCP/UDP, and application layers, and demonstrates detailed HTTP request‑response analysis using Wireshark, HttpWatch, and browser developer tools.
This article recounts a real‑world incident where a change to the Access‑Control‑Allow‑Origin header triggered CORS errors for credentialed requests, analyzes the CDN caching and Vary‑header issues that caused inconsistent responses, and outlines the steps taken to fix and prevent the problem.
This article explains the concept of idempotent HTTP requests, defines idempotency, lists which HTTP methods are idempotent or not, and clarifies why methods like GET, HEAD, PUT, DELETE are safe to retry while POST, PATCH, and CONNECT are not.
This article provides a comprehensive overview of TCP, UDP, and HTTP protocols, explaining their definitions, layered roles, connection establishment and termination processes, segment structures, and key differences in reliability and performance for network communication.
This article provides a detailed tutorial on the curl command-line tool, covering its purpose, common options such as -A, -H, -b, -c, -d, -F, -L, -k, and advanced usage like file uploads, proxy settings, and response testing, with practical code examples for each.
This article explains the fundamentals of HTTP, how browsers build and send requests, the structure of request and response messages, and the performance improvements introduced by HTTP 2.0 and the QUIC protocol built on UDP.
This article recounts the 23.9‑year lifespan of a curl cookie handling vulnerability, tracing its origins in 1998, the evolution of cookie specifications, the discovery of the CVE‑2022‑35252 bug, and the eventual fix that finally eliminated the flaw after nearly 9,000 days.
The article recounts how a flaw introduced in curl 4.9's cookie engine in 1998 persisted for 23.9 years, why the dual‑syntax cookie RFC caused confusion, how the bug allowed control‑character cookies to be sent, and how a simple reject‑bytes patch finally fixed CVE‑2022‑35252.
This article explains the fundamentals of the HTTP protocol, covering request preparation, message structure, methods, headers, caching, the request/response cycle, HTTP/2 enhancements, and the QUIC protocol's advanced features for faster, more reliable web communication.
The article recounts the 23.9‑year‑long history of a curl cookie handling vulnerability, explains how ambiguous cookie specifications caused a dual‑syntax challenge, describes the CVE‑2022‑35252 bug and its simple fix, and reflects on the broader implications for HTTP security.
This article explains HTTP content encoding, transfer (chunked) encoding, and range requests, detailing their purpose, relevant headers, encoding types, and providing Java client and Netty server code examples to demonstrate how to implement and analyze these features for large file transfers.
The Axios 1.1.0 release introduced a corrupted build that caused the axios.get function to be undefined, leading to widespread request failures in both browser and Node.js environments, prompting developers to roll back or upgrade to patched versions.
This article explains what web crawlers are, compares static and dynamic web pages, outlines their characteristics, advantages, and challenges, and provides practical tips for extracting data from both types of pages using tools like browser developer consoles and packet‑capture utilities.
This comprehensive guide walks you through installing Postman, navigating its interface, sending your first request, and mastering essential and advanced features such as collections, batch execution, logging, assertions, variables, pre‑request scripts, request chaining, and extracting nested JSON values for effective API testing.
This article explains multiple approaches for invoking third‑party HTTP APIs in Java, covering JDK HttpURLConnection, Apache HttpClient, CloseableHttpClient, SpringBoot RestTemplate, and OkHttp, with detailed code examples, configuration steps, and usage patterns for GET and POST requests.
This article explains why servlet request/response streams are single‑read, introduces Spring's ContentCaching wrappers, and provides step‑by‑step code for creating a reusable HttpBodyRecorderFilter and a pattern‑matching proxy to record bodies based on HTTP status codes.
This guide shows how to enable the PHP cURL extension and provides complete code examples for performing HTTP GET, POST, file upload, and flexible request operations using cURL functions in PHP.
This article explains the fundamentals of TCP, why raw TCP lacks message boundaries, how HTTP and RPC are built on top of TCP, and the practical reasons why both protocols coexist in modern software architectures.
This article explains why HTTP is a stateless protocol, introduces authentication and authorization concepts, and compares cookies, sessions, and token-based mechanisms such as JWT, detailing their characteristics, workflows, and security considerations for modern web applications.
This article explains the fundamentals of TCP sockets, why raw TCP lacks message boundaries, how custom protocols add headers to solve the sticky‑packet problem, and compares HTTP and RPC as application‑layer protocols, highlighting their histories, use‑cases, and performance trade‑offs.
This tutorial explains how to programmatically log into a campus network by analyzing HTTP requests, crafting POST data, retrieving the local IP address, automating Wi‑Fi connection on macOS using pywifi, and finally packaging the script into a standalone executable with pyinstaller.
This article presents a concise yet comprehensive guide to RESTful API design, covering resource-oriented naming, kebab‑case URLs, camelCase parameters, proper use of HTTP verbs, versioning, health/metrics endpoints, pagination, field selection, authentication headers, CORS, error handling, and golden rules for creating clean, maintainable backend services.
This article explains the evolution from raw TCP sockets to HTTP and RPC, highlighting why RPC remains useful despite HTTP's prevalence, covering TCP basics, message framing, service discovery, connection handling, serialization, and performance considerations.
The article explains why Dubbo's RPC design and single‑connection model make it inefficient for transmitting files, compares the memory‑heavy approach of sending byte arrays with the streaming nature of HTTP, and shows how Feign can upload files but still suffers from in‑memory buffering.
This article explains the fundamentals of HTTP and HTTPS, covering the protocol structure, common request methods, request and response message formats, differences between GET and POST, response status code categories, a full HTTP transaction flow, and the encryption mechanisms and drawbacks of HTTPS.
This article explains the fundamentals of HTTP and HTTPS, covering the protocol structure, common request methods, differences between GET and POST, the full lifecycle of an HTTP request, and how HTTPS adds encryption, authentication, and its trade‑offs.
This comprehensive guide walks you through Postman's installation, interface navigation, basic request types, response parsing, collection management, batch execution, logging, assertions, variables, pre‑request scripts, request chaining, and common value extraction, providing practical steps and code examples for effective API testing.
This article explains what cookies are, how they are represented and transmitted in HTTP, their lifecycle, common attributes, and demonstrates practical usage with Java's Cookie API, JSP pages, and servlet code to achieve automatic login and session management.
This article explains the OSI seven‑layer model, then compares RPC and HTTP services by detailing RPC’s architecture, synchronous versus asynchronous invocation, and the most popular open‑source RPC frameworks—gRPC, Thrift, and Dubbo—highlighting why RPC often offers higher efficiency for large‑scale enterprise applications.
The article explains how to add reliable HTTP communication in Go by implementing retry logic with configurable backoff and jitter, resetting request bodies for POST retries, using hedged parallel requests, and integrating circuit‑breaker patterns to prevent overload and cascading failures.
This article explains the fundamentals of HTTP and HTTPS, covering request and response structures, common methods, differences between GET and POST, response codes, the complete request flow, and how HTTPS adds SSL/TLS encryption for secure communication.
This article explains the REST architectural style, its core principles, resource modeling, representations, state transfer, and provides comprehensive guidelines for designing RESTful APIs, including HTTP verbs, URI conventions, versioning strategies, maturity levels, and practical code examples.
This article traces the development of the HTTP protocol from its earliest 0.9 version through 1.0, 1.1, 2.0, and the modern HTTP/3 over QUIC, detailing key features, header compression, multiplexing, caching mechanisms, server push, and the security and performance trade‑offs of each iteration.
This article explains the OSI seven‑layer model, compares RPC and HTTP services, details RPC architecture, synchronous vs asynchronous calls, and reviews popular RPC frameworks, helping developers choose the right approach for enterprise applications.
This tutorial explains how to use Java and the WebMagic framework to crawl thousands of images from Sogou image search, parse the JSON responses to extract image URLs, and download the pictures locally using multithreaded processing and custom HTTP utilities.
This article explains the fundamental distinctions between RPC and HTTP services, covering OSI network layers, the core components of RPC architecture, synchronous versus asynchronous calls, popular RPC frameworks such as gRPC, Thrift, and Dubbo, and a comparison with RESTful HTTP services.
This article explains the fundamental differences between RPC and HTTP services, covering OSI layers, RPC architecture, synchronous and asynchronous calls, and introduces popular RPC frameworks such as gRPC, Thrift, and Dubbo, while also showing a simple HTTP request example.
The article details a step‑by‑step investigation of a form‑submission cross‑origin error in a front‑back separated system, tracing the HTTP request flow through DNS, Nginx, Tomcat, and finally identifying a WAF XSS rule that blocked a specific moduleExport field, and explains how the issue was resolved by adjusting the WAF configuration.
This article explains how to simulate user HTTP requests in automated testing by sending GET/POST requests with Java, storing and extracting cookies from the application’s cookie store, and returning them as JSON, accompanied by a complete code example.
This article explains the fundamental differences between RPC and HTTP services, covering the OSI model, RPC architecture components, synchronous vs asynchronous calls, and reviews popular RPC frameworks such as gRPC, Thrift, and Dubbo, helping developers choose the right approach for backend development.
This article explains the various web caching mechanisms—including database, CDN, proxy, browser, and application‑level caches—why browser caching matters for performance, how ETag and Cache‑Control headers work, and practical checklist items for effectively managing cache in modern web applications.
This article explains the fundamental differences between RPC (Remote Procedure Call) and HTTP services, covering OSI layers, RPC architecture components, synchronous vs asynchronous calls, and popular frameworks such as gRPC, Thrift, and Dubbo, to help developers choose the right approach.
This article explains how to unify error handling between gRPC and traditional HTTP services by defining shared protobuf messages, mapping gRPC status codes to HTTP responses, and customizing response structures with additional fields like stat and msg for consistent business‑level error reporting.
This article demonstrates how to automate Zhihu login on Windows by analyzing network traffic with Fiddler, extracting required parameters, and implementing a Python script that builds HTTP requests using urllib2, handles cookies, captcha retrieval, and logs the results, complete with sample code and execution screenshots.
The article explains the technical reasons behind mandating POST for all API endpoints, comparing GET and POST in terms of security, payload size, data types, caching, and typical use cases, and argues that a balanced approach is usually more appropriate.
This article introduces the ApacheBench (ab) performance testing tool, explains key load‑testing concepts such as throughput and concurrency, provides step‑by‑step instructions for downloading, installing, and running ab on Windows, and describes how to interpret the generated test report.
The article recounts a real‑world incident where a JSON POST from a front‑end domain triggered a cross‑origin 418 error because a Web Application Firewall’s XSS filter mistakenly blocked a JavaScript validator field, and after the security team modified the WAF rules the issue was resolved, highlighting systematic debugging and deep knowledge of DNS, Nginx, ingress, Tomcat and WAF layers.
This article walks through the HTTP/1.1 keep‑alive model, shows how a simple Go program creates separate TCP connections for sequential requests, uses netstat and tcpdump to observe the behavior, and demonstrates how adjusting http.Client's transport settings enables true persistent connections even under concurrency.
This article explains the technical distinctions between HTTP GET and POST requests, covering how parameters are transmitted, practical limitations imposed by browsers and servers, differences in caching, security, and packet flow, and why both methods ultimately rely on the same TCP/IP transport.
When you type a URL and press Enter, the browser performs a series of steps—including URL parsing, DNS resolution across multiple caches, TCP three‑way handshake, HTTP request construction, server processing, and response handling—each involving specific protocols and layers that together deliver the requested web page.
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.
