Spring Boot Transactional Annotation Not Rolling Back

Singleton 🧵 : The request counter was wrong. The order list had missing entries. And once a week, production threw a ConcurrentModificationException — impossible to reproduce in dev. We stared at the code for an hour before it clicked. The service was a singleton. The fields were mutable. Spring beans are singletons by default — one instance shared across every thread in the JVM. When 50 requests hit simultaneously, they all share the same requestCount and the same ArrayList. requestCount++ is not atomic. It's three operations: read, increment, write. Two threads reading the same value before either writes means one increment is silently lost. Do this 10,000 times and your counter is off by hundreds. ArrayList is not thread-safe. Thread A iterating the list while Thread B adds to it changes the internal modCount mid-loop — ConcurrentModificationException. The fix: Replace int with AtomicInteger — hardware-level atomic operations, no locks Replace ArrayList with Collections.synchronizedList() or CopyOnWriteArrayList Better yet — keep the bean stateless. No instance fields. All state in local variables or the database. Local variables live on the thread stack. Each thread has its own stack. No sharing. No race conditions. No bugs. One mutable field in a singleton is all it takes. #JavaInProduction #RealWorldJava #Java #SpringBoot #Concurrency #ThreadSafety #BackendDevelopment #ProductionIssues #SoftwareEngineering

Spent 10 minutes wondering why my Spring Boot @Transactional was not rolling back on exception. The code looked fine: @Transactional public void createOrder(Order order) {   orderRepository_save(order);   paymentService.processPayment(order); } Exception was thrown in paymentService. But the order was still saved to the database. The problem: The exception was a checked exception, not a RuntimeException. The fix: @Transactional(rollbackFor = Exception.class) public void createOrder(Order order) {   orderRepository_save(order);   paymentService.processPayment(order); } One attribute. That was it. By default, Spring only rolls back on unchecked exceptions (RuntimeException). For checked exceptions, you need to explicitly specify rollbackFor. What transaction issue has caught you off guard? #Java #SpringBoot #Transactional #Debugging #BackendDevelopment

Something I still find fascinating about Spring Boot. You write a simple controller like this: @RestController public class UserController { @GetMapping("/users") public List<User> getUsers() { return service.getUsers(); } } Looks simple. But when a request hits this endpoint, a lot happens behind the scenes: • Tomcat accepts the HTTP request • Spring DispatcherServlet receives it • HandlerMapping finds the correct controller • Argument resolvers prepare method parameters • The method executes • Jackson converts the response into JSON All of that… just to return a list of users. Frameworks like Spring Boot hide an incredible amount of complexity so developers can focus on business logic. Sometimes it's worth pausing and appreciating how much engineering is happening behind one simple endpoint. #Java #SpringBoot #BackendDevelopment #SoftwareEngineering

Spring Boot Annotations Cheat Sheet for Developers While working with Spring Boot, annotations play a crucial role in simplifying configuration, dependency injection, REST APIs, and database interactions. Here is the quick cheat sheet of commonly used Spring Boot annotations that every backend developer should know. This can be useful for interview preparation, quick revision, or day-to-day development. Covers key annotations across: 🔹Core Spring Boot configuration 🔹REST API development 🔹Dependency Injection 🔹JPA & Database operations 🔹Request handling Having these annotations at your fingertips can significantly speed up development and improve code readability. Sharing this as a quick reference for fellow developers. Hope it helps! 💡 If you find it useful, feel free to save or share it with your network. #SpringBoot #Java #BackendDevelopment #FullStackDevelopment #JavaDeveloper #SpringFramework #SoftwareEngineering #CodingTips #DeveloperResources #TechLearning #InterviewPreparation

