Tagged articles
Custom Annotation
92 articles · Page 1 of 1
This article demonstrates how to implement API rate limiting in Spring Boot using Redis for request counting and a custom @RequestLimit annotation with an interceptor to enforce limits per user session, including complete code examples for the annotation, interceptor, configuration, and controller usage.
API SecurityBackendCustom Annotation
0 likes · 8 min read

This article demonstrates building an elegant API rate limiter in Spring Boot using interceptors and Redis, evolving from a basic fixed-window implementation to a flexible annotation-driven design supporting per-endpoint limits, class-level defaults, and solutions for path parameters and sliding window logic.
API SecurityCustom AnnotationInterceptor
0 likes · 21 min read

This article walks through designing a clean, unified API response format with categorized error codes, then shows how to automate response wrapping in Spring Boot using a custom @ResponseResult annotation, a handler interceptor, and ResponseBodyAdvice so controllers return plain domain objects while the framework handles consistent JSON serialization.
@ControllerAdviceAPI DesignCustom Annotation
0 likes · 9 min read

This article demonstrates how to implement per-endpoint dynamic field validation in Spring Boot 3.5.0 using a custom @DynamicValid annotation and HandlerMethodArgumentResolver, allowing flexible control over required, optional, and unknown fields for Map, JsonNode, or POJO parameters, with support for custom validators and integration with @Validated.
@DynamicValidCustom AnnotationDynamic Validation
0 likes · 12 min read

This tutorial demonstrates how to create a custom @ConvertJson annotation in Spring Boot 3.5.0 that automatically fetches JSON from a URL parameter and converts it into a typed Java object, using HandlerMethodArgumentResolver and BeanPostProcessor for both method-parameter and field-level injection with SpEL support.
BeanPostProcessorCustom AnnotationHandlerMethodArgumentResolver
0 likes · 12 min read

The article recounts a six‑year veteran’s encounter with a tangled Java data‑isolation implementation, explains how a custom MyBatis interceptor and annotation were used to inject and filter an env field across dozens of tables, and reflects on the code smell and refactoring lessons learned.
Custom AnnotationInterceptorJava
0 likes · 13 min read

This article explains how to simplify handling deeply nested JSON responses in Spring Boot by creating a custom @JsonPath annotation that leverages JsonPath expressions, allowing one‑line extraction, filtering, and modification of JSON data directly in controller method parameters.
Argument ResolverCustom AnnotationJSON parsing
0 likes · 10 min read

The article demonstrates how to create a custom @BatchProcess annotation combined with AOP to aggregate high‑frequency requests into batches, persist metadata in Redis, and process them efficiently, thereby reducing connection, I/O, and CPU overhead in distributed, high‑concurrency Spring Boot 3.5.0 applications.
AOPCustom AnnotationRedis
0 likes · 14 min read

This article explains the fundamental differences between Spring's @Valid and @Validated annotations, demonstrates how to apply group validation, nested object checks, and custom validation annotations, and provides a complete strategy for global exception handling and production‑grade best practices.
Custom AnnotationException HandlingJava
0 likes · 17 min read

The article explains how to eliminate boilerplate when using Spring Boot 3.5.0 RestClient by introducing two custom annotations, @ClientEnhance and @ClientConfig, together with an auto‑configuration class that injects logging interceptors and configurable timeouts into selected RestClient.Builder beans, enabling a non‑intrusive, declarative enhancement.
AutoConfigurationCustom AnnotationJava
0 likes · 8 min read

The article explains how Spring Boot's @AliasFor annotation, available since Spring 4.2, can create explicit and implicit attribute aliases in both built‑in annotations like @ComponentScan and custom composed annotations, with complete code examples and test output demonstrating the aliasing behavior.
@AliasForCustom AnnotationJava
0 likes · 7 min read

The article explains how to replace repetitive @Qualifier annotations in Spring by using generic‑type based injection and custom qualifier annotations, providing concrete code examples and showing how Spring resolves beans without explicit qualifiers.
@QualifierCustom AnnotationSpring Boot
0 likes · 5 min read

