xxl-job uses Netty HTTP for communication, employing dynamic proxy patterns, full asynchronous processing, and thread‑blocking mechanisms to efficiently dispatch tasks from the scheduler to executors, with detailed code examples illustrating request IDs, future responses, and synchronized result retrieval.
This tutorial demonstrates how to capture and reproduce the dynamic newSign parameter of the X‑Wu Android app by reverse‑engineering the request‑signing method with Frida, exposing it via an RPC server, and then using the generated signature to call the official search API.
This article explains the fundamentals of RPC, describes the components involved in a basic remote call, and provides a complete Java implementation using Spring, custom XML configuration, Netty for network communication, and Zookeeper for service registration and discovery, complete with server and client code examples.
This article explains how to employ Frida RPC to intercept and forward encrypted mobile app requests, demonstrates the required environment, provides hook scripts for encryption and decryption, and shows how to wrap them in a FastAPI service for automated crawling.
This article explains why forward and backward compatibility are crucial for evolving systems, covering database encoding, schema evolution, REST and RPC communication, message brokers, and actor frameworks, and provides practical guidance for designing compatible data flows across services.
This article chronicles ByteDance's transition from Python to Go, the shortcomings of the first‑generation Kite RPC framework, and the design, features, performance advantages, open‑source journey, and real‑world deployment lessons of the next‑generation Kitex framework for scalable microservices.
This article outlines a comprehensive approach to securing backend APIs through authentication, anti‑hijacking measures, and a custom RPC encryption scheme that combines asymmetric and symmetric keys, detailing design principles, data flow, and implementation resources.
An online service threw an IllegalArgumentException because a downstream system added a new enum constant without notifying dependent services, leading to deserialization failures in RPC calls; the article explains the root cause, JSON serialization behavior, and recommends using strings instead of enums for API parameters and return values.
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 article explains the fundamentals of RPC, walks through a complete Java implementation using Spring, Netty, and Zookeeper, and provides step‑by‑step code for both the service provider and consumer, including registration, dynamic proxy generation, network communication, and testing.
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 walks through Dubbo’s RPC communication using a packet‑as‑narrator metaphor, detailing the thread models of Netty 3 and Netty 4, OS socket handling, and practical troubleshooting steps for latency and timeout issues in a clear, engaging style.
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.
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 communication architecture of the XXL‑Job scheduler, detailing its Netty‑based transport layer, the overall task dispatch flow, and the clever design choices such as dynamic proxies, full asynchronous processing, and response wrapping that improve throughput and simplify remote calls.
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 presents a comprehensive overview of designing and implementing a custom RPC framework using Spring Boot and Netty, covering concepts, architecture, service registration with Zookeeper, load balancing, custom message protocol, serialization, handling TCP fragmentation, and various client invocation modes.
This article explains how to build a versatile browser message‑communication library that works across iframes, Web Workers, ServiceWorkers, BroadcastChannel and other MessagePort‑like objects, using a unified interface design, TypeScript typings, event‑driven architecture and JSON‑RPC for reliable remote procedure calls.
This article analyzes the four major API architectural styles—RPC, SOAP, REST, and GraphQL—detailing their mechanisms, strengths, weaknesses, and typical use cases, and provides guidance on selecting the most suitable style based on language, environment, and resource constraints.
In this interview, senior backend engineer Wang Jianshen shares the motivations, design choices, challenges, and successes behind Zhaunzhuan's self‑developed RPC framework and service‑governance platform, offering practical insights for building high‑availability, high‑concurrency microservice architectures.
This article compares four major API architectural styles—RPC, SOAP, REST, and GraphQL—explaining their mechanisms, strengths, weaknesses, and typical use cases, and provides guidance on selecting the most suitable style based on project constraints such as language, environment, and resources.
This article explains how leveraging real online traffic for offline replay can simultaneously reduce regression testing costs, ensure functional correctness, and improve test efficiency, illustrated through a detailed case study of the CaiHuoXia marketplace backend development.
This article examines four major API architectural styles—RPC, SOAP, REST, and GraphQL—detailing their mechanisms, advantages, disadvantages, and typical use cases, and offers guidance on selecting the most suitable style based on factors such as language, environment, performance, security, and resource constraints.
This article explains the concepts, components, and lifecycle of Remote Procedure Call (RPC), compares it with HTTP, and demonstrates how to use the open‑source C++ SRPC framework to build client and server applications, including code generation, serialization, compression, and protocol handling.
This article walks through the fundamentals of Apache Dubbo, covering its service discovery, RPC communication, traffic management, configuration, and deployment architecture, and provides a step‑by‑step SpringBoot implementation of a simple RPC service with Zookeeper registration, including code snippets for provider, consumer, and controller.
NextRPC is a multi‑stage RPC model that delivers partial responses over multiple network channels, improving latency and conversion in Taobao’s transaction and recommendation services; it employs a hybrid asynchronous streaming and parallel execution architecture with client‑side orchestration and server‑side sub‑request handling, achieving over 5% UV lift and up to 25% recommendation uplift.
This article explains the fundamentals of RPC communication, detailing its roles, step‑by‑step call flow, underlying technologies, differences from local function calls, and compares major RPC frameworks while highlighting how it contrasts with RESTful APIs in microservice architectures.
This article provides a comprehensive guide to building a custom RPC framework, covering core concepts, architecture diagrams, registration with Zookeeper, Netty communication, custom message protocols, serialization, load balancing, handling TCP packet issues, and practical deployment steps with starter modules.
The Go‑based GDP Streaming RPC framework extends Baidu’s internal brpc‑compatible RPC system with a high‑performance streaming transport that preserves message order, supports multiple concurrent streams per socket, offers customizable serialization and event‑driven handlers, and enables efficient large‑scale data transfers such as voice or replica synchronization, achieving comparable latency and throughput to the original C++ implementation.
The article explains Java naming conventions for primitive boolean and Boolean types, shows examples of getters and setters, discusses JavaBeans rules and RPC serialization issues, and recommends using wrapper types for POJOs while keeping primitives for local variables.
This tutorial walks you through using the jsrpc tool to reverse‑engineer a site’s encrypted parameters, extract data from 100 pages, and automate requests with Python, providing detailed code snippets, debugging tips, and a complete end‑to‑end example.
NextRPC introduces a multi‑segment payload RPC model that streams responses through successive "Next" stages, enabling parallel processing and decoupling of core and non‑core logic, which improved Alibaba’s Double‑11 transaction conversion rates by over 5% overall and more than 25% for optimal‑product selection scenarios.
This article explains the concept of Remote Procedure Call (RPC), demonstrates how to apply RPC for web reverse engineering by injecting JavaScript through WebSocket communication, and introduces the Sekiro framework and related tools for automating encryption parameter retrieval in browser environments.
This article explains the typical architecture of RPC frameworks, detailing the roles of servers, registries, and clients, the core functions of service discovery, serialization, and network transport, and surveys popular implementations such as RMI, Thrift, gRPC, Dubbo, and others.
A seemingly harmless RPC framework bug caused a 4 GB byte array allocation, leading to repeated OutOfMemoryErrors in service B after service A’s deployment, and the article walks through the diagnosis, root‑cause analysis, and a simple fix.
This article explains the principles of Remote Procedure Call (RPC), walks through a complete end‑to‑end RPC workflow—including interface definition, service registration, Netty‑based network communication, request/response handling, and client‑side dynamic proxy generation—while providing runnable Java code examples.
This article explains the fundamentals of Remote Procedure Call (RPC), detailing the end‑to‑end workflow from defining service interfaces and implementations, registering services in a Zookeeper registry, handling network communication with Netty, and generating client‑side proxies using Spring and JDK dynamic proxies, all illustrated with complete Java code examples.
This article presents a detailed overview of a custom Java RPC framework, covering its core concepts, architecture, communication flow, message protocol, load balancing, serialization, handling of TCP packet fragmentation, and practical implementation using Spring Boot, Netty, and Zookeeper, along with deployment instructions.
This article explains the fundamentals of Remote Procedure Call (RPC), detailing the definition, basic call flow, service interface design, server registration with Zookeeper, Netty-based network communication, dynamic proxy generation on the client side, and provides complete Java code examples for a working RPC framework.
This article explains the fundamentals of Remote Procedure Call (RPC), walks through the complete request‑response flow, and provides a step‑by‑step Java implementation using Spring, custom XML namespaces, Netty for network communication, and Zookeeper for service registration and discovery.
After lowering an NFS server's RAM from 8 GB to 4 GB, the server's max_block_size dropped, causing a mismatch with the client’s rsize/wsize settings, which led to RPC fragment‑too‑large errors; the article explains the root cause and shows how to resolve it by adjusting the server’s max_block_size.
This article examines the motivations for rewriting the Java‑centric Dubbo RPC framework in Go, discussing language efficiency, company‑level technology choices, the advantages of Go’s lightweight concurrency for gateways, and how Dubbo‑Go bridges Java and Go in modern microservice and service‑mesh architectures.
This article explains how the ZhiZhi RPC framework SCF handles connection lifecycle, including establishment timing, connection pooling versus multiplexing, keep‑alive mechanisms, automatic recovery, and graceful shutdown, providing practical guidance for designing robust RPC protocols.
This article explains JavaScript's single‑threaded nature, introduces the event loop and Web Workers, examines the Comlink library for RPC‑style multithreading, provides detailed source‑code analysis, and demonstrates practical use cases such as exporting large Excel files without blocking the UI.
This article explains the concepts, architecture, communication flow, and implementation details of a custom RPC framework built with Spring Boot, Netty, and Zookeeper, covering service registration, load balancing, custom message protocols, serialization, TCP handling, and deployment steps.
This article explains the fundamentals of Remote Procedure Call (RPC), detailing the end‑to‑end workflow—from interface definition and dynamic proxy generation on the client, through service registration in ZooKeeper, to server‑side handling with Spring and Netty—accompanied by complete Java code snippets and configuration examples.
This article compares four major API architectural styles—RPC, SOAP, REST, and GraphQL—detailing their mechanisms, strengths, weaknesses, and typical use cases, and provides guidance on selecting the most suitable style for a given project.
This article explains how Dubbo3’s Triple protocol, built on HTTP/2 and compatible with gRPC, improves performance, routing, security, and usability over classic RPC protocols like Dubbo2 and HTTP/1.1, while offering cross‑language support, streaming, and seamless integration with cloud‑native service governance.
Modern micro‑service architectures evolve from basic RPC protocols—covering serialization, transport, invocation modes, and governance—into comprehensive service‑oriented frameworks that integrate registration, load balancing, fault tolerance, observability, and automation, with popular open‑source tools like Dubbo, gRPC, and Thrift guiding implementation choices.
go-zero, a CNCF‑listed cloud‑native web and RPC framework, offers a minimalist API definition tool (goctl) that generates client code for multiple platforms, and provides built‑in microservice governance features such as TLS, rate‑limiting, circuit‑breaking, and seamless integration, with the latest release adding TLS support for REST, ZRPC, Redis, etc.
This article introduces Apache Dubbo, explains its core concepts and RPC fundamentals, and provides step‑by‑step demo projects—first a simple setup without a service registry using direct URL calls, then an enhanced version that registers services with Zookeeper, including all necessary Maven dependencies, Spring XML configurations, Java code, and execution results.
This article explains the fundamentals of Remote Procedure Call (RPC), its historical evolution, core concepts such as remote procedures and calls, practical examples, analogies, and the challenges it introduces—like latency, address‑space isolation, partial failures, and concurrency—while highlighting RPC’s pivotal role in enabling scalable distributed architectures.
This article compares the four major API architectural styles—RPC, SOAP, REST, and GraphQL—detailing their mechanisms, advantages, drawbacks, and typical use cases, and guides developers on selecting the most suitable approach based on project requirements, performance, and ecosystem considerations.
The article explains why naming Boolean fields with the isXXX pattern in Java is discouraged, illustrates correct and incorrect getter/setter conventions with code examples, discusses JavaBeans specifications and RPC serialization issues, and recommends using wrapper types for POJOs while keeping primitives for local variables.
An in‑depth comparison of the four major API architectural styles—RPC, SOAP, REST, and GraphQL—examining their mechanisms, strengths, weaknesses, and ideal use‑cases, helping developers choose the most suitable approach based on performance, scalability, security, and ecosystem considerations.
This article provides a comprehensive overview of Dubbo, the high‑performance Java RPC framework, covering its core components, advantages over alternatives, supported protocols, configuration methods, startup behavior, integration with Spring Boot, and detailed architecture for building scalable distributed services.
The article by the Vivo Internet Server Team details Apache Dubbo’s ten‑layer architecture—service, config, proxy, registry, cluster, monitor, protocol, exchange, transport, and serialization—explaining each layer’s role, the RPC invocation flow, registration/discovery mechanisms, configuration options, and how Dubbo’s extensive SPI‑based modular design enables loose coupling, extensibility, and robust micro‑service development.
During npm install, VS Code’s file explorer sometimes flashes due to misconfigured file‑watcher exclusions for node_modules, a bug in RPC argument handling and cancellation token processing; this article explains the root causes, demonstrates the faulty configurations, and provides concrete fixes and contribution tips.
The article explains gRPC fundamentals, illustrating service definition in .proto files, synchronous and asynchronous client and server implementations with CompletionQueue and CallData state machines, streaming RPC patterns, HTTP/2 protocol details, metadata handling, and the structure of generated stub and service code.
This article examines four major API architectural styles—RPC, SOAP, REST, and GraphQL—detailing their mechanisms, strengths, weaknesses, and typical use cases, and provides guidance on selecting the most suitable style for a given project based on technical and business constraints.
This article examines four major API architectural styles—RPC, SOAP, REST, and GraphQL—explaining how each works, outlining their advantages and disadvantages, and providing guidance on selecting the most suitable style for different project requirements.
This tutorial explains what Protocol Buffers are, why they outperform JSON/XML, and provides a step‑by‑step guide for installing the compiler, defining .proto schemas, generating Java code, integrating with Maven, and using protobuf for fast serialization in micro‑service RPC.
This article explains the motivation, design principles, model architecture, and implementation challenges of rebuilding ByteDance's Node.js RPC system, covering DDD‑based decomposition, protocol and connection abstractions, multi‑protocol nesting, client/server creation APIs, and performance‑optimized context extensions.
This article explains how to test and invoke Dubbo services without provider JARs by using telnet or generic calls, compares Java and Go implementations, details the underlying filters, and provides practical code samples for building a Dubbo-go based gateway or testing platform.
This guide explains how to install, configure, and use the Laravel‑Hprose extension built on hprose‑php, covering Composer installation, service provider registration, publishing configuration, defining server methods, starting the RPC socket server, and client‑side invocation with code examples.
Microservice communication can be handled via tightly‑coupled RPC calls or loosely‑coupled event‑driven messaging; this article examines various coupling types, compares RPC and event‑notification, explores event sourcing, API gateways, internal microservice design, and offers practical guidance on selecting the appropriate approach for different business scenarios.
This guide explains the NFS (Network File System) protocol, its reliance on RPC, the ports it uses, how to activate the required daemons, differences among NFSv2/v3/v4/v4.1, and provides step‑by‑step instructions for installing, configuring, and mounting NFS on CentOS 7, including firewall and export settings.
This article walks through the motivation, core components, technology choices, architecture, and implementation details—including service registration, provider and consumer modules, custom protocol design, serialization, load balancing, and Netty-based I/O—of a self‑written distributed RPC framework, and presents performance test results.
The article explains how microservices communicate through RPC and event‑driven approaches, analyzes different coupling types, discusses event notification and event sourcing, examines API gateways and service composition, and offers practical guidance on reducing tight coupling and managing microservice scale.
Apache Dubbo 3 modernizes the popular Java RPC framework by adopting cloud‑native principles, introducing an application‑level service discovery model, a next‑generation Triple RPC protocol, and seamless Kubernetes integration, while preserving its proven ease of use and performance benefits for large‑scale microservice deployments.
The article explains how Apache Dubbo 3 adapts to the cloud‑native era by introducing an application‑level service discovery model, the next‑generation Triple RPC protocol, and deep Kubernetes integration, highlighting performance gains, cross‑language support, and flexible deployment options for modern microservices.
This article explains Netty's role as a mature I/O framework, outlines the end‑to‑end remote‑call workflow of a distributed service, details protocol design, shares performance‑tuning tricks, and presents best practices for building scalable, low‑latency backend systems.
This article explains what Netty is, how to design a distributed service framework using it, details the RPC call flow, discusses protocol design, showcases performance‑boosting features and best practices, and provides deep insights into Netty's architecture, threading model, and low‑level optimizations.
This guide explains the NFS protocol fundamentals, activation steps, version comparisons, and provides a step‑by‑step CentOS 7 installation and configuration tutorial, including service setup, firewall adjustments, export file editing, and client mounting procedures.
The article announces Apache Dubbo 3.0's preview and upcoming official release, outlines its new application‑level service discovery, Triple RPC protocol, routing rules, performance improvements, Kubernetes integration, extension modules, compatibility with 2.7.x, and provides migration considerations for developers.
The article examines microservice communication methods, comparing RPC and event‑driven approaches, explains different coupling types, introduces event notification and event sourcing, discusses API gateways, service composition, internal microservice design, and offers practical guidance for reducing tight coupling and managing service scale.
The article analyzes microservice communication patterns, comparing RPC and event‑driven approaches, explains different types of coupling, explores event notification and event sourcing, discusses API gateways, versioning strategies, and offers guidance on sizing microservice architectures and internal microservice design.
The article explains what object serialization is, why it is needed for persistence and network transmission, outlines the major drawbacks of Java's built‑in serialization—including lack of cross‑language support, poor performance, and large payloads—and compares it with a custom ByteBuffer approach while reviewing popular alternative serialization frameworks.
The article explains how traditional scaling methods like sharding and RPC eventually hit connection limits, and introduces unitization as a strategy to achieve unlimited service expansion by limiting each application to a single database instance.
This article explains the fundamental differences between RPC and HTTP services, reviews the OSI network model, describes RPC architecture and sync/async calls, compares popular RPC frameworks such as gRPC, Thrift, and Dubbo with traditional RESTful HTTP, and offers guidance on choosing the right approach for a project.
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.
This article explains internal service communication patterns, covering request/response and asynchronous messaging, their implementations, message formats, RPC and REST principles, service discovery methods, channel types, and key considerations for choosing a message‑queue component.
The article explains how moving from monolithic applications to microservice‑based systems changes communication from in‑process method calls to RPC, asynchronous messaging, and REST, highlighting design principles such as smart endpoints, dumb pipes, and the importance of avoiding synchronous dependencies for resilient distributed systems.
This article reviews Nacos' evolution from its 1.x architecture—highlighting its five-layer design and service discovery issues—to the 2.0 version that introduces long‑connection RPC, a new client‑centric model, and improved performance, while also outlining upcoming roadmap plans.
This article provides a comprehensive overview of the Dubbo Java RPC framework, covering its historical evolution, protocol design, registry and clustering mechanisms, extensibility via SPI, generic invocation, and upcoming cloud‑native and reactive programming developments.
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 walks through Dubbo’s RPC encoding and decoding mechanisms, explaining how Netty pipelines add codec handlers, detailing the message header format, exploring Hessian2 serialization, and answering common pitfalls such as class‑path changes and field mismatches.
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 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.
Version v0.0.7 introduces a configurable keepalive timeout for the TCP RPC server, automatically closing idle client connections after a set period, reducing resource usage and preventing memory leaks while allowing the client to transparently reconnect when needed.
This article presents a PHP coroutine‑based Task Scheduler that enables high‑concurrency RPC calls and asynchronous MySQL queries, explains its design and implementation with code examples, compares performance against traditional synchronous and HttpMultiClient approaches, and discusses task dependency handling using DAG and topological sorting.
This article walks through the design and implementation of a Java RPC framework, detailing added serialization options, multiple load‑balancing strategies, client‑side service caching, TCP long‑connection handling with Netty, performance testing, and provides the full source code for replication.
This article describes a series of improvements to a Spring‑Boot based Java RPC framework—including support for Protobuf and Kryo serialization, multiple load‑balancing algorithms, client‑side service caching, TCP long‑connection reuse via Netty, and a performance test that reduces request latency by more than tenfold.
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.
An in‑depth guide demonstrates how to combine Netty with Protostuff for high‑performance RPC, detailing serialization setup, custom encoder/decoder implementation, multi‑threading pitfalls, and stress‑testing results that achieve up to 400,000 objects per second per server in a clustered environment.
This article explains the Java naming conventions for boolean and Boolean fields, why using the isXXX prefix can cause serialization issues in RPC frameworks, and recommends using wrapper types for POJO properties while keeping primitives for local variables.
This article presents a practical Netty‑based RPC solution using Protostuff serialization, detailing large‑scale stress testing, performance bottlenecks, and code‑level optimizations that enable handling hundreds of thousands of objects per second reliably.
This article traces Dubbo’s evolution from its Alibaba origins to its Apache graduation, outlines its core features such as protocol design, service registry, clustering, filters, and extensibility, and discusses recent cloud‑native and reactive programming directions shaping its future.
This article details how to build a high‑performance Netty RPC system using Protostuff for serialization, covering dependency setup, custom encoder/decoder implementation, multithreaded buffer handling, and stress‑test results that achieve hundreds of thousands of objects per second per server.
This article describes how a microservice architecture uses IP‑tag traffic routing to separate dynamic test environments from stable ones, implements RPC and MQ routing, and introduces a custom Zipkin‑based distributed tracing system called Tianwang to improve deployment efficiency, resource utilization, and debugging in large‑scale backend services.
