This guide walks you through Spring 6.1's new RestClient, covering project setup, global client creation, data retrieval, posting, deletion, error handling, and advanced exchange methods with clear code examples for modern Java backend development.
This article explains the fundamentals of TCP, why pure TCP communication faces boundary issues, how HTTP and RPC are built on TCP as application‑layer protocols, and compares their architectures, service discovery, serialization, and performance to clarify when each should be used.
This article explains the basic concepts of GET and POST, debunks common interview answers, reveals that both methods are fundamentally TCP connections, discusses browser and server limits, and highlights the practical impact of their packet‑level differences.
This article explains TCP connection basics, the three‑way handshake and four‑way termination, compares short and long connections, discusses keep‑alive mechanisms, and outlines when to use each approach in network and HTTP communication.
This article explains how to use HTTP Range headers for resumable downloads, how to detect server support, the relevant status codes, proper Range syntax, error handling, and provides a complete Spring Boot example that integrates with Ceph storage to serve partial file content.
This article explains how a mobile app’s search query travels across the internet, detailing the roles of DNS resolution, CDN caching, HTTP communication, TCP connections, and load‑balancing mechanisms, and shows how each layer contributes to delivering results to the user.
Although you can obtain a website’s IP address, accessing it directly via HTTPS often fails because the HTTP request’s Host header differs, and servers use this header to verify the intended domain, leading to 403 errors unless the correct Host value is supplied.
This article explains what JSON API is, outlines its key advantages such as compound documents, sparse fieldsets, optional features, pagination and caching, compares it with GraphQL, and illustrates its practical use through a FitBit case study, helping readers decide if it fits their API design needs.
The article explains why visiting a website by its IP address often results in errors, showing that the HTTP Host header differs from domain‑based requests, and demonstrates this with Fiddler and Postman experiments using Baidu as an example.
This article introduces Spring 6.1’s new synchronous RestClient, showing how to perform basic GET and POST requests, convert responses to objects, handle errors with onStatus, and use the advanced exchange method for custom request‑response processing, positioning RestClient as a modern replacement for RestTemplate.
This article explains why accessing a site via its IP address fails, revealing that the HTTP Host header distinguishes domain‑based requests from raw IP requests, and shows how adjusting the Host field restores access.
Webman is a high‑performance PHP HTTP framework built on Workerman that replaces the php‑fpm model, offering minimal core, extreme speed, easy extensibility, and detailed stress‑testing guidance, making it several times faster than traditional PHP stacks and even comparable Go frameworks.
This article walks through the root causes of CORS failures when a front‑end site accesses a back‑end service, explains the four essential CORS response headers, and provides detailed Nginx configurations—including handling preflight OPTIONS requests and adding missing headers—to reliably resolve cross‑origin issues.
This article outlines seven practical applications of PHP’s header() function, including page redirection, content‑type declaration, HTTP status codes, timed redirects, cache control, authentication prompts, and file download handling, providing code examples for each use case.
This article explains why an insecure cross‑origin setup in Nginx violates security standards, demonstrates how to reproduce the vulnerability with custom Origin headers, and provides a complete Nginx configuration using a map directive to whitelist origins, add proper CORS headers, and return 403 for disallowed requests.
This article details the design and implementation of a self‑built automated testing platform for backend services that achieves near‑full test‑case coverage by unifying HTTP/RPC access, introducing a parameter‑pool, leveraging JSON Schema and JSONPath, and automating case generation and promotion.
This article explains the fundamental differences between RPC and HTTP interfaces, their underlying protocols, component architectures, popular frameworks, performance characteristics, and provides guidance on when to use each approach in backend service development.
This article explains the fundamental differences between RPC and HTTP interfaces, describes their underlying client‑server architectures, compares performance, transport protocols, load balancing and service governance, and provides guidance on when to choose each approach in modern backend development.
This article compares RPC and HTTP interfaces, detailing their architectures, popular frameworks, performance characteristics, load‑balancing, and service‑governance features, and provides practical guidance on selecting the right approach for internal high‑performance services or external cross‑platform APIs.
This article explains how Spring Boot 3.0.5 processes errors, registers a default /error page, and returns either HTML or JSON responses based on the Accept header, detailing the underlying servlet and Tomcat mechanisms with code examples.
This article walks through the root causes of CORS errors when a front‑end site on port 8080 calls a back‑end service on port 59200, explains the four essential CORS response headers, demonstrates common error scenarios, and provides complete Nginx configuration snippets—including handling pre‑flight OPTIONS requests, custom headers, and method allowances—to reliably eliminate cross‑origin problems.
This article traces the evolution of the HTTP protocol from its original 0.9 version through HTTP/1.0, 1.1, HTTP/2, and HTTP/3, explaining the underlying design choices, extensions, and performance optimizations that shaped each milestone.
This article explains the fundamentals of HTTP caching, covering the structure of HTTP messages, the two main cache strategies—strong caching and validation caching—the relevant response headers such as Expires, Cache-Control, Last-Modified, and ETag, and provides practical guidelines for effective cache implementation in web development.
This article explains the fundamental differences between RPC and HTTP services, covering OSI model layers, RPC architecture components, synchronous vs asynchronous calls, popular RPC frameworks such as gRPC, Thrift, and Dubbo, and when to choose each approach for enterprise applications.
By dissecting OkHttp’s source, the article explains its layered architecture, the interceptor‑chain implementation of the Chain‑of‑Responsibility pattern, and shows how developers can add custom interceptors—such as authentication headers—to uniformly handle requests, retries, caching, and network I/O in Java and Android.
This article explains the structure of HTTP/1.1 request and response messages, the limitations of TCP such as head‑of‑line blocking, the evolution from SPDY to HTTP/2 with binary framing, multiplexed streams, header compression, server push, ALPN negotiation, and practical Wireshark capture techniques for HTTP/2 traffic.
This article explains the fundamental distinctions between RPC and HTTP services by reviewing the OSI network layers, RPC architecture components, synchronous versus asynchronous calls, popular RPC frameworks such as gRPC, Thrift, and Dubbo, and the typical use cases of each approach.
This article explains the concepts, purposes, and inner workings of TCP keepalive and HTTP keepalive, compares their roles in maintaining network connections, and provides practical guidance on configuring related parameters and handling socket lifecycles in server environments.
This article explains the fundamentals of HTTP GET and POST request methods, detailing their request line, headers, and body structures, illustrating each with real‑world examples and code snippets, and clarifying their safety, idempotence, caching, and practical differences.
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.
