BestHub
Sign in
Tagged articles

annotations

342 articles · Page 3 of 4
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.

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

Dependency InjectionJavaSpring
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.

@QualifierAutowiredDependency Injection
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 RefactoringJavaReflection
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.

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

AspectJBackend DevelopmentJava
0 likes · 9 min read
Master Spring AOP: Essential Annotations, Execution Order, and Common Pitfalls
JavaEdge
JavaEdge
Jan 11, 2022 · Fundamentals

Master Java Annotations: From Basics to Advanced Usage

This article explains what Java annotations are, how to define custom annotations, the built‑in meta‑annotations, annotation attributes, common built‑in annotations, and practical usage scenarios, providing code examples and runtime reflection details for developers.

JDKJavaReflection
0 likes · 13 min read
Master Java Annotations: From Basics to Advanced Usage
Top Architect
Top Architect
Jan 8, 2022 · Backend Development

Comprehensive Guide to Spring MVC and Spring Boot Annotations

This article provides a detailed overview of Spring MVC request‑mapping annotations, Spring Bean and dependency‑injection annotations, and essential Spring Boot configuration annotations, illustrating their usage with code examples and explaining how they work together to build robust backend applications.

Backend DevelopmentSpringSpring Boot
0 likes · 13 min read
Comprehensive Guide to Spring MVC and Spring Boot Annotations
JD Retail Technology
JD Retail Technology
Jan 4, 2022 · Backend Development

Using Jakarta Bean Validation for Robust Data Validation in Java Applications

This article explains the Jakarta Bean Validation standard, its applicable scenarios, annotation basics, integration with Hibernate Validator, configuration options, simple and advanced usage examples—including group sequencing and multi‑field validation—along with practical code snippets and deployment considerations for backend Java development.

Bean ValidationData ValidationHibernate Validator
0 likes · 15 min read
Using Jakarta Bean Validation for Robust Data Validation in Java Applications
Top Architect
Top Architect
Dec 29, 2021 · Backend Development

Detailed Guide to Lombok @Builder Annotation and Its Usage

This article provides a comprehensive tutorial on Lombok's @Builder annotation, covering basic usage, generated code details, @Singular collection handling, @Builder.Default defaults, toBuilder feature, and global configuration, with numerous Java code examples and explanations.

BuilderJavaLombok
0 likes · 14 min read
Detailed Guide to Lombok @Builder Annotation and Its Usage
Selected Java Interview Questions
Selected Java Interview Questions
Dec 25, 2021 · Backend Development

Implementation Principles of Spring Boot Auto‑Configuration

This article explains how Spring Boot’s auto‑configuration works by describing the role of @SpringBootApplication, the conditional annotations that drive bean creation, the use of META‑INF/spring.factories, and provides a step‑by‑step example of building a custom auto‑configuration module with full code samples.

@ConditionalAutoConfigurationJava
0 likes · 9 min read
Implementation Principles of Spring Boot Auto‑Configuration
Architect's Guide
Architect's Guide
Oct 28, 2021 · Backend Development

Core Features, Advantages, and Common Annotations of Spring Boot

This article provides an English overview of Spring Boot’s core functionalities—including standalone JAR execution, embedded servlet containers, starter POM simplification, auto‑configuration, production‑ready monitoring, and code‑free XML—while also discussing its pros and cons, key features, CLI tool, Maven parent, and commonly used annotations.

JavaSpring Bootannotations
0 likes · 5 min read
Core Features, Advantages, and Common Annotations of Spring Boot
Architect's Tech Stack
Architect's Tech Stack
Oct 28, 2021 · Backend Development

Commonly Used Spring Annotations – Core, MVC/REST, Boot, Stereotype, Transaction, Scheduling and Testing

This article provides a comprehensive overview of the most frequently used Spring annotations, covering core dependency‑injection annotations, MVC/REST mapping, Spring Boot configuration, stereotype components, transaction management, task scheduling, asynchronous execution, and testing support, with clear code examples for each.

DependencyInjectionJavaMVC
0 likes · 11 min read
Commonly Used Spring Annotations – Core, MVC/REST, Boot, Stereotype, Transaction, Scheduling and Testing
Selected Java Interview Questions
Selected Java Interview Questions
Oct 21, 2021 · Backend Development

Deep Dive into SpringBoot Auto‑Configuration and Startup Process

This article provides a comprehensive walkthrough of SpringBoot’s auto‑configuration mechanism, covering common annotations, configuration property binding, import strategies, conditional beans, the application startup flow, and the role of META‑INF/spring.factories in loading auto‑configuration classes.

Auto-ConfigurationDependency InjectionJava
0 likes · 16 min read
Deep Dive into SpringBoot Auto‑Configuration and Startup Process
macrozheng
macrozheng
Oct 19, 2021 · Backend Development

Simplify Excel Import/Export in Spring Boot with EasyPoi – A Complete Guide

This article introduces EasyPoi, a Spring Boot-friendly library that uses annotations to streamline Excel import and export, covering simple and complex export scenarios, import handling, custom data processing, and provides full code examples for quick integration.

