BestHub
Sign in
Tagged articles

annotations

342 articles · Page 2 of 4
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jul 3, 2024 · Backend Development

SpringBoot 3.3: Annotations @ModelAttribute, @SessionAttribute, @RequestAttribute

This article explains the purpose and proper usage of SpringBoot 3.3’s request‑handling annotations—@ModelAttribute, @SessionAttribute, @RequestAttribute—and the RedirectAttributes class, providing detailed code examples, configuration tips, and scenarios where each tool is essential for form submission, session management, and flash‑attribute redirects.

Web Developmentannotationsspringboot
0 likes · 9 min read
SpringBoot 3.3: Annotations @ModelAttribute, @SessionAttribute, @RequestAttribute
Top Architect
Top Architect
Jun 22, 2024 · Backend Development

Understanding Idempotency and Its Implementation with Custom Annotations in Java

This article explains the concept of idempotency, identifies which HTTP requests are naturally idempotent, discusses why idempotency is essential for retries, async callbacks, and message queues, and demonstrates a practical Java implementation using custom annotations, AOP, and Redis for token management.

AOPJavaRedis
0 likes · 11 min read
Understanding Idempotency and Its Implementation with Custom Annotations in Java
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jun 19, 2024 · Backend Development

Mastering Spring Boot Annotations: A Comprehensive Guide for Backend Developers

This article provides a thorough overview of Spring Boot's core, web, configuration, dependency injection, AOP, testing, security, transaction, scheduling, event, exception handling, property binding, and conditional annotations, complete with practical code examples for Java backend development.

Backend DevelopmentDependency InjectionSpring Boot
0 likes · 12 min read
Mastering Spring Boot Annotations: A Comprehensive Guide for Backend Developers
Top Architect
Top Architect
Jun 14, 2024 · Backend Development

Comprehensive Guide to Spring MVC, Bean, and Boot Annotations

This article provides a detailed overview of Spring MVC request‑mapping annotations, Spring Bean stereotypes, dependency‑injection and scope annotations, as well as Spring Boot conditional and lifecycle annotations, complete with code examples and usage tips for Java backend development.

JavaSpringSpring Boot
0 likes · 16 min read
Comprehensive Guide to Spring MVC, Bean, and Boot Annotations
Selected Java Interview Questions
Selected Java Interview Questions
May 26, 2024 · Backend Development

Comprehensive Guide to Spring Boot Annotations

This article provides a detailed overview of the most commonly used Spring Boot annotations, covering core, prototype, Spring Boot, Spring Cloud, caching, testing, database access, JPA, and global exception handling annotations, with clear explanations and practical Java code examples for each.

Backend DevelopmentJavaSpring Boot
0 likes · 17 min read
Comprehensive Guide to Spring Boot Annotations
Architecture Digest
Architecture Digest
May 14, 2024 · Backend Development

FastJSON Serialization Mechanism and How to Control Method Invocation

This article analyzes a FastJSON serialization issue where a getter method is unexpectedly invoked, explains the underlying ASM-generated serializer workflow, details which methods are considered during serialization, and provides best‑practice code annotations to prevent unwanted method execution.

ASMJavaannotations
0 likes · 6 min read
FastJSON Serialization Mechanism and How to Control Method Invocation
Programmer XiaoFu
Programmer XiaoFu
Apr 30, 2024 · Backend Development

Lombok Tricks: Using @onX, @Delegate, @Cleanup, @Singular/@Builder, and @With

This article showcases several handy Lombok annotations—@onX for custom constructor injection, @Delegate for method delegation, @Cleanup for automatic resource release, the @Singular/@Builder combo for fluent object creation, and @With for immutable copies—illustrating their usage with Spring and Java code examples while warning against overuse.

JavaLombokSpring
0 likes · 7 min read
Lombok Tricks: Using @onX, @Delegate, @Cleanup, @Singular/@Builder, and @With
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Apr 30, 2024 · Backend Development

Mastering Spring AOP: XML, Annotations, and ProxyFactoryBean Deep Dive

This article explains Spring AOP fundamentals, demonstrates XML‑based and annotation‑based configurations, and provides a comprehensive guide to using ProxyFactoryBean—including its properties, proxy‑interface and proxy‑class scenarios, CGLIB considerations, and wildcard interceptor matching—complete with runnable code examples.

AOPCGLIBProxyFactoryBean
0 likes · 9 min read
Mastering Spring AOP: XML, Annotations, and ProxyFactoryBean Deep Dive
Code Ape Tech Column
Code Ape Tech Column
Apr 29, 2024 · Backend Development

Advanced Lombok Annotations: @onX, @Delegate, @Cleanup, @Builder/@Singular, and @With

This article explains several powerful Lombok annotations—including @onX, @Delegate, @Cleanup, @Builder with @Singular, and @With—showing how they simplify Spring‑based Java code through automatic constructor generation, method delegation, resource management, and fluent builders, while also warning against overuse.

