This article explains the fundamental differences between RPC and HTTP services, covering the OSI network model, RPC architecture components, synchronous and asynchronous calls, and introduces popular open‑source RPC frameworks such as gRPC, Thrift, and Dubbo, before comparing their suitability for various enterprise scenarios.
An in‑depth guide to computer network architecture covers layered models, the OSI reference model versus TCP/IP, protocol functions from the physical to application layer, TCP three‑way handshake and four‑way termination, HTTP basics, encryption methods, and common interview questions for network engineers.
This guide demonstrates how to use Python's requests library for sending GET, POST, and HTTPS requests, handling file uploads and downloads, managing timeouts, performing authentication, session and token handling, generating signatures, and organizing a complete API test automation framework.
This article walks through the complete journey of a web request—from entering a URL, checking browser, OS, router, and ISP DNS caches, performing DNS queries, resolving MAC addresses via ARP, establishing a TCP three‑way handshake, sending an HTTP request, to finally rendering the HTML page in the browser.
This article provides an extensive overview of the HTTP protocol, covering its layered network architecture, request/response processes, detailed header fields, caching directives, status codes, message bodies, as well as related components such as cookies, proxies, and servers.
This whimsical diary narrates the evolution of the HTTP protocol—from its humble GET request origins to the sophisticated features of HTTP/2—using a client‑server love story to illustrate methods, headers, pipelining, chunked transfer, and server push in an engaging, educational way.
This article explains how to extract song information from KuGou by inspecting network requests, simplifying URLs, generating required MD5 signatures, constructing authenticated API calls, and using Python to download the resulting audio files to a local directory.
This comprehensive guide walks you through Postman's core capabilities—including installation, interface navigation, sending requests, handling query parameters, forms, JSON and file uploads, response analysis, collection management, batch execution, logging, assertions, variables, pre‑request scripts, and request chaining—empowering developers and testers to automate and streamline API testing workflows.
This article explains the fundamental differences between RPC and HTTP services, covering the OSI model, RPC architecture, synchronous vs. asynchronous calls, popular RPC frameworks, and when to choose RPC over HTTP for enterprise versus small‑scale applications.
This article provides a comprehensive overview of the HTTP protocol, covering its definition, stateless nature, connection handling, key characteristics, request/response workflow, header fields, status codes, caching mechanisms, and practical applications such as resumable downloads, multithreaded downloading, proxy servers and virtual hosting.
This article explains the fundamental differences between RPC and HTTP services, outlines the OSI model, describes RPC architecture, synchronous and asynchronous calls, compares popular RPC frameworks such as gRPC, Thrift, and Dubbo, and discusses when to choose each approach for backend development.
This article explains the inherent insecurity of plain HTTP, illustrates man‑in‑the‑middle attacks, shows why simple symmetric encryption is insufficient, and details how HTTPS (SSL/TLS) with asymmetric key exchange and CA verification protects data transmission.
This article reviews the fundamentals of the HTTP protocol, explains why its plaintext transmission makes it vulnerable to man‑in‑the‑middle attacks, and details how HTTPS—through SSL/TLS, asymmetric key exchange, and CA certificate verification—protects data integrity and confidentiality.
An in‑depth guide covering Java reflection fundamentals, three methods to obtain Class objects, and practical code examples, followed by a comprehensive overview of computer networking layers, protocols, TCP/IP versus OSI models, transport protocols, HTTP/HTTPS differences, status codes, GET/POST, cookies, sessions, tokens, and servlet lifecycle.
This article explains the fundamental differences between RPC and HTTP services, reviews the OSI network model, describes RPC architecture, synchronous and asynchronous calls, compares popular RPC frameworks such as gRPC, Thrift, and Dubbo, and discusses when to choose each approach for enterprise applications.
This article explains why caching is essential for web performance, describes the two main HTTP cache types (strong and negotiated), compares Expires and Cache‑Control headers, and details ETag generation, validation, and best‑practice considerations in server implementations such as Nginx.
This article explains HTTP’s key characteristics, compares short‑lived and persistent connections, and explores related concepts such as head‑of‑line blocking, concurrency, and domain sharding, providing readers with a comprehensive understanding of how HTTP manages connections and performance.
This article walks through the complete process of how a browser accesses a web resource, from parsing a URL and generating an HTTP request, through DNS name resolution, the construction of MAC, IP, TCP, and application headers, to the TCP three‑way handshake, data transmission, and the four‑step connection termination.
The article shares three interview scenarios—a puzzling HTTP GET failure, a rate‑limiting challenge solved with token‑bucket logic, and a deep dive into Java ThreadPoolExecutor behavior—each followed by personal insights on problem‑solving, algorithm application, and understanding underlying principles.
This article explains how to build a high‑performance large‑file HTTP upload service with resumable support by using a C‑based server, client‑side hash generation, cookie‑based browser IDs, AJAX queries for upload progress, and JavaScript code that slices files and tracks upload speed and progress.
This article provides a comprehensive overview of HTTP caching mechanisms, covering cache‑related header fields, legacy directives like Pragma and Expires, modern Cache‑Control directives, validation headers such as Last‑Modified and ETag, practical simulation with Fiddler, and best‑practice recommendations for both client and server side caching.
This article details the design evolution, architectural choices, performance tuning, monitoring, and future plans of Ximalaya's high‑traffic HTTP gateway, covering its migration from Tomcat NIO to a fully asynchronous Netty implementation and the associated engineering challenges and solutions.
This article provides a comprehensive overview of HTTP caching mechanisms, detailing cache‑related header fields, browser behaviors, legacy and modern directives, validation techniques, and practical tips for configuring efficient cache strategies in web applications.
This article introduces the Forest HTTP client framework, showing how it abstracts diverse third‑party API differences through configuration and annotations, provides easy Spring Boot integration, and offers powerful features like template expressions, HTTPS support, and extensive request customization.
This article explains how to transform a Java HttpRequestBase object into an equivalent curl command, enabling rapid request replay across servers and detailed timing analysis, and demonstrates the process with step‑by‑step code examples and a functional test using the FunTester framework.
This article explains how misconfigured HTTP Host headers can be abused for attacks such as cache poisoning, SSRF, password‑reset poisoning and other server‑side exploits, and provides practical detection methods and defensive recommendations for developers and security engineers.
This article explains what HTTP request smuggling is, how the vulnerability arises from conflicting Content‑Length and Transfer‑Encoding headers, describes common CL.TE, TE.CL and TE.TE attack patterns, and outlines detection techniques and defensive measures for modern web infrastructures.
This article examines the vulnerabilities of HTTP, illustrates man‑in‑the‑middle attacks, and explains how HTTPS—through SSL/TLS handshakes, certificate authorities, and asymmetric encryption—protects communications, providing a comprehensive understanding of web security fundamentals for developers and users alike.
This article details the design evolution, architectural redesign, and performance‑tuning techniques of Ximalaya's gateway—from an initial Tomcat NIO implementation to a fully asynchronous Netty‑based solution—covering traffic management, timeout handling, monitoring, and future HTTP/2 migration.
This article demonstrates how to build a Java-based web crawler that fetches image URLs from Sogou Image Search, parses the JSON response, and downloads thousands of pictures to a local directory using multithreaded processing and custom HTTP utilities.
This article explains the OSI seven‑layer model, compares HTTP RESTful services with RPC architectures, and shows when and why to choose RPC for high‑performance, distributed backend systems.
This comprehensive guide covers 66 key computer networking topics, from the evolution of HTTP protocols and request methods to TCP/IP fundamentals, TLS/HTTPS security, web performance optimization, caching strategies, cookies, tokens, and common interview questions, providing clear explanations, diagrams, and practical examples for developers.
The article explains how the IETF's RFC 7807 standardizes HTTP API error responses by defining a common problem‑details format, describing its fields, JSON/XML examples, benefits for clients and servers, and practical steps for adopting it across various programming ecosystems.
Hulk is a non‑intrusive HTTP mock platform built with Django, mitmproxy, Vue, MongoDB and MySQL that lets teams mock client‑side, gateway-level and inter‑service APIs via configurable responses, without modifying production code, thereby reducing test‑data creation effort, stabilizing automation and improving overall testing efficiency.
This article explains how to capture browser curl requests, parse them into Java HttpRequestBase objects, and run high‑concurrency performance tests using a custom FunTester framework, complete with code examples, metrics, and repository links.
This article explains how to quickly integrate the Retrofit HTTP client into a Spring Boot project with the retrofit‑spring‑boot‑starter, covering dependency setup, configuration annotations, interface definition, custom annotation‑based interceptors, connection‑pool management, logging, exception formatting, call adapters, converters, and global interceptors, all illustrated with complete code examples.
This article explains the Same Origin Policy, introduces the CORS standard, details simple and preflight request handling, lists essential response headers, and provides three practical Spring Boot solutions—including global configuration, a servlet filter, and the @CrossOrigin annotation—to resolve cross‑origin issues.
The article explains the vulnerabilities of plain HTTP, demonstrates how man‑in‑the‑middle attacks can intercept and modify traffic, and describes the evolution of security mechanisms—including symmetric and asymmetric encryption, TLS handshakes, and certificate authority verification—that together make HTTPS a robust solution for protecting web communications.
This article explains the core characteristics of the HTTP protocol—including its flexibility, reliability, application‑layer nature, request‑response model, and statelessness—and then details short and long connection management, related header fields, head‑of‑line blocking, and practical performance‑enhancing techniques such as concurrent connections and domain sharding.
This tutorial shows how to install the Python requests library and use it to perform GET and POST HTTP requests, covering required parameters, headers, and example code for handling responses.
This article explains HTTP's core characteristics—flexibility, reliability, application‑layer nature, request‑response model, and statelessness—then dives into short‑ and long‑connection management, head‑of‑line blocking, and practical optimization techniques such as concurrent connections and domain sharding.
This guide shows how to install the Python requests library and use it to perform GET and POST HTTP requests, explaining required parameters, headers, and providing complete code examples for calling remote APIs.
This article traces the evolution of HTTP from its 1991 origins through HTTP/1.0, 1.1, SPDY, and HTTP/2, explaining why the shift to UDP‑based QUIC in HTTP/3 promises faster, more secure web delivery while also highlighting the new protocol’s challenges.
This guide provides a concise reference of curl's most useful command‑line options, explaining how to customize headers, handle cookies, send data, manage redirects, control output, and debug requests for efficient web and API interactions.
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 explains the fundamentals of the HTTP protocol, demonstrates how its plaintext transmission enables man‑in‑the‑middle attacks, and then details how HTTPS (TLS/SSL) with certificate authority verification and asymmetric key exchange secures web communication against such threats.
This article explains why TCP KeepAlive is needed, how it differs from HTTP Keep-Alive, and provides practical Linux kernel and Nginx configuration steps to prevent session timeouts in load‑balancing scenarios such as LVS and F5 devices.
This guide provides a concise reference of curl's most useful command‑line options, explaining how to set headers, handle cookies, send data, control redirects, limit bandwidth, and debug requests, enabling developers and operators to replace GUI tools with a powerful terminal utility.
This article provides a detailed, step‑by‑step explanation of how a browser processes a simple HTTP request—from URL parsing, DNS lookup, and TCP connection through server handling, response reception, HTML/CSS parsing, layout, painting, reflow/repaint, and JavaScript execution—highlighting key concepts, optimizations, and common pitfalls.
This article explains how Chrome uses multiple processes, the fundamentals of TCP/IP reliability, the HTTP request lifecycle, caching mechanisms, and the step‑by‑step flow from entering a URL to rendering a page, providing essential knowledge for front‑end interviews.
This guide explains how to use curl for sending GET, POST, and other HTTP requests, covering headers, data payloads, authentication, file uploads, and submitting data from files with clear command examples.
This article explains the fundamental distinctions between HTTP GET and POST requests, covering parameter placement, caching, URL length limits, security implications, TCP packet behavior, and practical considerations for developers when choosing the appropriate method.
This guide shows how to use curl's --resolve option to force a specific IP address for a domain during HTTP or HTTPS requests, avoiding hosts file changes, DNS cache flushing, and the need to edit system configurations.
This article explains the fundamentals of HTTP, the differences between GET and POST, common status codes, HTTPS and TLS handshakes, the performance improvements of HTTP/2, binary framing, multiplexing, header compression, server push, QUIC, DNS resolution, and the complete browser loading process from URL to rendered page.
This article explains what Laravel middleware is, how to create custom middleware with Artisan, the structure of the handle method, the difference between global and route middleware, how to register middleware in the Kernel, and various ways to assign middleware to routes or controllers, including parameter passing.
This article explains the OSI model basics, compares RPC and HTTP service architectures, details synchronous and asynchronous calls, introduces major RPC frameworks like gRPC, Thrift, and Dubbo, and offers guidance on choosing between RPC and HTTP based on project needs.
This article walks through the complete lifecycle of a network request, explaining URL structure, HTTP methods and headers, DNS query mechanics, socket programming, TCP/IP communication, firewall filtering, and various load‑balancing strategies in clear, step‑by‑step detail.
This curated collection highlights recent essential reads for front‑end developers, covering the deprecation of LibSass, using service workers to turn single‑page apps into polyfills, career growth insights, comprehensive HTTP knowledge, overcoming technical and business bottlenecks, performance optimization tips, Node.js sandbox security, Facebook’s Recoil state‑management library, and the opportunities and challenges of enterprise‑level data visualization.
This article explains how to configure connection and read timeouts for HTTP calls in Spring Cloud, compares Feign and Ribbon settings, reveals common pitfalls such as overly long timeouts and automatic retries, and provides practical solutions for improving concurrency and preventing duplicate requests in Java microservices.
This article explains the principles and workflows of typical authentication mechanisms—including HTTP Basic authentication, cookie‑based sessions, JSON Web Tokens, and OAuth—detailing their encryption processes, storage strategies, token refresh techniques, and security considerations for modern web applications.
This article explores what “state” means in the HTTP protocol, clarifies the concepts of statelessness and connection‑lessness, demonstrates their impact through a simulated shopping‑cart scenario, and explains how cookies and sessions introduce state to enable practical web interactions.
This article explains the TCP/IP layered model, differences between TCP and UDP, the three‑way handshake and four‑step termination, how HTTP builds on TCP, common HTTP status codes, message format, and the step‑by‑step process that occurs from entering a URL to loading a web page.
This article demonstrates how to create a lightweight key/value store named kedis by integrating Facebook's RocksDB storage engine with the RestExpress HTTP container, providing step‑by‑step instructions, code examples for initializing the database, defining routes, and running the service via HTTP GET requests.
This guide walks you through using the Python httpx library to perform various HTTP methods—including GET, POST, PUT, DELETE, HEAD, and OPTIONS—handle query parameters, decode responses, work with JSON, custom headers, form data, file uploads, streaming, cookies, redirects, and authentication, all with clear code examples.
This guide explains how to install Axios, set up a reusable HTTP module in a Vue project, configure environment‑specific base URLs, define request timeouts and headers, and implement request and response interceptors along with simple get/post wrapper functions.
This article explains why the Kitty Cloud project integrates both Feign and Dubbo, discusses the need for dual‑protocol support during migration from Dubbo to Spring Cloud, presents three migration strategies, and shows how to implement and configure both HTTP and RPC calls within the same service.
This article explains the inherent insecurity of plain HTTP, demonstrates how man‑in‑the‑middle attacks can intercept and modify traffic, and shows how HTTPS—through SSL/TLS handshakes, RSA key exchange, and a trusted CA hierarchy—protects communications from such threats.
This article explains the fundamental similarities and practical differences between HTTP GET and POST requests, covering how parameters are transmitted, caching behavior, URL length limits, security considerations, underlying TCP mechanics, and the impact on performance and semantics.
This article explains the fundamental distinctions between GET and POST HTTP methods, covering how parameters are transmitted, caching behavior, URL length limits, security implications, and the underlying TCP packet flow, while debunking common myths and highlighting practical considerations for developers.
This article compares four Java HTTP client options—HttpURLConnection, Apache HttpComponents HttpClient, the Java 9 HttpClient, and OkHttp—detailing their features, code examples, configuration capabilities, and suitability for projects that need connection pooling, DNS control, form/JSON support, and synchronous or asynchronous calls.
This tutorial walks through creating a Netty HelloWorld server in IntelliJ IDEA using Gradle, adding the Netty dependency, implementing the server bootstrap, event loop groups, initializer and handler classes, and verifying the service with a curl request.
This guide walks through building a Java SMS verification service, covering code generation, API integration, session handling, and a reusable HTTP utility with full source examples, including Maven dependency setup, configuration file preparation, and step‑by‑step execution.
This article explains the fundamentals of the HTTP protocol, illustrates its vulnerability to man‑in‑the‑middle attacks, and details how HTTPS—through SSL/TLS, asymmetric key exchange, and a trusted CA certificate hierarchy—secures communications by encrypting data and preventing interception and tampering.
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 explains the limits of HTTP keep-alive, compares Ajax polling and long‑polling techniques for server push, and then details how the WebSocket protocol establishes a full‑duplex connection through a handshake and data‑transfer phase.
This article provides a thorough introduction to computer networking fundamentals, covering the OSI seven‑layer model, TCP/IP architecture, IP addressing, subnet masks, ARP/RARP, routing protocols, and key application layer protocols such as DNS, HTTP, and DHCP, with practical examples and diagrams.
This article explains the PHP mb_http_output() function, detailing how it sets or retrieves the HTTP output character encoding, its parameters, return values, and provides a complete example for configuring Unicode handling in PHP scripts.
Although HTTP is described as a stateless, connectionless protocol, this article dissects what “state” truly refers to, explains why the protocol lacks memory of client interactions, and demonstrates how mechanisms like cookies, sessions, and server‑side caching introduce stateful behavior to enable features such as login persistence and shopping carts.
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.
This guide explains the core concepts of TensorFlow Serving, shows how to prepare Docker images, save TensorFlow 2.x models in various formats, configure version policies, warm‑up models, start the service, and invoke it via gRPC or HTTP with complete code examples.
This tutorial introduces Python's Requests library, covering installation, basic GET and POST requests, adding headers and parameters, handling proxies, cookies, sessions, and disabling SSL verification, with clear code examples for each feature.
This article explains the core concepts of TensorFlow Serving, shows how to prepare the environment with Docker, convert TensorFlow 2.x models to the SavedModel format, configure version policies, warm‑up the service, and invoke predictions via gRPC or HTTP interfaces.
The article explains how to bypass internal network restrictions by configuring a Java HTTP proxy, provides demo code for setting and using the proxy, and includes utility methods for proxy validation and request configuration.
This article outlines essential RESTful API design guidelines, covering clear URL conventions, precise HTTP status code usage, proper JSON responses, error handling without misleading 200 codes, and the inclusion of hypermedia links to improve client navigation.
Fiddler Everywhere is a cross‑platform web debugging proxy that merges Fiddler and Postman features, offering a modern UI for capturing, editing, and replaying HTTP(S) traffic, though its free version limits sharing and some functionalities are still maturing.
This article outlines essential RESTful API design principles, covering clear URL structures, proper use of HTTP verbs, precise status codes, appropriate response formats, and the inclusion of hypermedia links to create intuitive, maintainable, and standards‑compliant web services.
This guide explains the essential HTTP request header fields—Accept, Accept‑Encoding, Accept‑Language, User‑Agent, Connection, and Host—detailing their meanings, typical values, and how to use them to disguise a Python crawler and reliably fetch web pages.
This article walks through the complete lifecycle of a web request, from entering a URL and DNS resolution, through HTTP and TCP processing, IP routing, ARP resolution, and Ethernet framing, explaining each protocol layer's role in encapsulation and de‑encapsulation.
Browser caching works by storing copies of web resources in memory, disk, or service‑worker caches and using HTTP headers such as Cache‑Control, Expires, ETag, and Last‑Modified to decide freshness, allowing strong (local) and negotiated (weak) cache stages, while developers can fine‑tune performance with CDN settings, IndexedDB, Service Workers, and HTML5 storage to create optimal, auditable cache strategies.
This article explains the fundamentals of HTTP caching, the role of Service Workers, various cache layers (memory, disk, push), cache-control directives, and provides practical code examples to help front‑end developers improve page load speed and reduce server load.
This tutorial introduces Python’s Requests library, covering installation, core methods like GET, POST, PUT, PATCH, DELETE, detailed parameters, session handling, exception management, header customization, proxy usage, and practical code examples to empower effective web scraping.
This article explains why API testing has become essential in modern agile and IoT‑driven development, outlines the API testing pyramid, covers HTTP and REST fundamentals, and provides practical guidance on selecting tools, creating functional and load tests, and ensuring early, rapid feedback.
This article provides a comprehensive overview of HTTP status codes—from informational 1xx responses to client‑error 4xx and server‑error 5xx codes—including the newer RFC 6585 codes, explaining their meanings and typical usage scenarios for developers.
This guide provides a step‑by‑step tutorial on using Apache JMeter for performance testing, covering JDK and JMeter installation, creating a complete test script for a Baidu search API, configuring thread groups, HTTP requests, listeners, assertions, executing the test, and analyzing the aggregate report results.
From entering a URL to rendering a page, this article walks through the complete HTTP request lifecycle, detailing DNS resolution, TCP/IP transport, protocol layering, encapsulation, and the structure of HTTP messages, providing a clear, step‑by‑step explanation of how data travels across the network.
The article explains the fundamental differences between HTTP and HTTPS, outlines how HTTPS adds SSL/TLS encryption to the standard HTTP protocol, describes the step‑by‑step communication process—including certificate verification, key exchange, and encrypted data transfer—and compares ports, security, and connection details.
The article explains how modern browsers manage TCP connections for HTTP requests, covering persistent connections, the limits on concurrent connections per host, the behavior of HTTP/1.1 pipelining, why SSL sessions may be reused, and how HTTP/2 multiplexing improves parallel request handling.
This article explains the fundamentals of HTTP caching, covering strong and conditional cache mechanisms, the relevant response headers, and provides practical Node.js/Express code samples to demonstrate how browsers handle cache validation and expiration.
This article explores what “state” means in the HTTP protocol, clarifying the concepts of statelessness, the role of cookies and sessions, and how they address the limitations of pure HTTP through practical examples and security considerations.
This concise Laravel Request cheat sheet enumerates the most useful Request facade methods—covering URL retrieval, path handling, headers, IP detection, AJAX checks, and content format detection—to help backend developers quickly access HTTP request data in their applications.