Spent 10 minutes wondering why my Spring Boot API was returning an empty JSON object. The code looked fine: public class User {   private String name;   private String email; } @GetMapping("/user") public User getUser() {   return new User("John", "john@email.com"); } No errors. Endpoint worked. But the response was just {}. The problem: Missing getters. Jackson cannot serialize private fields without getters. The fix: public class User {   private String name;   private String email;   // Constructor   public User(String name, String email) {     this.name = name;     this.email = email;   }   // Getters   public String getName() { return name; }   public String getEmail() { return email; } } Two getters. That was it. Spring does not warn you. It just returns an empty object. What serialization issue has caught you off guard? #Java #SpringBoot #Jackson #Debugging #BackendDevelopment

Spent 10 minutes wondering why my Spring Boot application was not picking up environment variables. The code looked fine: @Value("${DATABASE_URL}") private String databaseUrl; No errors at startup. But the value was always null. The problem: I was using underscores in the property name, but Spring expects dots or lowercase with hyphens. The fix: @Value("${database.url}") private String databaseUrl; And in application_properties: database.url=${DATABASE_URL} One mapping. That was it. Spring does not automatically convert environment variable names to property names. You need to map them explicitly. What environment variable issue has caught you off guard? #Java #SpringBoot #EnvironmentVariables #Debugging #BackendDevelopment

🚨 Most Spring Boot applications still do this wrong. Let's use some event and virtual threads 🚀 👉 A user registers. 1. You save the user. 2. Then you send an email. All Inside the same request. 💣 Bad idea. Why? Because now your API depends on: • SMTP latency • network delays • external failures Your simple signup endpoint suddenly becomes slow and fragile. 💡 A better pattern is Domain Events. Instead of sending the email directly, publish an event: eventPublisher.publishEvent( new NewUserRegisteredEvent(user.id(), user.name(), user.email()) ); Now your API just registers the user and everything else becomes a side effect. 🚀 We will handle the email asynchronously: @Async("eventTaskExecutor") @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT) public void onNewUserRegistered(NewUserRegisteredEvent event) { // send activation email } Notice the key detail: 👉 AFTER_COMMIT The email only runs after the transaction succeeds. No ghost emails. No inconsistent state. Now comes the interesting part. 💡 Instead of using a traditional thread pool… Use Java 21 Virtual Threads. @Bean public TaskExecutor eventTaskExecutor() { return new VirtualThreadTaskExecutor("event-vt-"); } This gives you: ⚡ Massive concurrency ⚡ Lightweight threads ⚡ No reactive complexity ⚡ Clean imperative code Suddenly you can handle thousands of async tasks like: • emails • notifications • integrations • audit logs • background jobs Without blocking requests. Without complicated frameworks. Java 21 quietly changed backend scalability. And most developers still haven’t realized it. Are you already using Virtual Threads in production or still relying on traditional thread pools? #Java #SpringBoot #Java21 #VirtualThreads #BackendDevelopment #SoftwareArchitecture

Handling Errors Like a Pro in Spring Boot In real-world applications, things WILL go wrong — Invalid input, server issues, database failures… So how do we handle them properly? Instead of writing try-catch everywhere, Spring Boot gives a clean solution: @ControllerAdvice @ExceptionHandler In simple terms: Spring Boot = “Don’t worry, I’ll handle all errors in one place.” --- Example: If a user is not found → return proper message If input is invalid → return clean error response --- Why this is important: ✔ Cleaner code (no messy try-catch everywhere) ✔ Centralized error handling ✔ Better API responses ✔ Production-ready backend --- Currently learning and applying these concepts step by step #SpringBoot #Java #BackendDevelopment #ExceptionHandling #LearningInPublic

🚀 Spring Boot Annotations Cheat Sheet for Developers While working with Spring Boot, annotations play a crucial role in simplifying configuration, dependency injection, REST APIs, and database interactions. Here is the quick cheat sheet of commonly used Spring Boot annotations that every backend developer should know. This can be useful for interview preparation, quick revision, or day-to-day development. Covers key annotations across: 🔹Core Spring Boot configuration 🔹REST API development 🔹Dependency Injection 🔹JPA & Database operations 🔹Request handling Having these annotations at your fingertips can significantly speed up development and improve code readability. Sharing this as a quick reference for fellow developers. Hope it helps! 💡 If you find it useful, feel free to save or share it with your network. #SpringBoot #Java #BackendDevelopment #FullStackDevelopment #JavaDeveloper #SpringFramework #SoftwareEngineering #CodingTips #DeveloperResources #TechLearning #InterviewPreparation