Spring Boot Validation with @Min and @Max Annotations

Hi everyone 👋 Continuing the Spring Boot Validation Series part 28 👇 📌 Validation Annotation – @Size The @Size annotation is used to define minimum and maximum length for a field 👇 🔹 Why do we use @Size? Sometimes we need to restrict input length. 👉 Example: - Username should be at least 3 characters - Password should be at least 8 characters @Size helps us enforce these rules. 🔹 Simple Example - public class User { @Size(min = 3, max = 20) private String name; @Size(min = 8) private String password; } @PostMapping("/users") public String createUser(@Valid @RequestBody User user) { return "User created"; } 👉 If value is too short or too long → validation fails ❌ 🔹 Important Point 👉 @Size works with: - String - Collection (List, Set, etc.) - Arrays 🔹 Example with List @Size(min = 1, max = 5) private List<String> roles; 👉 Ensures list size is between 1 and 5 🔹 Common Mistake 👉 @Size does NOT check for null ❌ So often we combine it with: @NotNull @Size(min = 3, max = 20) private String name; 🔹 In simple words @Size controls how short or long a value can be. 👉 🧠 Quick Understanding - Used for length validation - Works on String, List, Array #SpringBoot #Java #Validation #SizeAnnotation #BackendDevelopment #LearningInPublic

🚨 Why I stopped using field injection in Spring Boot I used to write this: @Autowired private UserService userService; Looks clean… but caused real issues. ❌ Problems: * Hard to test * Hidden dependencies * NullPointer risks in edge cases ✅ Now I always use constructor injection: public UserController(UserService userService) { this.userService = userService; } 💥 Real benefit: While writing unit tests, I realized I could mock dependencies easily without Spring context. 💡 Takeaway: Field injection is convenient. Constructor injection is production-safe. Small change. Big impact. #Java #SpringBoot #BackendDevelopment #SoftwareEngineering  #Microservices #RESTAPI #SystemDesign  #DeveloperLife #100DaysOfCode

🚀 Day 7 – Exception Handling: More Than Just try-catch Today I focused on how exception handling should be used in real applications—not just syntax. try { int result = 10 / 0; } catch (Exception e) { System.out.println("Error occurred"); } This works… but is it the right approach? 🤔 👉 Catching generic "Exception" is usually a bad practice 💡 Better approach: ✔ Catch specific exceptions (like "ArithmeticException") ✔ Helps in debugging and handling issues more precisely ⚠️ Another insight: Avoid using exceptions for normal flow control Example: if (value != null) { value.process(); } 👉 is better than relying on exceptions 💡 Key takeaway: - Exceptions are for unexpected scenarios, not regular logic - Proper handling improves readability, debugging, and reliability Small changes here can make a big difference in production code. #Java #BackendDevelopment #ExceptionHandling #CleanCode #LearningInPublic

🧠 After learning the Spring Bean Lifecycle, I explored another powerful concept today 👀 Singleton vs Prototype Bean Scope in Spring Boot 🚀 The default scope in Spring is singleton 👇 ✅ Only one object instance is created ✅ Shared across the whole application ✅ Best for services, repositories, controllers Then comes prototype 👇 🔁 A new object is created every time it is requested This makes it useful for: ✅ temporary objects ✅ stateful helpers ✅ per-request custom processing 💡 My takeaway: Bean scope directly changes how Spring manages memory and object reuse. Small annotations can completely change runtime behavior ⚡ #Java #SpringBoot #BeanScope #BackendDevelopment #LearningInPublic

🧠 After learning Request Scope, I explored something even more practical today 👀 **Session Scope in Spring Boot** 🌐 Here’s the simple idea 👇 ✅ One bean instance is created per **user session** ✅ The same object is reused across multiple requests from the same user ✅ Different users get different objects This makes it useful for 👇 🔹 user login data 🔹 shopping cart 🔹 session-based preferences 🔹 multi-step workflows 💡 Quick difference: Request Scope → new object every request Session Scope → same object for the same user 💡 My takeaway: Session scope helps maintain **user-specific state across multiple requests** without recreating objects again and again ⚡ #Java #SpringBoot #SessionScope #BackendDevelopment #LearningInPublic

