Gul Shair Butt’s Post

🔥 𝗪𝗵𝗮𝘁 𝗮 𝗱𝗲𝗯𝘂𝗴𝗴𝗶𝗻𝗴 𝗷𝗼𝘂𝗿𝗻𝗲𝘆 𝘄𝗶𝘁𝗵 𝗛𝗶𝗯𝗲𝗿𝗻𝗮𝘁𝗲 𝘁𝗼𝗱𝗮𝘆 — 𝗮𝗻𝗱 𝗜 𝗹𝗲𝗮𝗿𝗻𝗲𝗱 𝗺𝗼𝗿𝗲 𝗶𝗻 𝟮 𝗵𝗼𝘂𝗿𝘀 𝘁𝗵𝗮𝗻 𝗜 𝘄𝗼𝘂𝗹𝗱 𝗶𝗻 𝟮 𝘄𝗲𝗲𝗸𝘀 𝗼𝗳 𝗷𝘂𝘀𝘁 𝗿𝗲𝗮𝗱𝗶𝗻𝗴. Here's the full story: ❌ 𝗣𝗿𝗼𝗯𝗹𝗲𝗺: LazyInitializationException "Cannot lazily initialize collection of role Company.jobs — no session" My @OneToMany(fetch = LAZY) jobs list in Company was throwing this every time I hit the API. 🔁 𝗔𝘁𝘁𝗲𝗺𝗽𝘁 𝟭 — @𝗧𝗿𝗮𝗻𝘀𝗮𝗰𝘁𝗶𝗼𝗻𝗮𝗹 Added it to the service method. Fixed the exception... but then I noticed something in the logs. Hibernate was firing N+1 queries: → 1 query for all companies → 1 query per company to fetch its jobs → 5 companies = 6 queries. Not good. 🔁 𝗔𝘁𝘁𝗲𝗺𝗽𝘁 𝟮 — 𝗙𝗲𝘁𝗰𝗵𝗧𝘆𝗽𝗲.𝗘𝗔𝗚𝗘𝗥 Worked, but it always loads jobs — even when I don't need them. A performance trap waiting to happen. ✅ 𝗙𝗶𝗻𝗮𝗹 𝗳𝗶𝘅 — 𝗝𝗢𝗜𝗡 𝗙𝗘𝗧𝗖𝗛 @Query("SELECT c FROM Company c LEFT JOIN FETCH c.jobs") → 1 single SQL query → No session dependency → No N+1 problem → Maximum performance 🚀 💡 𝗕𝗼𝗻𝘂𝘀 𝗹𝗲𝘀𝘀𝗼𝗻: Don't use @Lob on a String field in PostgreSQL with Hibernate 6. PostgreSQL LOBs use numeric OIDs internally — so Hibernate tries to read your text as a long and crashes with "bad value for type long". Removing @Lob fixed it instantly. 𝗧𝗵𝗲 𝗹𝗲𝗮𝗿𝗻𝗶𝗻𝗴 𝗷𝗼𝘂𝗿𝗻𝗲𝘆: LazyInitializationException → @Transactional (N+1 problem) → EAGER (always loads, bad practice) → JOIN FETCH ✅ (one query, perfect) Sometimes the best way to understand a tool deeply is to break it in every possible way first. 😄 #Java #SpringBoot #Hibernate #JPA #Backend #SpringAI #SpringUsers #JavaDevelopmentDesign

While debugging a Hibernate issue recently, I came across something interesting 👇 `org.hibernate.ObjectNotFoundException` — a small error with a big lesson. At first glance, it looked like a typical lazy loading problem. But the actual root cause was deeper. 🔍 What was happening? Hibernate created a proxy for a related entity, but when it tried to initialize it, the corresponding row didn’t exist in the database. 👉 In short: The application assumed data integrity, but the database told a different story. ⚠️ The tricky part? The exception wasn’t thrown during query execution. It appeared during debugging when `toString()` was triggered on a proxy object. 💡 Key learnings from this: 🔹 ORM frameworks don’t guarantee data consistency — your database does 🔹 Lazy loading can hide issues until runtime (or even debug time) 🔹 Using Lombok `@ToString` blindly on entities can backfire 🔹 Circular relationships (OneToMany ↔ ManyToOne) can lead to unexpected behavior 🛠 What helped fix it: ✔ Verifying referential integrity at the database level ✔ Avoiding unnecessary eager access during debugging ✔ Restricting `toString()` to only essential fields ✔ Using LEFT JOIN fetch where relationships may be optional 🚀 Takeaway: Most production issues are not about complex logic — they are about mismatches between your assumptions and actual data. Always trust your database more than your ORM. #Java #Hibernate #SpringBoot #BackendDevelopment #Debugging #SoftwareEngineering #Production #ProductionIssues #ErrorHandling

