Atharv Mohite’s Post

🚀 Day 13/100 - Spring Boot Annotations - 4️⃣ @Configuration & @Bean ➡️ @Configuration 🔹What is it - A class-level annotation which tells Spring that this class contains bean definitions for the IoC container. - It is a modern replacement for XML-based configuration. 🔹Why to use - Makes configuration type-safe - Easy to read and maintain - Fully Java-based (no XML) ➡️ @Bean 🔹What is it - A method-level annotation used inside a @Configuration class to explicitly create and register a bean in the Spring container. 🔹Why to use - Useful when you cannot modify a class (e.g., third-party libraries) - Gives full control over object creation and configuration 📌 Key Takeaway @Configuration → where beans are defined @Bean → how a bean is created Next post: https://lnkd.in/d3pztG-x Previous post: https://lnkd.in/d8NzCVkB #100Days #SpringBoot #Java #BackendDevelopment #SoftwareEngineering

I just published Part 7 of my Spring Boot series. This installment focuses on making your APIs professional and production-ready by effectively handling errors and validating requests. In this article, I cover: ✔️ Why exception handling matters ✔️ Custom exceptions (e.g., ResourceNotFoundException) ✔️ Global exception handling with @RestControllerAdvice ✔️ Request validation using @Valid, @NotBlank, @Email ✔️ Returning clean 400/404 JSON responses instead of messy errors Read here. #SpringBoot #Java #RESTAPI #BackendDevelopment #LearningInPublic

Hi everyone 👋 Continuing the weekday Spring Boot series with another useful annotation 👇 📌 Spring Boot Annotation Series – Part 6 ✅ @Value annotation The @Value annotation is used to inject values into Spring beans 👇 🔹 Why do we use @Value? - To read values from application.properties or application.yml - To avoid hardcoding values in code - To manage environment-specific configurations 🔹 Where can we use @Value? To inject: - Configuration values - Environment variables - Default values 🔹 Simple example properties - server.port=8081 app.name=MySpringApp in java code - @Value("${server.port}") private int port; @Value("${app.name}") private String appName; 🔹 In simple words @Value helps us take values from configuration files and use them directly in our code. 👉 🧠 Quick Understanding (My Notes) - @Value injects external values into fields - Mostly used with application.properties - Helps keep code clean and configurable #SpringBoot #Java #ValueAnnotation #BackendDevelopment #LearningInPublic

