$ show apache/servicecomb-java-chassis
Apache ServiceComb Java Chassis is a production-grade microservices SDK for Java, providing a comprehensive framework for building, registering, discovering, and governing distributed services. It supports multiple programming models (Spring MVC, JAX-RS, POJO) and transport protocols (REST over Vert.x/Servlet, custom binary Highway, WebSocket). The architecture is modular: a core engine (SCBEngine, Invocation) orchestrates filter chains for consumer, provider, and edge roles; pluggable service registries (ServiceCenter, Consul, ZooKeeper, Nacos, etcd, lightweight) handle discovery and registration; governance modules (circuit breaker, retry, rate limiting, bulkhead, fault injection) are policy-driven via Resilience4j; and Swagger/OpenAPI generators automatically produce API contracts from Java annotations. Dynamic configuration is supported through multiple sources (config-center, Kie, Apollo, etcd) with priority-based injection and hot-reloading. External dependencies include Spring Boot, Vert.x, Jackson, Guava, Resilience4j, Zipkin, and Micrometer. In production, a typical data flow begins with a consumer invocation (via RestTemplate, Invoker.createProxy, or RpcReference) that passes through a consumer filter chain (load balancing, retry, circuit breaker), then a transport layer (REST or Highway) to the provider, which processes the request through a provider filter chain (rate limiting, validation, business logic) and returns a response. The framework handles service registration at startup, periodic heartbeats, and instance cache updates via discovery events. Edge/gateway services can apply custom authentication and routing filters. The codebase is large (3355 files) but well-organized into modules: core, transports, providers, governance, swagger, service-registry, clients, foundations, and demos. It demonstrates strong engineering practices: extensive use of SPI for extensibility, filter chain pattern for middleware, event bus for decoupled lifecycle events, and priority-based configuration management. However, the sheer number of demo modules and multiple registry implementations introduces maintenance overhead, and some legacy patterns (LegacyPropertyFactory, JMockit in tests) indicate areas of technical drift.
The LLM identified 4 files worth highlighting for reuse:
Manages the construction and resolution of filter chains for consumer, provider, and edge roles. Uses a list of FilterProvider beans (loaded via SPI) to build ordered FilterNode chains per microservice. Demonstrates a clean chain-of-responsibility pattern with role-based separation, ordering, and enable/disable support. Reusable in any framework requiring a configurable middleware pipeline.
Manages hierarchical property resolution with fallback across multiple configuration sources (YAML, properties, environment, dynamic). Supports priority-based injection via @InjectProperties and @InjectProperty annotations, with hot-reloading on configuration changes. Demonstrates a robust pattern for handling configuration precedence and dynamic updates, reusable in any Java application needing flexible configuration management.
Defines an ordered converter chain for mapping internal exceptions to standardized error responses. Implementations (e.g., TimeoutExceptionConverter, ConstraintViolationExceptionConverter) are loaded via SPI and ordered by priority. Demonstrates a clean strategy pattern for exception translation, reusable in any service framework that needs consistent error handling across transports.
Parses configurable access log patterns (similar to Apache HTTPD format) into a list of AccessLogItem instances. Supports custom items via SPI (VertxRestAccessLogItemMeta) and composite items. Demonstrates a flexible, extensible pattern parsing engine that can be reused in any logging or formatting system requiring user-defined format strings.