Dependency InjectionJavaLombok
0 likes · 7 min read
Advanced Lombok Annotations: @onX, @Delegate, @Cleanup, @Builder/@Singular, and @With
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Apr 23, 2024 · Backend Development

Understanding @Configuration vs @Component in Spring: Bean Creation and Proxies

This article explains the distinct roles of Spring's @Configuration and @Component annotations, demonstrates their behavior through code examples, compares bean initialization and proxy generation, and reveals how Spring's ConfigurationClassPostProcessor and related enhancers ensure singleton beans across method calls.

ComponentConfigurationDependency Injection
0 likes · 9 min read
Understanding @Configuration vs @Component in Spring: Bean Creation and Proxies
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Mar 18, 2024 · Fundamentals

Understanding Java Annotations: Definition, Essence, Details, and Parsing SOURCE‑Retention Annotations

This article explains what Java annotations are, their underlying nature as interfaces extending Annotation, the various meta‑annotations such as @Retention and @Target, how retention policies affect availability, and demonstrates how to parse SOURCE‑retention annotations using a custom AbstractProcessor with complete code examples.

Annotation ProcessingJavaMeta‑annotations
0 likes · 12 min read
Understanding Java Annotations: Definition, Essence, Details, and Parsing SOURCE‑Retention Annotations
Java Captain
Java Captain
Mar 7, 2024 · Backend Development

Applying Java Annotations in Concurrent Programming

This article explores how Java's annotation mechanism, introduced in JDK 5.0, can be leveraged to address concurrency challenges by providing thread-safety, locking, timeout, and asynchronous execution annotations, and discusses their integration with AOP for enhanced thread management and performance.

AOPJavaLocking
0 likes · 5 min read
Applying Java Annotations in Concurrent Programming
Java Captain
Java Captain
Mar 1, 2024 · Backend Development

Using Java Annotations to Solve Concurrency Timing Challenges

The article explains how Java's annotation mechanism, including @ThreadSafe, @NotThreadSafe, @GuardedBy, and @Immutable, can be applied to clarify and manage concurrent behavior, helping developers resolve the timing uncertainties inherent in multithreaded programming.

Javaannotationsconcurrency
0 likes · 5 min read
Using Java Annotations to Solve Concurrency Timing Challenges
Architecture Digest
Architecture Digest
Feb 29, 2024 · Backend Development

Comprehensive Guide to Spring MVC, Spring Bean, and Spring Boot Annotations

This article provides a detailed overview of Spring MVC request‑mapping annotations, Spring Bean lifecycle and dependency‑injection annotations, as well as Spring Boot configuration annotations, illustrating each with explanations and code examples to help Java backend developers use these tools effectively.

Backend DevelopmentJavaSpring
0 likes · 12 min read
Comprehensive Guide to Spring MVC, Spring Bean, and Spring Boot Annotations
Architect's Guide
Architect's Guide
Feb 25, 2024 · Backend Development

Understanding AOP in Spring Boot with Practical Code Examples

This article explains the fundamentals of Aspect‑Oriented Programming (AOP) in Spring, describes its core concepts such as pointcuts, advice, aspects, join points and weaving, and provides multiple Spring Boot examples—including simple @GetMapping logging, custom permission annotations, and the use of various AOP annotations—complete with full source code snippets.

AOPBackend DevelopmentJava
0 likes · 18 min read
Understanding AOP in Spring Boot with Practical Code Examples
Architect
Architect
Feb 20, 2024 · Backend Development

Implementing Interface Rate Limiting with Spring Interceptor and Redis in Java

This article demonstrates how to prevent API abuse in a Java Spring application by using a custom HandlerInterceptor combined with Redis to track request counts per IP and URI, covering basic implementation, configuration, custom annotations, reflection for flexible limits, and discusses potential pitfalls and improvements.

JavaReflectionSpring
0 likes · 19 min read
Implementing Interface Rate Limiting with Spring Interceptor and Redis in Java
Architect's Guide
Architect's Guide
Jan 25, 2024 · Backend Development

Automatic Unit Conversion in Java Using Maps and Custom Annotations

This article explains how to automate unit conversions for Java DTOs by first using a Map to mark fields and an enum for conversion types, then enhancing the solution with a custom annotation and reflection to make the process more reusable and maintainable.

JavaReflectionUnit Conversion
0 likes · 10 min read
Automatic Unit Conversion in Java Using Maps and Custom Annotations
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jan 23, 2024 · Backend Development

Understanding Java Annotations: Types, Usage, and Implementation

This article provides a comprehensive overview of Java annotations, covering their definition, common applications, classification into standard, meta, and custom annotations, detailed examples of built‑in annotations such as @Override, @Deprecated, @SuppressWarnings, and guidance on creating and using custom annotations with code snippets.

Backend DevelopmentJavaReflection
0 likes · 8 min read
Understanding Java Annotations: Types, Usage, and Implementation
macrozheng
macrozheng
Dec 28, 2023 · Backend Development

Master Spring Boot Validation: 10 Essential Tips & Custom Annotations