This guide shows how to mask sensitive fields like phone numbers and ID cards in Spring Boot responses without modifying business code, using a global ResponseBodyAdvice, JsonPath rules defined in application.yml, and optional custom @Masking annotation for fine-grained control.
Custom AnnotationJSONPathJackson
0 likes · 9 min read

This guide shows how Spring Boot’s built‑in validation (using @Valid, @Validated and Jakarta Validation annotations) can eliminate repetitive if‑statements, handle nested objects, support group validation, and be extended with custom constraint annotations for clean, maintainable request parameter checks.
@ValidCustom AnnotationHibernate Validator
0 likes · 10 min read

This article demonstrates how to add a single @Monitor annotation to Spring Boot 3.5.0 services and automatically obtain call‑trace and execution‑time metrics by leveraging Spring AOP, SimpleTraceInterceptor, PerformanceMonitorInterceptor, custom advisors, and a BeanPostProcessor, with full code examples and a test controller.
AOPBeanPostProcessorCustom Annotation
0 likes · 6 min read

This guide explains how to replace static custom‑annotation permission checks in Spring Boot with flexible SpEL expressions, covering annotation design, aspect definition, expression parsing, context setup, and practical usage examples for various access scenarios.
AspectJCustom AnnotationJava
0 likes · 9 min read

This article explains how to replace static permission annotations in Spring Boot with flexible SpEL expressions, showing step‑by‑step how to create a @PreAuth annotation, an AOP aspect, an expression parser, and a utility class that evaluates role‑ and time‑based access rules at runtime.
AOPCustom AnnotationSpEL
0 likes · 10 min read

Learn how to restrict API calls per user within a specific time window by creating a custom @RequestLimit annotation, an interceptor that checks Redis counters, and configuring Spring Boot's WebMvc to enforce rate limiting, with complete code examples and usage instructions.
Custom AnnotationInterceptorRedis
0 likes · 8 min read

This article explains how to restrict the number of requests to a Spring Boot API within a given time window by using a custom @RequestLimit annotation, a Redis‑backed interceptor, and the necessary configuration to register the interceptor in the application.
Custom AnnotationInterceptorJava
0 likes · 8 min read

This article demonstrates how to implement a lightweight circuit‑breaker mechanism in Spring Boot 3 by defining a custom @Breaker annotation, a failure‑tracking component using LongAdder, and an AOP aspect that handles opening, probing, and fallback logic without external libraries.
AOPCircuit BreakerCustom Annotation
0 likes · 10 min read

This article demonstrates how to decouple business logic from validation in Spring Boot 3 by creating a custom @BusinessValidation annotation, defining rule interfaces, implementing concrete validators, and using an AOP aspect to execute them with configurable fast‑fail and exception handling, complete with code examples and testing.
AOPBackendCustom Annotation
0 likes · 9 min read

This article demonstrates how to simplify and accelerate Excel export in Spring Boot 3 by using Alibaba's EasyExcel library together with a custom @ExportExcel annotation, a dedicated return‑value handler, and example controller code for static, dynamic, and template‑based exports.
Custom AnnotationEasyExcelExcel Export
0 likes · 11 min read

This article demonstrates how to implement flexible, decoupled data permission control in Spring Boot 3 by defining a @DataPermission annotation, creating strategy classes for different scopes, wiring them through an AOP aspect, and integrating the solution with JPA entities, MyBatis mappers, and comprehensive test cases.
AOPCustom AnnotationData Permission
0 likes · 13 min read

This article explains how Spring Boot leverages JSR‑380 for declarative request validation, walks through the internal processing chain from RequestResponseBodyMethodProcessor to Hibernate Validator, and demonstrates building custom annotations for enum checks and conditional field validation while supporting multilingual error messages.
Custom AnnotationHibernate ValidatorJSR-380
0 likes · 11 min read