EasyPOIExcelImport Export
0 likes · 14 min read
Simplify Excel Import/Export in Spring Boot with EasyPoi – A Complete Guide
Java Architect Essentials
Java Architect Essentials
Oct 15, 2021 · Backend Development

Master Spring MVC & Bean Annotations: A Complete Guide

This article provides a comprehensive overview of Spring MVC request‑mapping annotations, core Spring Bean annotations, dependency‑injection and scope configurations, container setup annotations, and essential Spring Boot annotations, each illustrated with clear code examples and usage tips.

Dependency InjectionJava backendSpring
0 likes · 16 min read
Master Spring MVC & Bean Annotations: A Complete Guide
Selected Java Interview Questions
Selected Java Interview Questions
Oct 5, 2021 · Backend Development

Overview of Spring Web MVC and Spring Bean Annotations

This article provides a comprehensive guide to Spring Web MVC and Spring Bean annotations, detailing usage, attributes, and examples of @RequestMapping, @GetMapping, @PostMapping, @ControllerAdvice, @Autowired, @Scope, and various Spring Boot conditional annotations, helping developers understand and apply them effectively.

Dependency InjectionSpringSpring Boot
0 likes · 16 min read
Overview of Spring Web MVC and Spring Bean Annotations
Java Architect Essentials
Java Architect Essentials
Sep 22, 2021 · Backend Development

Spring Framework Overview: Concepts, Modules, Configuration, and Annotations

This article provides a comprehensive overview of the Spring Framework, covering its definition, advantages, core features such as IoC, AOP, MVC, transaction management, the various modules and their purposes, configuration methods (XML, annotations, Java API), bean scopes, lifecycle, autowiring, and key annotations used in modern Java backend development.

Bean LifecycleDependency InjectionIOC
0 likes · 14 min read
Spring Framework Overview: Concepts, Modules, Configuration, and Annotations
Code Ape Tech Column
Code Ape Tech Column
Sep 21, 2021 · Backend Development

Overview of Spring Web MVC, Bean, and Boot Annotations

This article provides a comprehensive guide to Spring MVC request‑mapping annotations, Spring Bean lifecycle and dependency‑injection annotations, as well as Spring Boot conditional and configuration annotations, illustrating each with code examples and usage notes for Java backend development.

JavaSpringSpring Boot
0 likes · 13 min read
Overview of Spring Web MVC, Bean, and Boot Annotations
Architect's Tech Stack
Architect's Tech Stack
Sep 11, 2021 · Backend Development

Commonly Used Spring Framework Annotations Overview

This article introduces the most frequently used Spring framework annotations—including core, MVC/REST, Spring Boot, stereotype, transaction, scheduling, and testing annotations—explaining their purposes, usage locations, and providing Java code examples to illustrate how they configure beans, handle requests, and manage application behavior.

JavaSpringannotations
0 likes · 12 min read
Commonly Used Spring Framework Annotations Overview
Top Architect
Top Architect
Sep 11, 2021 · Backend Development

14 Tips for Writing Spring MVC Controllers

This tutorial explains fourteen practical techniques for building Spring MVC controller classes, covering annotation‑based definitions, interface implementation, extending AbstractController, URL mapping, request method handling, parameter binding, model handling, redirects, form validation, file uploads, dependency injection, and best practices such as single‑responsibility and domain‑specific controllers.

JavaModelAndViewWeb Development
0 likes · 15 min read
14 Tips for Writing Spring MVC Controllers
Top Architect
Top Architect
Sep 6, 2021 · Backend Development

Java Excel Import/Export Utility with Custom Annotations

This article explains how to create a reusable Java utility for Excel import and export using custom annotations, POI library, and helper methods to handle data mapping, dropdown validation, and HTTP response streaming, providing step‑by‑step code examples for both operations.

ExcelImportExportJava
0 likes · 9 min read
Java Excel Import/Export Utility with Custom Annotations
Architecture Digest
Architecture Digest
Aug 26, 2021 · Backend Development

Injecting Beans with Annotations in Spring

This article explains how to use Spring annotations such as @Component, @Configuration, @Bean, @Autowired, and @Qualifier to inject beans via XML replacement, constructor injection, setter injection, property injection, List and Map injection, providing code examples and detailed explanations for each method.

Dependency InjectionIOCJava
0 likes · 9 min read
Injecting Beans with Annotations in Spring
Programmer DD
Programmer DD
Aug 18, 2021 · Backend Development

How Does Spring’s @Autowired Work Under the Hood? A Deep Dive

This article explores the various ways to use Spring’s @Autowired annotation—including constructor, setter, field, and collection injection—examines its purpose, and provides a detailed analysis of its implementation in the Spring framework by dissecting the source code and related reflection mechanisms.

Dependency InjectionJavaReflection
0 likes · 17 min read
How Does Spring’s @Autowired Work Under the Hood? A Deep Dive
Architecture Digest
Architecture Digest
Aug 17, 2021 · Backend Development

Comprehensive Guide to Spring Validation: Best Practices, Scenarios, and Advanced Features