This article explains ten practical techniques for implementing robust parameter validation in Spring Boot applications, covering built‑in annotations, custom constraints, server‑side checks, internationalization, validation groups, cross‑field rules, exception handling, testing, and the importance of complementary client‑side validation.

JavaSpring Bootannotations
0 likes · 17 min read
Master Spring Boot Validation: 10 Essential Tips & Custom Annotations
Architect's Guide
Architect's Guide
Nov 4, 2023 · Backend Development

Eliminating Code Duplication in Java Backend Development with Design Patterns, Annotations, and Bean Mapping

This article explains how to reduce repetitive Java backend code by extracting common logic into abstract classes, applying the Template Method and Factory patterns, using custom annotations with reflection for API serialization, and leveraging bean‑mapping utilities to copy properties between DTOs and DOs.

Code RefactoringJavaReflection
0 likes · 21 min read
Eliminating Code Duplication in Java Backend Development with Design Patterns, Annotations, and Bean Mapping
政采云技术
政采云技术
Nov 1, 2023 · Backend Development

How Spring Boot Auto-Configuration Works: From @EnableAutoConfiguration to Bean Loading

This article explains Spring Boot's auto‑configuration mechanism, covering how @EnableAutoConfiguration loads configuration classes, the role of @AutoConfigurationPackage and @Import, the processing of spring.factories and metadata files, and how the main application class is registered in the IoC container.

Auto-ConfigurationDependency InjectionJava
0 likes · 12 min read
How Spring Boot Auto-Configuration Works: From @EnableAutoConfiguration to Bean Loading
Selected Java Interview Questions
Selected Java Interview Questions
Oct 20, 2023 · Backend Development

Using @ConfigurationProperties and @PropertySources in Spring Boot

This article explains the purpose and differences of Spring's @ConfigurationProperties and @PropertySources annotations, provides step‑by‑step guidance for creating POJOs, configuration classes, property files, and demonstrates how to bind and inject configuration values in a Spring Boot application with code examples.

JavaPropertySourcesSpring Boot
0 likes · 12 min read
Using @ConfigurationProperties and @PropertySources in Spring Boot
Selected Java Interview Questions
Selected Java Interview Questions
Oct 18, 2023 · Backend Development

Understanding Core Spring Boot Annotations: @SpringBootApplication, @SpringBootConfiguration, @EnableAutoConfiguration, and @ComponentScan

This article explains the core Spring Boot annotations—@SpringBootApplication, @SpringBootConfiguration, @EnableAutoConfiguration, and @ComponentScan—detailing their combined functionalities, usage patterns, and providing Java code examples to illustrate how they simplify application configuration and startup for developers.

Backend DevelopmentConfigurationJava
0 likes · 7 min read
Understanding Core Spring Boot Annotations: @SpringBootApplication, @SpringBootConfiguration, @EnableAutoConfiguration, and @ComponentScan
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Oct 13, 2023 · Fundamentals

Understanding Java Annotations and Custom Annotation Usage with Spring AOP

This article explains Java annotations, their purposes such as providing compiler metadata, generating code, runtime processing, and documentation, introduces built‑in and meta‑annotations, and demonstrates how to create and use custom annotations both via reflection and with Spring AOP for logging, including full code examples.

AOPCustomAnnotationJava
0 likes · 7 min read
Understanding Java Annotations and Custom Annotation Usage with Spring AOP
Java Architect Essentials
Java Architect Essentials
Oct 5, 2023 · Backend Development

Understanding and Implementing AOP in Spring Boot: Concepts, Annotations, and Practical Examples

This article explains the fundamentals of Aspect‑Oriented Programming (AOP) in Spring, describes key concepts such as pointcuts, advice, aspects, and weaving, and provides step‑by‑step code examples—including simple and advanced use cases and detailed annotation usage—to help developers integrate AOP effectively into their Spring Boot applications.

AOPJavaSpring AOP
0 likes · 17 min read
Understanding and Implementing AOP in Spring Boot: Concepts, Annotations, and Practical Examples
Architect
Architect
Sep 26, 2023 · Backend Development

Comprehensive Guide to Spring MVC Annotations and Related Spring Annotations

This article provides a detailed overview of Spring MVC and Spring Boot annotations such as @RequestMapping, @GetMapping, @PostMapping, @RequestBody, @ControllerAdvice, @Component, @Bean, @Scope, @Autowired, and others, explaining their purposes, attributes, usage patterns, and offering practical code examples for each.

Dependency InjectionJavaSpring
0 likes · 15 min read
Comprehensive Guide to Spring MVC Annotations and Related Spring Annotations
Java Captain
Java Captain
Sep 15, 2023 · Backend Development

A Comprehensive Guide to the 50 Most Common Spring Boot Annotations

This article provides an in‑depth overview of the most frequently used Spring Boot annotations, categorizing them into Spring MVC, Spring Data JPA, Spring Security, and other essential annotations, and demonstrates their practical usage with concise examples.