This article walks you through six essential validation strategies for Spring Boot applications, from using JSR‑303 annotations and global exception handling to custom validators, validation groups, cross‑field checks, and integrating a Drools rule engine, all illustrated with complete code examples and best‑practice tips.
Custom AnnotationDroolsException Handling
0 likes · 13 min read

The article describes how to enforce environment‑based data isolation in a shared database by adding an env column, using a MyBatis interceptor to inject and filter this field at runtime, and employing a custom @InvokeChainSkipEnvRule annotation with AOP to selectively bypass the rule, keeping existing code untouched.
AOPCustom AnnotationInterceptor
0 likes · 9 min read

This article demonstrates how to create a configurable data‑masking solution for Spring Boot APIs by defining a custom @DataMasking annotation, implementing masking strategies, building a custom Jackson serializer, integrating it via an AnnotationIntrospector, and testing the functionality with a sample controller.
Custom AnnotationJavaSerializer
0 likes · 8 min read

This article demonstrates how to create and apply custom Spring annotations for AOP logging, implements the corresponding aspect, and discusses the strategic use of abstract classes and interfaces to separate business logic from data access in both MongoDB and MySQL contexts.
AOPAbstract ClassBackend
0 likes · 8 min read

This article describes how to achieve multi‑environment data isolation in a Java backend by adding an env field to tables, using a MyBatis interceptor with JSqlParser to rewrite SQL, and applying custom annotations and AOP to control environment‑specific logic while preserving existing business code.
BackendCustom AnnotationInterceptor
0 likes · 9 min read

This article demonstrates how to solve Spring Boot API timeout issues by creating a custom @Timeout annotation combined with an AOP aspect, covering annotation definition, aspect implementation, executor handling, fallback logic, configuration, and practical test results.
AOPAPI timeoutCustom Annotation
0 likes · 10 min read

This article introduces a continuously updated Spring Boot 3 case collection and PDF e‑book, then dives into the @Conditional annotation, custom condition interfaces, parameterized enhancements, SpringBootCondition usage, and multi‑condition combinations, providing complete code examples and test results.
Custom AnnotationJavaSpring Boot
0 likes · 9 min read

This article demonstrates how to handle Java Long precision loss in Spring Boot 3 front‑end displays, configures Jackson to serialize Long as String, uses @JsonValue for single‑property serialization, and creates custom annotations with a SensitiveSerializer for data masking, complete with code examples and screenshots.
Custom AnnotationJSON SerializationJackson
0 likes · 9 min read

This article demonstrates how to build a flexible API rate‑limiting solution in Spring Boot by combining a HandlerInterceptor, Redis counters, and custom annotations with reflection, covering configuration, code examples, mapping rules, time‑window nuances, path‑parameter handling, and real‑IP considerations.
Custom AnnotationInterceptorJava
0 likes · 18 min read

Learn how to simplify repetitive error-handling code in Spring Boot by creating a custom @ErrorHandler annotation that leverages Spring AOP to automatically log exceptions, with step-by-step instructions, required dependencies, annotation definition, aspect implementation, and usage examples.
AOPCustom AnnotationError Logging
0 likes · 8 min read

This tutorial explains how to globally enforce data‑permission filtering in MyBatis‑Plus by creating a custom @UserDataPermission annotation, implementing an InnerInterceptor that modifies SQL WHERE clauses based on user roles, and configuring the interceptor within the MyBatis‑Plus plugin system.
Custom AnnotationData PermissionInterceptor
0 likes · 11 min read

This article explains why parameter validation is essential in Java web development, compares traditional manual checks with validator libraries, demonstrates practical usage of Bean Validation, Hibernate‑Validator, and Spring Boot starter‑validation, and covers advanced topics such as nested validation, group validation, custom constraints, and the underlying validation mechanism.
BackendCustom AnnotationHibernate Validator
0 likes · 32 min read

