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.
This article explains Laravel's Response helper—a key tool for returning data to the front end—provides a concise quick‑reference table, and includes practical code snippets for creating responses, JSON output, file downloads, header manipulation, and cookie attachment.
This article explains essential RESTful API design details—including URL conventions, HTTP verb usage, status‑code precision, proper JSON responses, and HATEOAS linking—to help developers create clear, consistent, and user‑friendly web APIs.
This article compares Postman with IntelliJ IDEA REST Client, explains why IDEA’s built‑in HTTP client is preferable, and provides step‑by‑step guidance on using its console, request history, environment configuration, scripting syntax, and response assertions for efficient API testing.
This guide explains the concepts of white‑box and black‑box monitoring, introduces Prometheus Blackbox Exporter, walks through installation, systemd setup, and detailed Prometheus configurations for HTTP, TCP, ICMP, POST and SSL checks, shows Grafana dashboard integration, and provides alert rule examples for reliable service health monitoring.
This article explains how to build two Java load‑testing modes—quantitative and timed—by extending thread‑limit classes, managing GCThread lifecycle, sending HTTP requests with FanLibrary, and correctly cloning request objects to avoid bugs during multithreaded performance testing.
This article provides a thorough, step‑by‑step explanation of the entire browser request‑response cycle—including URL parsing, DNS lookup, TCP connection, server handling, response processing, and the detailed rendering pipeline—offering clear insight for developers and interview preparation.
This article explains the best practices for using parameters and query strings in REST API design, covering pagination, parameterization concepts, HTTP methods, headers, caching, and authorization, and provides guidance on choosing the right approach to create efficient, stateless, and scalable APIs.
This article demonstrates how to create a custom Python SDK for Pinduoduo's order-related APIs, covering request signing, parameter assembly, URL encoding, and example calls to retrieve order lists, details, status, and incremental updates, complete with sample code and usage screenshots.
This article explains the REST architectural style, its fundamental concepts, the most important HTTP methods, response‑code categories, the Richardson maturity model, description languages, popular server frameworks and client tools, while providing concrete examples and RFC references for building robust web APIs.
This article explains how to build a modular automated API testing project in Java by creating a base class that encapsulates request handling, header and cookie management, common validation methods, and response processing, allowing individual test modules to focus solely on specific API parameters and responses.
This article explores the true meaning of HTTP’s stateless nature, clarifies common misconceptions, examines how cookies and sessions add state, and demonstrates through a simulated shopping scenario why additional mechanisms are needed to maintain user context across requests.
This article demonstrates practical API business validation using the FunTester testing framework, covering user registration and login scenarios with example Java code, and provides a series of instructional videos for HTTP request handling, response parsing, and header/cookie management.
This guide explains four practical methods—using a known cookie, simulating login with urllib or requests, maintaining a session, and employing a headless Selenium browser—to programmatically retrieve pages that require user authentication, complete with step‑by‑step instructions and code examples.
This article guides Java developers on creating a comprehensive interface testing project using the FunRequest framework, covering reusable utilities, request/response handling, and detailed code examples for HTTP GET and POST operations, while also providing links to related tutorial videos.
This article demonstrates how to handle HTTP headers and cookies within the FunTester automated testing framework, providing step-by-step explanations, video references, and a complete Java code example that shows registering users, developer login, and request execution using Apache HttpClient.
This guide explains how multipart/form-data enables sending JSON and binary data together, outlines its essential specifications, demonstrates front‑end FormData usage, and details Spring Boot back‑end handling with @RequestParam and @RequestPart annotations.
This article explains the fundamental principles of REST architecture, describes the main HTTP verbs and response codes, compares REST with SOAP, introduces the Richardson maturity model, and surveys common description languages, server frameworks, and client tools for building and consuming RESTful APIs.
This article compiles detailed front‑end interview answers covering HTTP request limits, Virtual DOM benefits, CommonJS vs ES6 modules, cookie/session/token differences, image format selection, first‑paint and white‑screen metrics, mini‑program vs H5 distinctions, floating‑point precision, and V8 engine execution.
This article continues the FunTester series by detailing the core functionality for sending HTTP requests, handling headers and cookies, parsing responses into JSON, and returning structured results, complete with practical Java code examples and step‑by‑step explanations.
This article explains how network packets map to the TCP/IP four‑layer model, uses Wireshark and browser developer tools to capture and dissect HTTP requests, and illustrates each layer—from Ethernet to application—with clear examples and visual screenshots.
This article explains how the FanLibrary testing framework provides overloaded methods to create HttpGet and HttpPost objects, supporting JSON, form, and multipart file uploads, with detailed Java code examples and guidance on parameter handling and URL encoding.
This article walks you through the structure and key directives of Nginx configuration files, covering the global, events, HTTP, and server blocks, with clear explanations, code examples, and visual diagrams to help beginners configure and optimize their Nginx server.
This article explains Envoy's core terminology, thread model, listener architecture, network (L3/L4) filters, HTTP connection manager, and routing configuration, providing a concise technical overview of how the service proxy operates within cloud‑native environments.
This article provides a comprehensive overview of REST architecture, covering its core concepts, differences from SOAP, the Richardson Maturity Model, detailed explanations of HTTP verbs and response codes, resource identification standards, description languages, server frameworks, and client tools for building and testing RESTful APIs.
This article explores the internal call chain of the Python Requests library, explains how the timeout argument is propagated through urllib3’s pool manager and HTTPConnection objects, and shows the relevant source code that makes socket-level timeouts work for HTTP requests.
This article explains the fundamentals of HTTP caching, covering forced and conditional cache strategies, key response headers like Cache-Control, Expires, ETag, and Last-Modified, and demonstrates how browsers decide when to serve cached content versus fetching fresh data.
