Fixing Duplicate Logging in Spring Boot with Logback and Log4j2

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

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

I understood how Spring injects dependencies… Now I explored how APIs actually work in Spring Boot What is a REST API? It allows applications to communicate using HTTP (GET, POST, PUT, DELETE) --- In Spring Boot, this is handled using @RestController It tells Spring: “This class will handle HTTP requests” --- Example flow: Client → sends request Controller → receives it Service → processes logic Response → sent back to client --- Key Annotations: • @RestController → marks class as API controller • @GetMapping → fetch data • @PostMapping → send data • @PutMapping → update data • @DeleteMapping → delete data --- In simple terms: @RestController = “Entry point of your backend” --- Learning step by step and building real backend skills Next: How Controller talks to Service layer internally #SpringBoot #Java #BackendDevelopment #RESTAPI #LearningInPublic

10 Spring Boot annotations — and what they ACTUALLY do. Most developers use these daily but can't explain them. 👇 1. @SpringBootApplication   = @Configuration + @EnableAutoConfiguration + @ComponentScan   Three annotations in one. This is why your app boots. 2. @RestController   = @Controller + @ResponseBody   Every method returns data directly. No view templates. 3. @Transactional   Wraps your method in a DB transaction.   Rolls back on RuntimeException. NOT checked exceptions by default. 4. @Autowired   Injects a Spring-managed bean. Constructor injection is preferred. 5. @Value("${property}")   Injects values from application.properties/yml at runtime. 6. @Async   Makes a method run in a separate thread pool.   Useless without @EnableAsync on your config class. 7. @Cacheable   Caches the return value. Same input = no method execution.   Massive performance win for read-heavy endpoints. 8. @Scheduled   Runs a method on a timer/cron.   Needs @EnableScheduling — easy to forget. 9. @Profile("prod")   Only loads this bean in the specified environment.   Lifesaver for environment-specific configs. 10. @ConditionalOnProperty   Only creates the bean if a config property exists/matches.   The secret weapon for feature flags in Spring Boot. Which one surprised you? And which one have you misused? 👇 Tag a Java dev who needs this cheat sheet. 🚀 #SpringBoot #Java #BackendDevelopment #JavaDeveloper #SoftwareEngineering #Programming #SpringFramework #LearnToCode

Spring Boot looks simple on the surface. But under the hood, it’s doing a lot. A single request typically flows through: • Controller → handles the request • Service → contains business logic • Repository → talks to the database What this really means is: You get a clean separation of concerns by default. That’s why Spring Boot scales well not just in traffic, but in code maintainability. #Java #SpringBoot #Backend #CleanArchitecture

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

#Post2 In the previous post, we understood what a REST API is. Now the next question is 👇 How do we actually build REST APIs in Spring Boot? That’s where @RestController comes in 🔥 @RestController is a special annotation used to create REST APIs. It combines two things: • @Controller • @ResponseBody 👉 Meaning: Whatever method returns → it is written directly to the HTTP response body (usually JSON for objects) Example: @RestController public class UserController { @GetMapping("/user") public String getUser() { return "Hello User"; } } Output → "Hello User" (sent as response) 💡 Key difference: @Controller → used for returning views (JSP/HTML) @RestController → used for REST APIs (JSON response) Key takeaway: If you are building APIs in Spring Boot → @RestController is your starting point 🚀 In the next post, we will understand how request mapping works using @GetMapping and others 🔥 #Java #SpringBoot #BackendDevelopment #RESTAPI #LearnInPublic

🚀 Spring Boot Internals Series – Part 3 Ever seen this error? 👉 404 Not Found 👉 405 Method Not Allowed And thought: “My controller is correct… why is this not working?” You’re not alone. The issue is often NOT your code. It’s how Spring is trying to find your method. --- 🔍 Who decides which method gets called? 👉 HandlerMapping This is the component that tells Spring: “Which controller method should handle this request?” --- ⚙️ What actually happens When a request comes in: 1️⃣ DispatcherServlet receives the request 2️⃣ It asks HandlerMapping 3️⃣ HandlerMapping scans all controllers 4️⃣ Matches URL + HTTP method 5️⃣ Returns the correct handler method --- 🧠 Example @GetMapping("/users") public List<User> getUsers() { return userService.getUsers(); } If your request is: GET /users 👉 It matches perfectly ✅ But if your request is: POST /users 👉 No match ❌ → 405 error --- ⚠️ Why developers struggle Because we assume: “If the method exists, it will be called” But Spring checks: - URL path - HTTP method (GET/POST/PUT/DELETE) - Request mappings If anything doesn’t match → request fails --- 💡 Key takeaway Spring doesn’t “guess” your method. 👉 It strictly matches request → mapping Understanding this saves hours of debugging. --- 📌 Next post: I’ll break down how Spring converts request data into Java objects (Data Binding) Follow if you want to understand backend systems deeply. #SpringBoot #JavaDeveloper #BackendDeveloper #SoftwareEngineering #Microservices #LearningInPublic

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

🔄 Spring Bean Lifecycle – From Creation to Destruction While working with Spring, one concept that really helped me understand how things run internally is the Bean Lifecycle. A Spring Bean goes through multiple stages from the moment it is created till it gets destroyed. Knowing this flow makes debugging and customization much easier. 👉 1. Instantiation Spring container creates the bean instance using constructor or factory method. 👉 2. Dependency Injection All required dependencies are injected (via constructor/setters/fields). 👉 3. Initialization Spring calls lifecycle callbacks like: @PostConstruct InitializingBean.afterPropertiesSet() custom init-method 👉 4. Bean Ready for Use Now the bean is fully initialized and ready to serve the application. 👉 5. Destruction Before removing the bean, Spring calls: @PreDestroy DisposableBean.destroy() custom destroy-method 💡 Why it matters? Understanding lifecycle hooks allows better control over resource management, logging, and custom initialization logic. 📌 For me, learning this made Spring feel less like “magic” and more predictable. #Java #SpringBoot #BackendDevelopment #SoftwareEngineering #LearningJourney