This article describes how to achieve database environment isolation and flexible data sharing in a Java backend by adding an env field, customizing a MyBatis interceptor to rewrite SQL, and defining reusable annotations to control environment filtering across services.
BackendCustom AnnotationInterceptor
0 likes · 9 min read

This article walks through a Spring Boot solution for dynamically masking sensitive user data—such as names, ID numbers, phone numbers, and custom fields—by defining custom annotations, a configurable rule engine, a Redis‑backed context holder, and a Jackson serializer that applies masking at JSON serialization time, all while keeping performance overhead low.
BackendCustom AnnotationDynamic Configuration
0 likes · 24 min read

This article describes a Java data isolation solution that adds an 'env' field to tables, uses a MyBatis interceptor to rewrite SQL for environment‑aware queries, and introduces custom annotations with AOP to selectively skip environment checks, detailing implementation, challenges, and best practices.
AOPBackendCustom Annotation
0 likes · 13 min read

This article walks through the challenges of sharing a single database across pre‑release, gray, and online environments, explains how to add an env field for isolation, and shows a custom MyBatis interceptor and annotation‑driven AOP solution that rewrites SQL to automatically handle environment filtering and insertion while keeping business code untouched.
Custom AnnotationInterceptorJava
0 likes · 9 min read

This article explains eight practical ways to control which DAO implementation Spring injects, covering @Qualifier, bean naming, custom qualifiers, manual lookup, profile‑based beans, @Primary, and @Priority, with complete code examples for each method.
@Primary@Profile@Qualifier
0 likes · 7 min read

Spring Boot offers several ways to validate request parameters—including the @Valid and @Validated annotations and custom validation annotations—each with its own strengths, allowing developers to enforce data integrity, improve code quality, and enhance user experience across different scenarios.
@Valid@ValidatedCustom Annotation
0 likes · 11 min read

This article explores how to create and use custom authorization annotations in Spring Security to achieve more flexible, expressive, and maintainable permission checks, covering the basics of Spring Security, advantages of custom annotations, step‑by‑step implementation, and additional use‑case scenarios.
Backend SecurityCustom AnnotationJava
0 likes · 9 min read

This article demonstrates how to integrate Spring Expression Language (SpEL) with custom annotations and AOP in Spring Boot to create a highly flexible, maintainable permission‑checking mechanism that can handle various complex access scenarios without scattering hard‑coded logic throughout the codebase.
Custom AnnotationJavaSpring Boot
0 likes · 11 min read

This article demonstrates how to create a customizable permission‑checking mechanism in Spring Boot by defining a @PreAuth annotation, an AOP aspect, and leveraging Spring Expression Language (SpEL) to express complex access rules such as role, time, and permission constraints.
Custom AnnotationSpELpermission
0 likes · 10 min read

This article walks through the challenges of environment‑specific data isolation in a Java project, explains why adding an env column to every table is impractical, and presents a clean solution using a MyBatis interceptor that rewrites SQL and custom annotations to control filtering, ensuring safe, maintainable code across pre‑release, gray, and production environments.
Custom AnnotationInterceptorJava
0 likes · 12 min read

This article walks through the problem of sharing a single database across pre‑release, gray, and production environments, explains why adding an env column to dozens of tables is error‑prone, and demonstrates a MyBatis interceptor‑based solution with custom annotations that isolates data while preserving backward compatibility.
BackendCustom AnnotationInterceptor
0 likes · 14 min read

This article presents a comprehensive design and implementation of a customizable data permission framework for Java backend applications, detailing the requirements, rule table structure, strategy pattern handling, custom annotations, AOP integration, and practical examples with full source code snippets.
AOPCustom AnnotationData Permission
0 likes · 22 min read

This article describes a practical approach to achieve environment‑based data isolation in Java services by adding an env field to tables, using a MyBatis interceptor to rewrite SQL, and defining custom annotations with AOP to control the isolation logic, while sharing code snippets and lessons learned.
Custom AnnotationJavaMyBatis
0 likes · 9 min read

