How to Implement Pagination in Spring Boot

💡 Writing Efficient Code: Lessons from Real-World Optimization After working on multiple backend systems, I’ve learned that writing efficient code isn’t about shorter syntax — it’s about designing smarter data flow and understanding your system’s behavior under real-world conditions. One of the most impactful optimizations I’ve implemented was preloading master data and using in-memory maps instead of frequent database lookups. This single change reduced latency and DB load significantly — especially in high-traffic modules. Key takeaways from performance tuning in real projects 👇 ⚙️ Leverage Java Streams & Collectors — they help process collections in a functional, parallel, and more readable way. ⚙️ Use Optional to simplify null handling and improve code safety. ⚙️ Design with caching layers (Spring Cache, Redis) to minimize redundant queries. ⚙️ Replace nested loops with efficient stream-based transformations like Grouping by, filter, and map. ⚙️ Profile early — tools like JProfiler or VisualVM can uncover performance bottlenecks long before production. Over time, I’ve realized: Efficiency is not just about speed — it’s about clarity, maintainability, and thoughtful system design. Clean, performant code evolves from understanding data flow, load patterns, and scalability, not just syntax. 🚀 #Java #SpringBoot #PerformanceOptimization #SystemDesign #CleanCode #FunctionalProgramming #BackendDevelopment #EngineeringExcellence

🚀 Learn JPA Relationships — Simplified! Master One-to-One, One-to-Many, and Many-to-Many mappings in Spring Data JPA with: 💻 Practical GitHub demo projects —explore real-world implementations 📘 Step-by-step Medium guides — gain clear theoretical understanding 🔁 Insights on unidirectional & bidirectional mappings ⚙️ Tips on key parameters, cascading, and fetching strategies 🔹 One-to-One GitHub = https://shorturl.at/EdAGY Article = https://shorturl.at/b7UJ3 🔹 One-to-Many GitHub = https://shorturl.at/bq5Z5 Article = https://shorturl.at/Cm1Qz 🔹 Many-to-Many GitHub = https://shorturl.at/kqSY2 Article = https://lnkd.in/e5ve8DgD 💡 Perfect for developers who want both theoretical clarity and hands-on practical skills in building efficient, scalable JPA/Hibernate relationships. ✍️ Written by Yesith Sri Hansana #SpringBoot #JPA #Hibernate #Java #BackendDevelopment #Programming #Developers #SpringDataJPA

Sharing the simple script I developed for my PhD research: an interactive Java program that generates problem instance files and matching solution files for vehicle routing / dropoff coordination experiments. It currently: Supports instance templates: 2, 3, 5, 9, 12, 15, 18, 21 Prompts for integer scenario parameters (vehicles, customers, depots, deployment time, capacity, demand/frequency, start/end depot) Produces two files per run: FINALDATA/p{N}.txt and FINALSOLUTION/pr{N}.txt (paths currently hard-coded) Includes ready-made solution routes and objective values per template (useful for benchmarking or as fixtures) #VehicleRouting #VRP #Logistics #RoutingAlgorithms https://lnkd.in/giFPQiNC

