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.
The article systematically refutes typical criticisms of Lombok—such as JDK compatibility, forced adoption, reduced readability, increased coupling, and technical debt—by arguing that these concerns are overstated and that Lombok remains a valuable tool for Java backend development.
The article challenges typical criticisms of Lombok—JDK compatibility, forced adoption, reduced readability, increased coupling, and perceived technical debt—by providing counter‑arguments that emphasize stable JDK usage, minimal learning curve, alternative Lombok features, and the practicality of the library in modern Java development.
This article explains why Lombok-generated getter/setter methods for fields whose second character is uppercase can cause MyBatis to store null values, shows the MyBatis PropertyNamer logic that leads to the problem, and also describes how the @Accessor(chain=true) annotation interferes with EasyExcel's reflection‑based export, offering practical workarounds for both issues.
This article examines how Lombok reduces boilerplate in Java by generating getters, setters, equals, hashCode, and toString methods, but also introduces version compatibility issues, hidden dependencies, reduced readability, increased coupling, and potential technical debt for backend developers.
This article explains how Lombok reduces Java boilerplate, compares Spring's field, setter, and constructor injection, and demonstrates using @RequiredArgsConstructor with final fields to create clean, concise constructors without extra annotations, improving code readability and maintainability.
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.
This article examines Lombok—a popular Java library that generates boilerplate code—by showing before‑and‑after examples, then detailing five major drawbacks such as JDK incompatibility, forced dependencies, reduced readability, tighter coupling, and overall cost‑benefit imbalance that can turn a seemingly elegant solution into a maintenance liability.
This article explains why recent IntelliJ IDEA versions stopped supporting the Lombok plugin, details the communication between the plugin author and JetBrains, describes the bug in the plugin platform, and provides the steps to obtain the fixed plugin version.
This article introduces five essential IntelliJ IDEA plugins—Key Promoter X, Lombok, Rainbow Brackets, Codota, and String Manipulation—explaining their features, installation steps, and how they can significantly improve Java developers' coding efficiency and productivity.
This guide explains how to install and use a curated list of IntelliJ IDEA plugins—including Lombok, RestfulTool, MyBatis helpers, and productivity enhancers—detailing both online and offline installation methods, configuration tips, and practical examples for 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.
This guide explains what Delombok is, how it transforms Lombok-annotated Java classes into standard Java source files, and provides step‑by‑step instructions—including environment setup, project preparation, script creation, and execution—to de‑compile Lombok code and resolve compatibility issues during upgrades.
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.
This article examines Project Lombok’s ability to cut boilerplate in Java, walks through before‑and‑after code examples, and reveals five major drawbacks—including JDK compatibility, forced adoption, readability issues, increased coupling, and technical debt—helping developers decide whether to embrace or avoid Lombok.
This article examines the trade‑offs of using Project Lombok in Java projects, showing how its syntactic sugar reduces boilerplate but can introduce technical debt, version‑compatibility issues, hidden coupling, and readability problems that may outweigh its short‑term benefits.
After a year of using Project Lombok, the author reflects on how the library initially simplifies Java boilerplate but eventually introduces technical debt, version‑compatibility issues, hidden complexity, and tighter coupling, urging teams to weigh its short‑term convenience against long‑term maintainability.
The article compiles a comprehensive set of Java refactoring techniques—ranging from ternary operators, Optional handling, and Stream‑API transformations to Lombok annotations, generics, utility libraries, and design‑pattern applications—aimed at reducing boilerplate, improving readability, and eliminating dead code while preserving functionality and performance.
This guide introduces ten essential IntelliJ IDEA plugins—including JRebel, Codota, Lombok, and MyBatis—that streamline Java development, enhance code quality, and accelerate productivity through features like hot deployment, AI code completion, automatic boilerplate generation, and convenient project navigation.
This tutorial walks you through installing the EasyCode IntelliJ plugin, setting up a MySQL database, configuring a Spring Boot project, adding necessary Maven dependencies and YAML settings, and using EasyCode to automatically generate entity, DAO, service, controller, and mapper code without manual coding.
This guide walks you through installing the EasyCode plugin in IntelliJ IDEA, setting up a MySQL database, configuring Spring Boot dependencies, and using EasyCode to automatically generate entity, controller, service, DAO, and mapper classes, complete with Maven and application.yml settings.
This guide walks through installing the EasyCode IntelliJ plugin, setting up a MySQL database, configuring a Spring Boot project, adding necessary Maven dependencies and application.yml settings, and using EasyCode to automatically generate CRUD code for the defined tables.
This tutorial explains how to install the EasyCode plugin, set up a MySQL database, configure IDEA, generate entity, controller, service, DAO, and mapper code for a Spring Boot project, and adjust Maven and YAML settings to run the application successfully.
This article explains what Lombok is, how to integrate it into a Maven project, and demonstrates its most useful annotations—such as @Getter, @Setter, @Builder, @AllArgsConstructor, @NoArgsConstructor, @RequiredArgsConstructor, @NonNull, @Cleanup, and @SneakyThrows—to dramatically reduce boilerplate, simplify object creation, enforce null checks, manage resources, and streamline exception handling in Java applications.
This article examines Lombok—a Java library that reduces boilerplate through annotations—by outlining its installation steps, showcasing code examples, and critically discussing its drawbacks such as team dependency, readability, debugging challenges, upgrade constraints, and potential violation of encapsulation principles.
This article guides readers through configuring a Maven project for MyBatis-Plus by adding the necessary dependencies, installing Lombok, and addressing typical IDE and dependency‑resolution errors, providing code snippets and screenshots to help Java backend developers get started quickly.
This article explains why Spring's BeanUtils.copyProperties cannot copy static inner class fields and list properties, demonstrates the pitfalls with missing getters/setters, and provides a step‑by‑step solution to correctly copy such objects in Java applications.
The author, a former PHP engineer at Mafengwo, chronicles a two‑day crash‑course in Java and Spring Boot, detailing the adoption of Lombok, Druid, Maven, and various annotations while navigating pitfalls such as bean scopes, database connections, and data format mismatches before successfully launching the new service.
This tutorial walks you through Spring Boot 2.x fundamentals, explaining core MVC annotations, defining a User entity with Lombok, creating a full RESTful CRUD controller, and writing comprehensive MockMvc unit tests to verify each endpoint.
The article shares practical clean‑code guidelines for Java developers, covering how code serves as team communication, the importance of clear naming, keeping methods short, reducing nested if/else, extracting try/catch blocks, encapsulating many parameters, and leveraging Lombok and Apache Commons utilities.
This article explains why Lombok was created to eliminate repetitive Java code, shows how to add the Maven dependency, configure IDE support, describes its annotation‑processing mechanism, and demonstrates the most common Lombok annotations with before‑and‑after code examples.
This article discusses practical Java programming techniques, including proper DTO conversion, use of BeanUtils, Lombok annotations, builder patterns, static constructors, validation with JSR‑303, and design considerations such as refactoring, strategy versus state patterns, to help developers write cleaner, more maintainable backend code.
This tutorial explains how to provide default values for fields when using Lombok's @Builder pattern in Java, covering Maven setup, plain POJO definition, Lombok annotations, Builder.Default, custom builder class names, the toBuilder feature, and the trade‑offs of each approach.
This article presents seven practical techniques—including using IntelliJ IDEA, upgrading to JDK 8+, adopting Maven/Gradle, leveraging Lombok, writing unit tests, refactoring incrementally, and gathering regular customer feedback—to help developers produce shorter, clearer, and more maintainable Java code.
This article introduces Lombok—a Java library that eliminates boilerplate code—by showing how to install it in IntelliJ, demonstrating the most common annotations with runnable examples, and revealing the annotation‑processing mechanism that generates the bytecode during compilation.
This article introduces Lombok as a Java code‑simplification tool, explains how to install the IDEA plugin and add the Maven dependency, demonstrates basic and advanced annotation usage, discusses domain‑driven design models, and shows how Lombok can be combined with FreeMarker and MyBatis for automatic code generation.