This article provides an in‑depth tutorial on Spring Validation, covering basic usage, requestBody and requestParam validation, group and nested validation, collection handling, custom constraints, programmatic validation, fail‑fast mode, and the underlying implementation details within Spring MVC and Hibernate Validator.

DTOHibernateJava
0 likes · 15 min read
Comprehensive Guide to Spring Validation: Best Practices, Scenarios, and Advanced Features
Java Tech Enthusiast
Java Tech Enthusiast
Aug 13, 2021 · Backend Development

Handling Request Parameters in Spring MVC

Spring MVC lets developers retrieve request data using the raw HttpServletRequest, or more conveniently with annotations such as @RequestParam, @RequestHeader, @RequestBody, and @CookieValue, supports automatic binding to POJOs including nested objects, injects native Servlet objects like HttpSession, and handles character encoding via CharacterEncodingFilter.

Backend DevelopmentJavaRequest Parameters
0 likes · 9 min read
Handling Request Parameters in Spring MVC
Code Ape Tech Column
Code Ape Tech Column
Aug 10, 2021 · Backend Development

Understanding the Spring Boot Auto‑Configuration Mechanism

This article explains how Spring Boot’s auto‑configuration works, covering configuration files, key annotations like @EnableAutoConfiguration, conditionals, and the role of XxxxProperties and XxxxAutoConfiguration classes in binding properties and loading beans into the Spring container.

Auto-ConfigurationJavaSpring Boot
0 likes · 9 min read
Understanding the Spring Boot Auto‑Configuration Mechanism
Top Architect
Top Architect
Jul 31, 2021 · Backend Development

Java Excel Import/Export Utility with Custom Annotations

This article explains how to create a reusable Java utility for Excel import and export using custom annotations, detailing the required EnableExport, EnableExportField, and ImportIndex annotations, the implementation of parsing and exporting methods with Apache POI, and providing sample code and usage examples.

Apache POIExcelImportExport
0 likes · 8 min read
Java Excel Import/Export Utility with Custom Annotations
Yang Money Pot Technology Team
Yang Money Pot Technology Team
Jul 27, 2021 · Fundamentals

Understanding Java Class Compilation and Loading: Processes, Annotations, Syntax Sugar, and Class Loader Mechanisms

This article explains the complete Java class compilation and loading lifecycle, covering lexical, syntax, and semantic analysis, annotation processing, syntax‑sugar transformation, bytecode generation, class file structure, the five loading steps, class loader types, the parent‑delegation model, and practical use cases such as dependency conflict resolution, hot‑loading, and code encryption.

Class CompilationJavaannotations
0 likes · 22 min read
Understanding Java Class Compilation and Loading: Processes, Annotations, Syntax Sugar, and Class Loader Mechanisms
Java Interview Crash Guide
Java Interview Crash Guide
Jul 27, 2021 · Backend Development

Mastering Spring AOP: From Basics to Advanced Real‑World Examples

This article introduces Aspect‑Oriented Programming in Spring, explains core concepts such as pointcut, advice, aspect, join point and weaving, and provides step‑by‑step code examples—including a simple @GetMapping logger, a custom permission annotation with multiple aspects, and detailed usage of @Pointcut, @Around, @Before, @After, @AfterReturning and @AfterThrowing annotations—illustrated with diagrams and runnable snippets.

AOPJavaSpring
0 likes · 19 min read
Mastering Spring AOP: From Basics to Advanced Real‑World Examples
Selected Java Interview Questions
Selected Java Interview Questions
Jul 24, 2021 · Backend Development

Understanding AOP in Spring Boot: Concepts, Code Examples, and Annotation Guide

This article explains Aspect‑Oriented Programming (AOP) in Spring Boot, covering its core concepts, why it simplifies cross‑cutting concerns like logging and permission checks, provides step‑by‑step code examples of simple and advanced AOP implementations, and details the most commonly used AOP annotations.

AOPJavaSpring Boot
0 likes · 18 min read
Understanding AOP in Spring Boot: Concepts, Code Examples, and Annotation Guide
Top Architect
Top Architect
Jul 18, 2021 · Backend Development

Understanding the @Autowired Annotation in Spring: Usage, Implementation, and Underlying Mechanics

This article explains the @Autowired annotation in Spring, covering its various usage forms such as constructor, setter, method, field, and collection injection, and delves into the underlying implementation details within Spring's AutowiredAnnotationBeanPostProcessor, including metadata handling, reflection-based injection, and common pitfalls.

AutowiredBackend DevelopmentDependency Injection
0 likes · 19 min read
Understanding the @Autowired Annotation in Spring: Usage, Implementation, and Underlying Mechanics
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jun 29, 2021 · Backend Development

Why Your Custom Spring AOP Advisor Isn’t Triggered and How to Fix It

This article explains the behavior of Spring Boot’s @Configuration and @Import annotations, the reasons a custom PointcutAdvisor may not be applied when using JDK proxies, and provides two solutions—adding the @DS annotation to interface methods or forcing CGLIB proxying with proxyTargetClass=true—to ensure the advice executes correctly.

