Bean Scopes in Spring: Singleton, Prototype, Request, Session

#Post3 In the previous post, we understood the role of @RestController in building APIs. Now the next step is 👇 How do we map HTTP requests to methods? That’s where mapping annotations come in 🔥 In Spring Boot, we use: • @GetMapping → for GET requests • @PostMapping → for POST requests • @PutMapping → for UPDATE • @DeleteMapping → for DELETE • @PatchMapping → for partial updates Example: @GetMapping("/users") → fetch all users @PostMapping("/users") → create a new user 💡 What about @RequestMapping? @RequestMapping is a generic annotation that can handle all HTTP methods. Example: @RequestMapping(value="/users", method=RequestMethod.GET) 👉 But in modern Spring Boot, we prefer specific annotations like @GetMapping for cleaner and readable code Key takeaway: Use specific mapping annotations for better clarity and maintainability 👍 In the next post, we will understand how @RequestBody works in handling request data 🔥 #Java #SpringBoot #BackendDevelopment #RESTAPI #LearnInPublic

New to Spring Boot? You'll see these annotations in every project. Here's what they actually do: @SpringBootApplication → Entry point. Combines @Configuration, @EnableAutoConfiguration, @ComponentScan @RestController → Marks a class as an HTTP request handler that returns data (not views) @Service → Business logic layer. Spring manages it as a bean @Repository → Data access layer. Also enables Spring's exception translation @Autowired → Inject a dependency automatically (prefer constructor injection instead) @GetMapping / @PostMapping / @PutMapping / @DeleteMapping → Maps HTTP methods to your handler methods @RequestBody → Deserializes JSON from request body into a Java object @PathVariable → Extracts values from the URL path Bookmark this. You'll refer back to it constantly. Which annotation confused you the most when starting out? 👇 #Java #SpringBoot #Annotations #BackendDevelopment #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 Annotation-Based Configuration (Beginner Friendly Guide) If you’re starting with Spring, understanding how the IOC container works is super important. Let’s break it down with a simple example 👇 👉 1. Main Class (Entry Point) import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; public class Main { public static void main(String[] args) { // Step 1: Load Spring configuration file ApplicationContext container = new ClassPathXmlApplicationContext("applicationContext.xml"); // Step 2: IOC container is ready and beans are created automatically System.out.println("IOC Container Loaded Successfully ✅"); } } 👉 2. applicationContext.xml (Configuration File) <beans xmlns="https://lnkd.in/d858D-Nk" xmlns:xsi="https://lnkd.in/dNJZbNmc" xmlns:context="https://lnkd.in/dEDWzfEq" xsi:schemaLocation=" https://lnkd.in/d858D-Nk https://lnkd.in/dbit7sVK https://lnkd.in/dEDWzfEq https://lnkd.in/daN7U-FT"> <!-- Scan this package for annotations --> <context:component-scan base-package="org.annotationbasedconfiguration"/> </beans> 💡 What does this mean? ✔️ Spring reads the XML file ✔️ Scans the given package ✔️ Finds classes with annotations like: @Component @Service @Repository ✔️ Automatically creates objects (Beans) and manages them 🎯 Why use an Annotation-Based Approach? ✅ Less XML configuration ✅ Cleaner code ✅ Easy to manage ✅ Industry standard approach 👉 Simple Understanding: "Just add annotations in your class, and Spring will create & manage objects for you." #Java #SpringFramework #Beginners #BackendDevelopment #IoC #DependencyInjection #CodingJourney

