This article explains how reactive programming, introduced by Microsoft in 2009 and popularized through Spring 5 and frameworks like Reactor and RxJava, addresses high‑concurrency server challenges by using event‑driven models, back‑pressure mechanisms, and clear distinctions between concurrency and parallelism.
This article explains how Spring WebFlux, built on the Reactor project, provides a reactive, non‑blocking alternative to traditional Servlet‑based Spring MVC, detailing its advantages, limitations, and the considerations developers must evaluate before adopting it.
Gaode Yuntu transformed its backend from a blocking servlet architecture to an asynchronous, event‑driven reactive stack using Vert.x, Spring WebFlux, Project Reactor and OpenResty, achieving a 480% QPS boost, higher resource efficiency, stable latency, and plans for RSocket back‑pressure and domain‑driven design.
This article introduces Soul 2.2.0’s fully plugin‑based architecture, walks through downloading and running soul‑admin, shows how to build a Spring Boot gateway with required dependencies and configuration, demonstrates hot‑swap plugins for Dubbo, circuit‑breaker and rate limiting, and highlights its key features and typical use cases.
The article presents a Swift‑based declarative UI framework for UIKit that replaces AutoLayout with a flexible, CSS‑like style system, reactive state handling, and extensible layout nodes, enabling cleaner code, efficient animated lists, and improved development speed while planning future optimizations such as dirty‑checking and virtual layouts.
This article explains what reactive programming is, outlines the Reactive Manifesto's four core principles, describes the Reactive Streams standard and its key interfaces, showcases Java code examples with Reactor, and provides practical guidance for adopting reactive architectures in backend systems.
RxJava implements ReactiveX’s observer‑based, pull‑model paradigm by using Observable as a factory and template class whose static creators and chainable operators (e.g., flatMap) apply factory, template, observer and decorator patterns, enabling Java 8‑style asynchronous pipelines that developers can reason about, debug, and optimize.
The Beijing Cloud+ Developer Conference gathered experts from Tencent, Tongcheng‑Yilong and Beike Jinfu to examine 5G’s technical challenges, emerging application scenarios, reactive programming solutions, and edge‑cloud strategies, offering practical insights for developers and product teams navigating the new network era.
Spring Framework 5.2 has been officially released, bringing deep Kotlin 1.3 integration, enhanced reactive support for WebFlux, RSocket, and data stores like R2DBC, MongoDB, and Neo4j, along with a comprehensive list of new features and improvements for developers.
The Flower framework, built on Akka Actors, demonstrates how reactive programming’s responsive, resilient, elastic, and message‑driven principles can replace traditional blocking thread models with asynchronous, non‑blocking I/O, allowing a few container threads to handle many requests, doubling throughput, halving latency, and markedly improving system availability.
Learn how to create a reactive REST API using Spring Boot and RxJava, covering prerequisite knowledge, required dependencies, CRUD endpoint definitions, service layer implementation with RxJava Single, and web controller integration, plus essential Maven setup and tips to avoid common HttpMediaNotAcceptableException errors.
This article introduces RSocket, examines its production performance tests with Dubbo and Spring Flux, explains the protocol’s four interaction models and key features, and discusses the practical benefits of using RSocket for reactive business development and future back‑pressure scenarios.
This article explains the code types involved in synchronous remote calls, demonstrates how blocking IO leads to callback hell, and shows how to simplify the programming model using Java CompletableFuture, AsyncHttpClient, and Project Reactor’s reactive streams to efficiently retrieve city data.
This article introduces the fundamentals of microservices and reactive systems, explains how reactive programming integrates with microservice architectures, compares traditional and reactive approaches, outlines core components, design principles, and technology choices such as Spring Cloud, and provides guidance for building scalable, resilient reactive microservices.
This article explains RxJava2's backpressure mechanisms, compares the five Flowable strategies (MISSING, ERROR, BUFFER, DROP, LATEST), demonstrates their behavior with practical experiments, and shows how to use Subscription and FlowableEmitter to build a demand‑driven, memory‑safe data pipeline.
This article provides a comprehensive overview of RxJava2 for Android, covering its observer types, backpressure strategies, thread‑scheduling transformers, the compose() operator, differences between compose and flatMap, and the distinction between hot and cold observables with practical code examples.
This article explains why Spring WebFlux lacks RequestContextHolder, explores the ReactorContextWebFilter solution from Spring Security, and demonstrates a custom ReactiveRequestContextFilter and helper class that store and retrieve the request via Reactor's Context for exception handling and WebClient header propagation.
The article describes the motivation, analysis, architecture, performance optimizations, development challenges, and future plans of JD Finance’s LEGO backend platform, which uses Spring Boot, SpEL, Redis, and reactive programming to enable dynamic, high‑performance page configuration for a high‑traffic mobile app.
This article explains RxJava’s origins, core concepts, advantages, common operators, threading strategies, and practical experiences, illustrating how adopting RxJava with Java 8, Lambda, and Stream API can simplify complex, rapidly changing backend systems and improve code readability, maintainability, and performance.
This article explains React as a JavaScript library for building user interfaces, covering its component model, state‑driven rendering, DOM diffing, pure functions, the importance of treating it as a library rather than a framework, and practical state management with MobX.
By refactoring Xianyu’s key features with RxJava 2.0, the team replaced blocking logging, HTTP, RPC, and cache operations with asynchronous streams, cutting response time by half, boosting CPU utilization to 97%, raising throughput about 30%, and demonstrating a unified, core‑size thread‑pool model.
EasyReact is an iOS reactive programming framework that replaces closure‑based data flow with object‑graph nodes, offering visual EZRNode debugging, automatic memory management, and cross‑platform potential while delivering up to 725 % faster performance than ReactiveCocoa, simplifying learning, debugging, and future Swift‑based extensions.
The article explains how Flutter adopts a React‑style reactive architecture—using immutable widgets, InheritedWidget for communication, Dart Streams and a Redux‑like store with reducers and interrupters—to achieve clear model‑view separation, fine‑grained UI updates, componentized multi‑store widgets, and shares Xianyu’s practical implementation details and code examples.
The article contrasts push‑based reactive programming with imperative code, then walks through a simple EventEmitter with manual cleanup, examines Redux’s store subscriptions and middleware overhead, explores Mobx’s automatic dependency tracking via getters, setters and autorun, and compares the boilerplate, performance, and hidden‑dependency trade‑offs before previewing a future post on using Observables for asynchronous events.
This tutorial walks you through creating a reactive Spring WebFlux RESTful API using Spring Boot 2.0 and MongoDB, covering project setup, database connection, model, DAO, controller implementation, and testing the CRUD operations with practical code examples and screenshots.
This article explains the fundamentals of reactive programming in Spring 5, covering concepts like reactive streams, backpressure, Reactor's Mono and Flux types, and provides practical code examples for controllers and data layers to illustrate the benefits over traditional blocking approaches.
This article explains how an API Gateway simplifies client‑to‑microservice communication for mobile apps by aggregating multiple fine‑grained services into a single coarse‑grained endpoint, discusses its advantages and drawbacks, and outlines key design considerations such as performance, reactive programming, service discovery, and fault tolerance.
This article explains why an intermediate data structure is needed for 3D rendering in a React‑like Virtual DOM environment, how to keep it reactively synchronized with raw graph data using dependency analysis, proxies, and conversion functions, and the performance benefits of minimal partial updates.
This article explains the fundamentals of functional programming, its contrast with imperative coding, the role of pure functions and monads, and why its declarative and asynchronous features are increasingly essential for modern front‑end frameworks and reactive UI development.
The article explains how an API Gateway can consolidate multiple fine‑grained microservice endpoints into a single coarse‑grained API for mobile clients, discussing its design considerations, benefits, drawbacks, and implementation techniques such as reactive programming, service discovery, and fault tolerance.