AOPCGLIBCustom Advisor
0 likes · 10 min read
Why Your Custom Spring AOP Advisor Isn’t Triggered and How to Fix It
Top Architect
Top Architect
Jun 27, 2021 · Backend Development

Understanding and Implementing Spring's @Autowired Annotation

This article explains the various ways to use Spring's @Autowired annotation, explores its underlying implementation using reflection, analyzes the core processing classes in the Spring framework, and answers common questions about its lifecycle, bean relationships, and why static injection is discouraged.

AutowiredDependency InjectionJava
0 likes · 17 min read
Understanding and Implementing Spring's @Autowired Annotation
Java Tech Enthusiast
Java Tech Enthusiast
Jun 18, 2021 · Backend Development

Spring Annotation-Based Bean Registration Guide

The guide explains how Spring’s annotation-driven configuration—using @Configuration and @Bean to define beans, @ComponentScan for automatic detection, and additional annotations such as @Scope, @Lazy, @Conditional, @Import and FactoryBean—replaces verbose XML, streamlining bean registration and lifecycle management.

BeanConfigurationDependency Injection
0 likes · 10 min read
Spring Annotation-Based Bean Registration Guide
Top Architect
Top Architect
Jun 18, 2021 · Backend Development

Understanding Spring Boot @SpringBootApplication and Its Auto‑Configuration Mechanism

This article explains how Spring Boot's @SpringBootApplication annotation combines several meta‑annotations, how auto‑configuration classes are discovered from META‑INF/spring.factories, and how the framework creates and refreshes the application context, including the embedded Tomcat web server, with illustrative code snippets.

Auto-ConfigurationBackend DevelopmentJava
0 likes · 12 min read
Understanding Spring Boot @SpringBootApplication and Its Auto‑Configuration Mechanism
IT Xianyu
IT Xianyu
Jun 10, 2021 · Backend Development

Comprehensive Guide to MyBatis-Plus: CRUD, Annotations, Condition Builders, Pagination, and Advanced Features

This article provides a detailed tutorial on using MyBatis-Plus in Java, covering setup, entity and mapper definitions, CRUD operations, annotations, condition builders, pagination, AR mode, logical deletion, automatic field filling, optimistic locking, performance analysis, multi‑tenant support, dynamic table names, configuration options, and code generation.

CRUDJavaORM
0 likes · 45 min read
Comprehensive Guide to MyBatis-Plus: CRUD, Annotations, Condition Builders, Pagination, and Advanced Features
Top Architect
Top Architect
Jun 5, 2021 · Backend Development

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

This article provides a detailed overview of the most commonly used Spring Boot, Spring MVC, and JPA annotations, explains their purposes, shows how they interact, and includes practical code examples for building robust Java backend applications.

Backend DevelopmentJavaSpring Boot
0 likes · 11 min read
Comprehensive Guide to Spring Boot, Spring MVC, and JPA Annotations
Top Architect
Top Architect
Jun 1, 2021 · Backend Development

Comprehensive Guide to MyBatis‑Plus CRUD, Annotations, Wrappers, Pagination and Advanced Features

This article provides a detailed tutorial on using MyBatis‑Plus with Spring Boot, covering quick setup, entity and mapper definitions, CRUD operations, condition wrappers (including lambda and chain wrappers), pagination, ActiveRecord mode, primary‑key strategies, configuration options, code generation, and advanced features such as logical deletion, auto‑fill, optimistic locking, performance analysis, multi‑tenant and dynamic table name handling.

CRUDJavaORM
0 likes · 46 min read
Comprehensive Guide to MyBatis‑Plus CRUD, Annotations, Wrappers, Pagination and Advanced Features
Java Interview Crash Guide
Java Interview Crash Guide
May 12, 2021 · Fundamentals

Unlocking Java Annotations: What They Are, How They Work, and How to Create Your Own

Java annotations, introduced in Java 5, provide a metadata mechanism to associate information with program elements, enabling documentation generation, compile‑time checks, and runtime processing; this guide explains their purpose, underlying principles, meta‑annotations, common built‑in annotations, and demonstrates how to define and use custom annotations with full code examples.

Custom AnnotationsJavaMeta‑annotations
0 likes · 12 min read
Unlocking Java Annotations: What They Are, How They Work, and How to Create Your Own
Java Interview Crash Guide
Java Interview Crash Guide
Apr 27, 2021 · Backend Development

Unveiling Spring Boot’s @SpringBootApplication: How It Powers Your App Startup

This article explains how the @SpringBootApplication annotation combines @Configuration, @EnableAutoConfiguration, and @ComponentScan, walks through the SpringApplication.run execution flow, and reveals the inner workings of Spring Boot’s auto‑configuration mechanism using SpringFactoriesLoader and META‑INF/spring.factories.

Auto-ConfigurationBackend DevelopmentJava
0 likes · 16 min read
Unveiling Spring Boot’s @SpringBootApplication: How It Powers Your App Startup
Intelligent Backend & Architecture
Intelligent Backend & Architecture
Apr 13, 2021 · Backend Development

Why Spring Boot Revolutionizes Backend Development: A Complete Guide

