This article explains how Lombok’s generation of getter/setter methods for fields whose second character is uppercase can cause MyBatis to map properties incorrectly, leading to null values, and also examines why the @Accessor(chain=true) annotation breaks EasyExcel’s reflection, offering concrete solutions for each case.
When @Data and @Builder are used together on a Lombok‑annotated class, the generated code can lose getters, setters, and the no‑argument constructor, leading to compilation failures; the article explains the cause and shows how to fix it with @NoArgsConstructor and @RequiredArgsConstructor.
The article explains how Lombok’s @Data annotation generates getter and setter methods with a lowercase first letter for camel‑case fields, causing Jackson to serialize JSON property names in all lowercase, and offers three fixes: write methods manually, use @JsonProperty, or rename fields to avoid lower‑upper patterns.
This article explains how Lombok’s unconventional getter/setter method names cause MyBatis to store enum fields as null, why the @Accessor(chain=true) annotation breaks EasyExcel exports, and provides concrete code‑level solutions to resolve both issues in Java backend projects.
This tutorial explains why System.out.println() is unsuitable for production logging, shows how to add SLF4J and Logback dependencies, configure logback.xml, use Lombok's @Slf4j annotation to generate a logger, and provides practical code examples for unified API logging and exception tracking.
This article explains how Lombok generates getter and setter method names for fields with a lowercase first letter and uppercase second letter, causing mismatches with MyBatis property parsing and EasyExcel’s cglib reflection, and provides practical solutions.
This guide explains why logging is essential in Java, explores its various uses such as system monitoring, data collection, and audit, demonstrates how to print logs with SLF4J in Spring Boot, and provides detailed instructions for configuring log levels, persistence, file rotation, formatting, and Lombok shortcuts.
Learn why logging is essential in Java applications, explore Spring Boot’s built‑in SLF4J framework, discover how to print, configure levels, persist logs, customize formats, manage file rotation, and simplify logging with Lombok, all through clear examples and practical guidance.
This article explains why traditional System.out printing is insufficient, introduces Spring Boot's built‑in SLF4J/Logback logging, demonstrates how to obtain and use a logger, details log levels, configuration of log levels, file persistence, rolling policies, formatting, and shows how Lombok's @Slf4j annotation can simplify logger usage.
This article examines the drawbacks of using Lombok in Java projects, demonstrates how replacing Lombok annotations with Java Records, explicit constructors, and MapStruct improves code readability, IDE support, and runtime safety, and shares the measurable benefits of the migration.
The article analyzes a Lombok @Data‑generated getter/setter naming mismatch that causes MyBatis to store a null enum field, walks through debugging, examines MyBatis’s PropertyNamer source, demonstrates the issue with test code, and then explains a similar @Accessor(chain=true) problem in EasyExcel, offering concrete workarounds for both.
This article explores how Java Records and Lombok’s @Value annotation enable developers to create immutable objects, covering the definition of immutability, its benefits for thread safety and code simplicity, traditional implementation pitfalls, and concise modern approaches with practical code examples.
This article explains how Lombok’s automatic getter/setter generation can cause MyBatis to store enum fields as null, details the underlying JavaBeans naming conflict, and also reveals why EasyExcel fails with @Accessor(chain=true) annotations, offering practical solutions for both problems.
This article explains the hidden pitfalls of Lombok’s @Builder annotation, why it often violates the Builder pattern, and presents @Accessors and manual fluent setters as safer, more flexible alternatives for Java backend development.
This article provides a concise overview of the most commonly used annotations in MyBatis, Spring MVC, Spring, SpringBoot, and Lombok, explaining their purposes and typical usage scenarios for Java backend development.
The author shares a personal journey from early backend work to full‑stack responsibilities, critiques heavyweight admin frameworks, and explains how they rebuilt a lightweight enterprise admin using MyBatisPlus, Lombok, and streamlined architecture, while outlining future enhancements such as email, payment, multi‑tenant, and distributed scheduling.
This article explains how to activate Spring Boot DevTools for hot deployment, integrate Lombok to simplify Java beans, and add the Spring Configuration Processor for property metadata, providing step‑by‑step IDE settings, Maven dependencies, and configuration snippets for a smoother backend development experience.
This article explains why repetitive logger boilerplate in Spring Boot is a problem, introduces Lombok's @Slf4j annotation that auto‑generates a logger, shows basic and advanced usage with code examples, and outlines the benefits for real‑world backend projects.
This article examines the drawbacks of Lombok, demonstrates how replacing Lombok annotations with Java Records and MapStruct improves readability, type safety, and debugging, and shows the concrete benefits of reducing boilerplate and achieving compile‑time safety in Java backend projects.
This article examines the drawbacks of Lombok—such as reduced readability, IDE instability, and debugging challenges—and demonstrates how replacing Lombok annotations with Java Records, explicit constructors, and MapStruct for mapping yields cleaner, type‑safe, and maintainable code while eliminating boilerplate.
After a year of using Project Lombok, the author reflects on its initial appeal for reducing Java boilerplate, then reveals how hidden technical debt, version incompatibilities, reduced readability, and increased coupling can outweigh its benefits, urging teams to weigh its adoption carefully.
This article explains why Lombok's @Builder annotation ignores field default values in Java classes, demonstrates the issue with sample code, and shows how using @Builder.Default resolves the problem by generating static default methods in the compiled builder class.
This article demonstrates how Lombok’s advanced annotations such as @RequiredArgsConstructor(onConstructor=@__(@Autowired)), @Delegate, @Cleanup, and the combination of @Builder with @Singular can automatically generate Spring‑compatible constructors, delegate methods, manage resources, and build immutable objects, thereby reducing boilerplate and improving code readability in Java backend development.
Explore how Lombok’s powerful annotations—@onX, @Delegate, @Cleanup, @Singular, and @Builder—can dramatically simplify Java code, enable seamless Spring dependency injection, manage resources automatically, and streamline object construction, while highlighting best practices and potential pitfalls for maintainable backend development.
This article examines how Lombok reduces boilerplate in Java code, demonstrates the transformation of a typical JavaBean before and after Lombok, and critically discusses five major drawbacks—including JDK compatibility, forced dependency, reduced readability, increased coupling, and technical debt—guiding developers to weigh its benefits against long‑term maintenance costs.
This article demonstrates how Lombok annotations such as @RequiredArgsConstructor, @Delegate, @Cleanup, @Singular, and @Builder can be combined with Spring components to reduce boilerplate, automatically inject dependencies, manage resources, and build immutable objects, providing practical code examples and usage guidelines.
This article presents fourteen practical Java Spring development best‑practice tips—including using @ConfigurationProperties, Lombok's @RequiredArgsConstructor, modularizing code, throwing exceptions instead of returning error codes, minimizing unnecessary database calls, avoiding null returns, reducing if‑else chains, and leveraging IDE features—to help developers write cleaner, more maintainable backend code.
This article explains how to enable hot deployment in Spring Boot using DevTools, configure automatic recompilation in IDEs, simplify Java bean code with Lombok, and add the Spring Configuration Processor for property metadata, providing Maven snippets and step‑by‑step instructions.
This article presents fourteen practical Java backend optimization techniques—including configuration‑file management, Lombok’s @RequiredArgsConstructor, modular code design, exception handling, reducing DB queries, avoiding null returns, minimizing if‑else, slimming controllers, IDE shortcuts, source‑code reading, design patterns, and efficient collections—each illustrated with clear code examples.
This guide explains how to activate SpringBoot DevTools for hot deployment, integrate Lombok to reduce boilerplate code, and configure the Spring Configuration Processor for property metadata, including necessary Maven dependencies, IDE settings, and build plugin adjustments.
This article explains how Lombok's @RequiredArgsConstructor can replace repetitive @Autowired field injections in Spring services by generating a constructor for final fields, demonstrates the underlying annotation‑processing mechanism, and provides practical code examples for applying this technique in backend Java projects.
This article presents fourteen actionable techniques for improving Java backend code quality, including using configuration files, Lombok's @RequiredArgsConstructor, modular design, exception handling, reducing unnecessary database calls, avoiding null returns, simplifying if‑else logic, minimizing controller logic, leveraging IDE features, reading source code, applying design patterns, embracing new knowledge, mastering fundamentals, and efficiently checking element existence, supplemented with concrete code examples.
This article explains why combining Lombok's @Data and @Builder annotations can remove the automatically generated no‑args constructor, demonstrates the resulting compilation errors, and provides two practical solutions using @Tolerate or a combination of @RequiredArgsConstructor and @NoArgsConstructor, while also describing Lombok's annotation‑processing mechanism.
This article analyzes a NullPointerException triggered by Lombok's @Accessors(chain=true) when using BeanCopier, explains how the altered setter return type prevents JDK Introspector from recognizing write methods, and provides two practical solutions to fix the issue.
This article demonstrates how to create a custom insertable annotation processor in Java that automatically injects the jar version into component constants at compile time, enabling Prometheus monitoring of version usage without manual updates.
This article explains how to create a custom insertable annotation processor in Java that automatically injects the jar version into component constants during the Gradle build, eliminating manual updates and enabling version monitoring via Prometheus.
After a year of using Project Lombok, the author reflects on how its annotations dramatically shrink boilerplate but also introduce version incompatibilities, hidden dependencies, reduced readability, tighter coupling, and technical debt, urging developers to weigh its benefits against long‑term maintenance risks.
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.
This article presents fourteen actionable Java backend code‑optimization techniques—including configuration‑file management, Lombok’s @RequiredArgsConstructor, modularization, exception handling, database query reduction, null‑avoidance, strategic use of design patterns, IDE shortcuts, and efficient collection handling—to help developers write cleaner, more maintainable, and higher‑performance code.
This article presents fourteen actionable Java coding‑style and architecture tips—ranging from using configuration properties and Lombok constructors to modularizing methods, throwing exceptions, reducing DB calls, avoiding null returns, and leveraging IDE suggestions—to help developers write cleaner, more robust backend code.
This article explains the hidden pitfalls of Lombok’s @Builder annotation, demonstrates how it deviates from the classic Builder pattern, and presents safer alternatives such as @Accessors with practical code examples and guidance for mixing required and optional parameters in Java projects.
This article explains how to build a Maven‑based tool that scans a Java codebase, removes trivial getter and setter methods, adds Lombok’s @Data annotation, and rewrites the source files using JavaParser, complete with implementation steps, code examples, and usage instructions.
This article walks through a real‑world NPE caused by Lombok’s @Builder ignoring field initializers, explains the underlying double‑initialisation bug, shows how @Builder.Default restores the defaults, and outlines Lombok’s compile‑time annotation processing mechanism.
This article showcases clever Lombok tricks—including @onConstructor, @Delegate, @Cleanup, @Singular, @Builder, and @With—demonstrating how they simplify Java code, improve readability, and integrate with Spring for dependency injection while warning against overuse.
This article demonstrates advanced Lombok annotations such as @RequiredArgsConstructor, @Delegate, @Cleanup, @Builder, and @Singular, showing how they can be combined with Spring to reduce boilerplate, manage resources, and create fluent builders in Java backend projects.
This article presents a developer‑centric guide to designing a Java code‑optimization tool that automatically replaces trivial getter/setter methods with Lombok’s @Data annotation, detailing the scanning, filtering, modification steps, JavaParser usage, Maven integration, and practical usage instructions.
This article compares Java's native record feature with the Lombok library, showing how records can reduce boilerplate code, outlining scenarios where records can replace Lombok, and discussing the limitations of each approach for clean and maintainable backend development.
This article presents a comprehensive set of Spring Boot best practices for developers, covering proper package structuring, design patterns, starter dependencies, production-ready versions, Lombok usage, constructor injection, slf4j logging, controller responsibilities, service layer logic, null‑pointer avoidance, collection handling, pagination, caching, custom exception and response handling, code cleanup, meaningful naming, case conventions, simplicity, formatting standards, and tooling such as SonarLint.
This article explains the initialization order of Java classes, the pitfalls of using @Autowired for dependency injection, compares it with @Resource, and demonstrates setter, constructor, and Lombok-based injection methods with code examples to help avoid null‑pointer exceptions and improve coupling.
This article introduces Lombok, explains how it leverages Java's annotation‑processing (JSR‑269) and abstract syntax tree (AST) modifications to generate boilerplate code at compile time, and provides a step‑by‑step guide to manually implement a @Getter annotation processor with full Maven project examples.
This article explains how Lombok’s unconventional getter/setter naming for fields with a lowercase‑first, uppercase‑second pattern causes MyBatis to map enum properties as null, and how the @Accessor(chain=true) annotation in EasyExcel triggers cglib reflection issues, then provides practical workarounds for both problems.
Java 21, the latest LTS release, introduces virtual threads, sequenced collections, record patterns, and other enhancements; the article explains these new features, guides developers on configuring IDEs and runtimes with Azul Zulu and IntelliJ IDEA, and resolves Lombok incompatibility by updating to version 1.18.30.
The article explains the pitfalls of Lombok’s @Builder annotation—such as loss of default values, mutable builders, and limited applicability—and demonstrates how using @Accessors with chainable setters provides a safer, more flexible alternative for Java backend development.
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.
This article presents a comprehensive collection of Spring Boot best practices, covering package organization, design patterns, starter usage, dependency management, Lombok integration, constructor injection, logging with SLF4J, controller responsibilities, service layer design, null‑safety, collection handling, pagination, caching, exception handling, response objects, code cleanup, naming conventions, formatting, and tooling such as SonarLint.
This article explains how Lombok's @RequiredArgsConstructor can replace multiple @Autowired and @Resource annotations by promoting constructor injection, compares field, constructor, and setter injection in Spring, and demonstrates the resulting cleaner code with practical examples.
This article introduces the open‑source MapStruct library, shows how to configure Maven and Lombok dependencies, defines entity and DTO classes with Lombok annotations, creates a mapper interface, and demonstrates simple, list, multi‑source, and default‑value mappings with complete code examples.
This article explores how Lombok’s auto‑generated getter/setter methods can conflict with MyBatis property naming conventions and cause null values, examines the underlying reflection logic in MyBatis, and also reveals why the @Accessor(chain=true) annotation disrupts EasyExcel’s CGLIB‑based mapping, offering practical solutions.
This article explains how Lombok's generated getter and setter method names can conflict with MyBatis property resolution and cause issues when using EasyExcel's @Accessor(chain=true) annotation, and provides detailed code examples and solutions to resolve these incompatibilities.
This article provides comprehensive guidance on Java backend development, covering IDE selection, bean and DTO conversion techniques, validation with JSR‑303, extensive Lombok usage, builder patterns, proxy design, refactoring strategies, and the balance between business‑driven and technology‑driven development.
The article explains Spring's three dependency injection methods, highlights the drawbacks of field injection, recommends constructor injection, and demonstrates how Lombok's @RequiredArgsConstructor can generate the required constructor to eliminate @Autowired and @Resource annotations, simplifying code and preventing NullPointerExceptions.
This article explains Spring's three dependency injection methods—field, constructor, and setter injection—highlights the advantages of constructor injection for avoiding null pointers and circular dependencies, and demonstrates how Lombok's @RequiredArgsConstructor can simplify bean wiring in Java backend development.
This article explains the Lombok @Accessors annotation, detailing its source code, the meaning of its fluent, chain, and prefix attributes, and demonstrates how these settings affect generated getter and setter methods, while also providing usage examples and related promotional links.
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.
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.
The article explains common problems with Spring's @Autowired injection, compares it with @Resource, and presents alternative injection methods—including setter, constructor, and Lombok-based approaches—while providing code examples and best‑practice recommendations for reliable bean initialization.
The article explains common pitfalls of using Spring's @Autowired, compares it with the standard @Resource annotation, and demonstrates various injection techniques—including field, setter, constructor, and Lombok-based constructor injection—through detailed code examples and best‑practice recommendations.
This article demonstrates how to create a custom compile‑time annotation processor that automatically injects the jar version into Java component constants, enabling Prometheus monitoring of version usage without manual updates.
The brief explains how Lombok’s @Builder can clash with JSON libraries and how adding no‑args and all‑args constructors resolves it, shows how to adjust log levels at runtime via Arthas or Spring’s LoggingSystem, outlines JWT structure and security cautions, and warns of common Java 8 parallelStream performance and correctness pitfalls.
This article shows how to use Lombok's @Builder annotation in a SpringBoot project to create flexible object constructors, avoiding multiple overloaded constructors and allowing selective field assignment through a fluent builder API.
This article explains why using Lombok's @Data and @Builder together removes the default no‑argument constructor, demonstrates the compilation behavior, and provides two practical solutions—including @Tolerate and combining @RequiredArgsConstructor with @NoArgsConstructor—while also detailing Lombok's annotation‑processing mechanism.
The article explains that when using MapStruct with Lombok, Maven must list Lombok before MapStruct (or define annotationProcessorPaths) so Lombok’s annotation processor runs first, and then demonstrates basic and advanced mapping techniques, Spring integration, and singleton caching strategies.
This guide introduces twelve essential IntelliJ IDEA plugins—including Lombok, Free MyBatis, Translation, Alibaba Java Coding Guidelines, GenerateAllSetter, SequenceDiagram, CheckStyle‑IDEA, JRebel/XRebel, Codota, GsonFormat, Rainbow Brackets, and CodeGlance—that dramatically improve Java coding efficiency, reduce boiler‑plate, and streamline development workflows.
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.
This article explains the principles behind Java annotation processing tools such as APT, compares APT with AOP and Java agents, and provides a step‑by‑step guide to creating a custom Lombok‑style annotation processor that generates getters, setters, and toString methods at compile time.
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.
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.
This article explains how Lombok annotations such as @Data, @Builder, @Wither, and @Accessors can simplify Java bean creation for ORM entities, builder pattern utilities, wither-style object modification, and fluent accessor methods, while addressing common pitfalls like missing constructors and default values.
The July VS Code Java update introduces built‑in Lombok support, notification‑driven activation, language‑bar version management, toggleable settings, drag‑and‑drop file operations, inlay hint exclusions, function‑breakpoint debugging, expanded quick‑fix actions, and a Spring bean dependency view, all aimed at improving the Java developer experience.
This article explains what Lombok is, how it uses compile‑time annotations and the Java Annotation Processing Tool (APT) to automatically generate getters, setters, constructors and other boilerplate code, and provides step‑by‑step examples of defining custom annotations, processors, and compiling them to produce new classes.
This article explains how Lombok uses compile‑time annotations and the Java Annotation Processing Tool (APT) to automatically generate boilerplate code such as getters, setters, and constructors, and provides step‑by‑step examples of defining custom annotations, processors, and compiling them.
This article discusses practical techniques for Java developers, covering bean conversion using DTOs and Spring utilities, validation with JSR‑303, leveraging Lombok for cleaner code, applying design patterns, and systematic refactoring to improve readability, maintainability, and overall code quality in backend projects.
This article explores practical Java backend techniques, including IDE selection, domain vs entity naming, DTO conversion strategies with BeanUtils and custom interfaces, validation with JSR‑303, Lombok shortcuts, builder patterns, static constructors, and design‑pattern considerations, offering concrete code examples and refactoring tips for seasoned developers.
The article explains why a Spring Cloud project upgraded from Java 8 to Java 11 gets stuck during Maven compilation, shows how to enable detailed compiler logs with Maven‑compiler‑plugin settings, presents the lengthy compilation output, and advises cautious use of Lombok’s @Builder.Default to avoid similar hangs.
This article explains how to add SpringBoot DevTools for hot deployment, integrate Lombok to simplify JavaBean code, and configure the Spring Configuration Processor for property metadata, providing step‑by‑step instructions, IDE settings, and Maven dependency snippets for a smoother development experience.
This guide shows how to enable hot‑deployment in Spring Boot using DevTools, simplify JavaBean code with Lombok, and add the Spring Configuration Processor for better property‑binding support, including Maven dependencies, IDE settings, and example snippets.
This article presents six Java object‑creation techniques—including direct instantiation, cloning, reflection‑based allocation, dynamic class loading, constructor invocation via reflection, and deserialization—explaining each method with code examples and practical notes for developers.
This article explains how to enable SpringBoot DevTools for hot deployment, integrate Lombok to simplify JavaBean code, and add the Spring Configuration Processor to provide property‑binding assistance, including Maven dependency snippets and IDE configuration steps for a smoother development experience.
This article introduces how to enable SpringBoot DevTools for hot deployment, integrate Lombok to reduce boilerplate code, and use the Spring Configuration Processor for property binding hints, providing Maven dependencies, IDE settings, and example code snippets for Java backend development.
This article shares a collection of practical Java backend development habits, covering configuration with @ConfigurationProperties, Lombok's @RequiredArgsConstructor, code modularization, exception throwing, reducing DB queries, avoiding null returns, simplifying if‑else, keeping controllers thin, IDE tips, source code reading, design patterns, and fundamental coding techniques.
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.
This article introduces the open‑source MapStruct library for Java, shows how to configure Maven and Lombok, provides step‑by‑step code examples for basic and advanced entity‑to‑DTO mappings—including list conversions, multi‑object mappings, and default values—so developers can replace boilerplate conversion code with clean, type‑safe mappings.
This article reflects on a year of using Project Lombok, showing how its annotations can dramatically shrink Java boilerplate but also introduce version incompatibilities, forced dependencies, reduced readability, tighter coupling, and technical debt that may outweigh its short‑term convenience.
This article introduces the open‑source MapStruct library for Java, showing how to configure Maven dependencies, define entity and DTO classes with Lombok, create mapper interfaces, and perform simple and advanced object conversions such as list mapping, multi‑object merging, and default value handling.
This article examines the advantages and hidden risks of using Lombok in Java projects, illustrating how its annotations can dramatically reduce boilerplate code while also introducing version compatibility issues, forced dependencies, reduced readability, increased coupling, and technical debt, and suggests alternative approaches for cleaner code.
The article reviews a year of using Project Lombok, showing how its annotations dramatically shrink Java boilerplate but also introduce version incompatibilities, forced dependencies, reduced readability, tighter coupling, and technical debt, urging careful consideration before adoption.
This article introduces IntelliJ IDEA plugin installation methods—online and offline—and provides concise overviews of more than twenty essential plugins, including Lombok, RestfulTool, MyBatis helpers, code quality tools, and visual enhancements, helping Java developers boost productivity and code quality.
The article challenges typical objections to using Lombok—such as JDK version issues, forced plugin installation, reduced readability, increased coupling, and perceived technical debt—by providing detailed rebuttals that argue Lombok remains practical and beneficial for Java backend development.
This article explains why Spring's BeanUtils.copyProperties cannot copy static inner class fields or list generics without proper getters/setters, demonstrates the problem with a reproducible demo, and provides practical solutions for correctly copying such objects in Java backend projects.
The article examines typical criticisms of the Lombok library—JDK compatibility, forced adoption, reduced readability, increased coupling, and perceived drawbacks—while providing detailed rebuttals that argue Lombok remains useful for Java backend development despite these concerns.
