Centralized Exception Handling in Spring Boot Services

Global Exception Handling in Spring Boot using @ControllerAdvice While building REST APIs, handling exceptions properly is very important. Instead of writing try-catch blocks in every controller, I learned how to manage all exceptions in one place using @ControllerAdvice. What is @ControllerAdvice? It is a global exception handler in Spring Boot that allows us to handle exceptions across the entire application in a centralized way. Why use it? ✔ Clean and maintainable code ✔ Avoid repetitive try-catch blocks ✔ Centralized error handling ✔ Consistent API responses How it works? We create a class and annotate it with @ControllerAdvice, then define methods using @ExceptionHandler for different exceptions. Example: @ControllerAdvice public class GlobalExceptionHandler { @ExceptionHandler(Exception.class) public ResponseEntity<String> handleGlobalException(Exception ex) { return new ResponseEntity<>("Something went wrong: " + ex.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR); } @ExceptionHandler(NullPointerException.class) public ResponseEntity<String> handleNullPointer(NullPointerException ex) { return new ResponseEntity<>("Null value found!", HttpStatus.BAD_REQUEST); } } Result: Now whenever an exception occurs anywhere in the application, it will be handled here automatically. This approach makes APIs more professional and easier to debug. #SpringBoot #Java #BackendDevelopment #ExceptionHandling #WebDevelopment #Learning

What actually happens when you hit a REST API? 🤔 Let’s break it down step by step 👇 1️⃣ Client sends HTTP request 2️⃣ Request hits DispatcherServlet 3️⃣ HandlerMapping finds the correct controller 4️⃣ Controller processes request 5️⃣ Service layer applies business logic 6️⃣ Repository interacts with DB 7️⃣ Response is returned as JSON 💡 Behind the scenes: - Jackson converts Java → JSON - Spring handles dependency injection - Exception handling via @ControllerAdvice ⚡ Real benefit: Understanding this flow helps you: ✔ Debug faster ✔ Write better APIs ✔ Optimize performance Next time you call an API, remember — a lot is happening inside 🔥 Follow for more backend deep dives 🚀 #SpringBoot #Java #RestAPI #BackendDeveloper

One thing I’ve learned building backend systems: Audit logging always starts as a “simple requirement” …and ends up being a complex subsystem. - Who changed what? - When did it happen? - Can we query it efficiently? Most teams either: 1. Over-engineer it 2. Or build something they regret later So I decided to build it properly once. Introducing nerv-audit (now on Maven Central): A Spring Boot audit framework powered by Hibernate Envers, with: - Clean architecture - Queryable audit history - Production-ready design If you're building serious systems, this is something you’ll eventually need. Full write-up here: https://lnkd.in/g2sv9dsM Curious how others are handling audit trails in their systems 👇 #SpringBoot #Java #SoftwareEngineering #Backend #OpenSource

🚀 Day 19 – map() vs flatMap() in Java Streams While working with Streams, I came across a subtle but important difference: "map()" vs "flatMap()". --- 👉 map() Transforms each element individually List<String> names = Arrays.asList("java", "spring"); names.stream() .map(String::toUpperCase) .forEach(System.out::println); ✔ Output: JAVA, SPRING --- 👉 flatMap() Flattens nested structures List<List<Integer>> list = Arrays.asList( Arrays.asList(1, 2), Arrays.asList(3, 4) ); list.stream() .flatMap(Collection::stream) .forEach(System.out::println); ✔ Output: 1, 2, 3, 4 --- 💡 Key insight: - "map()" → 1-to-1 transformation - "flatMap()" → 1-to-many (and then flatten) --- ⚠️ Real-world use: "flatMap()" is very useful when dealing with: - Nested collections - API responses - Complex data transformations --- 💡 Takeaway: Understanding when to use "flatMap()" can make your stream operations much cleaner and more powerful. #Java #BackendDevelopment #Java8 #Streams #LearningInPublic

