Spring Bean Creation and Management Best Practices

𝗢𝗻𝗲 𝗼𝗳 𝘁𝗵𝗲 𝗺𝗼𝘀𝘁 𝗽𝗼𝘄𝗲𝗿𝗳𝘂𝗹 𝗹𝗶𝗻𝗲𝘀 𝗼𝗳 𝘁𝗵𝗲 𝗰𝗼𝗱𝗲 𝗶𝘀 𝗮𝗹𝘀𝗼 𝗼𝗻𝗲 𝗼𝗳 𝘁𝗵𝗲 𝘀𝗵𝗼𝗿𝘁𝗲𝘀𝘁 𝗶𝗻 𝘀𝗽𝗿𝗶𝗻𝗴 𝗯𝗼𝗼𝘁 𝗮𝗽𝗽𝗹𝗶𝗰𝗮𝘁𝗶𝗼𝗻𝘀. The annotation @𝗦𝗽𝗿𝗶𝗻𝗴𝗕𝗼𝗼𝘁𝗔𝗽𝗽𝗹𝗶𝗰𝗮𝘁𝗶𝗼𝗻 does more work under the hood It is a 𝗰𝗼𝗺𝗽𝗼𝘀𝗶𝘁𝗲 𝗮𝗻𝗻𝗼𝘁𝗮𝘁𝗶𝗼𝗻 meaning @SpringBootApplication combines multiple annotations into one annotation (@𝗦𝗽𝗿𝗶𝗻𝗴𝗕𝗼𝗼𝘁𝗖𝗼𝗻𝗳𝗶𝗴𝘂𝗿𝗮𝘁𝗶𝗼𝗻, @𝗘𝗻𝗮𝗯𝗹𝗲𝗔𝘂𝘁𝗼𝗖𝗼𝗻𝗳𝗶𝗴𝘂𝗿𝗮𝘁𝗶𝗼𝗻 and @𝗖𝗼𝗺𝗽𝗼𝗻𝗲𝗻𝘁𝗦𝗰𝗮𝗻) 1. 𝗦𝗽𝗿𝗶𝗻𝗴𝗕𝗼𝗼𝘁𝗖𝗼𝗻𝗳𝗶𝗴𝘂𝗿𝗮𝘁𝗶𝗼𝗻: Marker annotations that marks the class as Configuration class. 2. 𝗘𝗻𝗮𝗯𝗹𝗲𝗔𝘂𝘁𝗼𝗖𝗼𝗻𝗳𝗶𝗴𝘂𝗿𝗮𝘁𝗶𝗼𝗻: Enables Spring boot to automatically configure any components that spring framework thinks your application will needs. 3. 𝗖𝗼𝗺𝗽𝗼𝗻𝗲𝗻𝘁𝗦𝗰𝗮𝗻: Enables Spring to scan your application class path and will register the class that are annotated(with Component, Service, Repository, Controller) as components(bean) in Spring application context( container) When you run your application, 𝗺𝗮𝗶𝗻() method is invoked, this 𝗺𝗮𝗶𝗻() calls static 𝗿𝘂𝗻() method on SpringApplication class which bootstraps the spring application and create Spring Application Context (container) Look at the code example how short and simple it is. 💪 #Day2 #Java #JavaDeveloper #Backend #Spring #Springboot

🔍 Ever opened a Spring Boot project and felt overwhelmed by the file layout? Let's fix that today. When you generate a project via Spring Initializr, you get a carefully designed structure — and every single file has a purpose. Understanding it is foundational to writing clean, maintainable code. Here's what matters most: src/ ├── main/ │ ├── java/com/example/app/ │ │ └── AppApplication.java ← Entry point │ └── resources/ │ ├── application.properties ← Config │ ├── static/ ← CSS, JS, images │ └── templates/ ← Thymeleaf views └── test/ └── java/com/example/app/ ← Test classes pom.xml ← Dependencies & build The src/main/java folder is where your business logic lives — controllers, services, repositories. The resources/ folder holds configuration and static assets. And pom.xml is the brain of your build. Pro tip: Keep your package structure mirroring your domain (e.g., controller/, service/, repository/, model/) — it makes navigation effortless and follows the Single Responsibility #Java #SpringBoot #BackendDevelopment #SoftwareEngineering #Programming

