Java Archives - Page 14 of 29

Ankur in Hibernate

persist, save, merge, saveOrUpdate in Hibernate 7: The Five Decisions That Cause Duplicate Inserts

Here is the table that every Hibernate tutorial promises and none of them finish: MethodEntity state: TransientEntity state: ManagedEntity state: Detachedpersist()Schedules INSERT; ID assigned at flush (SEQUENCE) or immediately (IDENTITY)No-op — entity already trackedThrows PersistentObjectExceptionsave()Schedules INSERT; returns ID immediately (may fire INSERT for IDENTITY)Returns existing ID; entity already trackedTreats as new: ignores existing ID, generates new one — duplicate insertmerge()Copies state to new managed entity; returns the managed copyReturns same instance (identity)Issues SELECT to load current DB state; merges over it; returns managed copyupdate()Throws TransientPropertyValueExceptionNo-op if already in session; throws NonUniqueObjectException if different instance same IDRe-attaches; schedules UPDATE; throws NonUniqueObjectException if conflicting instance existssaveOrUpdate()Calls save() pathNo-op if already in sessionCalls update() path; same NonUniqueObjectException risk Most of the bugs that come to production code review — duplicate inserts, silent data loss, unexpected exceptions — trace to a mismatch between what the developer expected from the column above and what the table actually says. The rest of this post is a catalog of the five most common mismatches, with code showing exactly what goes wrong and why.

Ankur in Java

A Developer’s Guide to Testing Spring REST Clients with @RestClientTest

In modern microservices architecture, it's rare for a service to live in complete isolation. Most applications need to communicate with other services over the network, typically via REST APIs. When you build a component that consumes an external REST API, a critical question arises: how do you test it reliably without actually making network calls to a live, and potentially unstable, external service? This is where Spring Boot's test slices come to the rescue. For testing your REST clients, the framework provides a powerful and elegant solution: the @RestClientTest annotation. Let's dive deep into how you can use it to write clean, fast, and reliable tests for your HTTP client components. What Exactly is @RestClientTest? @RestClientTest is a "test slice" annotation specifically designed to test REST client components. Instead of loading your entire Spring application context (like @SpringBootTest does), it focuses only on the beans relevant to REST client operations. This makes your tests significantly faster and less prone to side effects from unrelated configurations. When you use @RestClientTest, Spring Boot will auto-configure the following for you: The Client Under Test: The specific REST client bean you want to test. MockRestServiceServer: A bean that lets you mock the server-side responses. You can instruct it: "When my client calls /api/employees/1, respond with this specific JSON." RestTemplateBuilder: Used to help construct RestTemplate instances. Jackson/Gson Support: It automatically includes support for serializing and deserializing JSON, so you can test your client-side data mapping. In short, it provides the perfect, minimal environment to verify that your client builds the correct HTTP request and correctly parses the HTTP response — all without a single packet leaving your machine.

Ankur in Hibernate

Mastering Sorting in Hibernate 7: A Comprehensive Guide for Clean Data Retrieval

In the world of high-performance Java applications, how you retrieve data is just as important as how you store it. Whether you are building a financial dashboard or a simple e-commerce list, Sorting using Hibernate is a fundamental requirement that directly impacts user experience and system performance. With the release of Hibernate 7, the integration with Jakarta Persistence 3.2 has become even tighter, offering more intuitive ways to order your data. The Problem: The Chaos of Unordered Data Imagine a user navigating an e-commerce platform where products appear in a completely random order every time the page refreshes. Newest items are buried on page ten, and price-sensitive shoppers can't find the cheapest deals. Without structured sorting, your application feels broken, unprofessional, and frustrating. The Agitation: Why "Simple" Sorting Isn't Always Simple You might think, "I'll just sort the list in Java after fetching it." This is a classic performance trap. Fetching 100,000 records from a database into JVM memory just to sort them is a recipe for OutOfMemoryError and sluggish response times. Furthermore, handling null values, case-sensitive strings, and complex joins manually in SQL leads to "spaghetti code" that is hard to maintain and prone to bugs. Developers often struggle with deciding whether to sort at the Database level or the Application level—a choice that can make or break your application's scalability. The Solution: Efficient Sorting with Hibernate 7 The modern way to handle this is to delegate the heavy lifting to the database using Hibernate’s robust API. Hibernate 7 allows us to write clean, typesafe, and high-performance sorting logic.

Ankur in Hibernate

Master Hibernate 7 Pagination: The Ultimate Guide for High-Performance Java Apps