JavaSpring Bootannotations
0 likes · 5 min read
A Comprehensive Guide to the 50 Most Common Spring Boot Annotations
Java Architect Essentials
Java Architect Essentials
Sep 14, 2023 · Backend Development

Understanding FastJson Serialization: Root Causes of NPE, Method Invocation Rules, and Best‑Practice Code Guidelines

This article reviews a production incident caused by a simple log statement, reconstructs the scenario with a CountryDTO example, analyzes FastJson's ASM‑based serializer internals, explains which getter/is methods are invoked during serialization, and proposes annotation‑driven coding standards to avoid similar bugs.

Backend DevelopmentFastJSONJava serialization
0 likes · 9 min read
Understanding FastJson Serialization: Root Causes of NPE, Method Invocation Rules, and Best‑Practice Code Guidelines
Java Backend Technology
Java Backend Technology
Aug 31, 2023 · Backend Development

Why Lombok @Data + @Builder Breaks No‑Args Constructors and How to Fix It

When Lombok's @Data and @Builder annotations are used together, the generated no‑argument constructor disappears, causing compilation errors; this article explains the root cause, demonstrates the problem with code examples, and provides two reliable solutions using @Tolerate or a combination of @RequiredArgsConstructor and @NoArgsConstructor.

@DataBuilderJava
0 likes · 6 min read
Why Lombok @Data + @Builder Breaks No‑Args Constructors and How to Fix It
Top Architect
Top Architect
Aug 15, 2023 · Backend Development

Elegant Parameter Validation in Spring Using @Validated and Custom Annotations

This article explains how to replace repetitive if‑statements with Spring's @Validated and @Valid annotations, shows how to import validation dependencies, demonstrates creating custom validation annotations and constraint validators, and provides a comprehensive list of built‑in javax.validation constraints for clean and maintainable backend code.

CustomValidatorJavaannotations
0 likes · 11 min read
Elegant Parameter Validation in Spring Using @Validated and Custom Annotations
Java Architect Essentials
Java Architect Essentials
Aug 7, 2023 · Backend Development

Choosing Between @Autowired, @Resource, and @Qualifier for Service Injection in Spring

This article explains three ways to inject a specific service implementation in Spring—using @Qualifier with @Autowired, using @Resource with type or name attributes, and naming @Service beans—detailing their semantics, bean‑matching rules, and providing complete code examples for each approach.

Backend DevelopmentDependency InjectionJava
0 likes · 5 min read
Choosing Between @Autowired, @Resource, and @Qualifier for Service Injection in Spring
Java Backend Technology
Java Backend Technology
Aug 3, 2023 · Backend Development

Eliminate Java Code Duplication with Design Patterns and Annotations

This article demonstrates how to reduce repetitive Java code in business applications by applying the Template Method and Factory design patterns, leveraging Spring’s IoC for dynamic cart selection, using custom annotations with reflection to serialize API parameters, and employing bean‑mapping utilities to automate DTO‑DO conversions, thereby improving maintainability and scalability.

JavaReflectionSpring
0 likes · 21 min read
Eliminate Java Code Duplication with Design Patterns and Annotations
Laravel Tech Community
Laravel Tech Community
Jul 13, 2023 · Databases

MyBatis-Flex: An Elegant MyBatis Enhancement Framework

MyBatis-Flex is a lightweight, high‑performance extension to MyBatis that adds full CRUD, pagination, multi‑table and batch operations while preserving all MyBatis features, supports multi‑datasource relations, recursive queries, and provides extensive annotations such as @Relation for flexible data mapping, with recent v1.4.9 updates and bug fixes.

JavaMyBatisORM
0 likes · 5 min read
MyBatis-Flex: An Elegant MyBatis Enhancement Framework
Programmer DD
Programmer DD
Jun 27, 2023 · Backend Development

When to Choose @Autowired vs @Resource in Spring? A Deep Dive

This article compares Spring's @Autowired and JDK's @Resource annotations, detailing their injection mechanisms, parameter differences, default behaviors, and usage scopes with code examples, while also offering interview advice and promoting a Java interview guide.

AutowiredDependency InjectionJava
0 likes · 21 min read
When to Choose @Autowired vs @Resource in Spring? A Deep Dive
Programmer DD
Programmer DD
Jun 14, 2023 · Backend Development

Mastering Spring Property Injection: From XML to SpEL

This article provides a comprehensive guide to Spring's property injection techniques, covering setter and constructor injection using both XML and Java annotations, external configuration with @PropertySource, and advanced SpEL expressions, complete with runnable code examples and output screenshots.

Dependency InjectionJavaSpEL
0 likes · 27 min read
Mastering Spring Property Injection: From XML to SpEL
IT Services Circle
IT Services Circle
May 30, 2023 · Fundamentals

Understanding Java Annotations: Concepts, Uses, and Implementation

This article explains Java annotations as metadata introduced in Java 5, covering their definition, built‑in and custom forms, purposes such as providing metadata, compile‑time checks, code generation and runtime processing, and demonstrates how to define, apply, and process them with code examples.