💡 Day 13 of my 𝗝𝗮𝘃𝗮 𝗕𝗮𝗰𝗸𝗲𝗻𝗱 𝗤𝘂𝗲𝘀𝘁𝗶𝗼𝗻 𝗼𝗳 𝘁𝗵𝗲 𝗗𝗮𝘆 𝘀𝗲𝗿𝗶𝗲𝘀: 🧠 Question: In Spring Boot, what is the difference between @𝘊𝘰𝘮𝘱𝘰𝘯𝘦𝘯𝘵, @𝘚𝘦𝘳𝘷𝘪𝘤𝘦, @𝘙𝘦𝘱𝘰𝘴𝘪𝘵𝘰𝘳𝘺, and @𝘊𝘰𝘯𝘵𝘳𝘰𝘭𝘭𝘦𝘳? 👉 When should you use each one? ✅ Answer: All four annotations are stereotypes used to register beans in the Spring container, but each represents a specific layer of your application. @𝐂𝐨𝐦𝐩𝐨𝐧𝐞𝐧𝐭 Generic Spring-managed bean. Use when the class does not fit into service/repository/controller categories. @𝐒𝐞𝐫𝐯𝐢𝐜𝐞 Represents business logic layer. Adds clarity and allows Spring to apply additional behaviors like transaction boundaries. @𝐑𝐞𝐩𝐨𝐬𝐢𝐭𝐨𝐫𝐲 Represents DAO / persistence layer. Also provides exception translation, converting DB exceptions into Spring’s DataAccessException. @𝐂𝐨𝐧𝐭𝐫𝐨𝐥𝐥𝐞𝐫 / @𝐑𝐞𝐬𝐭𝐂𝐨𝐧𝐭𝐫𝐨𝐥𝐥𝐞𝐫 Handles web requests. @𝘊𝘰𝘯𝘵𝘳𝘰𝘭𝘭𝘦𝘳 → returns views (MVC) @𝘙𝘦𝘴𝘵𝘊𝘰𝘯𝘵𝘳𝘰𝘭𝘭𝘦𝘳 → returns JSON responses directly ✅ Layered annotations improve readability, maintainability, and allow Spring to apply specific behaviors automatically. ⚙️ See you tomorrow for Day 14 👋 #Java #SpringBoot #Annotations #BackendDeveloper #Microservices #Architecture #ContinuousLearning #QuestionOfTheDay

Day 2 - Setting Up Your Spring Data REST Project 💬 The Question How do I start from scratch and get a working REST API in minutes? Understanding Repositories in Spring Data REST 💬 The Question What is a Repository and why does Spring Data REST care about it? 🧠 The Explanation A Repository in Spring Data JPA is an interface that tells Spring: “Hey, please create all the database CRUD operations for this entity.” When you extend JpaRepository or CrudRepository, Spring Data REST automatically turns it into REST endpoints. @RepositoryRestResource(path = "products") public interface ProductRepository extends JpaRepository<Product, Long> {} Now you get : | HTTP Method | Endpoint   | Action      | | GET     | `/products`  | List all products | | GET     | `/products/1` | Get one      | | POST    | `/products`  | Add new      | | PUT     | `/products/1` | Update      | | DELETE   | `/products/1` | Remove      | Learning never stops! Follow me for more Spring Boot, Java, and backend development content — let’s grow together 🙏 #Java #SpringBoot #SpringFramework #BackendDevelopment #SoftwareDevelopment #Programming #RESTAPI #APIDevelopment #BackendEngineer #JavaDeveloper #Developers #TechCommunity #TechLearning #LearnToCode #CareerGrowth

Performance doesn’t start at SELECT but it starts at CREATE. I have seen so many people (including myself, years ago) chase query optimization after a system goes live. Adding indexes, rewriting joins, tweaking SQL like it’s magic. But over time, I realized that performance is not born in the query. It’s born in the design. The moment you create that table. The way you pick your data types. The relationships you define (or ignore). If your foundation is not right, no amount of query tuning can truly save you. Good performance is just good design showing up at runtime. What’s one schema design choice you regret or learned from? #DatabaseDesign #PerformanceMatters #EngineeringThoughts #JavaDeveloper #SoftwareEngineer #BackendDevelopment #Java #SpringBoot #Microservices #DevOps #CloudComputing #CodingLife #DeveloperCommunity #FullStackDeveloper #TechLeadership #ContinuousLearning