When your database grows from hundreds to millions of records, fetching everything in a single query isn't just slow—it’s a recipe for an OutOfMemoryError. Whether you are building a modern dashboard or a high-traffic e-commerce site, Hibernate 7 pagination is the essential technique to keep your application responsive and your memory footprint low. In this guide, we’ll explore how to implement efficient pagination using the latest Jakarta Persistence (JPA) standards. The Problem: The "Data Avalanche" Imagine a user searching for products on your site. If your backend attempts to load 50,000 rows into memory just to display the first 10, the server will lag, the database will lock up, and the user will likely bounce before the page even loads. For high-concurrency systems, even a few unoptimized queries can saturate the database connection pool, leading to a total system outage. The Agitation: Why "Limit 10" Isn't Enough Many developers treat pagination as an afterthought, adding a simple limit at the end of a query. However, inefficient queries lead to high CPU usage and increased cloud infrastructure costs. Without a structured approach to Hibernate pagination, you risk: The N+1 Problem: Accidentally triggering thousands of extra queries for related data while trying to paginate the main list. Broken Sort Orders: Unpredictable result sets when new data is inserted between page loads. The Memory Trap: Fetching millions of rows into the application layer just to discard 99% of them in Java code. If your application can't scale its data delivery, it can't scale its user base.

Ankur in Hibernate

Mastering Hibernate 7 Interceptors: Tracking and Auditing Data Changes with Ease

Have you ever spent hours debugging a production database, trying to figure out exactly when a record was modified or who triggered a specific state change? It’s a common nightmare for developers. When your application scales, managing cross-cutting concerns like auditing, logging, and security checks manually within your service layer becomes a tangled mess of "spaghetti code." Hibernate Interceptors are the secret weapon for developers who want to keep their business logic clean while maintaining absolute control over the persistence lifecycle. In this guide, we will explore how to leverage the latest features in Hibernate 7 to hook into session events, ensuring your data remains consistent and audited without the manual overhead. The Problem: The "Audit Trail" Mess In a typical Java application, data doesn't just sit there. It changes. Business requirements often demand that we track every insertion, update, and deletion. If you try to handle this inside your Service or DAO classes, you end up with repetitive code: Manually setting lastUpdatedBy on every save. Hard-coding logging logic for every delete operation. Scattering validation rules across multiple controller or service methods. This approach is error-prone, violates the DRY (Don't Repeat Yourself) principle, and makes your codebase a nightmare to maintain as it grows. It creates "technical debt" that slows down future feature development.

Ankur in Hibernate

Hibernate 7 Batch Insert: 1M Rows in 12s — Settings, Benchmarks, and the JDBC Trap

One million rows, PostgreSQL, HikariCP pool of 10, SEQUENCE generator: approximately 12 seconds with proper Hibernate batch configuration. Without it, the same job runs for over two minutes — and that's before accounting for the OutOfMemoryError you get around row 80,000 if you skip the flush/clear cycle. The configuration is four properties. The JDBC trap is one silent gotcha that disables batching without any error. The flush/clear cadence is one loop pattern. This post covers all three and the approximate numbers so you can reason about what your specific job should take. The Problem: The "Chatty" Database Trap When you persist objects in a standard loop, Hibernate sends one INSERT or UPDATE statement per object. This creates massive network latency. Imagine you have 10,000 records and a 5ms network round-trip delay. You have already lost 50 seconds just to "talk" to the database, even before the engine starts processing the data. This is often called the "N+1 Problem of Writing." Each individual insert requires the database to parse the SQL, execute it, update indexes, and send an acknowledgment. Multiplying this overhead by thousands of records is the fastest way to kill application performance.

Ankur in Hibernate

Mastering Hibernate Search 7: Bring Modern Full-Text Search to Your Java Applications

Have you ever noticed how users abandon applications when the search bar feels "broken"? If your app relies on basic SQL LIKE %keyword% queries, you're likely frustrating your users with slow results, lack of typo tolerance, and irrelevant matches. In the modern web, a subpar search experience is a silent killer for user retention. Hibernate Search 7 is the widely adopted solution to this problem. By synchronizing your database entities with powerful search engines like Apache Lucene or Elasticsearch, it allows you to implement complex full-text search capabilities with just a few annotations. In this guide, we will explore how to integrate Hibernate Search 7 into your project to provide fast, relevant, and "intelligent" search results. This guide is intended for Java developers already using Hibernate ORM who want to implement production-grade full-text search without manually managing Elasticsearch or Lucene. The Problem: Why Traditional SQL Search Fails Standard relational databases are built for structured data retrieval—finding an exact ID or a specific category. When you try to perform "fuzzy" searches (e.g., searching for "Hiberante" and expecting "Hibernate"), SQL falls short. Performance: LIKE '%keyword%' queries are notoriously slow because they cannot use standard B-Tree indexes. They force the database to perform a full table scan, which might work for 1,000 rows but will crawl to a halt at 1,000,000. Relevance (Scoring): SQL treats every match as a binary "yes" or "no." It doesn't understand that a keyword appearing in the Title should rank higher than a keyword appearing in the Footer. Language Nuance: SQL doesn't know that "running," "runs," and "ran" are all variations of the word "run." This process, known as stemming, is a core feature of dedicated search engines.