This article explains how to handle enum and JSON string parameters in Spring MVC by creating custom annotations and argument resolvers, demonstrates the implementation steps with full code examples, and also reviews Spring MVC's built‑in parameter binding mechanisms such as @RequestParam, @PathVariable, @RequestBody, and @ModelAttribute.
Custom AnnotationEnum BindingJSON Parameter
0 likes · 10 min read

This article explains how to simplify Spring MVC interface calls by defining custom annotations, implementing a custom HandlerMapping, configuring it in Spring Boot 2.6.12, and demonstrating usage with example code, while also covering related handler adapters and underlying principles.
Custom AnnotationHandlerMappingSpring Boot
0 likes · 6 min read

The article explains why user privacy data must be masked, then walks through a Spring Boot solution that uses custom annotations, an aspect‑oriented filter, a contextual serializer and a flexible rule engine stored in Redis to achieve dynamic, high‑performance data desensitization without polluting business logic.
Custom AnnotationDynamic ConfigurationJackson
0 likes · 18 min read

This article explains why @Transactional may fail in multithreaded Spring Boot scenarios, shows how to enable @Async with a custom thread pool, and demonstrates a pair of custom annotations together with AOP to achieve coordinated multithreaded transaction management.
AOPCustom AnnotationMultithreaded Transaction
0 likes · 15 min read

This article explains why @Transactional fails in multithreaded Spring Boot scenarios, then demonstrates how to combine @Async, a custom thread‑pool, @MainTransaction and @SonTransaction annotations with AOP logic to achieve reliable multi‑threaded transaction control, complete with code examples and usage guidelines.
AOPCustom AnnotationJava
0 likes · 12 min read

This article demonstrates how to create a simple custom annotation that mimics Spring's @Autowired functionality by defining a new annotation, a BeanPostProcessor, configuring beans in XML, and wiring everything together in a test class to show the injection working at runtime.
BackendBeanPostProcessorCustom Annotation
0 likes · 8 min read

This article demonstrates how to prevent abusive API calls in a Spring Boot application by using an Interceptor together with Redis for counting requests, and extends the solution with configurable custom annotations and reflection to allow per‑endpoint rate‑limit settings.
Custom AnnotationInterceptorJava
0 likes · 18 min read

This article demonstrates a complete Spring Boot solution for limiting how many times a specific API can be called by a user within a given time window, using a custom @RequestLimit annotation, Redis for counting, and an interceptor to enforce the rule.
Custom AnnotationInterceptorJava
0 likes · 9 min read

This article explains how to protect user privacy by applying data desensitization in a Java backend, using a custom annotation and Jackson serializer to mask sensitive fields such as phone numbers, emails, IDs, and names during JSON serialization.
Custom AnnotationJacksonJava
0 likes · 11 min read

This article explains why back‑end parameter validation is essential, introduces the JSR‑303 Bean Validation specification and Hibernate Validator, demonstrates common constraint annotations, shows how to integrate validation in Spring Boot, create custom annotations, and resolve typical pitfalls.
Custom AnnotationHibernate ValidatorJSR-303
0 likes · 14 min read

This article demonstrates how to implement a flexible data‑masking solution for sensitive fields in Spring Boot APIs by defining a custom annotation, creating a serializer, integrating it with Jackson via an AnnotationIntrospector, configuring the ObjectMapper, and applying the annotation to domain objects.
Custom AnnotationJacksonJava
0 likes · 7 min read

This article explains how to redesign a Spring MVC controller so that a single endpoint can seamlessly handle JSON payloads, URL‑encoded form data, and multipart file uploads by creating a custom annotation, resolver, and Spring configuration, avoiding the pitfalls of manual HttpServletRequest parsing.
Content-TypeCustom AnnotationJava
0 likes · 7 min read

This article explains how to create a custom @IgnoreAuth annotation and integrate it with Spring Security to automatically whitelist controller methods, comparing the two standard ways of permitting requests—configure(WebSecurity) for static resources and configure(HttpSecurity) for filter‑chain‑aware endpoints—while providing full source code examples.
Custom AnnotationJavaSpring Security
0 likes · 8 min read