This article explains how Spring Boot, a Pivotal‑backed extension of the Spring framework, simplifies Java backend development by providing auto‑configuration, starter dependencies, embedded servers, and seamless integration with micro‑service architectures, while also covering core annotations, configuration files, security, and deployment options.

Backend DevelopmentConfigurationJava
0 likes · 35 min read
Why Spring Boot Revolutionizes Backend Development: A Complete Guide
Intelligent Backend & Architecture
Intelligent Backend & Architecture
Apr 12, 2021 · Backend Development

Mastering Spring MVC: Core Concepts, Components, and Annotations Explained

This comprehensive guide explains Spring MVC's MVC architecture, key components like DispatcherServlet and HandlerMapping, request processing flow, transaction management options, and essential annotations such as @Controller, @RequestMapping, @Autowired, and @Transactional, providing Java web developers with a clear, practical overview.

Dependency InjectionJavaTransaction Management
0 likes · 38 min read
Mastering Spring MVC: Core Concepts, Components, and Annotations Explained
Intelligent Backend & Architecture
Intelligent Backend & Architecture
Apr 12, 2021 · Backend Development

Master Spring Boot: From Basics to Advanced Annotations and Best Practices

This comprehensive guide explains what Spring Boot is, why it was created for micro‑service development, how it simplifies configuration with starters and auto‑configuration, and provides detailed coverage of core annotations, configuration files, security, CORS, transaction management, and deployment options for Java backend developers.

Backend DevelopmentConfigurationJava
0 likes · 38 min read
Master Spring Boot: From Basics to Advanced Annotations and Best Practices
Intelligent Backend & Architecture
Intelligent Backend & Architecture
Apr 9, 2021 · Backend Development

Understanding Spring: Core Concepts, IoC, DI, AOP, and Annotations Explained

This article provides a comprehensive overview of the Spring framework, covering its lightweight architecture, core principles such as Inversion of Control and Dependency Injection, AOP mechanisms, design goals, module structure, common design patterns, bean lifecycle, circular dependency handling, and the most frequently used Spring annotations with code examples.

AOPIOCJava
0 likes · 41 min read
Understanding Spring: Core Concepts, IoC, DI, AOP, and Annotations Explained
Architect's Tech Stack
Architect's Tech Stack
Mar 30, 2021 · Backend Development

BizLog SDK: Usage, Configuration, and Extension Guide for Spring Boot

This article introduces the BizLog SDK for Spring Boot, explaining how to add Maven dependencies, enable logging with @EnableLogRecord, configure log records using @LogRecordAnnotation for success, failure, categories, details, operators, custom parsing functions, and shows how to extend the framework with custom services and implementations.

AOPBizLogJava
0 likes · 14 min read
BizLog SDK: Usage, Configuration, and Extension Guide for Spring Boot
Top Architect
Top Architect
Mar 25, 2021 · Backend Development

Understanding the Working Principle of @ControllerAdvice in Spring MVC

This article explains how the @ControllerAdvice annotation is discovered and utilized within Spring MVC, detailing the initialization process, the caching of @ExceptionHandler, @ModelAttribute, and @InitBinder methods, and how these global configurations are applied by RequestMappingHandlerAdapter during request handling.

@ControllerAdviceExceptionHandlingJava
0 likes · 12 min read
Understanding the Working Principle of @ControllerAdvice in Spring MVC
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Feb 20, 2021 · Backend Development

Understanding Spring Boot Auto‑Configuration and Common Annotations

This article explains how Spring Boot’s auto‑configuration works, introduces the most frequently used annotations such as @Value, @ConfigurationProperties, @Import and @Conditional, and provides practical code examples to illustrate the underlying mechanisms and startup process of a Spring Boot application.

Auto-ConfigurationBackend DevelopmentJava
0 likes · 22 min read
Understanding Spring Boot Auto‑Configuration and Common Annotations
Top Architect
Top Architect
Feb 5, 2021 · Backend Development

Using Apache POI to Create and Read Excel Files in Java

This article introduces Apache POI, the Java API for Microsoft Office documents, explains its core components such as Workbook, Sheet, Row, and Cell, and provides detailed code examples for creating, reading, and converting Java object lists to Excel files, including Maven dependencies and annotation usage.

Apache POIExcelJava
0 likes · 11 min read
Using Apache POI to Create and Read Excel Files in Java
Qunar Tech Salon
Qunar Tech Salon
Jan 27, 2021 · Mobile Development

Implementing Global SDK Privacy Monitoring and Hooking in Android via ASM Transform and Custom Annotations

This article explains how QuNar’s front‑end team built a comprehensive Android SDK privacy monitoring system using a custom Transform, ASM bytecode manipulation, and annotation‑driven hook configurations, detailing both basic and advanced solutions for globally intercepting sensitive API calls and ensuring extensible, version‑independent protection.

ASMAndroidHook
0 likes · 20 min read
Implementing Global SDK Privacy Monitoring and Hooking in Android via ASM Transform and Custom Annotations
Architecture Digest
Architecture Digest
Jan 19, 2021 · Backend Development

Comprehensive Guide to Spring Validation: Best Practices, Scenarios, and Advanced Features