JavaMetadataReflection
0 likes · 6 min read
Understanding Java Annotations: Concepts, Uses, and Implementation
Top Architect
Top Architect
May 24, 2023 · Backend Development

Implementing Business Rate Limiting with Redis, Lua, and Kotlin Annotations

This article explains why a custom business rate‑limiting component is needed, outlines the required rules, chooses Redis + Lua for counting, and provides complete Kotlin/Spring code—including a Detect annotation, Lua scripts, and usage examples—to enforce daily, hourly, and combined limits with real‑time adjustments.

KotlinLuaRedis
0 likes · 10 min read
Implementing Business Rate Limiting with Redis, Lua, and Kotlin Annotations
政采云技术
政采云技术
May 18, 2023 · Backend Development

Understanding Spring Retry: A Comprehensive Guide to Retry, Backoff, and Circuit Breaker Mechanisms

This article explains the concept of retry in distributed systems, introduces Spring Retry and its annotations, demonstrates Maven dependencies, configuration, various retry policies, backoff strategies, circuit breaker support, and walks through the core implementation details with practical code examples.

BackoffCircuitBreakerJava
0 likes · 20 min read
Understanding Spring Retry: A Comprehensive Guide to Retry, Backoff, and Circuit Breaker Mechanisms
IT Xianyu
IT Xianyu
Apr 27, 2023 · Backend Development

Automatic Unit Conversion in Java Using Reflection and Custom Annotations

This article demonstrates how to automatically convert monetary, percentage, permillage and other numeric fields in Java DTOs by marking target properties with a map or a custom annotation, then applying reflection‑based logic to perform scaling, rounding and unit changes in a reusable utility class.

JavaReflectionUnit Conversion
0 likes · 10 min read
Automatic Unit Conversion in Java Using Reflection and Custom Annotations
Java Interview Crash Guide
Java Interview Crash Guide
Apr 19, 2023 · Backend Development

Master Spring MVC: Core Concepts, Annotations, and Interceptor Guide

This article explains the MVC pattern, the role of the DAO layer, details Spring MVC’s request handling flow, introduces key annotations such as @RequestMapping, @RequestParam, @RequestBody, and @PathVariable, and describes how to implement and register interceptors and request filters for comprehensive request processing.

Backend DevelopmentJavaWeb Framework
0 likes · 7 min read
Master Spring MVC: Core Concepts, Annotations, and Interceptor Guide
Programmer DD
Programmer DD
Mar 30, 2023 · Backend Development

Mastering Lombok @Accessors: Fluent, Chain, and Prefix Explained

Learn how Lombok's @Accessors annotation works by exploring its source code and understanding the three key attributes—fluent, chain, and prefix—so you can control getter and setter generation, customize method naming, and enable method chaining in your Java classes.

Fluent APIJavaLombok
0 likes · 4 min read
Mastering Lombok @Accessors: Fluent, Chain, and Prefix Explained
Architect's Guide
Architect's Guide
Mar 30, 2023 · Backend Development

Universal Java Class-to-Excel Export Using Reflection and CSV Formatting

This article explains how to build a generic Java utility that exports any list of objects to an Excel‑compatible CSV file by using reflection to extract field names for headers and values for rows, includes Maven dependencies, custom annotations, and practical usage examples.

Backend DevelopmentCSVExcel Export
0 likes · 9 min read
Universal Java Class-to-Excel Export Using Reflection and CSV Formatting
Programmer DD
Programmer DD
Mar 24, 2023 · Backend Development

Why Lombok @Data + @Builder Removes No‑Args Constructor and How to Fix It

This article explains why combining Lombok's @Data and @Builder annotations eliminates the default no‑argument constructor, demonstrates the compilation issues it causes, and provides two practical solutions—including using @Tolerate or separating constructors with @RequiredArgsConstructor and @NoArgsConstructor—while also detailing Lombok's compilation mechanism and a custom annotation example.

Builder PatternCompilationJava
0 likes · 6 min read
Why Lombok @Data + @Builder Removes No‑Args Constructor and How to Fix It
Selected Java Interview Questions
Selected Java Interview Questions
Mar 19, 2023 · Backend Development

Common Spring Boot Annotations and Their Usage

This article provides a comprehensive overview of Spring Boot and related Spring annotations, explaining their purposes, usage patterns, and code examples, helping developers master configuration, component scanning, conditional bean registration, and core Spring Boot features for efficient backend development.

Backend DevelopmentConfigurationJava
0 likes · 13 min read
Common Spring Boot Annotations and Their Usage
Selected Java Interview Questions
Selected Java Interview Questions
Feb 5, 2023 · Backend Development

Comprehensive Overview of Spring Boot: Features, Core Annotations, Configuration, and Best Practices

