This article details migrating from Spring Cloud/OpenFeign to Apache Dubbo 3 with Spring Boot 3, covering Triple protocol over HTTP/2, binary serialization, service governance (timeouts, retries, load balancing), streaming, observability, and production pitfalls with benchmark comparisons showing 3-5x throughput gains.
This article analyzes six public benchmark datasets comparing HTTP/1.1+JSON (REST) against binary protocols like gRPC+Protobuf and Dubbo, showing gRPC achieves roughly 2x throughput and half the latency, but argues the gap is often negligible in real business scenarios where database and logic dominate latency.
This article provides a comprehensive analysis of gRPC, covering core concepts, HTTP/2 and Protobuf fundamentals, four call patterns, interceptors, error handling, load‑balancing strategies, service discovery mechanisms, circuit‑breaking and rate‑limiting, security layers, and a complete Spring Boot 3 + JDK 21 runnable example with a detailed best‑practice checklist.
The article explains why gRPC is gaining popularity by comparing its performance, streaming capabilities, and cross‑language contract advantages over traditional REST + JSON, and provides a step‑by‑step guide to building a complete gRPC service with Spring Boot 4.1.
This article details production-ready gRPC integration with Spring Boot 3.x, covering contract-first Protobuf design, Maven code generation, timeout and retry strategies with Resilience4j, mTLS and JWT interceptors, JVM/Netty tuning for 40k+ QPS, Spring Cloud service discovery integration, and cross-language Java-Go benchmarking results showing 2x throughput over REST.
This article introduces gRPC, Google’s high‑performance RPC framework built on HTTP/2 and Protocol Buffers, compares it with REST, explains protobuf type mappings, demonstrates service definitions and all four communication patterns, and covers advanced topics such as interceptors, load balancing, deadlines, error handling, and microservice integration.
This guide details production-grade HTTP client tuning in Spring Boot, covering RestTemplate pitfalls, HttpClient 5 configuration, connection pool sizing via Little's Law, timeout layering, HTTP/2 trade-offs, business isolation patterns, interceptor chains, graceful shutdown, and metrics-driven troubleshooting for connection leaks.
The smart-servlet 3.3 release ran the full Jakarta Servlet TCK suite of 1,724 test cases, achieving a 99.8% pass rate with only four non‑critical errors, and the report details why this verifiable compatibility matters for middleware selection, compliance reviews, and migration risk, plus two spec‑compliant optimizations.
The Codex team uncovered a new HTTP/2 bomb that exploits HPACK compression and a zero‑byte window stall, allowing an attacker with just 100 Mbps bandwidth to consume up to 32 GB of memory on vulnerable servers such as nginx, Apache, IIS, Envoy and Cloudflare Pingora within seconds, and the article details the attack mechanics, historical context, disclosure timeline, and mitigation strategies.
By establishing baselines, methodically profiling logs, and applying layered tweaks—such as keepalive connections, gzip compression, proxy caching, worker tuning, HTTP/2, kernel parameters, and backend caching—this guide demonstrates how to reduce Nginx’s total response time from 500 ms to under 50 ms with measurable results.
This article explains the OSI seven‑layer model, TCP header fields, the three‑way handshake and four‑way termination processes, TIME‑WAIT timing, connection capacity calculations, packet fragmentation and reassembly, flow control, HTTP version differences, HTTPS security flow, and common analysis tools like Wireshark.
The article reviews Reqable, a free, cross‑platform API testing tool that eliminates Postman's performance bottlenecks, login requirements, and paid features, offering faster startup, lower memory usage, HTTP/2‑3 support, data migration, and an active open‑source community.
The article traces the evolution of HTTP from the persistent‑connection design of HTTP/1.1 through the multiplexed, binary framing of HTTP/2 to the QUIC‑based HTTP/3, while also explaining status codes, cookies, caching directives, RESTful principles, WebSocket upgrades, and practical Python examples.
This article walks through creating a gRPC client and server in Go, covering proto file creation, option go_package usage, import statements, protoc compilation, ordinary and streaming RPC calls, file transfer via streams, and the underlying HTTP/2 reasons for gRPC's streaming capabilities.
Discover the five crucial differences between the classic requests library and the modern httpx client—including async support, HTTP/2, type hints, streaming APIs, and client lifecycle management—so you can choose the right tool for high‑performance Python backend projects.
This article examines gRPC’s implementation principles, multi‑language support, Protocol Buffers foundation, advantages and disadvantages, and provides a C++/Go demo illustrating its cross‑language capabilities within cloud‑native environments, including project structure, code snippets, and discussion of HTTP/2 transport.
In many Envoy‑based gateways, enabling HTTP/2 can cause intermittent 404 errors because the :authority header and the TLS SNI value differ, especially when using wildcard certificates and multi‑domain routing, and this article explains the root cause and multiple mitigation strategies.
gRPC can halve request latency compared to REST+JSON by leveraging HTTP/2’s multiplexed connections and the compact binary Protobuf format, which reduces payload size and speeds serialization, though it introduces complexities like load balancing, debugging, and contract management.
The article explains why browsers limit concurrent connections per domain for performance and security reasons, compares HTTP/1.1 and HTTP/2 handling of these limits, and outlines practical frontend optimization strategies such as domain sharding, CDN usage, resource bundling, and lazy loading.
This article introduces Tonic, a Rust gRPC framework, explains its core features, components, and provides detailed, code‑rich instructions for building both server and client applications, while highlighting performance, security, and ideal use‑cases for microservices.
This guide explains how to switch the embedded web server in Spring Boot 3.2.5, disable it, customize ports (including random and range ports), enable HTTP compression, configure SSL and HTTP/2, add servlets, filters, listeners, set up logging, and fine‑tune Tomcat and Undertow settings, all with practical code examples.
This article walks through the painful migration from Apache HttpClient 4.x to 5.3, detailing modular design, customization, HTTP/2 support, connection management, API changes such as retry strategy, request/response configuration, interceptors, async client, and provides concrete Maven snippets and code comparisons to help developers evaluate whether the upgrade is worthwhile.
This tutorial explains what HTTP/2 is, lists required OpenSSL and Nginx versions, walks through compiling OpenSSL and OpenResty with the proper flags, shows how to replace Nginx binaries, configure HTTP/2 in nginx.conf, and verify the setup using Chrome’s net‑internals tool.
Apache Tomcat 10.1.10 has been released, bringing Jakarta EE 10 support, automatic migration of Java EE apps via the Jakarta EE Migration Tool, and notable updates such as virtual thread support, RFC‑9218 HTTP/2 priority, deprecation of xssProtectionEnabled, and an upgraded Tomcat Native 2.0.4 with OpenSSL 3.0.9.
cURL 8.1 introduces three main changes: support for HTTP/2 over HTTPS proxies via the –proxy-http2 option, rejection of hostnames ending with .onion during DNS resolution, and an expanded set of variables for the -w option to output URL components.
The article traces the evolution of Taobao’s unified mobile network library AWCN, detailing its MobileSDN architecture across north‑bound and south‑bound layers, key techniques such as IP‑list scheduling, adaptive protocol selection, multi‑path request handling and vendor acceleration, the challenges faced, performance gains observed during high‑traffic events, and future plans for finer network sensing and intelligent scheduling.
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.
The article explains how modern browsers handle TCP connections and HTTP requests, covering persistent connections, the limits of HTTP/1.1 pipelining, the advantages of HTTP/2 multiplexing, and browser-imposed limits on simultaneous connections per host.
The curl 7.88.1 update addresses several critical bugs—including HTTP/2 multiplexed data corruption, inaccurate connection timeout handling, uninitialized port values in runtests, missing SRP support checks, HTTP3 fallback when HTTP2 is unavailable, and socketpair EWOULDBLOCK handling—enhancing reliability across platforms.
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 explains why low‑latency Nginx HTTPS is crucial for instant search, breaks down TLS handshake round‑trips, and provides step‑by‑step configuration changes—such as enabling HTTP/2, adjusting ciphers, activating OCSP stapling, tweaking buffer sizes and session cache—to achieve roughly a 30% reduction in request latency.
This article explains the key features of HTTP/2, the performance and security enhancements of TLS 1.3, the benefits of ECC over RSA, Brotli compression, and provides step‑by‑step Nginx configuration snippets to enable these technologies in production environments.
This article shares Tubi’s experience using Elixir‑gRPC in production, covering performance optimizations, stability measures, HTTP/2 edge‑case handling, and practical code examples for efficient Protobuf processing; it also discusses Envoy sidecar integration, interceptor usage, and lessons learned from real‑world deployments.
HTTP/2 introduces a binary framing layer, multiplexed streams, header compression, and server push, replacing the limitations of HTTP/1.x by enabling a single TCP connection to carry multiple concurrent requests, reducing latency, improving bandwidth usage, and simplifying web development, while also presenting new debugging challenges.
This article explains the key features of HTTP/2—including binary framing, header compression, flow control, multiplexing, request priority, and server push—alongside TLS 1.3 enhancements, ECC advantages, and Brotli compression, and provides practical Nginx configuration steps to leverage all of them for faster, more secure web delivery.
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.
gRPC is a high‑performance, open‑source RPC framework built on HTTP/2 and Protocol Buffers, and this guide explains its core concepts, communication patterns, protobuf usage, and provides step‑by‑step Python examples for creating, compiling, and running client‑server services, plus deployment tips.
This article introduces gRPC, explains its HTTP/2 and Protocol Buffers foundations, walks through writing and compiling .proto files, provides complete Python server and client examples, and shows how to quickly set up the environment and integrate gRPC into microservice and Kubernetes deployments.
To prevent massive user loss from slow loads, iQIYI International overhauled its mobile app’s network stack—switching to HTTPDNS, enabling TCP Fast Open, upgrading to HTTP/2 and TLS 1.3, compressing payloads with Brotli and WebP, using protobuf, caching, and fallback protocols—cut latency, reduced failures, and boosted video playback across Southeast Asian markets.
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.
The article examines the limitations of TCP and HTTP/2, explains how Google's UDP‑based QUIC protocol addresses issues such as head‑of‑line blocking, connection migration, and RTT estimation, and compares performance in both good and poor network conditions, highlighting its multiplexing, flow‑control, and security advantages.
This article explains what APIs are, introduces RPC and gRPC, compares them with REST across protocols, data formats, performance, code generation, and browser support, and offers guidance on when to choose gRPC or REST for microservice and mobile applications.
This article introduces the high‑performance gRPC framework, explains why it uses HTTP/2 and Protocol Buffers, outlines its core components, and provides a step‑by‑step Python tutorial with environment setup, code generation, server and client implementations, and common application scenarios.
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 explains the shortcomings of HTTP/1.x, introduces the key innovations of HTTP/2 such as binary framing, multiplexing, server push, header compression, request priority, stream reset and flow control, and shows why mastering these concepts is essential for modern web development and 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.
HTTP/2, now widely supported by browsers and major sites, replaces HTTP/1.1 by introducing a binary framing layer, header compression, stream prioritization, server push, and flow control, addressing head-of-line blocking and inefficiencies while maintaining HTTP semantics, with detailed discussion of its evolution, structure, and deployment considerations.
This article explains practical Nginx configuration tweaks—including enabling gzip compression, setting cache headers, activating HTTP/2, optimizing logging, and limiting bandwidth—to reduce bandwidth usage and server load, illustrated with code examples and performance impact calculations for typical web traffic.
This article provides a comprehensive technical analysis of the HTTP/2 protocol, detailing its architectural improvements over HTTP/1.1, including HPACK header compression, binary framing, stream multiplexing, and server push, while demonstrating practical packet capture techniques to illustrate its performance optimizations.
This article presents a series of experiments comparing HTTP/1.1 and HTTP/2 request merging versus splitting, analyzing how concurrency, multiplexing, and header compression affect page load times for small images, large assets, and JavaScript under various network conditions.
The article explains how reusing HTTP connections with OkHttp—by leveraging persistent HTTP/1.1, multiplexed HTTP/2, and pre‑established sockets—dramatically cuts latency, details the underlying ConnectInterceptor and ConnectionPool implementation, and recommends enlarging the pool and adjusting keep‑alive settings to suit multi‑domain, high‑concurrency apps.
This article reviews Google’s pioneering SPDY protocol, its key features and impact on HTTP/2, then explores the disruptive QUIC protocol built on UDP, detailing its connection setup, Diffie‑Hellman encryption, multiplexing, connection migration, and other enhancements that boost web performance.
The article thoroughly explains HTTP/2, detailing its optional clear‑text or TLS connection setup, multiplexed frames and streams, HPACK header compression, server‑push mechanism, application‑layer flow control, and the protocol’s lingering challenges such as TLS handshake latency and TCP head‑of‑line blocking that HTTP/3 seeks to resolve.
This article reviews the pioneering SPDY protocol that inspired HTTP/2, then delves into Google's disruptive QUIC protocol—explaining its UDP foundation, Diffie‑Hellman encryption, connection migration, and advanced features that overcome TCP limitations, while comparing their roles in modern web communication.
This article reviews the development and core features of HTTP/2, explains why its TCP‑based design still suffers from head‑of‑line blocking and handshake latency, and argues that these inherent limitations make the transition to HTTP/3 over QUIC inevitable for modern web developers.
This article reviews the evolution of web communication protocols, detailing SPDY's pioneering features that influenced HTTP/2 and exploring QUIC's disruptive UDP‑based design, security mechanisms, multiplexing, connection migration, and other enhancements that reshape modern internet performance.
This article explains why web application performance is critical, presents ten practical optimization techniques—including reverse proxy, load balancing, caching, compression, SSL/TLS tuning, HTTP/2, software upgrades, Linux and web‑server tuning, and real‑time monitoring—to help developers and operators achieve up to tenfold speed improvements.
This article explains the fundamentals of RPC protocols, compares common designs such as HTTP/1.1, RESP, HTTP/2, and gRPC, and outlines the motivations and key features of Dubbo 3.0’s next‑generation protocol for better performance, extensibility, and cross‑language support.
This article explains the fundamentals of HTTP, the differences between GET and POST, common status codes, HTTPS and TLS handshakes, the improvements introduced by HTTP/2 such as binary framing, multiplexing and header compression, as well as the role of QUIC and DNS in the end‑to‑end web request flow.
This article provides a comprehensive overview of HTTP fundamentals, compares GET and POST, explains common status codes, details HTTPS and TLS mechanisms, introduces HTTP/2 features such as binary framing, header compression and server push, and walks through the full request‑response flow from DNS lookup to page rendering.
Web performance is critical in today's online economy; this article explains ten practical NGINX‑based techniques—including reverse proxy, load balancing, caching, compression, SSL/TLS tuning, HTTP/2, software upgrades, Linux tweaks, server tuning, and real‑time monitoring—that together can deliver up to tenfold speed improvements and higher conversion rates.
This article outlines ten practical techniques—including reverse proxy deployment, load balancing, caching, data compression, SSL/TLS optimization, HTTP/2 adoption, software upgrades, Linux tuning, web server configuration, and real‑time monitoring—that together can dramatically improve web application speed, reliability, and security.
This article explains why web performance matters, presents ten practical NGINX‑based techniques—including reverse proxy, load balancing, caching, compression, SSL/TLS optimization, HTTP/2, software upgrades, Linux and web‑server tuning, and real‑time monitoring—to help you achieve up to tenfold speed improvements.
The article chronicles the development of static resource services—from early ASP examples and static‑dynamic separation to modern CDN, cloud storage, URL handling, online concatenation, and multi‑region deployment—highlighting technical decisions, performance trade‑offs, and future challenges for front‑end infrastructure.
This article outlines essential API design principles and best practices, covering simple, understandable, consistent, stable, and secure APIs, then delves into RPC mechanisms, Protobuf serialization, RESTful conventions, Swagger documentation, Spring Boot integration, HTTP/2 performance improvements, and the powerful combination of HTTP/2 with Protobuf in gRPC.
This article systematically explains web image optimization, covering image formats, request and volume reduction techniques such as HTTP/2, lazy loading, caching, sprites, Base64, multi‑resolution handling, and accessibility considerations, providing practical code examples and tool recommendations for front‑end developers.
This article provides a comprehensive overview of the HTTP/2 protocol, explaining its binary framing, multiplexing, header compression, request prioritization, and server push features, and offers step‑by‑step guidance for upgrading Nginx to support HTTP/2 along with detection methods.
This article examines why occasional ECONNRESET errors occur in HTTP RPC keep‑alive connections, explains the underlying TCP and OS mechanisms, and compares several practical mitigation strategies—including retries, connection pre‑discard, idempotent handling, and protocol upgrades such as HTTP/2 and gRPC—to help developers choose the most reliable solution.
This article explains the core features of HTTP/2, TLS 1.3, ECC and Brotli, and provides practical Nginx configuration steps—including binary framing, header compression, flow control, multiplexing, request priority, server push, and module compilation—to dramatically improve web latency and bandwidth efficiency.
This article details the Mobile Service “秒开” project’s three‑step performance optimization, covering data‑driven monitoring, HTTP/2 features like header compression and multiplexing, long‑connection architecture with WebSocket, and an asynchronous caching component that together dramatically improve response times and reliability for mobile clients.
This article explains the core features of HTTP/2, TLS 1.3, ECC and Brotli, shows how they improve performance and security, and provides practical nginx configuration steps to enable these modern web technologies.
This article explains the HTTP Live Streaming (HLS) protocol, its standard playlist and segment structure, the latency challenges of traditional HLS, and details Apple’s low‑latency HLS draft with five technical improvements, demo implementation, and a comparison to Periscope’s LHLS approach.
HTTP/2, the first major update to HTTP since 1.1, introduces binary framing, multiplexing, server push, and header compression, dramatically improving web performance by reducing latency, consolidating connections, and optimizing resource delivery, as detailed in this comprehensive overview.
An in‑depth look at how browsers handle TCP connections during page loads, covering persistent connections, request limits per host, HTTP/1.1 pipelining, HTTP/2 multiplexing, and why SSL handshakes may be reused, illustrated with real‑world connection timing screenshots.
This article reviews HTTP/2's core features, evaluates its performance advantages and limitations in real‑world web deployments, discusses server‑push and proxy challenges, and offers a forward‑looking perspective on its adoption across the industry.
This article examines the limitations of HTTP/1.x, explains how HTTP/2 addresses them, details the NDSF framework's implementation choices, presents comprehensive JMeter‑based performance tests, and analyzes the results to show traffic reduction, latency stability, and overall business benefits.
This article reviews HTTP/2's core features such as binary framing, multiplexing, header compression, and server push, evaluates their performance benefits and real‑world limitations, discusses implementation challenges in Go and proxy servers, and provides references for further study.
This article demonstrates how to add on‑demand and periodic HTTP/2 server‑push functionality in Go, explaining the required handlers, showing complete Go code examples, and detailing the HTTP/2 frame exchange observed with an h2c client.
This article demonstrates how to build a minimal HTTP/2 server in Go that responds only with header frames, covering certificate generation, server code, frame structures, the http2Framer API, and how to test the implementation using curl, providing both conceptual explanations and full source listings.
This article explains HTTP/2's header compression using the HPACK format—including static and dynamic tables, Huffman coding, and literal encoding—and the Server Push mechanism with PUSH_PROMISE frames, illustrating how these features reduce bandwidth and improve request latency.
This article provides a comprehensive overview of HTTP/2, explaining its binary framing, multiplexing, and the various frame types such as DATA, HEADERS, PRIORITY, RST_STREAM, SETTINGS, PUSH_PROMISE, PING, GOAWAY, WINDOW_UPDATE, and CONTINUATION, with specific focus on how Go's HTTP server implements these features.
This article provides a comprehensive overview of the HTTP protocol, covering its relationship with DNS/TCP/IP, request/response structure, methods, design principles, persistent connections, cookies, compression, caching, status codes, and the enhancements introduced in HTTP/2.
Node.js 10 LTS introduces major updates such as native HTTP/2 support, BigInt, recursive directory creation, CLI flag auto‑completion, Windows installer improvements, V8‑based code coverage, deprecated Buffer constructors, and experimental Worker Threads, while also upgrading OpenSSL and adding PEM‑level encryption.
This article explains why HTTPS is essential by comparing HTTP’s performance drawbacks, detailing its security vulnerabilities, and describing the cryptographic mechanisms—including TLS, symmetric and asymmetric encryption, certificates, and HMAC—that HTTPS employs to protect data and enable modern features like HTTP/2.
The article examines Java 11’s long‑term support status, key enhancements like ZGC, Flight Recorder, HTTP/2 client, TLS 1.3, and numerous JEPs, explaining why engineers and IT decision‑makers should consider upgrading to leverage performance, security, and productivity gains.
This article demonstrates how to build an HTTP/2 server and client in Go, covering TLS certificate generation, server and client implementations, switching between HTTP/1.1 and HTTP/2, server‑push handling, and full‑duplex echo communication with complete code examples.
Tencent CDN’s implementation of HTTP/2 Server Push predicts and preloads dependent resources via link tags or headers, creates PUSH_PROMISE frames, and streams assets before the main response, yielding measurable latency reductions on real‑world pages when used with proper sizing, priority, and cache awareness, while avoiding slow‑start and buffer issues.
This article explains what head‑of‑line blocking is in HTTP, why HTTP/1.1 suffers from it, how HTTP/2 over TCP mitigates request‑level blocking but not transport‑level issues, and how QUIC over UDP fully resolves the problem.
This article explains HTTP/2 fundamentals, showcases its adoption by major Chinese sites, and provides a step‑by‑step Node.js tutorial—including installation, SSL setup, server code, and a demo that fires 100 parallel requests—to help developers experience the protocol’s benefits.
HTTP/2 replaces the text‑based HTTP/1.x with a binary, multiplexed protocol that reduces latency, eliminates head‑of‑line blocking, compresses headers, enables server push, and improves security, offering REST APIs faster, more efficient communication while preserving familiar semantics for developers.
This article compares HTTP/2 with its predecessor HTTP/1.x, detailing performance gains through multiplexing, binary framing, header compression, and server push, and explains the underlying mechanisms such as TCP behavior, binary frames, static and dynamic header tables, illustrating concepts with visual examples.
This guide compiles common HTTPS and HTTP/2 deployment problems—such as Let’s Encrypt validation failures, certificate transparency errors, SNI incompatibility, cipher‑suite misconfigurations, and mixed‑content issues—and provides concise, actionable solutions with reference links for each case.
HTTP/2 introduced server push to let servers proactively send resources, but it suffers from issues such as cache invalidation after connection closure, difficulty identifying needed pages, lack of authentication reuse, and other pitfalls, so understanding its traps and best practices is essential for effective use.
This article explains how modern websites rely on HTTPS and CDN, details SSL/TLS and HTTP/2 fundamentals, describes Alibaba Cloud's CDN HTTPS architecture, dynamic certificate management, key‑server solutions, optimization techniques, and practical guidance for deploying HTTPS end‑to‑end.
A recent analysis shows Nginx rapidly gaining market share to 33.3% worldwide, overtaking Apache which has fallen below 50%, with regional variations, protocol support advantages, and future trends indicating continued growth for modern web servers.