👉Arrays vs ArrayLists. Looks similar. But difference matters! Many people start with Arrays. Fixed size. Simple syntax. Everything feels under control. Then comes ArrayList. Dynamic size. Easy to use. No need to worry about capacity. Sounds like ArrayList is better, right? Not always. That’s where the realisation comes in. 👉Arrays are faster. They use fixed memory. Better when size is known. 👉ArrayLists are flexible. They resize automatically. But come with slight overhead. Same data. Different behavior. And that difference shows up in performance. The real takeaway is simple. ✨Use Arrays when size is fixed and performance matters. ✨Use ArrayList when flexibility is needed. Don’t just learn syntax — understand use cases. 👉Because in the end, choosing the right structure > writing more code. 👉 When do you prefer Arrays over ArrayList? #DSA #Java #CodingJourney #SoftwareDevelopment #CareerGrowth

🚀 Day 16 of #100DaysOfCode Today’s problem: Minimum Absolute Difference 📊 🔍 Problem Understanding: Given an array of distinct integers, find all pairs with the minimum absolute difference. 🧠 Approach: First, I sorted the array Then compared adjacent elements (since minimum difference will always be between neighbors in sorted order) Tracked the minimum difference and stored all valid pairs 👉 Key Insight: Sorting reduces unnecessary comparisons and simplifies the problem ⚙️ Concepts Used: Sorting (Arrays.sort) Greedy observation (check only neighbors) List handling for storing pairs 📊 Complexity: ⏱️ Time Complexity: O(N log N) (due to sorting) 💾 Space Complexity: O(N) (for storing result pairs) 📚 Key Learnings: Learned how sorting simplifies problems Understood how to reduce complexity from brute force O(N²) → O(N log N) Improved thinking in terms of patterns and optimization 💯 Result: ✔️ Accepted (All test cases passed) ✔️ Runtime: 1 ms (100%) 🔥 ✔️ Clean and efficient solution Sometimes the best optimization is just sorting + observation 💡 Let’s keep building consistency 🚀 #Day16 #100DaysOfCode #Java #DSA #LeetCode #ProblemSolving #Sorting

Day 95/200 – LeetCode Challenge. Problem: Remove Duplicates from Sorted List II (Java) Today’s focus was eliminating all duplicate values from a sorted linked list while keeping only distinct nodes. Implemented an efficient two-pointer approach with a dummy node to handle edge cases cleanly. Linked lists require careful pointer management. Dummy nodes simplify boundary conditions. One-pass solution ensures optimal performance. Continuing the 200-day journey, one problem at a time. #LeetCode #Java #CodingChallenge #200DaysOfCode #ProblemSolving

🚀 Developed a basic REST API using Spring Boot to handle HTTP requests and responses. 🔹 What I implemented: Created a REST Controller using @RestController Used @RequestMapping to define base URL (/api) Built a GET API using @GetMapping("/student") 🔹 API Endpoint: http://localhost:8080/api/student 🔹 Output: "Student data" 🔹 Key Learnings: How Spring Boot handles HTTP requests Understanding request → controller → response flow Basics of REST API development Excited to move next into POST APIs and sending real data using @RequestBody 🔥 #SpringBoot #Java #BackendDevelopment #LearningJourney #CSE 

Have you ever debugged a production issue where logs show the same error everywhere… but you still can’t figure out what actually failed? I used to make this mistake a lot — catch exception → log error → throw again Service logs Repository logs Controller logs Same exception 3–4 times. Just noise. Then I changed one simple thing: don’t log where you’re just throwing the exception. Now I follow this: Service/Repository → just throw or wrap the exception Log only once at the boundary (API / consumer) Always add context We often don’t pay much attention to logging, but it plays a crucial role when debugging a system. You need clarity on where to log, what to log, and where not to. Now instead of messy logs, I get one clear error log with full context. Debugging feels less like guessing and more like tracing a story. Less logs. Better logs. That’s the real strategy. #BackendDevelopment #Microservices #SystemDesign #Java #SpringBoot #Logging #SoftwareEngineering #CleanCode