As many of you know, the Spring community has strongly recommended constructor injection over field injection starting from newer versions of Spring Framework. If you’ve recently migrated from an older version of Spring Boot to a newer one, updating your code. 🔎 Key Change in Test Classes One common issue I’ve noticed during migration: ❌ Overusing @SpringBootTest which causes failure of some of the test cases. @SpringBootTest loads the full application context, which: Increases test execution time Makes tests heavier than necessary Reduces test isolation ✅ Recommended Approach Instead of using @SpringBootTest everywhere, prefer more focused test annotations depending on what you're testing: @WebMvcTest → For controller layer @DataJpaTest → For repository layer @RestClientTest → For REST client components @ExtendWith(MockitoExtension.class) → For pure unit tests with mocks This ensures: ✔ Faster test execution ✔ Better separation of concerns ✔ Cleaner and more maintainable test code Migration is not just about “making it work” — it’s about aligning with best practices for performance, maintainability, and clean architecture. #SpringBoot #Java #UnitTesting #SoftwareEngineering #CleanCode

🔹 Spring Concept: Bean Lifecycle In the Spring Framework, every object managed by the Spring IoC container is called a Bean. Understanding the Bean Lifecycle helps developers control how objects are created, initialized, and destroyed. 📌 Stages of Spring Bean Lifecycle 1️⃣ Instantiation Spring creates the bean instance. 2️⃣ Dependency Injection Spring injects required dependencies. 3️⃣ Initialization Custom initialization logic runs using: • @PostConstruct • InitializingBean • custom init-method 4️⃣ Bean Ready for Use The bean is now fully initialized and used in the application. 5️⃣ Destruction When the application context closes, cleanup logic runs using: • @PreDestroy • DisposableBean • custom destroy-method 💡 Example: @Component public class NotificationService {   @PostConstruct   public void init() {     System.out.println(“Bean Initialized”);   }   @PreDestroy   public void destroy() {     System.out.println(“Bean Destroyed”);   } } ✨ Understanding the Bean lifecycle helps developers manage resources efficiently and write better Spring applications. #Java #SpringBoot #SpringFramework #BackendDevelopment #SoftwareEngineering

Day 15 – Spring Boot Architecture Deep Dive Today I focused on understanding the architecture of Spring Boot and how it works internally. =>Spring Boot simplifies Java backend development by reducing configuration and providing an opinionated setup for building applications. =>One of the core features is auto-configuration. When we add a starter dependency like spring-boot-starter-web, Spring Boot automatically configures the embedded server, Dispatcher Servlet, and required beans. This reduces manual setup and speeds up development. =>Another important concept is starter dependencies. Starters bundle commonly used libraries together, making dependency management easier and more consistent. =>Spring Boot also provides an embedded server (Tomcat by default). This allows the application to run as a standalone JAR file without external deployment, which makes development and testing faster. =>Most Spring Boot applications follow a layered architecture: Controller → Service → Repository → Database This separation of concerns improves code maintainability, scalability, and clarity. Understanding the internal architecture gives better confidence in building production-ready backend systems instead of just writing APIs. Learning beyond syntax. Learning the structure. #Day15 #SpringBoot #BackendDevelopment #Java #SoftwareArchitecture #LearningJourney