🚀 Day 21 – Records in Java: The Modern Way to Model Data Java Records are a powerful feature introduced to simplify how we represent immutable data. No boilerplate. No ceremony. Just clean, minimal, and intention-driven code. Here’s what makes Records a game-changer: 🔹 1. Zero Boilerplate No need to manually write: ✔ getters ✔ constructors ✔ equals() ✔ hashCode() ✔ toString() Java auto-generates all of these. Your class becomes crystal clear about what it stores. 🔹 2. Immutable Data by Design Records are inherently final & immutable, making them: ✔ Thread-safe ✔ Predictable ✔ Side-effect-free Perfect for modern architectures using events, messages, DTOs, and API contracts. 🔹 3. Great for Domain Modeling When your class exists only to hold data — User, Order, GeoLocation, Config — Records provide a clean, concise model. 🔹 4. Perfect Fit for Microservices In distributed systems, immutability = reliability. Records shine as: ✔ DTOs ✔ API request/response models ✔ Kafka event payloads ✔ Config objects 🔹 5. Improved Readability & Maintainability A record makes your intent unmistakable: ➡ “This is a data carrier.” Nothing more. Nothing less. 🔹 6. Supports Custom Logic Too You can still add: ✔ validation ✔ static methods ✔ custom constructors ✔ business constraints …without losing the simplicity. 🔥 Architect’s Takeaway Records encourage immutable, predictable, low-boilerplate designs — exactly what you need when building scalable enterprise systems and clean domain models. Are you using Records in your project instead of POJOs? #100DaysOfJavaArchitecture #Java #JavaRecords #Microservices #CleanCode #JavaDeveloper #TechLeadership

🚀 Spring Boot & JPA – Architecture Overview Understanding how data is managed in Java applications is key for building scalable systems. This module explains how JPA (Java Persistence API) helps in storing business entities as relational data using POJOs. It highlights core components like EntityManagerFactory, EntityManager, EntityTransaction, Query, and Persistence, which work together to handle database operations efficiently. As shown in the class-level architecture (page 1), these components simplify data handling and reduce the need for complex SQL coding. Additionally, the relationships between components—such as one-to-many between EntityManagerFactory & EntityManager, and one-to-one between EntityManager & EntityTransaction (page 5)—demonstrate how JPA manages data flow and transactions effectively. 💡 A fundamental concept for Java developers working with Spring Boot, ORM, and database-driven applications. #SpringBoot #JPA #Java #BackendDevelopment #AshokIT

🚀 Still writing complex JOIN queries to manage relationships? What if you could handle everything using simple Java objects… without worrying about SQL complexity? That’s exactly where Association Mapping in Spring Boot (JPA) becomes a game-changer 🔥 🔍 What this image explains Managing relationships between database tables is one of the most challenging parts of backend development. 👉 Association Mapping solves this by: ✔ Defining how entities are connected ✔ Mapping real-world relationships directly in your code ✔ Letting JPA handle the underlying SQL 📌 Types of Relationships 🔹 One-to-One → One entity is linked to exactly one other entity 🔹 One-to-Many → One parent can have multiple children 🔹 Many-to-One → Multiple entities can relate to one parent 🔹 Many-to-Many → Complex relationships using a join/lookup table 💡 Why It Matters ✔ Cleaner & more readable code ✔ Maintains strong data integrity ✔ Reduces the need for complex SQL queries ✔ Improves scalability and maintainability 🔥 Core Insight: Stop thinking in tables… Start thinking in objects and relationships — JPA will handle the rest. 💬 Quick Question: Which mapping do you use most in real projects — One-to-Many or Many-to-One? #SpringBoot #Java #JPA #Hibernate #BackendDevelopment #SoftwareEngineering #DatabaseDesign #LearningInPublic #Developers #TechContent