This article provides a detailed introduction to Spring Boot, covering its purpose, advantages, core @SpringBootApplication annotation, supported logging frameworks, starter mechanism, new features in version 2.x, configuration methods, security, CORS handling, actuator monitoring, hot deployment, multi‑datasource setup, session sharing, and packaging differences, all aimed at helping developers quickly adopt and master the framework.

Backend DevelopmentConfigurationJava
0 likes · 24 min read
Comprehensive Overview of Spring Boot: Features, Core Annotations, Configuration, and Best Practices
Java Architect Essentials
Java Architect Essentials
Jan 12, 2023 · Backend Development

How to Eliminate Repetitive Java Code with Design Patterns, Annotations, and Bean Mapping

This article examines why duplicate code harms maintainability, then demonstrates three practical techniques—using factory and template method patterns, leveraging custom annotations with reflection, and applying bean‑copy utilities—to refactor Java business logic and dramatically reduce redundancy.

Code RefactoringJavaReflection
0 likes · 29 min read
How to Eliminate Repetitive Java Code with Design Patterns, Annotations, and Bean Mapping
Java Backend Technology
Java Backend Technology
Nov 22, 2022 · Backend Development

Why Adding a Simple Log Triggered NPE in FastJSON Serialization – Lessons Learned

A recent production incident caused by inserting a single log statement revealed how FastJSON's ASM‑generated serializer invokes methods like isChinaName(), leading to a NullPointerException, and the article dissects the root cause, serialization mechanics, and best‑practice annotations to prevent similar bugs.

Javaannotationsdebugging
0 likes · 9 min read
Why Adding a Simple Log Triggered NPE in FastJSON Serialization – Lessons Learned
Top Architect
Top Architect
Oct 14, 2022 · Backend Development

Spring Annotation Development and MyBatis Integration Guide

This article provides a comprehensive tutorial on using Spring annotations for pure annotation‑based development, defining beans, managing bean scopes, performing various injection techniques, reading configuration properties, and integrating Spring with MyBatis, complete with code examples and best‑practice tips.

Backend DevelopmentDependency InjectionJava
0 likes · 10 min read
Spring Annotation Development and MyBatis Integration Guide
Programmer DD
Programmer DD
Oct 12, 2022 · Backend Development

Why Lombok @Data + @Builder Breaks No‑Args Constructors and How to Fix It

This article explains why combining Lombok's @Data and @Builder annotations removes the automatically generated no‑argument constructor, demonstrates the compilation process behind Lombok, and provides two practical solutions using @Tolerate or @RequiredArgsConstructor/@NoArgsConstructor to restore the missing constructor.

@DataBuilderCompilation
0 likes · 6 min read
Why Lombok @Data + @Builder Breaks No‑Args Constructors and How to Fix It
Selected Java Interview Questions
Selected Java Interview Questions
Oct 7, 2022 · Backend Development

Configuring Date Formatting in SpringBoot Applications

This article explains how to customize the date format returned by SpringBoot REST controllers using configuration files, Jackson annotations, JavaBean annotations, and global converters, covering both JSON serialization and form data binding with practical code examples.

annotationsdateformatjackson
0 likes · 11 min read
Configuring Date Formatting in SpringBoot Applications
Java Architect Essentials
Java Architect Essentials
Sep 30, 2022 · Backend Development

Comprehensive Guide to Spring Annotation Development and MyBatis Integration

This article provides a step‑by‑step tutorial on using Spring annotations for bean definition, component scanning, scope management, autowiring, qualifier usage, simple value injection, property file loading, and finally demonstrates how to integrate Spring with MyBatis for streamlined data access in Java backend projects.

ConfigurationDependency InjectionMyBatis
0 likes · 9 min read
Comprehensive Guide to Spring Annotation Development and MyBatis Integration
macrozheng
macrozheng
Sep 20, 2022 · Backend Development

How Lombok Simplifies Java Boilerplate—and What Pitfalls to Watch

This article explains Java's verbosity problem, introduces Lombok as a code‑generation tool that uses annotations like @Data to auto‑create getters, setters, equals, hashCode and toString, shows installation and Maven setup, and discusses both the productivity gains and the hidden drawbacks such as team dependency, debugging challenges, inheritance issues, encapsulation concerns, and future JDK compatibility risks.

Backend DevelopmentJavaLombok
0 likes · 10 min read
How Lombok Simplifies Java Boilerplate—and What Pitfalls to Watch
macrozheng
macrozheng
Sep 15, 2022 · Backend Development

When to Use @Autowired vs @Resource in Spring? 5 Key Differences Explained

This article compares Spring’s @Autowired and Java’s @Resource annotations, detailing five key differences—including their origins, lookup order, supported parameters, injection styles, and IDE warnings—while providing code examples and diagrams to help developers choose the appropriate annotation.

Dependency InjectionJavaSpring
0 likes · 9 min read
When to Use @Autowired vs @Resource in Spring? 5 Key Differences Explained
Top Architect
Top Architect
Sep 8, 2022 · Backend Development

Commonly Used Spring Framework Annotations Explained