This article provides an in‑depth tutorial on Spring Validation, covering basic usage, dependency configuration, requestBody and requestParam validation, unified exception handling, group and nested validation, collection checks, custom constraints, programmatic validation, fail‑fast mode, and the differences between @Valid and @Validated.

DTOHibernate ValidatorJava
0 likes · 16 min read
Comprehensive Guide to Spring Validation: Best Practices, Scenarios, and Advanced Features
Architect's Tech Stack
Architect's Tech Stack
Jan 11, 2021 · Backend Development

Commonly Used Spring Framework Annotations and Their Usage

This article introduces the most commonly used Spring framework annotations—including core, MVC/REST, Boot, stereotype, data access, scheduling, and testing annotations—explains their purposes, usage scenarios, and provides Java code examples illustrating how to apply them in typical Spring applications.

DependencyInjectionSpringannotations
0 likes · 12 min read
Commonly Used Spring Framework Annotations and Their Usage
Architecture Digest
Architecture Digest
Jan 10, 2021 · Backend Development

Designing Unified API Response Wrappers with @ResponseResult in Spring

This article explains how to design a consistent JSON response structure for Spring-based micro‑service APIs, introduces a Result wrapper class, demonstrates annotation‑driven response handling, and shows controller, interceptor, and advice implementations to produce clean, maintainable backend responses.

APIJavaResponseWrapper
0 likes · 6 min read
Designing Unified API Response Wrappers with @ResponseResult in Spring
Programmer DD
Programmer DD
Dec 13, 2020 · Backend Development

Mastering Bean Validation with Hibernate Validator: A Complete Guide for Spring Boot

This article explains how to use JSR‑380 Bean Validation 2.0 and Hibernate Validator in Spring Boot applications, covering built‑in constraints, custom annotations, group validation, method and container element validation, fast‑fail mode, and integration with @Valid and @Validated for clean, reusable data checks.

Bean ValidationHibernate ValidatorJSR-380
0 likes · 19 min read
Mastering Bean Validation with Hibernate Validator: A Complete Guide for Spring Boot
Java Architect Essentials
Java Architect Essentials
Dec 9, 2020 · Backend Development

Designing a Unified API Response Structure for a Java E‑Commerce Platform

This article explains how to design a unified API response format in a Java-based fresh‑food e‑commerce system, covering overall architecture, JSON response schema, status‑code conventions, Result wrapper class, controller refactoring, custom annotations, and interceptor implementation to achieve clean and maintainable backend responses.

API designJavaREST
0 likes · 8 min read
Designing a Unified API Response Structure for a Java E‑Commerce Platform
Selected Java Interview Questions
Selected Java Interview Questions
Dec 1, 2020 · Backend Development

Using Annotations and Reflection to Eliminate Duplicate Java Backend Code

This article demonstrates how to replace repetitive Java backend code for constructing fixed‑length API request strings by defining POJOs, custom annotations, and a reflection‑based utility that formats parameters, pads strings, handles numeric and monetary fields, and appends an MD5 signature, thereby improving maintainability and reducing bugs.

APICode RefactoringJava
0 likes · 10 min read
Using Annotations and Reflection to Eliminate Duplicate Java Backend Code
JavaEdge
JavaEdge
Nov 20, 2020 · Backend Development

Why Java Annotations Don't Inherit to Subclass Methods and How to Work Around It

This article explains the limits of annotation inheritance in Java, demonstrates why subclass methods cannot automatically inherit parent annotations, and shows how to use @Inherited, Spring's AnnotatedElementUtils, and find/get semantics to retrieve inherited annotations effectively.

@InheritedAnnotatedElementUtilsJava
0 likes · 6 min read
Why Java Annotations Don't Inherit to Subclass Methods and How to Work Around It
Code Ape Tech Column
Code Ape Tech Column
Nov 20, 2020 · Backend Development

How Spring Boot Auto‑Configuration Works: Inside @SpringBootApplication and @EnableAutoConfiguration

This article dissects Spring Boot's auto‑configuration mechanism by examining the source code of @SpringBootApplication, @EnableAutoConfiguration, @AutoConfigurationPackage, and the ImportSelector, explaining how starter packages, component scanning, and spring.factories drive the framework's zero‑configuration experience.

Auto-ConfigurationBackend DevelopmentJava
0 likes · 7 min read
How Spring Boot Auto‑Configuration Works: Inside @SpringBootApplication and @EnableAutoConfiguration
IT Xianyu
IT Xianyu
Nov 16, 2020 · Backend Development

14 Tips for Writing Spring MVC Controllers

This article presents fourteen practical techniques for creating Spring MVC controller classes, covering annotation-based definitions, interface implementation, extending abstract controllers, URL mapping, HTTP method specification, request parameter binding, model and view handling, redirects, form validation, file uploads, dependency injection, request/response access, and adherence to the single‑responsibility principle.

Dependency InjectionJavaREST
0 likes · 14 min read
14 Tips for Writing Spring MVC Controllers
ITPUB
ITPUB
Nov 2, 2020 · Backend Development

When Lombok’s Magic Turns Toxic: Hidden Risks of Java Boilerplate Reduction