This article explains how to make a Spring MVC endpoint simultaneously accept JSON, URL‑encoded form data, and multipart/form‑data by creating a custom @GamePHP annotation, implementing dedicated argument resolvers, and configuring the necessary beans to replace the default @RequestBody and @RequestParam handling.
Content-TypeCustom AnnotationJava
0 likes · 7 min read

This article explains two Spring Security configuration approaches, introduces a custom @IgnoreAuth annotation, and shows how to automatically whitelist annotated endpoints by scanning RequestMappingHandlerMapping, complete with code examples and workflow details.
Anonymous AccessCustom AnnotationJava
0 likes · 10 min read

This guide explains how to create a custom annotation and an Aspect in Spring to capture detailed operation logs—including description, table name, parameters, user info, and execution result—and persist them to a database, covering AOP terminology, configuration styles, and complete code examples.
AspectJCustom AnnotationJava
0 likes · 15 min read

This article explains what Java annotations are, how they serve as metadata for classes, methods, and fields, outlines their common applications such as documentation generation and compile‑time checks, and details built‑in, meta‑ and custom annotations with code examples.
AnnotationsCustom AnnotationJava
0 likes · 8 min read

This article explains how to create a custom logging solution in Spring by defining annotation-based AOP aspects, configuring pointcuts, handling various advice types, and persisting log details such as user, operation, parameters, and results into a database using Java code examples.
AOPAspectJCustom Annotation
0 likes · 14 min read

This guide explains how to create a custom Spring AOP annotation for detailed logging, defines the necessary annotation and aspect classes, shows how to extract method details, parameters and user info, store them in a database, and demonstrates required Spring XML configuration and usage examples.
AspectJCustom AnnotationJava
0 likes · 16 min read

This guide explains how to create a custom Spring AOP logging solution by defining a @SystemCrmlog annotation, extracting its parameters via pointcuts, and persisting detailed log entries—including user, method, parameters, and execution results—to a database using aspect advice methods.
AOPCustom AnnotationJava
0 likes · 15 min read

This guide explains how to configure and use Spring Bean Validation, demonstrates simple and method‑level validation, and shows how to create custom constraint annotations with full code examples for a Spring Boot 2.4.11 application.
BackendBean ValidationCustom Annotation
0 likes · 7 min read

This tutorial explains why parameter validation is essential in Spring Boot APIs, shows how to integrate the JSR‑303 Validator, demonstrates custom annotations, group validation, and simplifies error responses with a global exception handler, providing complete code examples for each step.
Custom AnnotationException HandlingSpring Boot
0 likes · 17 min read

This guide explains the purpose of Spring Boot's @Enable* annotations, how they rely on @Import, and walks through creating a custom @EnablePack annotation with accompanying configuration and usage in a Spring Boot application.
Custom AnnotationJavaSpring Boot
0 likes · 4 min read

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.
Custom AnnotationInterceptorJava
0 likes · 4 min read

This article explains why a custom AOP annotation like @MyMonitor may not trigger advice in Spring Boot, analyzes the proxy‑based limitation of Spring AOP, and provides practical solutions such as self‑injection or AspectJ mode to ensure the advice executes correctly.
AOPAspectJCustom Annotation
0 likes · 8 min read

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.
Custom AnnotationInterceptorJava
0 likes · 6 min read

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.
Custom AnnotationInterceptorJava
0 likes · 4 min read

Learn how to create a custom SpringBoot annotation that supports ${…} placeholder expressions by adding AspectJ dependencies, defining the annotation, implementing an AOP aspect that resolves placeholders via EnvironmentAware, storing the result in a ThreadLocal, and using it in a service and controller.
AOPCustom AnnotationEnvironment
0 likes · 4 min read

