dyc87112/SpringCloud-Learning

Features

• Microservice Demonstrations - An educational project demonstrating Spring Cloud microservice patterns.
• Declarative Remote Service Proxies - Declares a shared Java interface so a provider implements it and a consumer calls it as a local bean.
• Service Discovery and Selection - Demonstrates service registration and discovery using Nacos, Eureka, and Consul.
• Remote Configuration Retrieval - Shows how to pull configuration from a remote server at application startup using data ID and group identifiers.
• Environment Configuration Management - Demonstrates applying different configuration values based on the active deployment environment, such as development or production.
• Service Configuration Management - Stores and retrieves configuration properties centrally with dynamic updates without restarting services.
• Nacos Service Discovery - Registers and discovers microservices using Nacos as the registry, integrated via a Spring Cloud starter.
• Declarative Remote Service Proxies - Provides annotated Java interfaces that generate remote service proxies for transparent inter-service calls.
• Centralized Configuration Management - Provides hands-on examples of storing and serving application configuration from a central server for live updates.
• Environment Configuration Profiles - Loads environment-specific configuration profiles from a remote server using profile names and namespaces.
• Nacos Configuration Loading - Shows how to load application configuration from a Nacos server by matching Data ID and Group to client settings.
• Nacos Configuration Management - Provides hands-on examples of storing and managing application configuration in Nacos with multi-environment support.
• Dynamic Configuration Management - Updates configuration values in a running application without restart by detecting changes in the remote store.
• Client-Side Load Balancing - Distributes outgoing requests among multiple service instances using client-side load balancing.
• Circuit Breaking - Protects microservices from cascading failures and traffic spikes using Sentinel with a dashboard and real-time configuration.
• Service Discovery Resolvers - Resolves logical service names to live instance addresses for load-balanced HTTP requests.
• Eureka - Registers and discovers microservice instances using Eureka for load-balanced, resilient service-to-service calls.
• Centralized Configuration Storage - Stores all application configuration in a central server, enabling separation of environment-specific settings and secure permission management.
• Publish-Subscribe Messaging - Publishes and subscribes to asynchronous messages through a message broker to decouple microservices.
• HTTP Client Integrations - Creates annotated Java interfaces that automatically generate HTTP client implementations for service calls.
• Client-Side Load Balancing - Resolves logical service names to available instances from a registry and distributes requests via client-side load balancing.
• Message Broker Consumers - Processes messages from a message broker with retries, dead-letter queues, and delayed delivery.
• Configuration Change Broadcasting - Demonstrates broadcasting configuration changes to all microservice instances via a message bus for live updates.
• Circuit Breakers - Wraps remote calls with Hystrix to provide fallback logic, isolate failures, and prevent cascading outages.
• Gateway Routing - Demonstrates routing external API requests through Spring Cloud Gateway with declarative rules and filters.
• API Gateways - Implements API gateway patterns for routing external requests to internal microservices.
• Application Configuration - Provides examples of storing and serving configuration properties centrally, allowing live updates without restarting services.
• Dynamic Service Discovery - Looks up available service instances from a registry at runtime to enable load-balanced remote calls.
• Fault Tolerance - Implements circuit breakers, rate limiting, and fallback logic for service resilience.
• Service Discovery and Invocation - Looks up registered service instances by name and routes requests with client-side load balancing across instances.
• Service Discovery Registries - Shows how to register and discover microservice instances using Nacos.
• Service Instance Lifecycle Management - Queries a registry to find available instances of a service and load-balances requests across them.
• Nacos Instance Registrations - Registers microservice instances with Nacos so they become discoverable by other services in the cluster.
• Nacos Service Registrations - Demonstrates registering microservices with Nacos as a primary service discovery mechanism.
• Proxy-Based Remote Invocation - Generates remote service proxies from annotated Java interfaces for transparent local-style invocation.
• Service Registry Publications - Publishes service instances to a registry so consumers can discover and invoke them without hardcoded addresses.
• Rate Limiting and Circuit Breaking - Implements both rate limiting and circuit breaking with Sentinel and Hystrix for service resilience.
• Request Tracing - Correlates logs and timing data across microservices using Zipkin for end-to-end request visualization.
• Distributed Request Tracing - Collects and visualizes request traces across microservices using Zipkin for debugging and performance analysis.
• Declarative API Clients - Defines Java interfaces annotated with HTTP method mappings that generate remote API client implementations.
• Configuration Persistence - Persists configuration changes durably in a database so they survive restarts and are shared across nodes.
• Per-File Refresh Marking - Shows how to mark individual configuration files for automatic runtime refresh when the remote source changes.
• Nacos MySQL Backends - Provides a concrete walkthrough for persisting Nacos data to MySQL for cluster deployments.
• Relational Configuration Stores - Stores application configuration properties in a relational database table instead of a Git repository, enabling SQL-based retrieval.
• Sentinel Flow Rule Stores - Persists Sentinel flow-control rules in Nacos or Apollo so they survive restarts and can be managed centrally.
• Service-Profile Configuration Retrieval - Queries configuration values for a specific application, environment, and label using a customizable SQL statement.
• Data ID Based Retrieval - Demonstrates retrieving configuration content from a remote server using a unique Data ID and Group identifier.
• Resource Protection Rules - Applies rate-limiting and circuit-breaking rules persisted externally for dynamic traffic management.
• Sentinel Flow Rule Stores - Demonstrates persisting Sentinel flow control rules in Apollo for dynamic rule management across environments.
• Configuration Merging - Demonstrates combining settings from several external configuration files and merging them into a single application context.
• Data ID and Group Overrides - Demonstrates overriding default Data ID, file extension, or Group to load specific configuration sets from Nacos.
• Multi-File Remote Loading - Demonstrates loading several external configuration files from a remote store, each with its own refresh setting.
• Configuration Server Clusters - Demonstrates deploying multiple Nacos configuration server instances for high availability.
• Nacos Server Clusters - Provides a walkthrough for forming a Nacos server cluster for high availability.
• Sentinel Flow Rule Stores - Persists Sentinel flow control rules in Apollo configuration center so rules survive service restarts and remain synchronized across instances.
• Dead Letter Queues - Routes repeatedly failing messages to a dead-letter queue for later inspection and reprocessing.
• Nacos Cluster Load Balancers - Demonstrates proxying a Nacos cluster behind a load balancer for unified client access.
• Sentinel Rate Limiting - Applies rate-limiting rules with Sentinel to protect API endpoints from traffic surges.
• Consul Service Discovery - Registers Spring Boot applications as service providers with a Consul agent for service discovery and health checking.
• Channel Bindings - Maps input and output channels to a shared topic for message flow between services.
• Broker Abstractions - Abstracts message broker interactions behind a unified programming model with retries, dead-letter queues, and delayed delivery.
• Dubbo Integration - Integrates Dubbo as an RPC protocol for inter-service communication within a Spring Cloud architecture.
• Declarative Client Replacements - Replaces Feign and Ribbon with Dubbo while preserving the Feign programming model for service calls.
• Dubbo RocketMQ Bridges - Integrates Dubbo RPC and RocketMQ messaging for unified service communication.
• Protocol and Registry Settings - Shows how to configure Dubbo protocol, port, and registry address in application properties for service communication.
• Declarative Client Protocol Bridges - Integrates Dubbo as an alternative RPC protocol while preserving the existing Feign declarative client model.
• Sentinel - Applies rate-limiting rules with Sentinel to protect services from traffic spikes.
• Request Size Limiters - Restricts API endpoints to a maximum QPS threshold, blocking excess traffic when exceeded.
• Sentinel Flow Rule Stores - Persists Sentinel flow control rules in Nacos so they survive restarts and can be managed centrally.
• Fault-Tolerant Fallbacks - Specifies handler functions that return safe default responses when requests are blocked or exceptions occur.
• Configuration Propagation Buses - Propagates configuration changes to all connected microservice instances instantly via a message bus.
• Event Driven Messaging - Demonstrates asynchronous message-driven microservices with retries, DLQ, and delayed delivery.
• Microservice Decomposition Patterns - Demonstrates decomposing a monolith into independent web applications that each own their data.
• Configuration Namespace Isolation - Demonstrates separating service discovery and configuration into distinct namespaces for multi-environment deployments.
• Configuration Source Priority - Demonstrates defining the priority of configuration sources so later-loaded values override earlier ones.
• Shared Configuration Files - Shares the same configuration files among multiple applications by listing their identifiers in a single property.
• Path Request Rate Limiters - Restricts request rates per API endpoint to prevent overload using path-specific rate limiters.
• Dashboard-Configured Rate Limits - Configures rate-limiting rules via Sentinel dashboard to restrict access to specific resources.
• Sentinel Flow Rule Stores - Persists flow control rules in Nacos so they survive restarts and can be managed centrally.
• Service Degradation Strategies - Triggers circuit-breakers when method error rates or response times exceed thresholds, blocking calls for a set window.
• Provider Swappable Registries - Shows how to switch between Nacos, Eureka, and Consul registries without code changes.
• QPS-Based Rate Limits - Restricts API endpoints to a maximum QPS threshold, blocking excess traffic when exceeded.
• Sleuth & Zipkin Implementations - Demonstrates distributed request tracing with Zipkin across microservices.
• Configuration Precedence Resolvers - Determines which configuration value wins when the same key appears in multiple loaded files based on defined precedence.

Star history