This article dissects three real-world authentication failures in Spring Cloud Gateway, explaining why gateway-only auth is insufficient, how to reconcile stateless JWT with immediate revocation, and why downstream services must verify internal signatures rather than trust headers, with production-ready code and configuration patterns.
This article analyzes Spring Cloud Gateway's reactive architecture through three production incidents, detailing route predicates, filter chain mechanics, source code flow, and four critical tuning dimensions—thread model, connection pooling, timeout hierarchy, and off-heap memory—to prevent gateway failures under high concurrency.
This article explains why gateway-only JWT validation is insufficient in zero-trust microservices, detailing Token Relay and Token Exchange patterns with Spring Boot 3.5 code examples for secure service-to-service authentication and authorization.
This article traces an HTTP request through Spring Boot's Servlet and reactive stacks, explaining how SpringApplication chooses between Tomcat and Netty, detailing Netty's event-loop decoding, Spring Cloud Gateway's routing and filtering, Tomcat's request processing to DispatcherServlet, and four common gateway-downstream issues including timeout alignment, header forwarding, thread-model mismatch, and unsafe retries.
This guide covers the top 10 Nginx and API gateway production faults—including 502/504 errors, retry storms, load imbalance, rate limiting failures, CORS issues, and 499 errors—with root cause analysis, configuration fixes, and a step-by-step SOP for rapid diagnosis and long-term prevention.
The article compares three approaches to restrict APIs to internal-only access in microservices: service isolation, gateway whitelist with Redis, and a gateway-plus-AOP solution that adds a header at the gateway and validates it via annotation-driven aspect, favoring the latter for performance and developer efficiency.
This comprehensive guide covers Spring Cloud microservices architecture, comparing Eureka, Nacos, and Consul for service discovery; details OpenFeign dynamic proxy and load balancing; explains Sentinel rate limiting, circuit breaking, and degradation; contrasts Sleuth/Zipkin with SkyWalking for distributed tracing; and provides production pitfalls and interview strategies for Spring Cloud Alibaba ecosystem.
This article explains why Spring Cloud Gateway cannot coexist with Spring MVC due to fundamental model differences, and details how Spring Boot's DeferredImportSelector and conditional annotations enable intelligent auto-configuration by evaluating classpath, beans, and environment at runtime.
This article details a production-ready full-chain gray release system using Spring Cloud Gateway and Dubbo, distinguishing canary from gray release, covering implementation, four real-world pitfalls with solutions, and a seven-step standardized rollout process for zero-downtime microservice deployments.
The article analyzes five reasons why Spring Cloud Gateway's Redis-based token bucket rate limiting fails to protect downstream services during traffic bursts, including QPS vs. concurrency confusion, burstCapacity spikes, multi-route quota multiplication, KeyResolver fallback flaws, and Redis bottleneck fail-open behavior, then recommends tightening burst limits, adding downstream concurrency isolation with Sentinel/Resilience4j, and hardening KeyResolver configuration.
This article provides a comprehensive production guide for Spring Cloud Gateway based on real e-commerce experience, covering unified JWT authentication with whitelist, header-based and weight-based canary release strategies, Sentinel integration for global rate limiting and circuit breaking, and six critical production pitfalls including header loss, CORS errors, 504 timeouts, blocking I/O, static routing, and ineffective rate limiting with solutions.
This article details the development of custom Spring Cloud Gateway plugins for rate limiting, circuit breaking, and gray release to overcome Sentinel's production limitations, covering architecture design, Redis-based rule storage with pub/sub, token bucket and sliding window algorithms, circuit breaker state machines, tag-based canary routing, and production lessons learned with performance benchmarks.
This comprehensive guide explains browser same-origin policy, compares four cross-origin solutions (CORS, Nginx reverse proxy, frontend dev proxy, JSONP), provides production-ready Spring Boot CORS filters with OPTIONS preflight handling, Spring Cloud Gateway config, dynamic origin whitelists, and covers interview-focused topics like credential handling, security framework conflicts, and WebSocket cross-origin.
This comprehensive guide compares Session-Cookie, JWT, OAuth2.0, and SSO authentication schemes, details production-ready dual-token JWT implementation with RS256, Redis blacklist/whitelist, Spring Cloud Gateway filters, and covers concurrency, revocation, and security hardening with code examples and interview insights.
This article details a comprehensive enterprise API security implementation using Spring Boot, covering OAuth 2.1 with PKCE and token exchange, mutual TLS for transport security, API signature verification to prevent tampering and replay, JWT encryption with JWE, fine-grained permission control, security auditing, gateway-level authentication, and alignment with OWASP API Top 10 vulnerabilities.
This article provides a comprehensive four-phase strategy (emergency mitigation, root cause analysis, targeted remediation, long-term defense) for handling malicious traffic attacks on PC websites, detailing a five-layer defense architecture (CDN, WAF, Gateway, Service, Data) with production-ready code for Nginx rate limiting, Spring Cloud Gateway + Sentinel, Resilience4j circuit breaking, Redis cache protection, and API signature verification, plus interview-focused technical deep-dives.
This article presents a detailed technical blueprint for building an enterprise‑grade single sign‑on system that combines Apereo CAS, OAuth2, and JWT across four microservices, covering service responsibilities, data models, API contracts, deployment trade‑offs, and operational safeguards.
The article explains why a gateway is the first traffic entry in microservice systems and how Spring Cloud Gateway achieves million‑level concurrent handling through a reactive model, non‑blocking I/O, event‑driven scheduling, zero‑copy transmission, and built‑in rate‑limiting mechanisms.
When a company’s internal tools each required separate logins, the team built an enterprise‑grade CAS single sign‑on system that unified identity, login entry, logout handling, and extensible integration, and they document the entire process across nine detailed articles.
The article explains how Spring Cloud Gateway achieves ultra‑high QPS by leveraging Netty's non‑blocking I/O, Project Reactor's event‑driven streams with backpressure, and lightweight route predicates combined with load‑balancing to maximize thread utilization and system throughput.
The article explains that achieving stable performance for Spring Cloud Gateway at a million‑request scale requires a reactive non‑blocking model, comprehensive rate‑limiting and circuit‑breaker mechanisms, and optimized connection management and routing to handle high concurrency efficiently.
This article details integrating Sentinel with Spring Cloud Gateway to achieve intelligent rate limiting, circuit breaking, dynamic routing, and security controls, covering cluster flow control modes, hot rule updates via Nacos, performance tuning for reactive pipelines, and production-grade security patterns including IP filtering and API signature verification.
This article details a production-ready implementation of full-chain gray release using Spring Cloud Gateway, covering context propagation via Reactor Context and headers, dynamic rule engine with Caffeine and Nacos, deterministic traffic splitting, downstream interception, circuit breaking, rollback strategies, and lessons learned from reactive blocking, cache consistency, distributed transactions, and header injection pitfalls.
The article explains that although Spring Cloud Gateway offers token‑bucket rate limiting via Redis, adding a coarse‑grained Nginx limit protects the gateway from traffic spikes, reduces JVM pressure, and ensures continuous flow control even during restarts or GC pauses.
This article walks through five practical ways to implement gray (canary) releases in Spring Boot 3.5.0, covering gateway‑based weight and header routing, programmatic route configuration, a custom reactive load‑balancer, and application‑layer annotations with custom HandlerMapping, each illustrated with concrete code samples.
The article explains that a gateway serves as the unified entry point of a microservice system, handling routing, authentication, rate limiting, logging and protocol conversion, compares architectures with and without a gateway, details Spring Cloud Gateway's core concepts, shows configuration and custom auth filter code, and contrasts it with Zuul, providing interview‑ready insights and sample questions.
This article compares four API‑gateway solutions—Spring Cloud Gateway, NGINX, Envoy, and Kong—detailing their core strengths, drawbacks, suitable scenarios, configuration snippets, and practical selection rules to help architects pick the right gateway for microservice systems.
This article presents a comprehensive production-grade approach to API version management in Spring Boot, covering version identification strategies, custom routing via RequestCondition, DTO isolation with MapStruct, deprecation interceptors with Prometheus metrics, gateway-level traffic splitting using Spring Cloud Gateway and Nginx, and a lifecycle state machine with automated retirement rules.
In a micro‑service architecture, a centralized gateway eliminates the need for front‑ends to call dozens of services by handling authentication, rate‑limiting, logging, CORS, and security, and Spring Cloud Gateway—built on WebFlux and Netty—offers a non‑blocking, high‑throughput alternative to Zuul with detailed configuration and code examples for production use.
This tutorial walks through adding Spring Cloud Gateway as a single entry point for client calls to multiple microservices, covering why a gateway is needed, project structure, dependency and configuration setup, global logging and authentication filters, startup verification, and common pitfalls with solutions.
The article explains that Nginx and Spring Cloud Gateway serve distinct roles—Nginx as a network‑level gateway handling static assets, SSL termination, and load balancing, while Gateway focuses on business‑level routing and filters—making the two‑layer architecture both logical and efficient.
The article explains that Nginx and Spring Cloud Gateway serve different roles—Nginx as a network gateway handling static files, load balancing, SSL termination, and ops tasks, while Gateway focuses on business routing—so using both together improves performance, scalability, and operational separation.
This article walks through a practical implementation of gray (canary) release in a Spring Cloud ecosystem using Nacos for service discovery, Spring Cloud Gateway for routing, Ribbon (or Spring Cloud LoadBalancer) for load balancing, and custom interceptors to control traffic based on request metadata.
A production incident caused by replacing two Nginx reverse proxies introduced an upstream name with an underscore, resulting in invalid Host headers and 400 Bad Request responses from Spring Cloud Gateway; the article details the step‑by‑step investigation, evidence from logs, tcpdump, and code, and presents configuration fixes to restore normal operation.
When a business service needs an API that should only be callable within the internal network, this article evaluates three approaches—microservice isolation, gateway‑Redis whitelist, and gateway‑AOP—and demonstrates a concrete AOP implementation to enforce intranet‑only access.
This article provides a detailed technical overview of Spring Cloud Gateway, covering its role as a second‑generation API gateway built on Spring 5, WebFlux, and Reactor, its core responsibilities, architectural placement, key concepts like routes, predicates and filters, the request processing flow, and a concrete YAML configuration example.
This article explains how Spring Cloud Gateway leverages a reactive, non‑blocking architecture, OS‑level tuning, zero‑copy networking, and built‑in rate‑limiting and circuit‑breaker features to reliably sustain million‑level concurrent traffic in production environments.
The article explains that without a gateway each microservice must duplicate authentication, rate‑limiting, logging and other cross‑cutting concerns, leading to maintenance overhead and security risks, and shows how a gateway centralises these functions while providing routing, load‑balancing, circuit‑breaking and observability, backed by real‑world code examples and a comparative analysis of popular gateway solutions.
A microservice gateway misidentifies legitimate requests as replay attacks due to client-server time drift, causing 401 errors; the article explains the core logic, offers an emergency manual time sync, then details three progressive fixes: tiered gateway time thresholds, idempotency keys to eliminate time dependence, and internal NTP deployment for permanent synchronization.
Even with Nginx handling high‑performance load balancing and static content, a dedicated API gateway is essential for flexible routing, dynamic service discovery, fine‑grained traffic governance, and centralized business logic such as authentication and logging in microservice architectures.
This article explains the fundamental differences between gray release and A/B testing, provides step‑by‑step guidance for implementing both strategies with Spring Cloud Gateway, Nacos and Kubernetes, and compares container‑level canary deployments with gateway‑level traffic routing to help you choose the right approach for reliable production releases.
This article explains how Spring Cloud Gateway leverages asynchronous non‑blocking I/O, horizontal scaling, Redis‑based rate limiting, and circuit‑breaker patterns to sustain massive QPS, reduce latency, and improve system resilience in microservice architectures.
This article walks through a complete design and implementation of a unified single sign‑on system using OAuth2.0 authorization‑code flow, Spring Cloud Gateway, JWT, Redis, and Nacos, comparing JWT, authentication, and authorization while presenting performance metrics, security considerations, and interview‑ready answers.
Spring Cloud Gateway leverages reactive programming, Netty’s non‑blocking I/O, and cluster scaling on Kubernetes or Docker to support tens of millions of QPS, using techniques like sharding, load‑balancing, DNS/Anycast, and built‑in rate‑limiting and circuit‑breaker mechanisms for resilient, high‑throughput microservice traffic.
This article outlines the key building blocks of a microservice architecture—including Nginx as the traffic entry, Spring Cloud Gateway, service registration, Redis caching, MySQL persistence, Elasticsearch, message queues, ELK logging, distributed scheduling, and object storage—providing practical guidance on design choices and high‑availability setups.
This article explains how to use Spring Cloud Gateway for traffic coloring and gray release, enabling you to tag requests, route VIP or test traffic to new service versions gradually, and ensure safe, controlled rollouts in production environments.
After a year‑long mystery, we discovered that Spring Cloud Gateway 3.x caches stale weight data from Nacos, causing 404 errors when routes are removed, and we detail the debugging steps, root‑cause analysis, and a custom solution that synchronizes the weight cache on configuration changes.
This guide walks through using Spring Cloud Gateway to replace direct service calls with a unified entry point, covering service discovery, load‑balanced routing, predicate definitions, custom predicates, rewrite‑path filters, global filters, and CORS configuration for microservice architectures.
The article walks through a year‑long investigation of a 404 error that appears after updating Nacos dynamic routing in Spring Cloud Gateway 3.0.1, explains how stale weight caches cause the failure, and presents a custom event‑listener solution that synchronizes the gateway's weight cache with the latest Nacos configuration.
This article explains how Spring Cloud Gateway leverages a non‑blocking NIO model, Reactor's reactive programming, cluster horizontal scaling, token‑bucket rate limiting, and Resilience4j circuit breaking to sustain million‑level concurrent traffic while maintaining low latency and high throughput.
This article provides a comprehensive overview of Spring Cloud Gateway, covering its role as a reactive API gateway, core functionalities such as routing, security authentication, rate limiting, logging, circuit breaking, the request lifecycle, and a comparison with other gateway solutions.
This article explains how Spring Cloud Gateway leverages an asynchronous non‑blocking model built on Netty and Project Reactor, along with rate limiting, circuit breaking, and degradation strategies, to sustain million‑level concurrent traffic while protecting backend services.
Circuit BreakingSpring Cloud Gatewaybackend development
The article explains how Spring Cloud Gateway leverages a fully non‑blocking, reactive architecture built on Project Reactor and Netty to handle millions of concurrent requests, and discusses essential protection mechanisms such as rate limiting, circuit breaking, and degradation for high‑traffic scenarios.
This guide walks through upgrading a Spring Cloud Gateway by integrating Nacos as a service registry and configuration center, showing how to enable automatic request forwarding, dynamic route loading, and load‑balancing with step‑by‑step code examples and configuration files.
This article introduces Spring Cloud Gateway as a high‑performance replacement for Zuul, explains its core components (Route, Predicate, Filter) and request flow, provides step‑by‑step setup of a gateway project, demonstrates route configuration, custom GlobalFilter and GatewayFilter implementations, and validates the behavior with example requests.
This article provides a comprehensive walkthrough of Spring Cloud Gateway, covering its core concepts, architecture, key components such as Route, Predicate, and Filter, and detailed source‑code analysis with configuration examples and the underlying HTTP handling flow.
This article explains symmetric and asymmetric encryption principles, digital signatures, HTTPS with certificate authorities, and demonstrates how to implement combined encryption, digital signing, and URL protection using Spring Cloud Gateway filters and Java code examples.
This tutorial introduces Spring Cloud Gateway, explains its core features and Actuator integration, and provides step‑by‑step practical examples for viewing routes, global filters, route filters, refreshing routes, managing routes via REST endpoints, creating and deleting routes, and sharing routes with Redis, all accompanied by code snippets and configuration details.
This article explains the fundamentals of symmetric and asymmetric encryption, how digital signatures and HTTPS work with certificate authorities, and demonstrates a practical implementation of secure URL encryption, key exchange, and request validation using custom Spring Cloud Gateway filters written in Java.
This comprehensive guide explains why a gateway is essential in microservice architectures, outlines Spring Cloud Gateway's core features, walks through building a gateway from scratch, and demonstrates advanced topics such as custom predicates, filters, Nacos service discovery, dynamic routing, and global error handling.
This article explains what a microservice gateway is, outlines the advantages of Spring Cloud Gateway, and provides step‑by‑step instructions with code examples to create, configure, and run a reactive API gateway for Java microservices.
Learn how to set up Spring Cloud Gateway, configure routes, predicates, and filters—including custom global filters and time-based predicates—while testing load balancing, weight distribution, and request handling in a microservices environment effectively.
This article introduces Spring Cloud Gateway as a high‑performance, reactive API gateway for microservice architectures, explains why it is chosen, details Maven and YAML configuration, demonstrates routing predicates and filters with code examples, and evaluates its performance impact compared to alternatives.
This article explains how to create custom predicate and gateway filter factories in Spring Cloud Gateway, covering the underlying concepts, implementation steps, example code, and YAML configuration to tailor routing conditions and request handling for specific business needs.
This article introduces Spring Cloud Gateway as a powerful tool for building scalable microservice gateways, explains its reactive architecture and advantages, and provides a step‑by‑step tutorial—including Maven dependency, route configuration, custom filter code, and deployment instructions—plus suggestions for advanced features.
This tutorial explains how to use Spring Cloud Gateway for unified API routing, metrics collection, metadata handling, timeout settings, fluent Java route definitions, service‑discovery routing, and troubleshooting techniques in microservice architectures.
This article explains how to achieve full‑link gray (canary) release in a microservice architecture by adding a gray tag in a Spring Cloud Gateway global filter, propagating it through request headers, customizing Ribbon load‑balancing rules to select gray instances from Nacos, and using an OpenFeign interceptor to transmit the tag downstream, ensuring seamless A/B testing and stable deployments.
This article demonstrates how to replace heavyweight Spring Security with the lightweight Sa-Token framework by configuring token generation, session management, role and permission retrieval, and global gateway filters in a Spring Cloud micro‑service architecture, including complete code examples and deployment tips.
The article explains how to safely upgrade services by using gray (canary) release strategies with Spring Cloud Gateway, compares rolling and blue‑green deployments, and demonstrates weight‑based routing, hint‑based routing, and custom ServiceInstanceListSupplier implementations to control traffic between old and new service versions.
This article demonstrates how to replace heavyweight Spring Security with the lightweight Sa-Token framework by configuring token generation, session storage in Redis, service discovery via Nacos, and permission checks in a Spring Cloud Gateway micro‑service architecture, complete with code examples and deployment settings.
This article explains how to use Spring Cloud Gateway 3.1.5 to create a lightweight API gateway by configuring routes in YAML and implementing routing logic directly in a Spring MVC or WebFlux controller with ProxyExchange, covering features, code examples, and dynamic path mapping.
This article explains how EDAS enhances Spring Cloud Gateway by fixing memory‑leak issues, adding route‑validation, providing dynamic configuration, custom plugins, observability features, and step‑by‑step deployment instructions for Java‑based microservice environments.
This article reviews how Spring Cloud Gateway modifies HTTP requests/responses with built‑in filters, introduces the Higress cloud‑native gateway’s Transformer plugin as a higher‑performance alternative, compares their CPU and memory usage, and provides step‑by‑step deployment and configuration instructions.
This tutorial explains how to configure Spring Cloud Gateway, set up static routes, and then use Nacos for dynamic route management by adding dependencies, configuring bootstrap.yml, defining JSON route data, and implementing a listener bean to refresh routes without restarting the service.
This guide explains what a microservice gateway is, outlines the advantages of Spring Cloud Gateway, and provides a step‑by‑step tutorial—including Maven dependency, YAML routing configuration, custom filter code, and deployment instructions—to help developers build scalable, reactive API gateways for modern backend systems.
API GatewaySpring Cloud Gatewaybackend-development
LApiGateway is Huolala's custom Java-based microservice gateway built on Spring Cloud Gateway, featuring service discovery via Consul, centralized configuration, a rich plugin system, DSL-driven routing, high‑availability designs like physical and service isolation, gray‑scale migration, traffic pre‑warming, and adaptive load balancing to ensure stable, efficient API management.
After a sudden 500 error crippled an online service, the author traced the issue to Spring Cloud Gateway’s HttpMessageReader creating temporary directories for every request, eventually exhausting inode space; the article explains the root cause, inode basics, and how upgrading to version 5.2.16 resolves the problem.
This article introduces Spring Cloud Gateway as a unified entry for microservices, explains its core functions, advantages over Zuul, Maven dependencies, YAML routing configuration, detailed route components, filter types with code examples, custom global filters, execution order, and CORS solutions for backend development.
This article explains why URL mappings that worked in Spring Boot 2.x break after upgrading to Spring Boot 3, demonstrates the issue with trailing slashes, and provides three practical solutions—including a filter, Nginx rule, and Spring Cloud Gateway optimization—to restore correct routing.
This guide explains why API rate limiting is essential, outlines common algorithms, and walks through three practical implementations in Spring Boot 3—using Guava, Spring Cloud Gateway with RedisRateLimiter, and a custom annotation‑based solution with Redis backing.
This article explores how Spring Cloud Gateway (Hoxton.SR11) initializes predicate factories, binds configuration values, creates Route objects, and uses CachingRouteLocator and RouteDefinitionRouteLocator to locate and match routes at startup, detailing the underlying code flow and key classes involved.
This article introduces Spring Cloud Gateway as a unified entry point for microservices, explains its core functions, compares it with Zuul, provides Maven and YAML configuration examples, details route definitions, filter types and ordering, shows how to implement custom filters, and demonstrates CORS solutions using both YAML and Java code.
This article explains the purpose of an API gateway, introduces Spring Cloud Gateway as a modern, WebFlux‑based solution, outlines its features, core concepts such as routes, predicates and filters, shows configuration examples, dynamic routing, and how to create custom predicates and filters for microservice architectures.
This article explains how Spring Cloud Gateway (Hoxton.SR11) creates and configures predicate factories, binds their Config objects, builds Route objects, caches them with CachingRouteLocator, and finally matches incoming requests to the appropriate route using asynchronous predicates.
The team discovered that frequent Logback file rotations created thousands of FileOutputStream objects whose finalize‑based FinalReference instances flooded the G1GC reference‑processing phase, causing 13‑second pauses, and resolved the issue by enabling parallel reference processing, enlarging log rotation size, and adjusting GC initiation thresholds.
This article explains the role of API gateways in microservice architectures, outlines their four core functions, discusses design priorities such as high performance, availability, and scalability, and compares major open‑source gateway solutions like OpenResty, Kong, Zuul, and Spring Cloud Gateway.
This article explains why API gateways are essential in micro‑service architectures, outlines their four core functions, discusses high‑performance, high‑availability, and scalability design goals, and compares major open‑source gateways such as OpenResty, Kong, Zuul, and Spring Cloud Gateway to help engineers choose the right solution.
This guide explains how to configure route metadata in Spring Cloud Gateway 3.1.4, retrieve metadata via ServerWebExchange, set global and per‑route HTTP timeouts, use Java DSL for timeout settings, and enable DiscoveryClient‑based routing with custom predicates and filters.
An in‑depth walkthrough of Spring Boot 2.7.10 with Spring Cloud Gateway 3.1.6 shows how the RouteToRequestUrlFilter, ReactiveLoadBalancerClientFilter, NettyRoutingFilter, and NettyWriteResponseFilter sequentially transform incoming URLs, resolve service instances via load balancing, and forward requests to target microservices.
This article explains the fundamentals of API gateways, outlines their core functions, compares popular solutions such as Nginx, Zuul, Spring Cloud Gateway, Kong, and Traefik, and details a custom Traefik‑based gateway architecture with its technology stack, backend design, and protocol‑conversion module.
This article explains three practical approaches—separate microservices, gateway + Redis whitelist, and gateway + AOP—to restrict external access to internal APIs, and provides a detailed Spring Cloud Gateway and AOP code implementation for Java microservice architectures.
This article explains why an API gateway is essential in micro‑service architectures, introduces Spring Cloud Gateway’s core features, walks through project setup, routing predicates, filters, integration with Nacos for service discovery and dynamic routing, and demonstrates custom global error handling.
The article explains why Spring Cloud Gateway may still call a downed service due to a stale CachingRouteLocator cache, and demonstrates how to listen to Nacos InstancesChangeEvent to evict the cache so the gateway always uses the latest service list.
This guide explains how to configure HTTP connect and response timeouts globally and per route in Spring Cloud Gateway using YAML, Java DSL, and DiscoveryClient integration, including code examples for timeout settings, route predicates, filters, and custom metadata.
This guide explains the purpose, signatures, and ordering of GlobalFilter and GatewayFilter in Spring Cloud Gateway, shows how to combine them, and provides detailed code examples for custom global filters, forward routing, load‑balancing, Netty, WebSocket, and other core filters, including configuration tips.
This article provides a step‑by‑step guide to building a Spring Cloud Gateway for microservices, covering system setup, request routing, cross‑origin handling, token‑bucket rate limiting, password hashing with BCrypt, an overview of symmetric and asymmetric encryption, and JWT‑based authentication with code examples and configuration details.
This article explains why browsers enforce same‑origin policies causing CORS problems, outlines common remedies such as the @CrossOrigin annotation, HttpClient usage, and Spring Cloud Gateway integration, and provides detailed configuration and code examples for implementing these solutions in a Java backend.
This tutorial walks you through setting up a Spring Cloud Gateway service using Spring Boot, configuring static and Nacos‑driven dynamic routes, and implementing a custom authentication filter with Redis token validation, providing a complete beginner‑friendly guide to gateway development.
This article explains what an API gateway is, why it is needed in micro‑service architectures, outlines core design ideas such as routing, service registration, load balancing, resilience and security, distinguishes traffic and business gateways, and compares major open‑source implementations like OpenResty, Kong, Zuul 1/2 and Spring Cloud Gateway.