In software architecture, Separation of Concerns is a guiding principle. Nowhere is this more critical than between your database state (@Entity) and your public API contract (what you send to the client). Exposing your JPA @Entity directly from a Spring Boot controller tightly couples your internal database schema to the outside world. This is a recipe for security flaws, poor performance, and brittle code. The solution is simple and robust: DTOs (Data Transfer Objects). Here are 5 critical reasons why DTOs are essential for any production-grade API: 1. Security & Data Shielding: @Entity: Risk leaking sensitive fields (passwordHash, salary). DTO: An explicit contract, exposing only what the client needs. A true data shield. 2. API Contract Stability & Decoupling: @Entity: Database changes break your public API contract. DTO: Decouples API from DB schema. Refactor your DB, clients remain stable. 3. Performance & LazyInitializationException: @Entity: Serializing lazy-loaded entities outside transactions leads to LazyInitializationException or N+1 queries. DTO: Forces explicit data fetching. Use JPA Projections for efficient, precise data loading. 4. Separation of Concerns (Clean Code): @Entity: Models DB state. DTO: Models API requests/responses. Mixing them creates bloated "god objects" and maintainability nightmares. Keep concerns separate! 5. Flexible & Precise Validation: @Entity: Validation for data integrity. DTO: Validation for user input. Different DTOs (e.g., CreateUserDTO, UpdateUserDTO) allow precise, flexible validation impossible with a single entity. ✅  Don't map DTOs by hand! Use MapStruct. It generates mapping code at compile-time, giving you clean separation and zero runtime overhead. Essential in my pom.xml! #SpringBoot #Java #SoftwareArchitecture #SystemDesign #CleanCode #JPA #Hibernate #BackendDevelopment #TechLeadership #Security #Performance

💻 Day 53 of #100DaysOfCode – LeetCode #206: Reverse Linked List Today’s challenge was one of the most classic problems in data structures — reversing a linked list.  This problem is a great way to strengthen your understanding of pointers and linked list manipulation. 🧩 Problem:  Given the head of a singly linked list, reverse it and return the new head. ⚙ Approach:  I used an iterative approach with three pointers:  prev, curr, and next. Store the next node Reverse the current node’s pointer Move forward until the list is reversed 🧠 Key Learning:  This problem really helped me visualize how pointers work in linked structures — a great exercise for understanding memory links and iterative logic. ✅ Time Complexity: O(n)  ✅ Space Complexity: O(1) Here’s my simple Java solution: class Solution {   public ListNode reverseList(ListNode head) {     ListNode prev = null, curr = head;     while (curr != null) {       ListNode next = curr.next;       curr.next = prev;       prev = curr;       curr = next;     }     return prev;   } } 🔥 Every day, one step closer to mastering data structures!  #Day53 #LeetCode #Java #100DaysOfCode #CodingJourney #LinkedList #DSA #Programming #ReverseLinkedList

328. Odd Even Linked List — A Clean O(1) Space, O(n) Time Solution Here’s the challenge 👇 Problem: Given the head of a singly linked list, group all the odd-indexed nodes first (1st, 3rd, 5th, …), followed by all the even-indexed nodes (2nd, 4th, 6th, …). The relative order within both groups must remain the same. Example: Input: [1, 2, 3, 4, 5] Output: [1, 3, 5, 2, 4] 🧠 Approach: The trick is to rearrange the pointers, not the node values — ensuring O(1) extra space and O(n) time. We maintain two separate chains: One for odd-indexed nodes One for even-indexed nodes At the end, we simply connect the tail of the odd list to the head of the even list. 💻 Code: public ListNode oddEvenList(ListNode head) { if (head == null || head.next == null) return head; ListNode odd = head; ListNode even = head.next; ListNode evenHead = even; // Save starting point of even list while (even != null && even.next != null) { odd.next = even.next; // connect current odd to next odd odd = odd.next; // move odd pointer forward even.next = odd.next; // connect current even to next even even = even.next; // move even pointer forward } odd.next = evenHead; // attach even list at the end of odd list return head; } 🧩 Example Walkthrough: For input 1 → 2 → 3 → 4 → 5 Odd sequence builds as 1 → 3 → 5 Even sequence builds as 2 → 4 Finally merged → 1 → 3 → 5 → 2 → 4 ⚙️ Complexity: Time: O(n) — each node visited once Space: O(1) — no extra list or data structure used In-place reordering with clean pointer manipulation 💬 My Take: This problem beautifully tests your understanding of linked list pointer manipulation. Once you get the logic right, the solution feels almost magical — simple, elegant, and efficient. #LeetCode #Java #LinkedList #DSA #LinkedInLearning