Projects sharing features with Incubator Seata

This project is a Java implementation of the try-confirm-cancel pattern, providing a distributed transaction framework and management library. It functions as a coordinator that manages the lifecycle of multi-phase transactions to ensure consistency across multiple distributed services. The framework includes a distributed transaction coordinator server that offloads event and task operations from local services. It also provides a dedicated dashboard for visualizing transaction status and manually operating distributed events and tasks. The system manages consistency through a three-phase c

pgdog is a PostgreSQL sharding proxy, distributed SQL router, and connection pooler. It is designed to enable horizontal data distribution by splitting tables and indices across multiple independent servers to scale storage and processing capacity. The project distinguishes itself through online resharding capabilities, using logical replication to move data between shards without application downtime. It supports multiple routing strategies, including hash, list, and range-based query routing, and manages distributed atomic transactions using a two-phase commit process to ensure consistency

tx-lcn is a distributed transaction framework and Java transaction middleware designed to manage atomic operations and data consistency across multiple microservices and relational databases. It functions as a distributed transaction coordinator that synchronizes commit and rollback operations to ensure global data integrity. The system provides a microservice consistency manager that tracks and resolves transaction flows across service boundaries. It features an integration layer compatible with middleware such as Spring Cloud, Dubbo, and Motan, allowing it to operate across different servic

TinyKV is a distributed key-value store designed for storing and retrieving data across multiple nodes with high availability. It functions as a distributed database system that incorporates a dedicated key-value storage engine for raw data persistence and retrieval on individual nodes. The project includes a Raft consensus engine to ensure data consistency and fault tolerance across a cluster of servers. It also features a distributed transaction manager that coordinates atomic commits and concurrency control to maintain data integrity across shards. The system covers cluster membership man

This project is an integration framework that bootstraps Apache Dubbo remote procedure call services within Spring Boot applications. It serves as a microservice communication framework that enables the implementation of RPC services, service discovery, and distributed governance through automated configuration. The project distinguishes itself by providing a cross-language RPC bridge, allowing services written in different languages to communicate via standards such as gRPC and Protobuf. It further enables the exposure of backend microservices as REST endpoints using the Triple protocol for

Seata is a distributed transaction coordinator and consistency framework designed to maintain data integrity across multiple microservices. It functions as a manager that synchronizes state across separate databases to ensure atomic commits or rollbacks of global transactions. The project provides a toolkit for implementing distributed transaction patterns, using a two-phase commit protocol and centralized status tracking to prevent data anomalies. It orchestrates eventual consistency through state-machine-based tracking and message-driven coordination to handle timeouts and failures in distr

EasyTransaction is a distributed transaction framework that coordinates data consistency and failover across independent microservices. It implements unified patterns such as SAGA, Try-Confirm-Cancel, and reliable messaging to handle multi-service operations and failures safely. The framework combines diverse transaction styles and nests operations to manage complex workflows without relying on central coordinators. It includes an automatic compensation engine that executes reverse operations and rollback workflows sequentially when downstream failures occur, alongside an automated crash reco

Eventuate Tram Sagas is a framework for managing distributed transactions across microservices. It functions as an event-driven workflow engine that coordinates complex business processes by executing sequences of local operations and maintaining state transitions across independent service boundaries. The framework implements the transactional outbox pattern to ensure atomicity between database updates and message publishing. It coordinates distributed workflows through asynchronous messaging, utilizing a message broker to decouple services and guarantee reliable delivery of commands and rep

SpringBoot-Labs is a collection of educational resources and reference implementations for Java backend architecture and distributed systems. It provides practical lab guides and code samples focused on building applications with the Spring Boot framework and designing scalable microservices architectures. The project specifically covers service governance and distributed cloud deployment patterns using Spring Cloud and Spring Cloud Alibaba. It includes a dedicated kit for microservices and a guide for executing remote procedure calls and managing service discovery via the Dubbo protocol. Th

ShardingSphere is a distributed SQL database middleware that provides sharding, read-write splitting, and distributed transaction management for relational databases. It functions as a layer that intercepts SQL queries to distribute data across multiple physical database instances for horizontal scaling. The project is distinguished by its ability to operate as either a standalone transparent database proxy or via direct integration as a JDBC driver. It features a SQL dialect translator that parses queries into abstract syntax trees to convert syntax between different database engines, enabli

RocketMQ is a cloud-native distributed messaging platform and streaming engine. It functions as a distributed transactional queue that ensures atomicity between local transactions and message delivery, and serves as an MQTT IoT message broker to bridge lightweight device traffic into high-performance data streams. The system is distinguished by a Kubernetes-native architecture that decouples compute from storage to allow independent scaling of traffic and data retention. It utilizes a tiered storage model to offload older data to remote storage and employs quorum-based replication and automat

Dubbo is a Java RPC framework and microservices governance platform designed for high-performance remote procedure calls in distributed architectures. It provides the foundational components necessary to connect distributed services across a network, including a binary data serialization library and a distributed service registry. The platform distinguishes itself through a comprehensive governance suite that manages service discovery, load balancing, and traffic routing. It enables precise control over network traffic via conditional routing and a pluggable extension mechanism based on a ser

This project is a comprehensive Java backend engineering guide and technical reference focused on high-concurrency design, distributed systems, and microservices architecture. It provides detailed strategies for decomposing monolithic applications, managing service discovery, and implementing the architectural patterns required for scalable backend environments. The repository distinguishes itself through an extensive collection of big data algorithmic references and database scaling strategies. It covers memory-efficient techniques for analyzing massive datasets, such as Top-K element extrac