Ankur in Hibernate

equals() and hashCode() in Hibernate: Five Patterns That Look Right and Aren’t

A team added a Product to a HashSet, called em.persist(product), and then checked whether the set contained it. The answer was false. The entity was in the database. It was in the set before the persist call. After the call it had effectively vanished from the set, even though nobody removed it. The bug is the database-generated ID in hashCode(). Before persist, id is null; hashCode() returns some value based on null. After persist, id is 42; hashCode() returns a completely different value. The entity is now sitting in the wrong bucket of the HashSet. contains() looks in the right bucket, finds nothing, returns false. The entity is lost — not from the database, just from the set — and every operation that relied on that set produces wrong answers. This is pattern one. There are four more, each equally invisible until the wrong moment. Each one looks like a reasonable implementation when you read it. The problem only shows up at runtime, often under specific conditions that don't reproduce in unit tests.

Ankur in Hibernate

Master Java Bean Validation with Hibernate Validator 7: A Complete Guide

Have you ever spent hours debugging a "NullPointerException" or a corrupted database entry only to realize the data was malformed from the start? Manually writing if (user.getName() == null) checks across your entire service layer is not just tedious—it's a maintenance nightmare that leads to "spaghetti code." In the world of modern Java development, ensuring data integrity is paramount. This is where Java Bean Validation with Hibernate Validator 7 comes into play, providing a robust, annotation-based framework to handle constraints elegantly. In this guide, we’ll dive deep into how Hibernate Validator (the reference implementation of Jakarta Bean Validation) works with Hibernate 7 to keep your data clean and your code concise. The Problem: The "Validation Logic" Chaos Imagine a registration form for a high-traffic application. You need to ensure: The username isn't empty. The email is valid and follows global standards. The age is at least 18. The password meets complex security requirements (uppercase, digits, special characters). Without a centralized system, you end up duplicating this logic in your REST controllers, your service layer, and sometimes even at the database level using DDL constraints. This inconsistency leads to "Validation Drift," where one part of the app accepts data that another part rejects. This results in inconsistent system states, obscure runtime errors, and a poor user experience. The Agitation: Maintenance Debt and Data Corruption As your application grows, managing manual validation becomes a massive bottleneck. If the business requirement for a "valid phone number" changes to include international formats, you have to find every single if statement across dozens of files. Miss one? You’ve just introduced a security vulnerability or a data integrity issue that could poison your database for months.

Ankur in Hibernate

Master Hibernate 7 Connection Pooling with HikariCP: The Definitive Performance Guide

Are you struggling with sluggish database response times or "Connection is closed" exceptions in your Java logs? In modern enterprise applications, your database connection pool is the heart of your infrastructure. If that heart beats too slowly, your entire system suffers. In this guide, we explore how to integrate Hibernate 7 with HikariCP—the "zero-overhead" connection pool—to achieve maximum throughput and reliability. The Problem: The Latency of Connection Handshakes Database connections are heavy. When Hibernate needs to execute a query without a pool, it must perform a series of time-consuming steps: Open a network socket to the DB server. Complete a TCP/IP handshake. Negotiate SSL/TLS security. Authenticate the database user. Under high load, these milliseconds accumulate, leading to massive latency spikes. Without a pool, your application spends more time "connecting" than actually "querying." The Agitation: Why "Old School" Pools are Falling Behind For years, developers relied on pools like c3p0 or DBCP. While reliable, these libraries were built for an era of lower concurrency. They often suffer from: Internal Locking: Threads frequently block each other just to "borrow" a connection. Complexity: Dozens of confusing parameters that lead to misconfiguration. Size: Heavyweight codebases that increase your application's memory footprint. The Solution: Hibernate 7 + HikariCP HikariCP is widely recognized as the fastest connection pool available for the JVM. It is built on highly optimized, lock-free data structures and micro-benchmarked to ensure near-zero overhead.