This guide demonstrates how to add a custom AOP‑based caching layer to a SpringBoot application, using Redis to store frequently queried MySQL table data, defining @AopCacheEnable and @AopCacheEvict annotations, implementing an aspect, handling key generation, expiration, and cache eviction on CRUD operations.
AOPCacheCustom Annotation
0 likes · 9 min read

This tutorial explains how to move data desensitization to the JSON serialization stage using Jackson, defines a @Sensitive annotation, custom strategies, a contextual serializer, and demonstrates the approach with a User class example that masks personal fields during serialization.
Custom AnnotationJSONJackson
0 likes · 6 min read

This article explains Java annotations introduced in Java 5, covering their purpose, usage, built‑in meta‑annotations, retention policies, target elements, and provides step‑by‑step examples of defining and applying custom annotations with accompanying code and output.
AnnotationsCustom AnnotationJava
0 likes · 11 min read

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.
Custom AnnotationInterceptorJava
0 likes · 6 min read

The article demonstrates how to create a custom @ValidShop annotation and an AOP aspect that intercepts Spring MVC controller methods, extracts the annotated parameter via reflection, validates the shop code through a helper service, and proceeds only when the check succeeds.
AOPCustom AnnotationJava
0 likes · 6 min read

Learn how Spring Boot’s @Enable* annotations work, explore the role of @Import, and follow a step‑by‑step example that defines a custom @EnablePack annotation, implements ImportAware, and demonstrates its usage in a Spring Boot application.
Custom AnnotationImportAwareSpring Boot
0 likes · 3 min read

This guide demonstrates how to enforce login authentication in a Spring Boot application by defining a @LoginUser annotation, creating a corresponding interceptor, registering it in the MVC configuration, and testing the functionality with sample controller endpoints, illustrating session handling and thread‑local user storage.
Custom AnnotationJavaLogin Interceptor
0 likes · 8 min read

This article explains why Spring AOP advice does not trigger when a method calls itself via this, demonstrates how to reproduce the problem, and provides a solution using AopContext.currentProxy() together with proper proxy configuration to ensure the aspect executes correctly.
AOPBackendCustom Annotation
0 likes · 7 min read

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.
AOPCustom AnnotationInterceptor
0 likes · 12 min read

This article explains how to define custom Java annotations for field, method, and class validation, demonstrates the required @Target and @Retention settings, shows how to implement a ConstraintValidator, and provides practical Spring examples for permission checks and caching using interceptors and aspects.
Aspect-Oriented ProgrammingCustom AnnotationJava
0 likes · 9 min read

This article demonstrates how to create a reusable, method‑level parameter validation mechanism in SpringBoot using custom @Check annotations, covering the motivation, usage examples, Maven dependencies, annotation definition, core AOP logic, validation algorithm, and future enhancements.
AOPCustom AnnotationSpringBoot
0 likes · 9 min read

This article demonstrates how to replace cumbersome if‑else logic in an order‑processing system with a concise Strategy pattern implementation, using a custom @HandlerType annotation and Spring bean registration to make adding new order types effortless and maintainable.
Custom AnnotationJavaSpring
0 likes · 4 min read

This article explains the purpose and mechanics of Java annotations introduced in JDK 5, describes the five standard annotations, details the four meta‑annotations (@Target, @Retention, @Inherited, @Documented), and provides step‑by‑step guidance on defining, using, and processing custom annotations with reflection.
AnnotationsCustom AnnotationJava
0 likes · 13 min read

This article explains Java annotations—what they are, how they work, their common uses such as documentation generation and compile‑time checks, the four built‑in meta‑annotations, standard annotations like @Override, and how to create and apply custom annotations with a complete code example.
AnnotationsCustom AnnotationJava
0 likes · 7 min read

This article explains Java annotations, covering their advantages, common built‑in annotations, classification by lifecycle and source, meta‑annotations, how to create and apply custom annotations, and demonstrates parsing them at runtime using reflection, all illustrated with clear code examples.
Custom AnnotationJavaprogramming
0 likes · 10 min read