Spring Boot Annotations by Layers — A Complete Guide for Developers Understanding how Spring Boot annotations are structured across layers is essential for writing clean, scalable, and maintainable applications. Here’s a structured breakdown 👇 1. Controller Layer (Presentation Layer) Handles incoming HTTP requests & sends responses Annotations: ✔️ @RestController ✔️ @Controller ✔️ @RequestMapping ✔️ @GetMapping / @PostMapping / @PutMapping / @DeleteMapping ✔️ @RequestParam, @PathVariable, @RequestBody 2. Service Layer (Business Logic Layer) Contains core application logic Annotations: ✔️ @Service ✔️ @Component ✔️ @Transactional 3. Repository Layer (Persistence Layer) Interacts with the database Annotations: ✔️ @Repository ✔️ @EnableJpaRepositories ✔️ @Query ✔️ @Modifying 4. Entity Layer (Model Layer) Represents database tables Annotations: ✔️ @Entity ✔️ @Table ✔️ @Id ✔️ @GeneratedValue ✔️ @Column ✔️ @OneToMany / @ManyToOne / @ManyToMany 5. Configuration Layer Manages application setup Annotations: ✔️ @Configuration ✔️ @Bean ✔️ @ComponentScan ✔️ @EnableAutoConfiguration ✔️ @SpringBootApplication 6. Cross-Cutting Concerns (Common Across Layers) Annotations: ✔️ @Autowired, @Qualifier, @Primary ✔️ @Valid, @NotNull, @Size ✔️ @ControllerAdvice, @ExceptionHandler Why this matters? A clear understanding of these layers helps you: Write clean and modular code Improve scalability and maintainability Perform better in interviews Design real-world enterprise applications Always explain Spring Boot in this flow: Controller → Service → Repository → Entity → Configuration If you found this helpful, feel free to 👍 like, 💬 comment, and 🔖 save for future reference. #SpringBoot #Java #BackendDevelopment #Microservices #Programming #SoftwareEngineering #InterviewPreparation

Hi everyone 👋 📌 Spring Boot Annotation Series Part 22– @RequestParam @RequestParam is used to read query parameters from the request URL and bind them to method parameters. It is part of the Spring Framework and commonly used in REST APIs built with Spring Boot. 🔹 Why do we use @RequestParam? Sometimes we need to pass additional information through the URL. Example: GET /users?age=25 Here, age is a query parameter. @RequestParam helps us capture that value in the controller method. 🔹 Simple Example @RestController @RequestMapping("/users") public class UserController { @GetMapping("/search") public String getUserByAge(@RequestParam int age) { return "User age is: " + age; } } 👉 Request URL: GET http://localhost:8080/users/search?age=25 Output: User age is: 25 🔹 In Simple Words @RequestParam takes values from query parameters in the URL and passes them to the controller method. 👉 🧠 Quick Understanding Used in filtering, search APIs Can be optional using required=false Can provide default values Used to read query parameters from URL Mostly used in GET APIs #SpringBoot #Java #RESTAPI #RequestParam #BackendDevelopment #LearningInPublic

Hi everyone 👋 Continuing the Spring Boot Annotation Series 👇 📌 Spring Boot Annotation Series part 24 – @ResponseBody @ResponseBody is used to return data directly in the HTTP response body instead of returning a view (HTML page). It is part of the Spring Framework and is commonly used in REST APIs built with Spring Boot. 🔹 Why do we use @ResponseBody? In Spring MVC: Without @ResponseBody → returns a view (HTML/JSP) With @ResponseBody → returns data (JSON/XML) 👉 It is mainly used for building REST APIs. 🔹 Simple Example @Controller public class UserController { @GetMapping("/user") @ResponseBody public String getUser() { return "User details"; } } 👉 Output will be directly shown in response body, not a view. 🔹 Returning Object as JSON @GetMapping("/user") @ResponseBody public User getUser() { return new User(1, "Asmita"); } 👉 Spring automatically converts it into JSON. 🔹 How does it work? - Spring uses Jackson library internally - Converts Java object → JSON - Sends it in HTTP response 🔹 In Simple Words @ResponseBody tells Spring to send data directly in the response instead of returning a web page. 👉 🧠 Quick Understanding - Returns data, not view - Converts object → JSON - Used in REST APIs - Not needed with @RestController #SpringBoot #Java #ResponseBody #RESTAPI #BackendDevelopment #LearningInPublic