The article examines Lombok’s ability to shrink Java boilerplate with annotations, walks through code before and after its use, and highlights five major drawbacks—including JDK incompatibility, forced plugin dependence, reduced readability, tighter coupling, and technical debt—suggesting careful team evaluation before adoption.

JavaLombokannotations
0 likes · 10 min read
When Lombok’s Magic Turns Toxic: Hidden Risks of Java Boilerplate Reduction
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Nov 2, 2020 · Backend Development

Understanding the Three Core Annotations of Spring Boot: @Configuration, @ComponentScan, and @EnableAutoConfiguration

This tutorial explains Spring Boot's three core annotations—@Configuration, @ComponentScan, and @EnableAutoConfiguration—by showing how Java Config replaces XML, demonstrating bean creation, lifecycle management, component scanning, and auto‑configuration with practical code examples for a Spring application.

Backend DevelopmentConfigurationJava
0 likes · 6 min read
Understanding the Three Core Annotations of Spring Boot: @Configuration, @ComponentScan, and @EnableAutoConfiguration
JavaEdge
JavaEdge
Oct 25, 2020 · Backend Development

How to Eliminate Duplicate Code with Factory & Template Method Patterns in Java

This article explains why duplicate code harms maintainability, then demonstrates step‑by‑step refactoring techniques—using factory and template method patterns, custom annotations with reflection, and BeanUtils—to consolidate business logic for different cart types and API calls while preserving extensibility.

Factory PatternJavaReflection
0 likes · 15 min read
How to Eliminate Duplicate Code with Factory & Template Method Patterns in Java
Top Architect
Top Architect
Oct 24, 2020 · Backend Development

Designing a Unified API Response Format for Java Backend Services

This article explains how to create a consistent JSON response structure for Java backend APIs, covering status‑code conventions, a Result wrapper class, static helper methods, a custom @ResponseResult annotation, response‑body advice, and tips for simplifying controller code and handling exceptions.

API designJavaSpring
0 likes · 7 min read
Designing a Unified API Response Format for Java Backend Services
Top Architect
Top Architect
Oct 18, 2020 · Backend Development

Understanding Spring @Enable Annotation Logic and the Role of ConfigurationClassPostProcessor

This article explains how Spring's @Enable annotations are driven by @Import, walks through the entry points in spring.handlers, details the processing flow of ConfigurationClassPostProcessor, distinguishes full and lightweight configuration modes, and describes the CGLIB enhancement that ensures proper @Bean method semantics.

BeanDefinitionCGLIBJava
0 likes · 10 min read
Understanding Spring @Enable Annotation Logic and the Role of ConfigurationClassPostProcessor
Top Architect
Top Architect
Oct 17, 2020 · Backend Development

Understanding Java Annotations: Benefits, Types, Custom Annotations and Runtime Parsing

This article explains the purpose and advantages of Java annotations, introduces common JDK and third‑party annotations, classifies them by lifecycle and source, shows how to define custom annotations with meta‑annotations, and demonstrates parsing them at runtime using reflection with concrete code examples.

CustomAnnotationJavaannotations
0 likes · 9 min read
Understanding Java Annotations: Benefits, Types, Custom Annotations and Runtime Parsing
Code Ape Tech Column
Code Ape Tech Column
Oct 15, 2020 · Backend Development

Master Spring Boot Auto-Configuration: 6 Essential Annotation Patterns

This article explains six key patterns for customizing Spring Boot auto‑configuration, covering how to locate auto‑configuration classes, the role of @Conditionalxxx, @EnableConfigurationProperties, @Import, @AutoConfigurexxx annotations, and the significance of internal static configuration classes, with concrete code examples.

Auto-ConfigurationJavaSpring Boot
0 likes · 10 min read
Master Spring Boot Auto-Configuration: 6 Essential Annotation Patterns
Top Architect
Top Architect
Oct 12, 2020 · Backend Development

Comprehensive Guide to Common Spring Framework Annotations

This article provides a comprehensive overview of the most commonly used Spring Framework annotations, including core, stereotype, Spring Boot, MVC/REST, data access, scheduling, and testing annotations, with explanations and code examples illustrating their usage in Java backend development.

DependencyInjectionJavaSpring
0 likes · 12 min read
Comprehensive Guide to Common Spring Framework Annotations
Programmer DD
Programmer DD
Oct 7, 2020 · Backend Development

Spring Boot Annotations: @SpringBootApplication, @RestController & JPA Basics

This article provides a comprehensive overview of essential Spring Boot and Spring MVC annotations—including @SpringBootApplication, @RestController, @RequestMapping, @Autowired, and JPA annotations—explaining their purposes, usage examples, and how they simplify configuration, component scanning, request handling, and database mapping in Java backend development.

Backend DevelopmentJavaSpring Boot
0 likes · 10 min read
Spring Boot Annotations: @SpringBootApplication, @RestController & JPA Basics
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Sep 18, 2020 · Backend Development

Optimizing Service Calls with ThreadLocal Cache and Custom Annotations in Java