🚀 Day 22/100: Spring Boot From Zero to Production Topic: REST Controllers Why REST APIs Feel Easy in Spring Boot? Spring Boot gives you everything under one roof. No extra setup. No boilerplate. Just annotate and go. @RestController, Two Annotations in One. It's actually a combo of: @Controller → marks the class as an MVC controller @ResponseBody → ensures JSON is returned, not a view/template Without @ResponseBody, Spring would look for an HTML template. With it? Pure JSON. Every time. Structuring Your Endpoints Add @RequestMapping("/api/v1/resource") at the class level for the common base URL Then map individual methods using: @GetMapping → fetch data @PostMapping → create @PutMapping → full update @PatchMapping → partial update @DeleteMapping → delete Each annotation takes an optional path extension like ("/{id}"). 4 Ways to Accept Input 📥 @PathVariable → from the URL → /products/{id} @RequestParam → from query string → /products?name=shoes @RequestBody → from JSON body → deserialized automatically via Jackson @RequestHeader → from HTTP headers → useful for tokens/auth Control Your Response with ResponseEntity Don't just return objects blindly. Wrap them in ResponseEntity<T> to control: Status codes (201 Created, 404 Not Found, 204 No Content) Response headers Response body Handle Errors in One Place 🛡️ No try/catch in every method. Use @RestControllerAdvice to catch exceptions globally and return clean, consistent error responses across your entire API. One class. Full REST API. That's Spring Boot. #Java #SpringBoot #SoftwareDevelopment #100DaysOfCode #Backend #RESTfulAPI

🚀 Understanding HTTP Status Codes in REST APIs While building APIs, one important thing is not just sending data… 👉 It’s also about sending the right response status. These are called HTTP Status Codes. They help the client understand what happened with the request. 🔹 Common Status Codes ✔ 200 – OK Request was successful Example: Data fetched successfully ✔ 201 – Created New resource created Example: User registered successfully ✔ 400 – Bad Request Invalid input from client Example: Missing or wrong data ✔ 404 – Not Found Requested resource not found Example: User ID does not exist ✔ 500 – Internal Server Error Something went wrong on the server 🔹 Example in Spring Boot @GetMapping("/users/{id}") public ResponseEntity<User> getUser(@PathVariable Long id) { User user = userService.findById(id); return ResponseEntity.ok(user); } If user is not found, we can return: return ResponseEntity.status(HttpStatus.NOT_FOUND).build(); 💡 Why Status Codes are important ✔ Help frontend understand response ✔ Improve API communication ✔ Make APIs more professional ✔ Very common in interviews Understanding status codes helped me connect concepts like exception handling, validation, and API design. #Java #SpringBoot #BackendDevelopment #APIDesign #Learning

⚠️ Hot Reload in Spring Boot Isn’t Magic. It’s ClassLoader Isolation. When you change code and see: 👉 App restarts in seconds 👉 No full JVM restart What’s really happening? 1️⃣ Two ClassLoaders — The Core Idea Spring Boot DevTools splits your app into: Base ClassLoader   → dependencies (stable) Restart ClassLoader → your application code (changing) 2️⃣ Why This Matters Dependencies (like Spring, Hibernate): Loaded once Heavy to reload Rarely change Your code: Changes frequently Needs fast reload So only your code is reloaded. 3️⃣ What Happens on Code Change You modify a .class file DevTools detects change (file watcher) Discards Restart ClassLoader Creates a new one Reloads your classes Base ClassLoader stays untouched 4️⃣ Why It’s Faster Than Full Restart Without DevTools: JVM restarts All classes reloaded Framework reinitialized With DevTools: Only your classes reload Dependencies reused Startup drastically reduced 5️⃣ What Actually Gets Restarted? Spring ApplicationContext Beans created again Config reloaded But: 👉 JVM process stays alive 👉 Core libraries remain loaded 6️⃣ Common Gotcha (Very Important) Static state survives in Base ClassLoader. Example: static Map cache = new HashMap(); If loaded by base loader: It won’t reset after reload Leads to weird bugs 7️⃣ Why Some Changes Don’t Reload DevTools won’t reload when: Dependency JAR changes Config outside classpath changes Native resources updated Requires full restart 8️⃣ Comparison With Other Tools Tool Approach DevTools ClassLoader restart JRebel Bytecode rewriting HotSwap Limited JVM replacement DevTools doesn’t “reload classes” It replaces the ClassLoader that loaded them #Java #SpringBoot #JVM #ClassLoader #HotReload #BackendEngineering #SoftwareEngineering #LearnInPublic

