Understanding Stateless Beans in Spring Framework

Hi everyone 👋 📌 Spring Boot Annotation Series Part 18 – @PostMapping The @PostMapping annotation is used to handle HTTP POST requests in a Spring Boot application. It is part of the Spring Framework and is mainly used to create new resources in REST APIs. 🔹 What is @PostMapping? @PostMapping is a shortcut for: @RequestMapping(method = RequestMethod.POST) It makes the code cleaner and more readable. 🔹 When Do We Use POST? ✔ To create new data ✔ To submit form data ✔ To send request body (JSON/XML) ✔ When data is modified on the server Example use cases: Create a new user Place an order Register a customer Submit login details 🔹 Basic Example - @RestController @RequestMapping("/api/users") public class UserController { @PostMapping public String createUser(@RequestBody String user) { return "User created: " + user; } } 👉 Handles: POST http://localhost:8080/api/users 🔹 In Simple Words @PostMapping handles create operations in REST APIs. When a POST request hits the URL, Spring executes the mapped method and processes the request body. #SpringBoot #Java #RESTAPI #BackendDevelopment #InterviewPreparation #LearningInPublic

A small backend lesson that changed how I write APIs: Most bugs don’t happen in the “happy path”. They happen at the boundaries. What do I mean by boundaries? • When input is empty • When a field is null • When another service is slow • When the database returns unexpected data • When a user sends something you didn’t anticipate Earlier, I used to focus only on making the main logic work. Now I try to think: “What could go wrong here?” Even simple checks like: • Validating input properly • Handling null safely • Returning meaningful error responses make a huge difference in real systems. Still learning, but thinking about edge cases has already improved how I approach backend code. What’s one backend mistake that taught you an important lesson? #BackendEngineering #Java #SpringBoot #SoftwareEngineering #LearningInPublic

📌 Spring Boot Annotation Series – Part 9 ✅ @Service annotation The @Service annotation is used to mark a class as a service layer component in Spring 👇 🔹 What is @Service? @Service is a specialization of @Component. It tells Spring: 👉 “This class contains business logic. Create and manage it as a bean.” 🔹 Why do we use @Service? To separate business logic from controllers To follow layered architecture To make the code clean and organized 🔹 How does it work? When Spring Boot starts: It scans for classes annotated with @Service Creates an object (bean) Makes it available for dependency injection 🔹 Simple example - @Service public class UserService { public String getUser() { return "User details"; } } Now it can be injected into a controller: @Autowired private UserService userService; 🔹 In simple words @Service is used to mark classes that contain business logic, and Spring manages them as beans. 👉 🧠 Quick Understanding @Service = specialized @Component Used for business logic layer Enables dependency injection #SpringBoot #Java #ServiceAnnotation #BackendDevelopment #LearningInPublic

⚖️ Streams vs imperative loops: where Streams hurt readability Java Streams are powerful. But in real enterprise systems, power isn’t always clarity. I’ve seen Streams make code beautifully concise. I’ve also seen them make business logic almost unreadable. Streams tend to hurt readability when: ● Multiple business rules are embedded inside lambdas ● Filtering, mapping, grouping, and calculations are chained together ● The why is harder to grasp than the how In backend systems with heavy business logic, I often prefer: ● Explicit intermediate variables ● Named methods that reflect business meaning ● Slightly more verbose code, but easier to reason about and debug Especially in financial or rule-driven systems, clarity beats cleverness. Code is read far more often than it’s written, and usually by someone else. Streams are a great tool. They just shouldn’t hide the business. Where do you personally draw the line between Streams and imperative code? #Java #BackendEngineering #CleanCode #EnterpriseSoftware #BackendDevelopment #SeniorDeveloper #CodeReview #Programming

📌 Spring Boot Annotation Series Part 17 – @GetMapping The @GetMapping annotation is used to handle HTTP GET requests in Spring Boot applications. It is part of the Spring Framework and is mainly used in REST APIs. 🔹 What is @GetMapping? @GetMapping is a shortcut for: @RequestMapping(method = RequestMethod.GET) Instead of writing the long version, we use this cleaner and more readable annotation. 🔹 Basic Example - @RestController @RequestMapping("/api") public class UserController { @GetMapping("/users") public String getUsers() { return "List of users"; } } 👉 This handles: GET http://localhost:8080/api/users 🔹 When Do We Use GET? ✔ To fetch data ✔ No modification of data ✔ Safe and idempotent operation Example use cases: - Get all users - Get user by ID - Fetch product list - Retrieve order details 🔹 In Simple Words @GetMapping handles read operations in REST APIs. When a GET request hits the URL, Spring executes the mapped method. #SpringBoot #Java #RESTAPI #BackendDevelopment #InterviewPreparation #LearningInPublic

Day 11/30 – LeetCode streak Today’s problem: Sort Integers by The Number of 1 Bits You have to sort an array by popcount first (fewer 1s come earlier), and if two numbers have the same count, sort them by their actual value. Instead of using 'Arrays.sort' with a comparator, I tried writing the sort logic myself with insertion sort: - For each element, treat it as 'key' and move larger elements (based on custom “bit count, then value” order) one step to the right. - 'Swap(a, b)' returns true if 'a' should come after 'b' in the final order, using a manual 'countBits' function to compare the number of 1s. - If bit counts differ, the one with more 1s is considered “greater”; if they’re equal, compare the raw integers. Day 11 takeaway: This was a nice chance to practice writing a custom sort order from scratch—once the comparison rule is clear (“by 1-bits, then by value”), the rest is just plugging that into any sorting algorithm. #leetcode #dsa #java #bitmanipulation #sorting