The article explains how to reduce redundant service calls in Java back‑end systems by passing required data from upper layers, applying cache annotations, and implementing an elegant ThreadLocal‑based caching mechanism using custom annotations, aspects, and filters to improve performance without extensive code changes.

AspectJJavaThreadLocal
0 likes · 9 min read
Optimizing Service Calls with ThreadLocal Cache and Custom Annotations in Java
Top Architect
Top Architect
Sep 8, 2020 · Backend Development

Comprehensive Guide to Spring Boot and JPA Annotations

This article provides a detailed overview of common Spring Boot, Spring MVC, and JPA annotations—including @SpringBootApplication, @RestController, @RequestMapping, and JPA mapping annotations—explaining their purposes, usage patterns, and example code snippets for building Java backend applications.

JavaSpring Bootannotations
0 likes · 9 min read
Comprehensive Guide to Spring Boot and JPA Annotations
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Aug 31, 2020 · Backend Development

Using Java Annotations for Log Masking and Bank API Request Simplification

This article explains how to employ custom Java annotations together with reflection to mask sensitive fields in logs, define flexible desensitization rules, and dramatically reduce repetitive code when building fixed‑length, signed bank API requests, improving maintainability and extensibility of backend services.

Backend DevelopmentBank APICode Reuse
0 likes · 21 min read
Using Java Annotations for Log Masking and Bank API Request Simplification
Selected Java Interview Questions
Selected Java Interview Questions
Aug 6, 2020 · Backend Development

Understanding SpringBoot @SpringBootApplication, Core Annotations and the Startup Process

This article explains the composition of the @SpringBootApplication annotation, details the roles of @Configuration, @ComponentScan and @EnableAutoConfiguration, and walks through the SpringApplication.run execution flow and the underlying auto‑configuration mechanism that powers Spring Boot applications.

AutoConfigurationJavaannotations
0 likes · 16 min read
Understanding SpringBoot @SpringBootApplication, Core Annotations and the Startup Process
Programmer DD
Programmer DD
Aug 6, 2020 · Backend Development

When to Use @Validated vs @Valid for Nested Validation in Spring

This article explains the differences between Spring's @Validated and the standard @Valid annotations, covering grouping support, where each can be applied, and how to enable nested validation for complex objects in controller parameters.

Nested ValidationSpringannotations
0 likes · 6 min read
When to Use @Validated vs @Valid for Nested Validation in Spring
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Aug 2, 2020 · Backend Development

Pros and Cons of Using Lombok in Java Development

This article examines Lombok's ability to auto‑generate boilerplate code such as getters, setters, toString, and equals, demonstrates its usage with Maven dependencies and annotated examples, and discusses its advantages and drawbacks—including IDE reliance, JDK compatibility, and debugging challenges—before concluding with a recommendation for its selective use.

Backend DevelopmentJavaLombok
0 likes · 9 min read
Pros and Cons of Using Lombok in Java Development
Senior Brother's Insights
Senior Brother's Insights
Jul 26, 2020 · Backend Development

How Spring Boot Auto‑Configuration Works: Deep Dive into @EnableAutoConfiguration

This article explains Spring Boot's auto‑configuration mechanism, detailing the roles of starters, spring.factories, @EnableAutoConfiguration, related annotations, and the AutoConfigurationImportSelector, while showing source code examples and how to customize or disable specific auto‑configurations.

Auto-ConfigurationBackend DevelopmentJava
0 likes · 12 min read
How Spring Boot Auto‑Configuration Works: Deep Dive into @EnableAutoConfiguration
Architecture Digest
Architecture Digest
Jun 25, 2020 · Backend Development

The Hidden Pitfalls of Using Project Lombok in Java Development

After a year of using Project Lombok, the author reflects on how the library initially reduces boilerplate but ultimately introduces version incompatibilities, forced dependencies, reduced readability, tighter coupling, and technical debt, urging developers to weigh its benefits against long‑term maintenance risks.

JavaLombokannotations
0 likes · 10 min read
The Hidden Pitfalls of Using Project Lombok in Java Development
vivo Internet Technology
vivo Internet Technology
Jun 10, 2020 · Backend Development

Understanding Spring Boot Configuration Class Parsing and Core Annotations

Spring Boot parses @SpringBootApplication by combining @SpringBootConfiguration, @EnableAutoConfiguration, and @ComponentScan, then processes @Import, @Conditional, and bean post‑processors, uses SpringFactoriesLoader for auto‑configuration, and follows an eight‑step configuration‑class parsing flow to register beans during startup.

Auto-ConfigurationBean ProcessingConfiguration
0 likes · 35 min read
Understanding Spring Boot Configuration Class Parsing and Core Annotations
Java Architect Essentials
Java Architect Essentials
Mar 31, 2020 · Backend Development

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

This article provides a detailed overview of common Spring Boot, Spring MVC, and JPA annotations—including their purposes, usage patterns, and code examples—helping developers understand how to configure, map, and manage beans, controllers, and persistence in Java backend applications.

Backend DevelopmentSpring Bootannotations
0 likes · 9 min read
Comprehensive Guide to Spring Boot, Spring MVC, and JPA Annotations