This article explains the conceptual differences between Spring MVC interceptors and servlet filters, demonstrates how to implement each with Java code, shows the necessary configuration in Spring and web.xml, and summarizes their respective use cases, lifecycles, and limitations for backend development.
This article explains how to replace OpenFeign's default HTTP client with OkHttp, configure request and response interceptors, and customize OkHttpClientBuilder in Spring Cloud, providing detailed code examples and configuration steps for effective interceptor implementation.
Explore the 11 most commonly used Spring extension points—from custom interceptors and bean factories to global exception handling, type converters, import mechanisms, startup runners, bean lifecycle processors, and custom scopes—complete with clear code examples and practical guidance for enhancing Java backend applications.
This article explains the conceptual differences between Spring MVC interceptors and Servlet filters, shows how to implement each with Java code, details their configuration in Spring and web.xml, and summarizes when to use one over the other in backend development.
This article provides a comprehensive overview of OkHttp, covering its overall request process, the role of the dispatcher, how application and network interceptors work, TCP connection reuse via the connection pool, idle‑connection cleanup, key advantages, and the design patterns employed in the framework.
This article demonstrates how to create a Java annotation for access limiting, implement the corresponding Spring Boot interceptor that checks Redis counters, register the interceptor in the application, and apply the annotation to a controller method to enforce request rate limits.
This article explains how to add a universal app‑key whitelist authentication feature to a Spring‑Boot web framework by using four different mechanisms—traditional AOP, HandlerInterceptor, custom HandlerMethodArgumentResolver, and a Servlet Filter—while comparing their execution order and extensibility.
This tutorial demonstrates how to protect Spring Boot services from malicious requests by creating a custom interceptor that tracks request counts per IP and URL, uses Redis for distributed locking, and disables abusive IPs after a configurable threshold within a defined time window.
Learn how to secure a Spring Boot service by limiting request frequency per IP and URL using a custom interceptor combined with Redis distributed locks, automatically blocking abusive IPs after a configurable number of hits within a set time window.
This article demonstrates how to protect a Spring Boot service from malicious requests by creating a custom interceptor that tracks URL‑IP request counts, uses Redis for distributed locking, and disables offending IPs after a configurable threshold, with full code examples and configuration steps.
This article explains how to create a custom MyBatis Interceptor using Java dynamic proxies, detailing the Interceptor interface, the plugin generation process, the wrap and invoke methods, and common use‑cases such as pagination, SQL analysis, encryption, and performance monitoring.
This article explains how to standardize API responses in a Spring backend by defining a JSON result structure, designing status codes, using @ResponseResult annotations, interceptors, and controller advice to automatically wrap results, while also discussing optimization and best‑practice considerations.
This article explains how to use Mapped Diagnostic Context (MDC) in Java logging frameworks to propagate traceId across threads and HTTP calls, covering API usage, advantages, common pitfalls, and practical solutions including interceptor implementation, thread‑pool wrappers, and client‑side interceptors for HttpClient, OkHttp, and RestTemplate.
This article explains what MDC is, its API, common pitfalls like traceId loss in child threads and HTTP calls, and provides practical solutions using custom thread pool wrappers and interceptors for HttpClient, OkHttp, and RestTemplate to reliably propagate trace identifiers.
This article explains four Spring‑Boot techniques—traditional AOP, HandlerInterceptor, custom HandlerMethodArgumentResolver, and Servlet Filter—to perform generic authentication with code examples and a final comparison of their execution order.
This article demonstrates how to automatically encrypt sensitive fields such as ID numbers and phone numbers before storing them in a database and decrypt them after retrieval by leveraging MyBatis plugins, custom annotations, and Spring Boot components, providing a clean, reusable solution for backend applications.
This article introduces MDC, explains its API and benefits, and provides concrete solutions—including a thread‑pool wrapper and HTTP client interceptors—to reliably propagate traceId across threads and remote calls in Java backend applications.
This article demonstrates how to build a token‑bucket based rate‑limiting solution in a Spring Boot application using a custom annotation, an interceptor, a bucket utility class, scheduled token generation, and global AOP exception handling to control access to APIs.
This article explains the concept of MDC (Mapped Diagnostic Context) in Java logging, details its API, demonstrates how to propagate traceId across threads and HTTP calls using interceptors and custom thread‑pool wrappers, and shows how to configure log patterns to include the traceId.
This tutorial explains how to achieve automatic API idempotency in Spring Boot by leveraging Redis for token storage, creating a custom @AutoIdempotent annotation, configuring an interceptor to validate tokens, and providing complete code examples and test cases to prevent duplicate operations.
This article introduces the retrofit‑spring‑boot‑starter library, shows how to add the Maven dependency, configure @RetrofitScan, define HTTP interfaces, inject them into services, and demonstrates advanced features such as annotation‑based interceptors, custom interceptors, connection‑pool management, logging, exception formatting, call adapters, converters, and global interceptors for Spring Boot projects.
This article demonstrates how to achieve automatic request idempotency in Spring Boot applications by leveraging Redis for token storage, custom annotations, and interceptor configuration, providing step-by-step code examples for building a Redis service, token service, custom annotation, interceptor, and testing the solution.
This article reviews four Spring‑Boot techniques—traditional AOP, HandlerInterceptor, custom ArgumentResolver, and Servlet Filter—to implement a reusable app‑key whitelist authentication, provides complete code examples for each, and explains their execution order within the request processing chain.
This article explains how to configure Gradle and AndroidManifest files to run individual modules independently in a multi‑module Android project and demonstrates the implementation of ARouter login interceptors to control navigation across modules.
This article demonstrates how to achieve automatic request idempotency in Spring Boot applications by leveraging Redis for token storage, custom annotations, and a handler interceptor, detailing the underlying concepts, code implementation, configuration, and testing procedures to prevent duplicate processing.
This article explains how to achieve reliable API idempotency in Spring Boot applications by using Redis for token storage, defining a custom @AutoIdempotent annotation, configuring an interceptor to enforce token checks, and providing complete Java code examples and testing steps.
This article explains how MyBatis plugins work, shows how to create a custom interceptor with Java code, configure it in XML, and details the underlying mechanism that uses dynamic proxies to intercept Executor methods.
This article explains how to add a reusable appkey whitelist check to a Spring‑Boot web framework by comparing four implementation methods—traditional AOP, Spring Interceptor, custom ArgumentResolver, and Servlet Filter—detailing their code, configuration steps, extensions, and execution order.
This tutorial explains the concept of idempotency in web APIs and demonstrates a complete Spring Boot solution using Redis, custom annotations, token validation, and interceptor configuration to ensure that each request modifies the database only once, even under repeated calls.
The article introduces retrofit-spring-boot-starter, a Spring Boot‑compatible lightweight HTTP client library that integrates Retrofit with extensive features such as custom OkHttpClient injection, annotation‑driven interceptors, logging, retry, error decoding, circuit‑breaker support, connection‑pool management, call adapters and data converters, providing a concise way to perform HTTP calls in Java backend projects.
This article explains four approaches to adding a generic appkey whitelist check in a Spring Boot web framework—traditional AOP, HandlerInterceptor, custom HandlerMethodArgumentResolver, and Servlet Filter—providing implementation steps, code examples, and a discussion of their execution order and extensibility.
This article explains how to set up permission validation in a Spring MVC project using user‑role‑resource tables, compares three verification approaches, and demonstrates a custom annotation solution with full controller and interceptor code examples.
This article demonstrates how to create a custom @AccessLimit annotation in Spring Boot, implement a rate‑limiting interceptor that checks request frequency via Redis, register the interceptor, and apply the annotation to controller methods to enforce request limits with optional login verification.
This article demonstrates how to create a custom @AccessLimit annotation, implement a Spring Boot interceptor that checks Redis for request counts, register the interceptor, and apply the annotation to a controller method to enforce rate‑limiting with optional login verification.
This article explains four Spring‑Boot techniques—traditional AOP, HandlerInterceptor, HandlerMethodArgumentResolver, and Servlet Filter—to implement a reusable appkey whitelist validation, provides complete code examples for each, and clarifies their execution order within the request processing pipeline.
This article explains how to implement permission validation in Spring MVC by defining user, role, and resource tables, exploring three approaches—including request URI checks, method inspection, and custom annotations—and provides complete Java code examples for a custom annotation, controller, and interceptor to enforce access control.
This article demonstrates how to create a custom @AccessLimit annotation in Spring Boot, implement a rate‑limiting interceptor using Redis, register the interceptor, and apply the annotation to controller methods to restrict request frequency, with full Java code examples.
This article explains how to replace direct OkHttp or RestTemplate usage in Spring Boot projects with the retrofit‑spring‑boot‑starter, covering dependency setup, annotation configuration, interface definition, injection, custom interceptors, connection‑pool management, logging, exception formatting, call adapters, converters, and global interceptors.
This article explains how to obtain a user's city from their IP address in a Java Spring backend, using the QQWry IP database, custom utility classes, and a login interceptor to count visits per city, with complete code examples and deployment considerations.
This article explains how to add a generic app‑key whitelist authentication feature to a Spring Boot web framework using four different mechanisms—traditional AOP, HandlerInterceptor, custom HandlerMethodArgumentResolver, and Servlet Filter—providing implementation steps, code examples, and a discussion of their execution order.
This article explains how to add a generic appkey whitelist authentication feature to a Spring Boot web framework using four approaches—traditional AOP, HandlerInterceptor, HandlerMethodArgumentResolver, and Servlet Filter—providing implementation steps, code examples, and a discussion of their execution order.
The article explains how Spring Boot versions up to 2.3.0.RELEASE normalize request paths—including decoding %2e and handling directory traversal—which can be exploited to bypass authentication, and shows the code differences that cause this behavior in newer releases.
This article demonstrates how to create a custom @AccessLimit annotation, implement a Spring Boot interceptor that uses Redis to track request counts, register the interceptor, and apply the annotation to controller methods for fine‑grained rate limiting.
This article demonstrates how to automatically encrypt sensitive fields such as ID numbers and phone numbers before storing them in a database and decrypt them after retrieval by using Spring Boot, MyBatis plugins, and custom annotations, eliminating manual encryption logic in business code.
This guide explains what CSRF attacks are, outlines common defense strategies such as captchas, referer checks, and token validation, and provides a complete Spring Boot implementation—including custom annotations, token storage with Guava or Redis, an interceptor, configuration, and a token‑generation endpoint—complete with testing steps.
This tutorial explains how to create a custom @AccessLimit annotation, an interceptor that uses Redis to count requests, register the interceptor in Spring Boot, and apply the annotation to controller methods to enforce per‑endpoint rate limiting.
This article explains how to protect API endpoints that interact with front‑end applications by using token‑based authentication, timestamp checks, and MD5 signatures, detailing the implementation of open and secured controllers, login logic, signature verification, replay‑attack mitigation, and a Spring interceptor.
This article explains how to quickly integrate the Retrofit HTTP client into a Spring Boot project with the retrofit‑spring‑boot‑starter, covering dependency setup, configuration annotations, interface definition, custom annotation‑based interceptors, connection‑pool management, logging, exception formatting, call adapters, converters, and global interceptors, all illustrated with complete code examples.
This article explains how MyBatis supports plugins, covering configuration, how to write an Interceptor, the runtime mechanism, registration timing, initialization process, and the principles behind pagination plugins, with detailed code examples and annotations.
This guide explains the concepts, implementation steps, configuration examples, and key differences between Servlet Filters and Spring MVC Interceptors, helping developers choose the right tool for request preprocessing, logging, and access control in Java web applications.
This guide introduces retrofit-spring-boot-starter, a lightweight HTTP client for Spring Boot that simplifies request management, offers rich features such as custom OkHttp injection, annotation‑based interceptors, logging, retry, circuit‑breaker, and detailed configuration, with full code examples and usage patterns.
This article provides a comprehensive overview of MyBatis plugins, explaining their interception capabilities, typical use cases such as pagination, common field assignment, and performance monitoring, while detailing the underlying dynamic‑proxy implementation, configuration loading, and relevant design patterns for backend Java development.
This tutorial explains the core concepts of Spring AOP, shows how to integrate AOP in Spring Boot to create custom annotations and interceptors, and provides practical solutions for the common self‑invocation issue that causes AOP advice to be ignored.
This article explains how to design a network framework from the ground up, explores the three‑layer understanding of frameworks, details the core components, thread scheduling, request/response processing chains, and then deep‑dives into OkHttp and Retrofit implementations, their limitations, and extensibility techniques.
This article explains the concept of API idempotency, presents common solutions such as unique indexes, token mechanisms, and distributed locks, and provides a complete Spring Boot implementation using Redis to generate, store, and validate tokens via custom annotations, interceptors, and service classes, including testing and performance verification.
This article explains how to create, configure, and apply custom Spring MVC interceptors in Spring Boot, including a practical example that uses Redis to block repeated requests within a short time window, with full code demonstrations.
This article explains the concept of API idempotency, reviews common solutions, and provides a complete Spring Boot implementation using a Redis‑based token mechanism, custom @ApiIdempotent annotation, interceptor, and supporting services, along with testing and important concurrency considerations.
This article explains MyBatis's plugin architecture, shows how to create a custom interceptor to modify query parameters, demonstrates injection into Spring Boot, and analyzes the underlying proxy generation and execution flow, including a brief look at the popular PageHelper pagination plugin.
This article explains the concept of API idempotency, outlines common solutions, and provides a complete Spring Boot implementation using Redis and a token mechanism, including custom annotation, interceptor, utility classes, and testing procedures to ensure safe, single‑execution requests.
This article explains how to achieve API idempotency in a Spring Boot application by generating unique tokens, storing them in Redis, and using a custom @ApiIdempotent annotation with an interceptor to prevent duplicate requests, including code examples, configuration, and testing procedures.
This article explains why identifying a user's city via IP is crucial for operations, outlines various IP-to-city methods, and provides a complete Spring Boot implementation—including IP extraction, QQWry library integration, custom interceptors, and REST endpoints—to count visits per city.
This guide explains how to integrate Retrofit into a Spring Boot project using the retrofit‑spring‑boot‑starter, covering dependency setup, annotation configuration, custom interceptors, connection pool management, logging, exception formatting, call adapters, converters, and global interception to make HTTP client development more elegant and maintainable.
This article explains how to implement automatic idempotency for Spring Boot APIs using Redis, a custom @AutoIdempotent annotation, token generation and validation, and an interceptor, providing step‑by‑step code examples, configuration details, and testing procedures to ensure each request is processed only once.
This article explains how to implement adaptive global exception handling in Spring Boot, demonstrates default behavior, walks through key code examples, highlights common pitfalls such as interceptor loops, and offers practical solutions for robust error management in backend services.
This article explains the typical use cases of MyBatis plugins, introduces the concept of MyBatis interceptors, details the supported interception points and execution stages, describes how plugin configuration is loaded and proxy objects are generated, and provides a practical example of implementing a pagination plugin.
This article explains how to configure SpringBoot interceptors, covering both URL‑based and annotation‑based implementations, provides full Java code examples, and shows how to register them in a WebMvcConfigurer while noting recent Spring framework changes.
This article explains how to implement automatic idempotency for Spring Boot APIs using Redis, a custom @AutoIdempotent annotation, token generation and verification, and an interceptor, providing step‑by‑step code examples and a testing workflow to prevent duplicate operations.
This article explains the design principles of Spring MVC interceptors, introduces the key interfaces and classes involved, demonstrates how they are wired within the framework, and provides step‑by‑step guidance for configuring and implementing custom interceptors in a Java web application.
This article explains how to implement automatic API idempotency in Spring Boot using Redis for token storage, custom annotations, and interceptor configuration, covering token generation, validation, Redis service utilities, and testing with Postman to prevent duplicate operations and ensure data consistency.
This article explains how to configure Spring Boot interceptors using both URL‑pattern matching and custom annotations, provides the necessary Java code for the interceptors and constant definitions, and shows how to register them in a @Configuration class for comprehensive request handling.
This article explains how to implement automatic API idempotency in Spring Boot by using Redis for token storage, a custom @AutoIdempotent annotation, and a request interceptor, providing code examples and test steps to ensure duplicate requests are rejected.
Learn how to ensure API idempotency in Spring Boot applications by leveraging Redis for token management, creating a custom @AutoIdempotent annotation, configuring interceptors, and handling token creation and validation to prevent duplicate submissions and maintain data integrity.
This article explains how to achieve interface idempotency in a Spring Boot application by generating a unique token for each request, storing it in Redis, validating the token via a custom annotation and interceptor, and provides complete code examples and testing guidance.
This article demonstrates how to create a custom @AccessLimit annotation, implement a Spring MVC interceptor that uses Redis to count requests, register the interceptor in a Spring Boot application, and apply the annotation to controller methods to achieve rate‑limiting functionality.
This article explains the concept of idempotency, lists common solutions, and demonstrates a practical implementation using Spring Boot, Redis, and a token‑based mechanism with custom annotations and interceptors, including full code examples, testing steps, and important pitfalls to avoid.
ARetrofit is an Android routing framework that enables concise, component‑to‑component communication by generating compile‑time route metadata via annotation processing, injecting bytecode with the Transform API, creating service proxies through dynamic proxies, and applying an OkHttp‑style interceptor chain for flexible, cross‑module extensions.
This article analyzes a bug where rapid route switching in a Vue H5 project caused data from different routes to mix, explains how Axios CancelToken works, shows the implementation of request cancellation via interceptors, and discusses deeper insights and further possibilities for frontend developers.
