Sudip Biswas’ Post

Stop labeling your Spring Beans randomly! 🛑 I see many projects where @Component, @Service, and @Repository are used interchangeably. They all register a Bean in the context, so they are the same, right? Not exactly. Using the right stereotype is about Communication and Semantics. 🔹 @Service: Clearly states: "This is where the business logic lives." It's your domain's heart. 🔹 @Repository: Signals: "I talk to the database." Spring provides an extra layer of magic here: it automatically translates platform-specific exceptions (like SQLException) into Data Access Exceptions. 🔹 @Component: The generic catch-all. Use it for utility classes or anything that doesn't fit the service/repository pattern. Tip: Using the correct label makes your code readable for the next dev. It tells a story about what each class is responsible for before they even read a single line of implementation. How strict is your team with stereotyping their Spring components? Let’s talk below! 👇 #Java #SpringBoot #SoftwareArchitecture #CleanCode #Backend #SpringFramework #CleanDesign

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 84 of 100 — Logging with SLF4J & Logback in Spring Boot 📌 Objective Today I learned how to implement logging in Spring Boot using SLF4J and Logback to track application behavior, debug issues, and monitor performance. 🚀 What is Logging? Logging is used to record application events such as: ✔ Errors ✔ Debug information ✔ Application flow ✔ System activities 🌱 What is SLF4J? SLF4J (Simple Logging Facade for Java) is a logging API that provides a standard interface for different logging frameworks. ✔ Decouples logging implementation ✔ Supports multiple logging frameworks 🌱 What is Logback? Logback is the default logging framework used in Spring Boot. ✔ High performance ✔ Flexible configuration ✔ Supports file & console logging 📘 Using Logger in Spring Boot import org.slf4j.Logger; import org.slf4j.LoggerFactory; @RestController public class UserController { private static final Logger logger = LoggerFactory.getLogger(UserController.class); @GetMapping("/test") public String test() { logger.info("Test API called"); logger.debug("Debugging information"); logger.error("Error occurred"); return "Logging working!"; } } 📊 Log Levels Level. Purpose TRACE. Detailed information DEBUG. Debugging INFO. General info WARN. Warning ERROR. Errors ⚙️ Configuration (application.properties) Properties logging.level.root=INFO logging.level.com.example=DEBUG 📁 Log Output Example INFO - Test API called DEBUG - Debugging information ERROR - Error occurred 🧠 What I Learned ✔ Importance of logging in applications ✔ Difference between SLF4J and Logback ✔ Using Logger in Spring Boot ✔ Managing log levels for debugging and monitoring 💬 Post Description Day 84 of my 100 Days of Code Challenge! Today I implemented logging in Spring Boot using SLF4J and Logback. Logging helps track application behavior, debug issues, and improve system monitoring. #Day84 #100DaysOfCode #SpringBoot #Logging #SLF4J #Logback #JavaBackend #BackendDevelopment #CodingJourney #LearnJava

Testcontainers + MockMvc Most developers test their database code against an in-memory database. It's fast, it's easy to set up, and it lies to you. Your production app runs on PostgreSQL. Your tests run on H2, which has a different engine, different behavior, and different edge cases. You can have 100% passing tests and still ship a bug that only exists in production. So I made a different choice. My integration tests spin up a real PostgreSQL container via Testcontainers, run every assertion, then tear it down. My end-to-end tests go one step further using MockMvc to fire real HTTP requests through the full Spring stack, hitting the actual controller, service, repository, and database. No shortcuts at any layer. No mocks. No surprises in production. Testcontainers (testcontainers.com) makes this easy; it supports Java, Go, Python, .NET, and has native integration with Spring Boot 3+. Not the easiest path. The correct one. --- 💬 Do you test against a real database or an in-memory one? Drop it in the comments. 🔗 Full project: https://lnkd.in/dse3hHTV 🔗 Testcontainers: https://testcontainers.com #Java #SpringBoot #Testing #BackendDevelopment #SoftwareEngineering

⚠️ 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

Your @Transactional might not be working… and Spring won’t warn you. 🚨 I’ve seen this bug more than once: Code looks correct. @Transactional is there. But rollback never happens. Why? 👇 Because Spring transactions work through proxies. That means: Calling a @Transactional method from another method inside the SAME class = Transaction won’t apply. No error. No warning. Just silent failure. Other common traps 👇 → Checked exceptions don’t trigger rollback by default → Private methods won’t be proxied → Async calls break transaction boundaries What I always check 👇 ✔ Is the transactional method being called through Spring proxy? ✔ Is rollback configured for the right exception type? ✔ Are transaction boundaries placed at the service layer? @Transactional is powerful… But dangerous when assumed instead of understood. Framework annotations are not magic. They still follow rules. Have you ever debugged a transaction issue that “should have worked”? 👇 #Java #SpringBoot #Transactional #SpringFramework #BackendDevelopment #SoftwareEngineering

🚀 Mastering Spring Stereotype Annotations – The Backbone of Clean Spring Boot Architecture! In every well-structured Spring application, there's a clear separation of concerns that makes the code maintainable, scalable, and testable. This visual perfectly breaks down the 4 main layers and the powerful stereotype annotations that define their roles: 📌 Presentation Layer (Top Orange Layer) @Controller & @RestController Handles all incoming client requests (Web/Mobile/API) ⚙️ Service Layer (Green Layer) @Service Contains the core business logic of your application 💾 Data Access Layer (Purple Layer) @Repository Responsible for all database operations and data persistence 🛠️ Core Components (Bottom Grey Layer) @Component Utility beans, helper classes, and common code that doesn’t fit in other layers All of this is automatically detected thanks to Component Scan – Spring’s intelligent way of finding and registering your beans. Pro Tip: Using the right stereotype annotation not only improves readability but also enables Spring to apply specific behaviors (like exception translation in @Repository). Whether you're a beginner or an experienced Spring developer, understanding these annotations is fundamental to building professional-grade applications. 💡 Which layer do you work with the most? Drop a comment below 👇 #SpringBoot #Java #SpringFramework #BackendDevelopment #Microservices #SoftwareEngineering #Coding #TechTips

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

Spring doesn’t just create beans- it manages their entire lifecycle. Many developers stop at "@Autowired", "@Qualifier", and "@Primary". But to build reliable and production-ready applications, understanding the Spring Bean Lifecycle is essential. ------ 🧠 What happens behind the scenes? A Spring bean goes through multiple stages: • Instantiation • Dependency Injection • Initialization (e.g., "@PostConstruct") • Ready for use • Destruction (e.g., "@PreDestroy") ------ 🔥 Key idea: • "@PostConstruct" → Used for initialization after dependencies are injected • "@PreDestroy" → Used for cleanup before the bean is destroyed ----- 💡 Why this matters: Proper lifecycle management helps you: ✔ Avoid resource leaks ✔ Manage connections effectively ✔ Write cleaner and more maintainable code ✔ Build stable, production-ready applications ----- 🎯 Best practice: Avoid placing heavy logic (such as database calls) inside constructors. Instead, use lifecycle annotations to handle initialization and cleanup in a structured way. ----- 📌 Takeaway: If your Spring knowledge ends at dependency injection, you’re only scratching the surface. 👉 Understanding the lifecycle is what separates good developers from great ones. #SpringBoot #SpringFramework #JavaDeveloper #BackendDevelopment #SoftwareEngineering #CleanCode #CodingBestPractices #LearnInPublic #Developers #Java