🚨 I solved this problem… but the real learning was in how I stored data. Day 26 of my Backend Developer Journey — and today was all about thinking ahead while iterating 👇 🧠 LeetCode Breakthrough Solved LeetCode 3761. Minimum Absolute Distance Between Mirror Pairs 💡 What clicked: → Reverse the number to find its mirror → Store reversed values in HashMap → Check distance while iterating ⚡ The key trick: Instead of searching later… 👉 Prepare data in advance while traversing 🔍 Key Insight 👉 Store future-use data (reversed numbers) 👉 Avoid nested loops 👉 Reduce time complexity to O(n) 🔗 My Submission: https://lnkd.in/gUZ5QUKc ☕ Spring Boot Learning 🔄 Hibernate Entity Lifecycle Deep Dive Today I didn’t just learn states… I understood how Hibernate actually behaves internally 👉 Transient – Only in heap memory 👉 Persistent – Connected & tracked by Hibernate 👉 Detached – Exists but not tracked 👉 Removed – Marked for deletion ⚡ Real Game Changer 💡 Persistence Context (First-Level Cache) 👉 Same entity = same reference 👉 Avoids repeated DB calls 👉 Managed automatically using @Transactional 🔥 Powerful Concept 👉 Updating entity WITHOUT calling save() still works Why? Because Hibernate tracks changes in Persistent State ⚡ This is called: Dirty Checking (not Dirty Read — common mistake 👀) 🧠 The Shift 👉 Efficient coding = smart data preparation 👉 Hibernate is not magic — it’s predictable when understood 👉 Backend = Data + Lifecycle + Optimization 📘 Spring Boot Notes: https://lnkd.in/gRgxP7Th 📈 Day 26 Progress: ✅ Improved hashmap intuition ✅ Understood Hibernate internals deeply ✅ Learned real-world DB optimization concept 💬 Did you know Hibernate updates data even without calling save()? 😄 #100DaysOfCode #BackendDevelopment #SpringBoot #Java #LeetCode #CodingJourney

I recently built nerv-audit, a library on top of Hibernate Envers focused on vertical auditing. Most audit discussions focus on system-wide (horizontal) logs. But in practice, debugging usually comes down to a simpler question: 👉 What exactly changed in this entity? That’s where vertical auditing shines: • Clear, per-entity history • Precise diffs you can actually reason about • Less noise compared to aggregated audit streams • Better alignment with domain-driven design Instead of reconstructing state from a global timeline, you can directly inspect the evolution of a single entity with confidence. GitHub: https://lnkd.in/gSBi_ksN Curious how others approach auditing in their systems — vertical, horizontal, or a mix? #java #springboot #hibernate #ddd #softwareengineering

#SpringUnpackedSeries - 03 Continuing from: https://lnkd.in/gJ4Wg6XN === HOW SPRING BOOT + JPA SIMPLIFY YOUR DATA LAYER? === Ever wonder how Spring Boot manages to connect to a database with almost zero manual setup? It’s all about the "Autopilot" mode! When you combine Spring Boot with JPA (Java Persistence API), the framework takes over the repetitive, "boring" parts of coding, allowing you to focus on building features rather than plumbing. --- The 3-Step Magic Trick --- • Step 1: The Input You provide the basics: a few dependencies in your build.gradle, simple properties, and your @Entity classes. That’s it! • Step 2: The Autopilot Spring Boot kicks in to scan your project. It finds your database drivers, initializes Hibernate, and automatically sets up the EntityManagerFactory. • Step 3: The Result The framework builds the "heavy" machinery. It generates SQL, manages transactions, and handles connection pooling without you writing a single line of JDBC code. --- Why This Matters? --- • Speed: Go from an empty project to a working database layer in minutes. • Clean Code: No more messy boilerplate or manual SQL management. • Efficiency: Let the framework handle complex tasks like Transaction Management and Data Access automatically. #SpringUnpacked #SpringBoot #Java #JPA #Hibernate #SoftwareDevelopment #CodingLife #BackendDevelopment #ProgrammingTips #TechCommunity #WebDevelopment

Was working on a Spring Boot REST API the other day. Everything looked fine entity class, repository, controller all set up. But two fields, createdAt and updatedAt, were coming back null in every response. Spent time checking the constructor, the DTO mapping, the database config. Turns out I just needed two annotations: @CreationTimestamp → auto-sets the time when record is created @UpdateTimestamp → auto-updates the time on every save Two lines. That's it. Hibernate handles everything behind the scenes you don't set these manually. One more thing I'd missed without @JsonFormat, Java's Timestamp serializes weirdly in JSON. Add this and it formats cleanly: @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss") Small things. But they'll silently break your API if you miss them. #Java #SpringBoot #Backend #LearningInPublic #HibernateJPA