🚀 What Exactly Is a Bean in Spring? (Simple but Important) Sometimes the simplest questions are the ones we forget to explain clearly. As Spring developers, we often say: “Bean is just an object managed by Spring IoC.” But what does that really mean? In the Spring Framework: A Bean is an object that is: ✔ Created by the Spring IoC container ✔ Managed by the container ✔ Injected using Dependency Injection (DI) ✔ Stored inside the ApplicationContext ✔ Controlled through its lifecycle If you create an object using new, it’s just a normal object. If Spring creates and manages it — it becomes a Bean. Example: @Service public class PaymentService { } Because of @Service, Spring registers this class as a Bean and manages it inside the container. 💡 Why this matters? Understanding Beans properly helps in: Debugging injection issues Avoiding NoUniqueBeanDefinitionException Managing lifecycle correctly Writing clean architecture Sometimes we use Spring daily but forget the fundamentals behind it. Still learning. Still refining basics. #SpringBoot #Java #BackendDevelopment #CleanCode #SoftwareEngineering

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

🌱 Common Spring Beginner Mistakes🚀 Common Spring Beginner Mistakes (and How to Avoid Them) When starting with Spring, these mistakes are very common 👇 ❌ 1. Using 'new' Instead of Dependency Injection Car car = new Car(); ❌ ✔ Always let Spring manage objects using DI ❌ 2. Not Understanding IoC & DI Clearly Writing code without knowing who creates objects Leads to confusion and poor design 📌 Learn IoC & DI before moving ahead ❌ 3. Using @Component Everywhere @Service → business logic @Repository → database layer @Controller → request handling ✔ Use the right annotation for the right layer ❌ 4. Mixing Controller, Service & Repository Logic @Controller class UserController { // DB logic here ❌ } ✔ Follow layered architecture ❌ 5. Field Injection Everywhere @Autowired private Service service; ❌ ✔ Prefer Constructor Injection ❌ 6. Ignoring Bean Lifecycle Not using @PostConstruct Not closing resources properly ✔ Understand create → use → destroy ❌ 7. Not Reading Error Messages Spring errors look big but are very informative Stack traces help you learn faster #Spring #SpringBoot #Java #LearningInPublic #BackendDevelopment #JavaDeveloper

Day 17 – Spring Boot Annotations Explained Today I focused on understanding some important Spring Boot annotations that power backend applications. -> @RestController Combines @Controller and @ResponseBody. It is used to create REST APIs and return JSON responses directly. -> @RequestMapping Maps HTTP requests to specific handler methods. It defines the URL path and supports different HTTP methods like GET, POST, PUT, and DELETE. -> @Autowired Used for Dependency Injection. Spring automatically injects required beans into a class. -> @Configuration Indicates that a class contains bean definitions. Spring processes it to generate and manage beans in the application context. Understanding these annotations helps in writing clean, structured, and maintainable backend code. Spring Boot reduces complexity, but knowing what happens behind the scenes makes a real difference. #Day17 #SpringBoot #Java #BackendDevelopment #Annotations #LearningJourney

❓ What actually happens inside Spring when our application starts? Day 2 of learning Spring Framework deeply 🌱 Today I explored the core concept behind Spring — IoC (Inversion of Control). Earlier, developers were responsible for creating and managing objects, but with Spring, this responsibility is handled by the IoC Container, improving flexibility and maintainability. Here’s what I learned today: 🔹 Types of IoC Containers BeanFactory → Lazy loading (bean created only when requested using getBean()) ApplicationContext → Eager loading (creates beans at application startup) 🔹 Lazy Initialization Using lazy-init="true" allows beans in ApplicationContext to be created only when needed. 🔹 Bean Scopes Singleton → Same instance returned every time (default) Prototype → New instance created for each request 🔹 Key Insight Prototype beans are instantiated on demand, making them behave similarly to lazy initialization. Understanding how Spring manages objects internally is helping me connect theory with real backend architecture. Continuing to build strong Core Spring fundamentals before moving toward Spring Boot 🚀 #SpringFramework #Java #BackendDevelopment #LearningInPublic #SoftwareEngineering