This article provides a comprehensive overview of the most frequently used Spring and Spring Boot annotations, explaining their purposes, usage scenarios, and includes practical Java code examples for core, MVC/REST, stereotype, data access, scheduling, asynchronous, and testing annotations.

DependencyInjectionJavaSpring
0 likes · 13 min read
Commonly Used Spring Framework Annotations Explained
Selected Java Interview Questions
Selected Java Interview Questions
Sep 2, 2022 · Backend Development

Understanding the @SpringBootApplication Annotation in Spring Boot

This article explains the core @SpringBootApplication annotation, its composition of @EnableAutoConfiguration, @ComponentScan, and @SpringBootConfiguration, shows its source code, demonstrates custom composite annotations, and details how Spring Boot performs component scanning and automatic bean configuration.

@SpringBootApplicationSpring Bootannotations
0 likes · 8 min read
Understanding the @SpringBootApplication Annotation in Spring Boot
FunTester
FunTester
Aug 30, 2022 · Fundamentals

JUnit Annotations for Selenium Testing: Overview and Usage

This article explains why JUnit is a popular Java testing framework, lists its key features, and provides a comprehensive guide to using JUnit annotations—including @BeforeClass, @Before, @Test, @After, @AfterClass, @Ignore, and advanced annotations—in Selenium WebDriver automation scripts, complete with code examples and execution order details.

JUnitJavaSelenium
0 likes · 11 min read
JUnit Annotations for Selenium Testing: Overview and Usage
Cognitive Technology Team
Cognitive Technology Team
Aug 28, 2022 · Fundamentals

Common Pitfalls When Using Lombok in Java Projects

This article outlines several common pitfalls of the Lombok library in Java, such as StackOverflowError from @ToString, missing no‑arg constructors with @AllArgsConstructor, hash‑based collection issues with @EqualsAndHashCode, and accessor mismatches caused by @Setter/@Getter, providing code examples and recommendations.

JavaLombokannotations
0 likes · 5 min read
Common Pitfalls When Using Lombok in Java Projects
Top Architect
Top Architect
Aug 28, 2022 · Backend Development

Spring Boot Parameter Validation with javax.validation and Custom Annotations

This tutorial demonstrates how to replace verbose manual checks in Java services with Spring's javax.validation annotation‑based validation, covering built‑in constraints, Maven setup, DTO annotations, validation groups, custom validators, and a global exception handler for unified error responses.

ExceptionHandlingJavaSpring
0 likes · 13 min read
Spring Boot Parameter Validation with javax.validation and Custom Annotations
Architecture & Thinking
Architecture & Thinking
Jul 19, 2022 · Backend Development

Master Java Annotations: From Basics to Custom Usage

This article provides a comprehensive guide to Java annotations, covering built‑in annotations, meta‑annotations, retention policies, repeatable annotations, and how to create and apply custom annotations with reflection and AOP for practical use cases.

Custom AnnotationsJavaMeta‑annotations
0 likes · 22 min read
Master Java Annotations: From Basics to Custom Usage
Code Ape Tech Column
Code Ape Tech Column
Jul 15, 2022 · Backend Development

Eliminating Code Duplication in Java Business Logic with Design Patterns, Annotations, and Bean Mapping

This article explains how to reduce repetitive Java business code by applying the factory and template‑method patterns for shopping‑cart processing, using custom annotations with reflection to generate API requests, and leveraging bean‑mapping utilities to copy properties between DTO/DO objects, while illustrating each technique with concrete code examples.

Code RefactoringFactory PatternJava
0 likes · 21 min read
Eliminating Code Duplication in Java Business Logic with Design Patterns, Annotations, and Bean Mapping
Top Architect
Top Architect
Jun 30, 2022 · Backend Development

Spring Boot Cache: JCache Specification, Cache Abstraction, Annotations, and Redis Integration

This article explains Spring Boot caching by introducing the JSR‑107 JCache specification, detailing core cache interfaces, showing the Spring Cache abstraction and its implementations, demonstrating cache annotations such as @Cacheable, @CachePut and @CacheEvict, and finally covering Redis setup and custom CacheManager usage.

CacheJCacheJava
0 likes · 19 min read
Spring Boot Cache: JCache Specification, Cache Abstraction, Annotations, and Redis Integration
FunTester
FunTester
Jun 21, 2022 · Fundamentals

Comparing TestNG and JUnit: Features, Annotations, and Usage in Java Unit Testing

This article explains unit testing concepts, outlines the differences between TestNG and JUnit—including test suite configuration, annotations, grouping, parameterization, dependency handling, exception and timeout testing—and provides code examples to help developers choose the most suitable Java testing framework.

JUnitJavaTestNG
0 likes · 11 min read
Comparing TestNG and JUnit: Features, Annotations, and Usage in Java Unit Testing
Java Backend Technology
Java Backend Technology
Jun 15, 2022 · Backend Development

Master Spring Boot Annotations: From @RequestMapping to @SpringBootApplication