Spring Cloud Alibaba is a suite of libraries designed to connect distributed Java applications to Alibaba cloud middleware and infrastructure services. It provides a comprehensive set of tools for messaging, configuration, task scheduling, transaction coordination, and service discovery. The project implements distributed infrastructure capabilities including a transaction coordinator for maintaining data consistency across multiple services and a configuration manager for storing external settings in a centralized cloud repository with automatic updates. It includes a distributed job schedul

Dubbo is a high-performance Java remote procedure call framework and microservice governance platform. It enables communication between distributed services using a remote service orchestrator and a distributed service registry to locate available providers in real time. The system provides a microservice monitoring suite for health tracking and distributed tracing, alongside integrated security plugins for access control. It manages network traffic through routing strategies, rate limiting, and thread pool isolation to maintain system stability. The framework covers broader capabilities in

Apollo is a microservice configuration management system and dynamic configuration center. It serves as a centralized platform for storing, distributing, and syncing application settings across distributed environments to maintain consistency across various clusters. The system distinguishes itself through a dynamic configuration orchestrator that supports real-time updates to connected applications, eliminating the need for manual service restarts. It features a grayscale configuration deployment tool for rolling out changes to a small subset of service instances and a version control system

Mycat-Server is a MySQL database middleware system that functions as a sharding proxy, distributed database coordinator, and high availability manager. It acts as a proxy layer that routes SQL traffic between applications and multiple backend MySQL database instances to enable horizontal scaling. The system coordinates distributed transactions, generates global unique sequences to prevent primary key collisions, and executes distributed join queries across multiple database shards. It includes a load balancer that performs read-write splitting by directing traffic between primary and slave no

TiKV is a cloud-native distributed transactional key-value store and storage engine. It provides a distributed database designed for horizontal scalability and strong consistency across a cluster of physical nodes. The system uses a Raft-based consensus mechanism to maintain data availability and state synchronization. It ensures ACID compliance for distributed transactions through a two-phase commit workflow and manages data distribution via multi-Raft sharding. The engine handles massive datasets using automated range splitting and cluster load balancing to distribute data across different

This project is a reference implementation of a distributed system built using Spring Cloud Alibaba, Spring Boot, and JDK 17. It serves as a comprehensive model for implementing a microservices architecture. The system integrates a wide range of distributed patterns, including global transaction coordination for data consistency, OAuth2 and JWT for identity management, and Kubernetes-based container orchestration. It features a dedicated observability stack for distributed request tracing, log aggregation, and service health monitoring. The implementation covers several functional domains, i

CAP is a .NET distributed transaction framework and event bus designed to manage asynchronous communication in microservices. It implements the outbox pattern to ensure eventual consistency and reliable message delivery by persisting messages in local database tables until transactions commit. The framework includes a distributed message monitor and web dashboard for tracking the status of sent and received messages. It provides tools for event traffic visualization, distributed request tracing, and the ability to manually trigger retries for failed delivery attempts. The system supports var

Kitex is a high-performance remote procedure call framework for building distributed microservices in Go. It provides a communication system compatible with gRPC and Protobuf standards and includes a suite of tools for microservices governance. The framework features proxyless service mesh integration, which allows it to manage network traffic and governance directly without adding sidecar proxy latency. It optimizes data throughput through a high-performance communication library that minimizes memory copies. The system covers a broad surface of distributed capabilities, including service d

Apache Dubbo Go is a Go language implementation of the Apache Dubbo framework designed for building high-performance microservices. It serves as a cross-language RPC framework and microservices communication layer that enables remote procedure calls between services written in different programming languages. The framework functions as a service governance toolset and a distributed service mesh proxy, allowing data planes to connect with external control planes in proxy or proxyless modes. It specifically provides a compatibility layer to facilitate communication between Go and Java-based ser

This project is a .NET implementation of the gRPC framework, providing a system for executing functions on remote servers as if they were local calls. It serves as a high-performance remote procedure call (RPC) framework that utilizes HTTP/2 for service connectivity and binary communication protocols to ensure efficient data exchange. The implementation includes a gRPC-Web proxy, which acts as a translation layer to enable browser-based applications to communicate with gRPC services through web-compatible requests. It further supports the creation of HTTP/2 service meshes to connect distribut

Spring Cloud Alibaba is a microservices orchestration framework that provides a standardized programming model for building distributed systems. It functions as a cloud-native integration layer, bridging enterprise application frameworks with distributed infrastructure to manage service discovery, traffic control, and state consistency across complex, multi-part application environments. The framework distinguishes itself through specialized components for managing distributed operations, including aspect-oriented traffic control that enforces flow rules, circuit breaking, and rate limiting a

This project is a reference implementation of microservices architectures using the Spring Cloud ecosystem. It provides a set of example services that demonstrate the construction of distributed systems through automated service discovery, dynamic routing, and shared configuration. The implementation covers core distributed patterns, including a service discovery system for tracking network components and an API gateway for orchestrating incoming traffic. It features a centralized configuration manager to propagate application settings across multiple instances and a distributed tracing syste

dubbo-admin is a web-based administration console and management interface for the Apache Dubbo ecosystem. It serves as a centralized tool for configuring and monitoring services, providers, and consumers across distributed microservices architectures. The project functions as a traffic control plane and service governance tool, enabling the implementation of request routing rules, canary deployments, and traffic regulation. It provides a dedicated interface for orchestrating service mesh data planes and proxy configurations to connect services within a unified network management layer. The

Consul is a distributed coordination service and service mesh tool used for service discovery, health monitoring, and cluster state management across dynamic networks. It provides a platform for locating network addresses of services and managing traffic across distributed infrastructure using DNS and HTTP interfaces. The project distinguishes itself through multi-datacenter network orchestration, enabling the federation of services across different regions using mesh gateways. It secures communication via a service mesh architecture that employs identity-based authorization and mutual TLS en