5 posts tagged with "Best Practices"

Shared code starts with good intentions: stop copying the same tracing setup, validation rules, or test helpers into every service. Then, six months later, you have a mystery JAR that pulls in half of Spring, overrides application beans, and requires a Slack message to configure.

The problem is not sharing code. The problem is treating a shared library as a bucket of reusable classes instead of a product with consumers, compatibility promises, and a sensible onboarding path.

In this post we'll look at:

• A module layout that keeps framework code contained — core code stays portable while Spring Boot integration stays convenient
• Starters and auto-configuration that help instead of hijack — useful defaults with clear escape hatches
• Configuration and test support as part of the public API — discoverable properties and reusable conventions
• Documentation and releases that scale to more than one project — fewer archaeology sessions and safer upgrades

Every time a @Transactional method runs in your Spring Boot application, Spring grabs a JDBC connection from the pool. Immediately. Before your code even executes. Before it knows whether you'll actually touch the database. That connection sits there, reserved for you, doing absolutely nothing — while some other thread might be blocked waiting for a free connection. Your Hibernate second-level cache just returned the result from memory? Doesn't matter. Connection was already checked out. That's the equivalent of renting a car to walk across the street.

Spring Boot 4.1 fixes this with first-class support for lazy JDBC connections. One property. Massive performance win.

In this post we'll look at:

• The problem with eager connections — why Spring grabs a connection before you need one
• What LazyConnectionDataSourceProxy does — the mechanism behind lazy fetching
• Spring Boot 4.1's auto-configuration — enabling it with a single property
• Before vs after — what you had to do manually (and why nobody bothered)
• Real-world scenarios where this shines — cache hits, conditional logic, and read/write routing

Java records, introduced in Java 16 (JEP 395), finally let you delete Lombok. You know, that library you added to avoid writing 50+ lines of getters, then spent hours debugging @Data annotation conflicts and weird IDE plugin issues. One line. No plugins. No magic. Just the Java compiler doing what it should have done 25 years ago.

In this guide, you'll learn:

• The problem records solve — why we needed them
• Core syntax and features — compact constructors, immutability, and generated methods
• Real-world patterns — DTOs, value objects, projections, and configuration
• When records fit (and when they don't) — practical guidance for your codebase

In Spring Framework, dependency injection (DI) is a fundamental concept that allows for the creation of loosely coupled components. Two common methods for DI are using the @Autowired annotation and constructor-based injection. This article explores when to use each method.

In Spring applications, proper transaction management is crucial for both data integrity and performance. This article explores how to optimize database operations using Spring's @Transactional annotation with a focus on read-only transactions and Hibernate optimizations.