This comprehensive guide explains the most commonly used Spring Boot annotations—including MVC mapping, bean definitions, dependency injection, scope management, container configuration, and bootstrapping—providing clear examples and visual diagrams to help developers write cleaner, more efficient Java code.

annotationsdependency-injectionrest-controller
0 likes · 16 min read
Master Spring Boot Annotations: From @RequestMapping to @SpringBootApplication
Selected Java Interview Questions
Selected Java Interview Questions
Jun 12, 2022 · Fundamentals

Understanding Java Annotations: Concepts, Built‑in Annotations, Custom Annotations, and a Simple Test Framework

This article explains the purpose and syntax of Java annotations, describes built‑in annotations such as @Override, @Deprecated and @SuppressWarnings, shows how to create and use custom annotations with meta‑annotations, and demonstrates a lightweight testing framework that records annotation‑driven test failures.

Custom Annotationsannotationsjavadoc
0 likes · 11 min read
Understanding Java Annotations: Concepts, Built‑in Annotations, Custom Annotations, and a Simple Test Framework
Top Architect
Top Architect
Jun 3, 2022 · Backend Development

Understanding @Valid vs @Validated, Group Validation, Group Sequence, and Nested Validation in Spring/Hibernate

This article explains the differences between @Valid and @Validated annotations, demonstrates how to use validation groups, group sequences, and nested validation in Spring and Hibernate Validator, and provides complete code examples illustrating each concept for robust backend data validation.

Backend DevelopmentHibernate ValidationJava
0 likes · 8 min read
Understanding @Valid vs @Validated, Group Validation, Group Sequence, and Nested Validation in Spring/Hibernate
Architect's Tech Stack
Architect's Tech Stack
May 1, 2022 · Backend Development

Using JMH for Java Microbenchmarking: A Comprehensive Guide

This article introduces Java Microbenchmark Harness (JMH), explains why warm‑up is needed, walks through project setup with Maven, demonstrates benchmark code for LinkedList iteration, details common JMH annotations, shows how to run and interpret results, and concludes with practical usage tips, while also mentioning a promotional book giveaway.

JMHJavaannotations
0 likes · 12 min read
Using JMH for Java Microbenchmarking: A Comprehensive Guide
Java Architect Essentials
Java Architect Essentials
Apr 15, 2022 · Backend Development

Comprehensive Guide to Common Spring Framework Annotations

This article provides a detailed overview of the most frequently used Spring annotations—including core, MVC/REST, Boot, stereotype, data access, scheduling, and testing annotations—explaining their purposes, usage rules, and providing Java code examples for each.

DependencyInjectionSpringSpringMVC
0 likes · 13 min read
Comprehensive Guide to Common Spring Framework Annotations
macrozheng
macrozheng
Apr 12, 2022 · Backend Development

Mastering Spring Retry: How @Retryable Simplifies Robust Backend Calls

This article explains how Spring Boot's spring-retry module and the @Retryable annotation enable clean, annotation‑driven retry logic for common failure scenarios, covering configuration, code examples, recovery handling with @Recover, and important usage precautions.

Backend DevelopmentJavaRetryable
0 likes · 7 min read
Mastering Spring Retry: How @Retryable Simplifies Robust Backend Calls
Zhuanzhuan Tech
Zhuanzhuan Tech
Apr 6, 2022 · Backend Development

Design and Implementation of an Annotation‑Based HTTP Client in Spring

This article presents a design pattern for a unified, annotation‑driven HTTP client in a Spring‑based payment system, detailing custom annotations, dynamic proxy enhancement, and bean registration via FactoryBean and ImportBeanDefinitionRegistrar, with complete code examples and a summary of key concepts.

Dynamic ProxyHTTP ClientJava
0 likes · 16 min read
Design and Implementation of an Annotation‑Based HTTP Client in Spring
Java High-Performance Architecture
Java High-Performance Architecture
Mar 31, 2022 · Backend Development

How SpringBoot Auto‑Configuration Works: From @SpringBootApplication to Conditional Annotations

This article explains how SpringBoot simplifies Spring’s XML configuration by providing convention‑over‑configuration and automatic setup, walks through the key annotations such as @SpringBootApplication, @EnableAutoConfiguration, and @ComponentScan, and details the internal loading mechanism using META‑INF/spring.factories and conditional annotations.

Auto-ConfigurationJavaSpring Framework
0 likes · 13 min read
How SpringBoot Auto‑Configuration Works: From @SpringBootApplication to Conditional Annotations
Selected Java Interview Questions
Selected Java Interview Questions
Mar 26, 2022 · Backend Development

Comparison of @Resource and @Autowired for Bean Injection in Spring

This article explains the similarities and differences between Spring's @Autowired and the JSR‑250 @Resource annotations, covering their packages, injection mechanisms, usage on fields and setters, configuration options, IDE warnings, and best‑practice recommendations for bean injection in Java backend development.

Dependency InjectionSpringannotations
0 likes · 6 min read
Comparison of @Resource and @Autowired for Bean Injection in Spring