🚦 Spring Boot Simplified: @Primary vs. @Qualifier 🚦 Ever found yourself with multiple beans of the same type in your Spring application and wondered how Spring knows which one to inject? 🤔 🌟 @Primary Think of this as setting a default. If multiple beans of a type exist, the one marked with @Primary is the one Spring picks—unless told otherwise. @Bean @Primary public DataSource primaryDataSource() { // ... } ✨ @Qualifier Want to be more explicit? Use @Qualifier to specify exactly which bean you want, by name! @Autowired @Qualifier("secondaryDataSource") private DataSource dataSource; 🔑 Key Takeaway: Use @Primary for a sensible default. Use @Qualifier for precision control. These annotations give you the flexibility to manage complex dependency graphs cleanly and clearly—making your codebase more robust and readable! #SpringBoot #Java #CodingTips #BeanInjection #SoftwareEngineering #SpringFramework

Deep dive into Spring Framework – Understanding Beans 🌱 Today, I focused on one of the most important concepts in Spring: Beans. ➤ A Spring Bean is a Java object that is created, configured, and managed by the Spring IoC container. Instead of manually handling objects, Spring takes care of their lifecycle and dependencies. ➤ Beans can be created using annotations like @Component, @Service, @Repository, @Controller, or explicitly using @Bean inside @Configuration classes. These annotations allow Spring to automatically detect and manage objects. ➤ I also learned about the Bean Lifecycle, which includes instantiation, dependency injection, initialization, and destruction—giving better control over how objects behave during application runtime. ➤ Lastly, I explored Bean Scopes such as singleton (default), prototype, request, and session, which define how long a bean instance lives and how it’s shared. Strong fundamentals here make Spring applications clean, scalable, and maintainable. Learning Spring made easier thanks to Anuj Kumar Sharma #SpringFramework #SpringBoot #Java #BackendDevelopment #SoftwareEngineering #LearningJourney

📌 Spring Boot Annotation Series – Part 8 ✅ @Component annotation The @Component annotation is used to mark a class as a Spring-managed bean 👇 🔹 Why do we use @Component? To tell Spring: 👉 “Create an object of this class and manage it.” - To enable dependency injection - To let Spring detect the class during component scanning 🔹 How does it work? When Spring Boot starts: - It scans packages (using @ComponentScan) - Finds classes annotated with @Component - Creates and registers them as beans in the Spring container 🔹 Simple example @Component public class EmailService { public void sendEmail() { System.out.println("Email sent"); } } Now this class can be injected using: @Autowired private EmailService emailService; 🔹 In simple words @Component tells Spring to automatically create and manage this class as a bean. 👉 🧠 Quick Understanding - Marks a class as a Spring bean - Detected during component scanning - Enables dependency injection #SpringBoot #Java #Component #BackendDevelopment #LearningInPublic

𝗦𝗽𝗿𝗶𝗻𝗴 𝗕𝗼𝗼𝘁 — 𝗠𝗮𝗱𝗲 𝗦𝗶𝗺𝗽𝗹𝗲 🚀 (𝗣𝗮𝗿𝘁 𝟲) Never trust user input. 𝘜𝘴𝘦𝘳𝘴 𝘤𝘢𝘯 𝘴𝘦𝘯𝘥: 𝘌𝘮𝘱𝘵𝘺 𝘧𝘪𝘦𝘭𝘥𝘴. 𝘞𝘳𝘰𝘯𝘨 𝘧𝘰𝘳𝘮𝘢𝘵𝘴. 𝘐𝘯𝘷𝘢𝘭𝘪𝘥 𝘥𝘢𝘵𝘢. And if you don’t validate properly? Bad data enters your system and causes problems later. In this carousel, I break down: • Why 𝘷𝘢𝘭𝘪𝘥𝘢𝘵𝘪𝘰𝘯 𝘮𝘢𝘵𝘵𝘦𝘳𝘴 • How @𝗩𝗮𝗹𝗶𝗱 𝘄𝗼𝗿𝗸𝘀 • Common constraints like @𝗡𝗼𝘁𝗡𝘂𝗹𝗹, @𝗦𝗶𝘇𝗲, @𝗘𝗺𝗮𝗶𝗹 • How to handle 𝘃𝗮𝗹𝗶𝗱𝗮𝘁𝗶𝗼𝗻 𝗲𝗿𝗿𝗼𝗿𝘀 𝗰𝗹𝗲𝗮𝗻𝗹𝘆 𝗡𝗼 𝗷𝗮𝗿𝗴𝗼𝗻. 𝗡𝗼 𝘂𝗻𝗻𝗲𝗰𝗲𝘀𝘀𝗮𝗿𝘆 𝘁𝗵𝗲𝗼𝗿𝘆. 𝗝𝘂𝘀𝘁 𝗽𝗿𝗮𝗰𝘁𝗶𝗰𝗮𝗹 𝗦𝗽𝗿𝗶𝗻𝗴 𝗕𝗼𝗼𝘁. 📌 Save this if you're building APIs 👉 Follow for Part 7 - Spring Boot JPA Basics #SpringBoot #SpringFramework #Java #JavaDeveloper #BackendDevelopment #LearnJava #RESTAPI #SoftwareEngineering #SpringBootMadeSimple

📌 Spring Boot Annotation Series ✅ @Configuration Ever wondered where Spring creates beans from @Bean methods? That’s exactly what @Configuration is for 👇 🔹 Why do we use @Configuration? @Configuration tells Spring: 👉 “This class contains bean definitions.” It is used to define beans using Java code instead of XML. 🔹 When do we use @Configuration? 1)When we want to create beans using @Bean 2)When we need to set up things like: - Database connection (DataSource) - RestTemplate - Security configuration - Common utility beans 3) When we are using external libraries and need to create beans manually 🔹 How does it work? Spring creates a proxy of the configuration class, so that each @Bean method returns the same singleton object. 🔹 Simple example @Configuration public class AppConfig { @Bean public RestTemplate restTemplate() { return new RestTemplate(); } } In simple words, when a class is annotated with @Configuration, Spring treats it like a configuration file and scans it for @Bean methods. These beans are then managed by the Spring container. #SpringBoot #Java #Configuration #BackendDevelopment #LearningInPublic

🚨 Spring Boot, @Bean inside @Component behaves VERY differently Look at this: @Component public class AppConfig {   @Bean   public OrderService orderService() {     return new OrderService();   } } Looks fine, right? ❌ But this does NOT behave like @Configuration. 🧠 What actually happens at runtime When @Bean is inside @Component: ❌ No CGLIB proxy ❌ No method interception ❌ No singleton guarantee on method calls Calling: orderService(); orderService(); 👉 creates NEW objects every time This mode is called Lite Configuration. ✅ Correct way (Full Configuration Mode) @Configuration public class AppConfig {   @Bean   public OrderService orderService() {     return new OrderService();   } } Here Spring: Creates a CGLIB proxy Intercepts method calls Always returns the same singleton bean 🚨 Why this matters in real projects @Bean public PaymentService paymentService() {   return new PaymentService(orderService()); // 💥 different instance } ➡ Silent bugs ➡ Unexpected behavior ➡ Painful production debugging No exception. No warning. Just wrong behavior. 🎯 Golden Rule @Configuration changes how Java methods behave. @Component does not. #SpringBoot #Java #SpringFramework #Backend #SoftwareEngineering #JVM #SpringTips

🚀 Day 30/100 - Spring Boot - Handling Request Parameters When building REST APIs, handling client input correctly is key. Spring Boot provides a few powerful annotations for this 👇 ➡️ @PathVariable 🔹Binds a URL path segment to a method parameter 🔹Example: /users/{id} → @PathVariable Long id 🔹Used when the value is part of the URL itself ➡️ @RequestParam 🔹Extracts query parameters from the URL 🔹Example: /users?role=admin → @RequestParam String role 🔹Best for optional filters, search params, pagination, etc ➡️ @RequestBody 🔹Maps the request body (JSON/XML) directly to a Java object 🔹Example: JSON POST → @RequestBody User user 🔹Commonly used in POST/PUT APIs ➡️ Why this matters 🔹Clean API contracts 🔹Automatic data binding 🔹Less manual parsing 🔹Readable and maintainable code Next post: https://lnkd.in/dRHkuPyT Previous post: https://lnkd.in/da4MExJy #100Days #SpringBoot #Java #RESTAPI #PathVariable #RequestParam #RequestBody #BackendDevelopment #WebDevelopment #SoftwareEngineering