📌 Spring Boot Annotation Series – Part 5 ✅ @Bean Ever wondered how Spring creates objects that are not annotated with @Component? That’s where @Bean comes in 👇 🔹 Why do we use @Bean? @Bean tells Spring: 👉 “Create an object from this method and manage it as a bean.” It is mainly used when: 1) We want full control over object creation 2) We are using third-party classes 3) We cannot add Spring annotations to a class 🔹 When do we use @Bean? To create beans manually For objects like: - RestTemplate - ObjectMapper - DataSource When configuration logic is required 🔹 Simple example @Configuration public class AppConfig { @Bean public RestTemplate restTemplate() { return new RestTemplate(); } } 🔹 In simple words @Bean is used to tell Spring what object to create and manage when auto-scanning is not enough. ⭐ Important note @Bean is usually used inside a @Configuration class. By default, beans created using @Bean are singleton. 👉 🧠 Quick Understanding @Bean is a spring annotation used to explicitly declare a method as a bean producer. When a method is annotated with @Bean , Spring will execute that method and register its return value as a bean in the Spring application context. #SpringBoot #Java #Bean #BackendDevelopment #LearningInPublic

💡 Sometimes the biggest debugging sessions end with the smallest fixes. Recently, a friend reached out saying their Spring Boot API wasn’t returning any data. No errors, No exceptions, Just… empty responses. We assumed it was something serious: - Database issue? - Transaction problem? - Mapping error? - Serialization issue? We checked: ✔ Entity mappings ✔ Repository queries ✔ Logs ✔ API responses ✔ Even database records directly Everything looked correct. After almost an hour of digging… We found the actual issue. 👉 The API request parameter name didn’t match the method parameter name. The controller had: @RequestParam("userId") But the frontend was sending: userid Just a small case mismatch. Spring couldn’t bind the value correctly — so it returned empty results. - One tiny detail. - One simple mismatch. - One hour of overthinking. Big lesson: Before assuming complex failures, always verify the small things. In backend development, sometimes the problem isn’t architecture — it’s a lowercase letter. #Java #SpringBoot #BackendDevelopment #Debugging #ProblemSolving #SoftwareEngineering #Developers #CodingLife #TechCommunity #Programming #Learning

𝗦𝗽𝗿𝗶𝗻𝗴 𝗕𝗼𝗼𝘁 — 𝗠𝗮𝗱𝗲 𝗦𝗶𝗺𝗽𝗹𝗲 🚀 (𝗣𝗮𝗿𝘁 𝟰) You click a button. Your app sends data. But… 𝗵𝗼𝘄 𝗱𝗼𝗲𝘀 𝗦𝗽𝗿𝗶𝗻𝗴 𝗕𝗼𝗼𝘁 𝗿𝗲𝗮𝗱 𝗶𝘁? 🤔 That confusion hits almost every beginner. In this carousel, I break down the 𝟰 𝗺𝗮𝗶𝗻 𝘄𝗮𝘆𝘀 𝗱𝗮𝘁𝗮 𝗲𝗻𝘁𝗲𝗿𝘀 𝘆𝗼𝘂𝗿 𝗔𝗣𝗜: • @GetMapping & @PostMapping • @PathVariable (data in the URL) • @RequestParam (filters & search) • @RequestBody (JSON → Java object) With 𝘀𝗶𝗺𝗽𝗹𝗲 𝗿𝘂𝗹𝗲𝘀, 𝗿𝗲𝗮𝗹 𝗲𝘅𝗮𝗺𝗽𝗹𝗲𝘀, and 𝘇𝗲𝗿𝗼 𝗷𝗮𝗿𝗴𝗼𝗻. No memorization. Just understanding. 📌 𝗦𝗮𝘃𝗲 𝘁𝗵𝗶𝘀 if Spring Boot APIs ever confused you 👉 𝗙𝗼𝗹𝗹𝗼𝘄 for Part 5 — coming soon 🚀 💬 𝗪𝗵𝗶𝗰𝗵 𝗼𝗻𝗲 𝗰𝗼𝗻𝗳𝘂𝘀𝗲𝗱 𝘆𝗼𝘂 𝘁𝗵𝗲 𝗺𝗼𝘀𝘁 𝘄𝗵𝗲𝗻 𝘆𝗼𝘂 𝘀𝘁𝗮𝗿𝘁𝗲𝗱? @PathVariable or @RequestParam 👇 #SpringBoot #SpringFramework #Java #JavaDeveloper #BackendDevelopment #SpringBootAnnotations #RESTAPI #LearnJava #JavaProgramming

How a system like BookMyShow can use Bloom Filters Imagine millions of users searching for: Is seat A1 available? 1. Thousands of concurrent checks 2. High traffic during big releases 3. Massive read pressure on the database Instead of hitting the databse evrytime, a System can use a bloom filter 1. Seat Id is checked in the Bloom filter first 2. If bloom filter say’s definitely not present Skip db call completely 3. If it says might be present Then verify using the databse If it says doesn’t exist - guaranteed true If it says seat exists - verify before confirming Bloom filters trade a little accuracy for huge performance gains. At scale, that trade off matters #SystemDesign #Backend #Java