This article presents a comprehensive solution for decoupled operation‑log recording in multi‑project backend systems, detailing the design goals, technology choices such as AOP, annotations, SpringEL and MongoDB, the system architecture, implementation steps, a practical case study, and future enhancements.
This article explains how to use the MyBatis @MapKey annotation to map query results into a Java Map, provides a concrete code example, and delves into the internal processing steps—including MapperProxy, MapperMethod, MethodSignature, and DefaultMapResultHandler—that enable this functionality.
This article explains how to apply Redisson's distributed lock in Java, demonstrates the basic lock and tryLock APIs, shows how to create a custom @DistributedLock annotation and an AOP aspect to handle locking automatically, and provides a practical usage example with two services.
This article provides an in‑depth overview of Spring Validation, covering standard Bean Validation 2.0 annotations, Hibernate extensions, the differences between @Valid and @Validated, practical usage in controllers, programmatic validation, Dubbo integration, group validation, and how to create custom validation annotations with full code examples.
This article introduces Spring's event mechanism, covering the creation of custom ApplicationEvent classes, implementing listeners via ApplicationListener and @EventListener annotations, publishing events, using @Async for asynchronous handling, configuring custom event multicaster, and controlling listener execution order with @Order, complete with code examples.
This article introduces a Java library that simplifies downloading various resources—files, HTTP URLs, or custom objects—by using a single @Download annotation, reactive programming, customizable handlers, source factories, concurrent loading, compression, and event‑driven logging to streamline complex download workflows in Spring MVC and WebFlux applications.
This article demonstrates how to use ChatGPT step‑by‑step to design, generate, refine, and test a lightweight Java framework that automatically maps enum descriptions for front‑end consumption, covering problem definition, annotation design, core class implementation, code snippets, and performance evaluation.
This guide explains how to use Spring Boot's Formatter SPI to create custom type converters, implement both simple and annotation‑based formatters, register them in a WebMvcConfigurer, and test the conversions through REST endpoints, complete with code examples.
This article explains how to solve the WebSocket message delivery problem in microservice architectures by using a lightweight library that provides an @EnableWebSocketLoadBalanceConcept annotation, detailing its design, connection management, message routing, and customizable selectors for targeted delivery.
This article demonstrates how Java developers can leverage ChatGPT to design and iteratively refine a lightweight backend framework that automatically scans annotated enums and generates key‑description maps for front‑end consumption, complete with code examples, performance testing, and deployment guidance.
This article explains the concept of idempotency, identifies which HTTP methods are naturally idempotent, and demonstrates a complete Java Spring solution—including custom annotations, AOP handling, token generation, and Redis storage—to guarantee safe retry and duplicate‑request protection.
This article explains the concept of idempotency, identifies naturally idempotent HTTP methods, discusses why idempotency is essential for retries, async callbacks, and message queues, and provides a complete Spring Boot implementation using a custom @Idempotent annotation, AOP, and Redis for token storage.
TheRouter-iOS is a lightweight, annotation‑driven routing middleware that brings Java‑style dependency injection, hard‑code elimination, dynamic redirection, interceptors, and flexible navigation to iOS, offering a unified solution for complex mobile architectures and seamless integration with Android and web components.
This article explains how to achieve API idempotency in high‑concurrency scenarios by creating a custom @RepeatSubmit annotation, using AOP interception, Redis setNx for locking, and a request‑wrapper to allow repeated reading of request parameters in Spring applications.
This article investigates how Spring generates bean names from annotated classes, explains the default lower‑casing rule, highlights the special case when the first two characters are uppercase, and shows the underlying JDK decapitalize method through source‑code exploration.
This article explains how to limit the number of requests an API endpoint can receive within a specified time window by creating a @RequestLimit annotation, a Redis‑backed interceptor, and the necessary Spring Boot configuration and controller examples.
The article explains how to protect Spring Boot APIs from unauthorized data access by adding data‑level permission checks, encrypting request parameters with AES and RSA, signing requests with SHA1WithRSA, and encapsulating the logic in a reusable @ApiSecurity annotation and AOP aspect.
This article demonstrates a step‑by‑step implementation of API request throttling in a Spring backend using an Interceptor and Redis, covering the underlying principle, configurable limits, custom annotations, reflection‑based flexibility, and practical considerations such as path parameters and real‑IP handling.
This article explains why Spring Boot is popular, how @ComponentScan discovers @Component, @Controller, @Service, and @Repository beans across packages, demonstrates usage with code examples, and details the internal processing flow involving ConfigurationClassPostProcessor and related parsers.
This article explains how to limit the number of requests an interface can receive within a specific time window in a Spring Boot application by using a custom @RequestLimit annotation, Redis for counting, and a Spring interceptor to enforce the limits, complete with full code examples and configuration steps.
This article introduces the BizLog SDK for Java, explains its Spring Boot autoconfiguration, demonstrates how to add Maven dependencies, enable logging with @EnableLogRecord, craft log messages using @LogRecordAnnotation with SpEL expressions, and extend the framework with custom parse functions and operator services.
This tutorial explains why backend API permission checks are essential in RBAC‑based systems, walks through configuring Spring Security for authentication and authorization, demonstrates URL‑level and annotation‑based access control, and discusses token‑driven role verification and caching strategies.
This article explains why a custom business rate‑limiting (risk‑control) component is needed for AI‑driven services, compares open‑source solutions, and provides a complete implementation using Redis+Lua scripts, Kotlin code, and Spring AOP annotations, including testing and deployment tips.
This article provides a comprehensive guide to Java's reflection mechanism, class loading process, ClassLoader usage, and dynamic proxy techniques, illustrating how to inspect class structures, create objects, access fields and methods, retrieve generic type information, and implement both static and dynamic proxies with practical code examples.
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 implement a flexible, annotation‑driven data‑masking solution for Java backend services by defining custom masking annotations, serializers, and integrating them into Spring's ObjectMapper to automatically mask sensitive fields in API responses.
This article demonstrates how to create a configurable, multi‑strategy data‑masking solution in Spring Boot by defining custom annotations, serializers, and integrating them with Jackson's ObjectMapper to automatically mask sensitive fields in API responses.
This article explains how to create a flexible, annotation‑driven data‑masking solution for Spring Boot APIs by defining custom masking strategies, integrating a Jackson serializer, and configuring the ObjectMapper to automatically mask sensitive fields in response objects.
This article explains Spring's core.convert package, the ConversionService API, Formatter SPI, default and custom formatters, annotation-based formatting, and how to configure and use them in Spring MVC and Spring Boot applications.
This article demonstrates how to define a simple Java interface, provide two implementation styles (Spring‑annotation and pure‑reflection), package the implementation as a JAR, and dynamically load, register, replace, or remove the implementation at runtime using URLClassLoader and Spring's bean factory.
This article explains how to mask sensitive fields such as ID numbers, phone numbers, and addresses in Java APIs by creating a custom @Sensitive annotation, defining masking strategies, implementing a Jackson serializer, and testing the solution with a Spring REST controller, providing complete code examples and sample output.
This article explains how to prevent duplicate backend requests caused by rapid user clicks by creating a reusable @ApiLock annotation that leverages distributed locks, generates lock keys from request parameters, and integrates an AOP aspect to acquire and release locks around controller methods.
This article explains how Spring's @Scheduled annotation works, covering configuration options like cron, fixedDelay and fixedRate, the internal processing by ScheduledAnnotationBeanPostProcessor, method reflection, task registration with ScheduledTaskRegistrar, and the underlying execution using ThreadPoolTaskScheduler and ScheduledThreadPoolExecutor.
This article demonstrates how to create a lightweight Spring‑style IoC container in Java by parsing a properties file for XML‑like configuration, implementing annotation‑driven bean registration with a custom @Bean annotation, and adding automatic field injection using a custom @Autowired annotation, complete with full source code examples.
This article explains why dynamic data sources are needed in high‑traffic Spring Boot applications, shows how to configure multiple databases via Maven, YAML and Java, and demonstrates a custom annotation‑driven AOP solution for seamless runtime routing.
This article explains the differences between @RestController and @Controller, shows how @RestController combines @Controller with @ResponseBody, and details the internal processing flow of the @ResponseBody annotation within Spring MVC's handler adapters and return‑value handlers.
This article explains how to design a dictionary entity, create a custom annotation, and use Spring's ResponseBodyAdvice together with Java reflection to automatically convert enum values to their textual representations in API responses, improving front‑end display without manual mapping.
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 presents a comprehensive evaluation framework for OPPO's XiaoBu AI assistant, covering the concept and purpose of evaluation, the five key evaluation elements, data sampling strategies, dimension and rule selection, annotation scoring, reporting guidelines, and detailed procedures for assessing wake‑up, ASR, NLU, and TTS performance.
The team replaced Baidu Wenku’s HTML‑CSS reader with a Canvas‑based architecture (CReader) that separates logic, data, parsing, rendering and application layers, enabling direct long‑image export, fast text selection, anti‑copy protection, annotation support, and cross‑platform deployment on PC, WAP and mini‑programs.
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 demonstrates how to implement elegant, business‑logic‑independent operation logging in Java back‑ends by using AOP‑driven annotations, SpEL dynamic templates, custom parse functions, thread‑local context, and a Spring Boot starter, offering flexible persistence and automatic operator retrieval.
This comprehensive guide explores every way to define Spring beans—from classic XML configurations and constructor or setter injection to modern @Component annotations, JavaConfig @Bean methods, and advanced @Import, ImportSelector, and post‑processor techniques—empowering developers to choose the most suitable approach for any project.
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 guide explains how to install the iszsw/mock library via Composer, add test controllers with annotation routing and validation, configure static resources, generate nested mock data using MockPack, and produce API documentation, providing complete code examples for PHP backend projects.
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 guide explains three ways to register Servlets in Spring Boot 2.3.9—including @ServletComponentScan with @WebServlet, ServletRegistrationBean, and dynamic registration via ServletContextInitializer—while detailing the underlying scanning mechanism, BeanFactory post‑processor workflow, and how Tomcat ultimately registers the servlet.
This article explains how the BizLog component records who performed which action at what time in Spring Boot applications, covering Maven setup, annotation usage, custom operators, detail fields, category segregation, SpEL expressions, custom parse functions, and extension points for persistence and operator retrieval.
This article introduces a Spring Boot component that automatically records who performed which operation at what time, explains its Maven dependency, configuration, usage of @EnableLogRecord and @LogRecordAnnotation with SpEL expressions, custom operators, detail fields, log categories, and extensibility through custom parse functions and service implementations.
This article explains how to store and inject collection types such as List, Map, Set, and arrays from Spring configuration files using @Value, @ConfigurationProperties, and Spring Expression Language, while handling missing keys and reducing code‑configuration coupling.
This article explains the purpose and inner workings of Spring’s @Transactional annotation, detailing how AOP creates proxies, defines pointcuts, and orchestrates transaction management through BeanPostProcessors, advisors, interceptors, and the TransactionInterceptor, illustrated with source code snippets and diagrams.
This article introduces the BizLog SDK for Spring Boot, explains how to add the Maven dependency, enable the @EnableLogRecord switch, use @LogRecordAnnotation for various logging scenarios, customize operators, details, categories, and parse functions, and shows how to extend the framework with custom services and implementations.
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 tutorial explains how to transparently encrypt and decrypt sensitive fields such as ID numbers, phone numbers, and real names in a Spring Boot application by leveraging MyBatis plugins, custom annotations, and interceptor implementations for both input and output data.
The article dissects Spring Boot’s @SpringBootApplication annotation, revealing it as a composite of seven meta‑annotations—including @SpringBootConfiguration, @EnableAutoConfiguration and @ComponentScan—and explains the underlying registrar, import selector, metadata loading, and exclusion mechanisms that together drive Spring Boot’s automatic configuration process.
This article walks you through setting up the Erupt Java annotation‑based framework, configuring Maven dependencies and datasource, launching a ready‑made admin UI, customizing pages with @Erupt annotations, and extending functionality via data proxies, all without writing front‑end code.
This article presents Ant Financial's intelligent middle platform, detailing AI use cases such as risk control, wealth management, lending, marketing, insurance, and customer service, alongside the AI capability map, data foundation architecture, annotation workflows, security measures, and the overall impact on fintech innovation.
MXReflection is a Java framework built on the mXparser library that lets developers perform sophisticated mathematical calculations using simple @Arg and @Expression annotations, with Maven/Gradle integration, comprehensive function support, and example-driven usage for both simple and complex scenarios.
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 design a unified API response format in a Spring backend by defining a JSON result structure, using standardized status codes, creating a @ResponseResult annotation, and implementing interceptors and ResponseBodyAdvice to automatically wrap controller outputs for cleaner, more maintainable code.
This article explains how to standardize backend API responses by defining a JSON result structure, categorizing status codes, and using a custom @ResponseResult annotation with Spring's ResponseBodyAdvice to automatically wrap controller outputs, improving readability and error handling for front‑end developers.
This talk explains Alibaba’s P2C product that extends design‑to‑code automation to PRD‑to‑code, detailing its layered architecture, annotation workflow, logical‑point extraction, code generation, and roadmap toward AI‑driven zero‑annotation development for front‑end engineers and product designers.
This article describes Qunar's comprehensive API standardization effort, detailing the evolution of their API tools, the motivations behind adopting DDD and API governance, the theoretical foundations, the QDoc annotation framework, implementation steps, challenges faced, achieved outcomes, and future plans for continuous improvement.
This article explains how SpringBootApplication, ComponentScan, and MapperScan annotations affect package scanning in Spring Boot, their precedence, differences, and the pitfalls of using them together, providing practical guidance for correctly configuring component and mapper scans in Java backend projects.
This article explains why findViewById breaks after re‑packaging game SDKs, introduces a Gradle‑based custom resource class (SqR) to replace dynamic getIdentifier calls, and outlines how annotation injection can provide a ButterKnife‑like solution for mobile developers.
This article explains Spring Boot's two configuration file formats—properties and YAML—detailing their syntax, how to map them to Java classes, and the various annotations (@ConfigurationProperties, @Value, @PropertySource) for retrieving configuration values, including custom file handling.
This article explains the concepts, challenges, and practical implementations of idempotency in backend systems, covering simple database‑record checks, concurrency handling with locks, a reusable idempotent component with multi‑level storage, annotation support, automatic key generation, and sample Java code.
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 why idempotency is essential, presents simple database‑based and concurrency‑safe implementations, and then details a generic, annotation‑driven idempotent framework with multi‑level storage, code examples, and deployment guidelines for Java backend services.
This article explains how Spring's @Transactional annotation works, common pitfalls such as using it on private methods, and the correct ways to configure propagation, isolation, and bean injection to ensure proper transaction rollback and non‑rollback behavior.
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.
Flutter’s lack of runtime reflection forces developers to use compile‑time annotation‑based code generation, where simple const annotations trigger custom generators defined via source_gen, configured in build.yaml, and can emit code through string concatenation, Mustache templates, or the code_builder library, offering a flexible alternative to Java’s APT approach.
This article explains the internal mechanics of Spring's @Enable annotations, detailing how they rely on @Import, the role of ConfigurationClassPostProcessor, the parsing flow of configuration classes, and how CGLIB enhances @Configuration classes to manage @Bean method invocations.
This article walks through the complete process of designing and implementing a lightweight Java logging framework—covering motivation, core components, annotation processing, configuration handling, message queuing, and a full example with code snippets and test results.
This article explains Spring Boot’s @Transactional implementation, covers transaction isolation levels and propagation, walks through the core source code of TransactionInterceptor and PlatformTransactionManager, and guides you step‑by‑step to create a custom annotation that rolls back on specified exceptions using JDBC and AOP.
This guide introduces EasyExcel, a Java library for memory‑efficient Excel read/write, shows how to add the Spring Boot starter dependency, and demonstrates basic, custom, multi‑sheet, password‑protected, and template‑based export techniques using the @ResponseExcel annotation.
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.
This article explains how to use Bean Validation in Spring Boot to replace repetitive IF‑ELSE checks with annotation‑driven parameter checks, covers built‑in and Hibernate‑specific constraints, demonstrates custom validators, group validation, and shows how to centralize error responses with a global exception handler.
Spring’s shift from XML to annotation‑based configuration is explained, covering @Configuration and @Bean requirements, example Java classes, equivalent XML, annotation definitions, bean scopes, component scanning, unit‑testing, and practical tips for wiring beans without field injection, providing a complete guide for modern Spring development.
This article explains the business background of a flash‑sale (seckill) scenario, analyzes naive locking approaches, introduces Redis‑based distributed locks, and provides a complete Java demo with custom annotations, dynamic proxies, and a multithreaded test to ensure correct inventory decrement under high concurrency.
This article explores the inner workings of Spring Boot by dissecting a simple Hello World application, analyzing its startup sequence, class loading via FatJar, the custom JarLauncher, and automatic registration of RestControllers, while highlighting performance considerations and the complexity of its annotation-driven configuration.
This article explains how to implement scheduled tasks in Spring using the lightweight Spring Task framework, covering both XML‑based and annotation‑based configurations, providing complete code examples, cron expression details, and practical tips for Java backend developers.