🚀 Day 47/90 How Spring Boot loads 130+ AutoConfigurations (and how to debug them) Today’s learning connected two very important concepts: 👉 How Spring Boot loads auto-configurations internally 👉 How we can see which ones are applied or skipped 🔹 How Spring Boot loads AutoConfigurations? Spring Boot doesn’t magically configure everything. It follows a structured process: 1️⃣ Your application starts with @SpringBootApplication 2️⃣ This internally includes @EnableAutoConfiguration 3️⃣ Spring Boot then scans a special file: 📄 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports This file contains a list of 100+ AutoConfiguration classes like: - DataSourceAutoConfiguration - HibernateJpaAutoConfiguration - WebMvcAutoConfiguration 4️⃣ These classes are loaded into the Spring context But here’s the catch 👇 👉 They are NOT blindly applied Each auto-configuration uses conditions like: @ConditionalOnClass @ConditionalOnBean @ConditionalOnProperty So Spring Boot decides: ✔ Apply if conditions match ❌ Skip if conditions fail 🔹 How to see this decision (VERY IMPORTANT 🔥) We can enable debugging using this property: debug=true 📍 Add it in application.properties 🔹 What happens after enabling this? At application startup, Spring prints a Condition Evaluation Report in logs: You will see: ✅ Positive Matches Configurations that were successfully applied ❌ Negative Matches Configurations that were skipped + reason ⚠️ Conditional Matches Dependent configurations 🔹 Example Insight You might see logs like: ✔ DataSourceAutoConfiguration matched ❌ JpaRepositoriesAutoConfiguration did not match (missing dependency) This tells you EXACTLY why something is working or not. 🔹 Why this is powerful? ▪️Understand which beans Spring created automatically ▪️Debug issues in: JPA / Hibernate Security DataSource 🔹 Pro Tip ⭐ Instead of full debug, you can use targeted logging: logging.level.org.springframework.boot.autoconfigure=DEBUG 🔹 Today's Tiny Win 💡 Today you moved from: 👉 “Spring Boot works magically” to 👉 “I can SEE and DEBUG Spring Boot decisions internally”🍀☘️ #SpringBoot #AutoConfiguration #Java #BackendDeveloper #90DaysChallenge

💡 Types of Dependencies in Spring Framework: In the 🌱 Spring Framework, Dependency Injection (DI) is a core concept that helps achieve loose coupling and better code maintainability. Let’s explore the three main types of dependencies used in Spring: 🔹 1. Primitive Dependency This involves injecting simple values like int, double, boolean, or String. 👉 Example: Injecting a username, age, or configuration value into a bean. ✔️ Configured using @Value annotation or XML ✔️ Commonly used for constants and environment properties ✔️ Lightweight and easy to manage 💡 Use case: Application properties like app name, port number, etc. 🔹 2. Collection Dependency Spring allows injecting collections such as List, Set, Map, or Properties. 👉 Example: List of email recipients Map of key-value configurations ✔️ Supports bulk data injection ✔️ Can be configured via XML or annotations ✔️ Useful for dynamic and flexible data handling 💡 Use case: Storing multiple values like roles, configurations, or URLs. 🔹 3. Reference Dependency (Object Dependency) This is the most important type where one bean depends on another bean. 👉 Example: OrderService depends on PaymentService Car depends on Engine ✔️ Achieved using @Autowired, @Inject, or XML <ref> ✔️ Promotes loose coupling ✔️ Core concept behind Spring IoC Container 💡 Use case: Service layer calling repository layer, or controller calling service. 🚀 Why Dependency Injection Matters in Spring? Reduces tight coupling between classes Makes unit testing easier Improves code reusability and maintainability Enables better separation of concerns 🔥 Pro Tip: Prefer constructor injection over field injection for better immutability and testability. #SpringFramework #Java #DependencyInjection #BackendDevelopment #SoftwareEngineering #TechLearning Anand Kumar Buddarapu