BestHub
Sign in
Tagged articles
333 articles
Page 2 of 4
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.

Code GenerationJavaLombok
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.

ComponentConfigurationJava
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 ProcessingBackendJava
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.

JavaTimeoutannotations
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 Boot
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.

Aspect Oriented ProgrammingBackend 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.

InterceptorJavaReflection
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.

BackendJavaReflection
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
Selected Java Interview Questions
Selected Java Interview Questions
Dec 18, 2023 · Backend Development

Implementing API Idempotency with Spring Boot, Redis, and Custom Annotations

This article explains the concept of idempotency, presents several strategies to achieve it, and provides a complete Spring Boot implementation using Redis, a custom @AutoIdempotent annotation, token generation and verification, interceptor configuration, and test cases to ensure only the first request succeeds.

BackendIdempotencyInterceptor
0 likes · 10 min read
Implementing API Idempotency with Spring Boot, Redis, and 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 RefactoringDesign PatternsJava
0 likes · 21 min read
Eliminating Code Duplication in Java Backend Development with Design Patterns, Annotations, and Bean Mapping
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.

Configuration ManagementConfigurationPropertiesJava
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.

BackendCustomAnnotationJava
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.

Aspect Oriented ProgrammingJavaSpring Boot
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.

BackendJavaSpring Boot
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.

BackendJavaSpring Boot
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 DevelopmentCode reviewJSON
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 DevelopmentJavaSpring Boot
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.

JavaReflectionannotations
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.

FrameworkJavaMyBatis
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.

AutowiredJavaannotations
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.

JavaProperty InjectionSpEL
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.

JavaReflectionannotations
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.

KotlinLuaannotations
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 DevelopmentJavaSpring MVC
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 DevelopmentCSVJava
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 RefactoringDesign PatternsJava
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.

DebuggingJavaannotations
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 DevelopmentJavaMyBatis
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.

JacksonSpringBootannotations
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.

ConfigurationMyBatisannotations
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 DevelopmentCode GenerationJava
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.

Javaannotationsdependency-injection
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.

DependencyInjectionJavaSpringBoot
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.

Code GenerationJavaLombok
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.

Javaannotationsexceptionhandling
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 AnnotationsJavadocannotations
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 DevelopmentGroup ValidationHibernate Validation
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.

JMHJavaPerformance Testing
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.

DependencyInjectionSpringBootSpringMVC
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 ProxyFactoryBeanHTTP client
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.

JavaSpring FrameworkSpringBoot
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.

annotationsdependency-injectionspring
0 likes · 6 min read
Comparison of @Resource and @Autowired for Bean Injection in Spring
Java High-Performance Architecture
Java High-Performance Architecture
Mar 21, 2022 · Backend Development

Boost Spring Cache Performance with Custom Annotations and a SCAN‑Based RedisCacheWriter

This article explains how to enhance Spring Cache by creating custom cache annotations, replacing the costly KEYS command with SCAN in a rewritten DefaultRedisCacheWriter, and dynamically registering RedisCacheManager beans to support per‑module TTL and transaction‑aware caching, all illustrated with full Java code examples.

BackendCacheJava
0 likes · 28 min read
Boost Spring Cache Performance with Custom Annotations and a SCAN‑Based RedisCacheWriter
macrozheng
macrozheng
Mar 10, 2022 · Backend Development

Master Spring Annotations: @Component vs @Bean, @Autowired vs @Resource, @ControllerAdvice

This article explains several often‑confused Spring annotations—including the differences between @Component and @Bean, the injection behaviors of @Autowired versus @Resource, the roles of @Component, @Repository, @Service, and @Controller, the purpose of @Configuration and @ControllerAdvice, and provides practical code examples for each.

Exception HandlingJavaannotations
0 likes · 11 min read
Master Spring Annotations: @Component vs @Bean, @Autowired vs @Resource, @ControllerAdvice
Java Tech Enthusiast
Java Tech Enthusiast
Mar 9, 2022 · Backend Development

Annotation‑Based Bean Management and Dependency Injection in Spring

Spring’s annotation‑based bean registration and dependency injection replace verbose XML by using component scanning with @Component, @Controller, @Service, and @Repository, while @Autowired (or @Qualifier/@Primary) injects beans by type, @Resource supports name‑based injection, and @Value together with @PropertySource loads external configuration, though developers must handle issues such as NoUniqueBeanDefinitionException when multiple candidates exist.

AutowiredJavaannotations
0 likes · 8 min read
Annotation‑Based Bean Management and Dependency Injection in Spring
Code Ape Tech Column
Code Ape Tech Column
Mar 9, 2022 · Backend Development

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

This article explains how to reduce repetitive business‑level Java code by applying the Template Method and Factory patterns, leveraging custom annotations with reflection, and using bean‑mapping utilities, thereby improving maintainability, extensibility, and overall code quality.

Code RefactoringDesign PatternsJava
0 likes · 20 min read
Eliminating Code Duplication in Business Logic with Design Patterns, Annotations, Reflection, and Bean Mapping
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Mar 6, 2022 · Fundamentals

Comprehensive Guide to Java Annotations (Detailed)

This article provides an in‑depth overview of Java annotations, covering their definition, common applications, built‑in standard annotations, meta‑annotations, functional interfaces, and step‑by‑step instructions for creating and using custom annotations with complete code examples.

Custom AnnotationsJavaMeta-annotations
0 likes · 8 min read
Comprehensive Guide to Java Annotations (Detailed)
Top Architect
Top Architect
Feb 20, 2022 · Backend Development

Using JMH for Java Microbenchmarking: Demo, Annotations, and Best Practices

This article introduces Java Microbenchmark Harness (JMH), explains why warm‑up is needed, shows how to build a benchmark project with Maven, provides a complete LinkedList iteration benchmark example with all relevant JMH annotations, demonstrates execution commands, and interprets the resulting performance reports.

BenchmarkingJMHJava
0 likes · 13 min read
Using JMH for Java Microbenchmarking: Demo, Annotations, and Best Practices
Top Architect
Top Architect
Feb 16, 2022 · Backend Development

Understanding Spring AOP Annotations and Their Execution Order

This article explains the common Spring AOP annotations such as @Before, @After, @AfterReturning, @AfterThrowing and @Around, demonstrates how to set up a Spring Boot project, write an interface, implementation, aspect, and discusses execution order, multiple aspects, and proxy‑failure scenarios.

JavaProxyannotations
0 likes · 8 min read
Understanding Spring AOP Annotations and Their Execution Order
Programmer DD
Programmer DD
Feb 16, 2022 · Backend Development

Master Spring AOP: Essential Annotations, Execution Order, and Common Pitfalls

This article revisits the fundamentals of Spring AOP, detailing its core annotations such as @Before, @After, @Around, and their execution sequence, while providing a complete demo project, code examples, and insights into common pitfalls like proxy failures and multi‑aspect ordering.

Backend DevelopmentJavaProxy
0 likes · 9 min read
Master Spring AOP: Essential Annotations, Execution Order, and Common Pitfalls