Learning and implementing REST APIs with Spring Boot What's happening here: @RestController :- marks this class as a REST API handler @RequestMapping("/employee") :- base URL for all endpoints @Autowired :- injects the Service layer dependency GET /display :- a simple test endpoint to verify the API is live POST /save :- accepts Employee data as JSON and saves to DB GET /getAll :- fetches all employee records from the database Implementing Dependency Injection and a structured Layered Architecture has highlighted the importance of writing clean, maintainable code. #REST #API #BackendDevelopment #SpringBoot #Java

🧬 Spring Boot – Understanding API Responses Today I explored how Spring Boot sends data from backend to frontend. 🧠 Key Learnings: ✔️ Returning a Java object automatically converts it to JSON ✔️ Spring Boot uses Jackson internally for this conversion ✔️ "@ResponseBody" ensures data is sent directly as response 💡 Best Practice: 👉 Using "@RestController" simplifies everything (Combination of @Controller + @ResponseBody) ✔️ Explored different return types: • Object • List • String • ResponseEntity (for better control over status & response) 🔁 API Flow: Request → Controller → Service → Return Object → JSON Response → Client 💻DSA Practice: • Even/Odd check using modulus • Sum of first N numbers (optimized using formula) ✨ Understanding how backend responses work is key to building real-world REST APIs. #SpringBoot #Java #BackendDevelopment #RESTAPI #WebDevelopment #DSA #LearningInPublic #SoftwareEngineering

💡 How many of us REALLY know how "@Transactional" works in Spring Boot? Most developers use "@Transactional" daily… But under the hood, there’s a lot more happening than just "auto rollback on exception". Let’s break it down 👇 🔹 What is "@Transactional"? It’s a declarative way to manage database transactions in Spring. Instead of manually writing commit/rollback logic, Spring handles it for you. --- 🔍 What actually happens behind the scenes? 1️⃣ Spring creates a proxy object around your service class 2️⃣ When a method annotated with "@Transactional" is called → it goes through the proxy 3️⃣ The proxy: - Opens a transaction before method execution - Commits if everything succeeds ✅ - Rolls back if a runtime exception occurs ❌ --- ⚙️ Execution Flow Client → Proxy → Transaction Manager → Target Method → DB --- 🚨 Important Gotchas ❗ Works only on public methods ❗ Self-invocation (method calling another method inside same class) will NOT trigger transaction ❗ By default, only unchecked exceptions trigger rollback ❗ Uses AOP (Aspect-Oriented Programming) --- 🧠 Advanced Concepts ✔ Propagation (REQUIRED, REQUIRES_NEW, etc.) ✔ Isolation Levels (READ_COMMITTED, SERIALIZABLE) ✔ Transaction Manager (PlatformTransactionManager) ✔ Lazy initialization & session handling --- 🔥 Example @Service public class PaymentService { @Transactional public void processPayment() { debitAccount(); creditAccount(); // If credit fails → debit will rollback automatically } } --- ✨ Pro Tip Understanding "@Transactional" deeply can save you from: - Data inconsistencies - Hidden bugs - Production failures --- 👉 Next time you use "@Transactional", remember — you're not calling a method… you're triggering a proxy-driven transaction lifecycle! #SpringBoot #Java #BackendDevelopment #Microservices #TechDeepDive #Learning