Spring Boot @Bean behavior differs in @Component vs @Configuration

Hi everyone 👋 📌 Spring Boot Annotation Series Part 20 – @PatchMapping @PatchMapping is used to handle HTTP PATCH requests for partial updates in REST APIs. It is part of the Spring Framework and widely used in applications built with Spring Boot. 🔹 Why Do We Need PATCH? In REST: PUT → Full update (replace entire object) PATCH → Partial update (update specific fields only) If we only want to update one or two fields, using PUT would require sending the entire object. 👉 PATCH is more efficient. 🔹 What Happens Internally? @PatchMapping is a shortcut for: @RequestMapping(method = RequestMethod.PATCH) 🔹 In Simple Words @PatchMapping updates only the fields that are sent in the request. #SpringBoot #Java #RESTAPI #PatchMapping #BackendDevelopment #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

🚨 Most Spring Boot applications still do this wrong. Let's use some event and virtual threads 🚀 👉 A user registers. 1. You save the user. 2. Then you send an email. All Inside the same request. 💣 Bad idea. Why? Because now your API depends on: • SMTP latency • network delays • external failures Your simple signup endpoint suddenly becomes slow and fragile. 💡 A better pattern is Domain Events. Instead of sending the email directly, publish an event: eventPublisher.publishEvent( new NewUserRegisteredEvent(user.id(), user.name(), user.email()) ); Now your API just registers the user and everything else becomes a side effect. 🚀 We will handle the email asynchronously: @Async("eventTaskExecutor") @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT) public void onNewUserRegistered(NewUserRegisteredEvent event) { // send activation email } Notice the key detail: 👉 AFTER_COMMIT The email only runs after the transaction succeeds. No ghost emails. No inconsistent state. Now comes the interesting part. 💡 Instead of using a traditional thread pool… Use Java 21 Virtual Threads. @Bean public TaskExecutor eventTaskExecutor() { return new VirtualThreadTaskExecutor("event-vt-"); } This gives you: ⚡ Massive concurrency ⚡ Lightweight threads ⚡ No reactive complexity ⚡ Clean imperative code Suddenly you can handle thousands of async tasks like: • emails • notifications • integrations • audit logs • background jobs Without blocking requests. Without complicated frameworks. Java 21 quietly changed backend scalability. And most developers still haven’t realized it. Are you already using Virtual Threads in production or still relying on traditional thread pools? #Java #SpringBoot #Java21 #VirtualThreads #BackendDevelopment #SoftwareArchitecture

Recently, I came across this interesting question: Why does a Spring Boot application consume more memory compared to a normal Java application? Here’s a structured explanation 1. Auto-Configuration When we use @SpringBootApplication, it internally enables: • @EnableAutoConfiguration • @Configuration • @ComponentScan Spring scans the entire classpath and automatically creates multiple beans. Even if some features are not directly used, they may still get loaded. More beans = More objects in heap = Higher memory usage. 2. Embedded Server Spring Boot applications run with embedded servers like: • Apache Tomcat • Jetty • Undertow These servers run inside the JVM and consume memory for: • Thread pools • Request processing • Session management 3. Actuator & Monitoring If Spring Boot Actuator is enabled: • Health indicators • Metrics registry • Monitoring endpoints All create additional background objects that consume memory. 4. Starter Dependencies Spring Boot starters bring multiple dependencies such as: • Jackson • Hibernate • Logging frameworks • Validation libraries Each dependency adds to memory usage. Conclusion Spring Boot consumes more memory due to: Auto-configuration Embedded servlet container Additional monitoring components Multiple dependencies #SpringBoot #Java #BackendDeveloper #Microservices #InterviewPreparation #SoftwareEngineering

📌 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

Hi everyone 👋 📌 Spring Boot Annotation Series Part 21 – @PathVariable @PathVariable is used to extract values from the URL path and bind them to method parameters. It is part of the Spring Framework and widely used in REST APIs built with Spring Boot. 🔹 Why Do We Use @PathVariable? In REST APIs, resources are identified using IDs in the URL. Example: GET /users/101 Here, 101 is part of the URL path. @PathVariable helps us capture that value inside the controller method. 🔹 Basic Example @RestController @RequestMapping("/users") public class UserController { @GetMapping("/{id}") public String getUserById(@PathVariable Long id) { return "User ID is: " + id; } } 👉 If request is: GET http://localhost:8080/users/101 Output: User ID is: 101 🔹 In Simple Words @PathVariable takes dynamic values from the URL and passes them to the controller method. #SpringBoot #Java #RESTAPI #PathVariable #BackendDevelopment #InterviewPreparation

☕ @Bean & @Configuration — Manual Bean Registration in Spring Boot Most Spring developers rely on @Component and @Autowired — but what happens when you need full control over how your beans are created? That's where @Configuration + @Bean shine. Instead of letting Spring auto-detect classes, you explicitly define beans in a dedicated config class: @Configuration public class AppConfig { @Bean public PasswordEncoder passwordEncoder() { return new BCryptPasswordEncoder(12); } @Bean public RestTemplate restTemplate() { RestTemplate rt = new RestTemplate(); rt.setRequestFactory(new HttpComponentsClientHttpRequestFactory()); return rt; } } 🔑 Why manual registration matters: — Third-party classes you can't annotate (Jackson, RestTemplate, external libs) — Complex initialization logic with multiple dependencies — Conditional beans with @Conditional / @ConditionalOnProperty — Multiple implementations of the same interface @Bean @ConditionalOnProperty(name = "feature.cache", havingValue = "redis") public CacheManager redisCacheManager(RedisConnectionFactory factory) { return RedisCacheManager.create(factory); } @Configuration classes are CGLIB-proxied — meaning @Bean method calls are intercepted to return the same singleton instance every time. This is a subtle but important Spring internals detail every senior dev should know. #Java #SpringBoot #BackendDevelopment #SpringFramework #Programming

Hello Connections 👋 While revisiting some Spring Boot basics recently, I came across something simple but quite useful — how to see all the beans managed by the Spring container. There are actually a couple of easy ways to do this: 👉 1. Using Spring Boot Actuator Just expose the beans endpoint in application.properties: management.endpoints.web.exposure.include=beans Then hit: /actuator/beans You’ll get a detailed view of all beans along with their dependencies. This is really helpful when you want to understand what Spring is creating behind the scenes. 👉 2. Using ApplicationContext programmatically You can also fetch all bean names directly from the container: String[] beanNames = applicationContext.getBeanDefinitionNames(); for (String beanName : beanNames) { System.out.println(beanName); } I found this especially useful while debugging and understanding auto-configuration behavior. If you’ve used any other way to inspect Spring beans, would love to know! #SpringBoot #Java #BackendDevelopment #Learning

Is JDBC over because of JPA ? In short, No. JDBC is not over. As a backend developer, here’s the reality 👇 • JPA is built on top of JDBC. Without JDBC, JPA doesn’t even work. • JPA simplifies development. It reduces boilerplate and speeds up CRUD-based applications. 🎯 Developer Advice Don’t think of it as: JPA vs JDBC ❌ Learn both. Use JPA for productivity. Use JDBC when performance demands precision. . . . #SpringBoot #SpringFramework #SpringDataJPA #JDBC #JavaDeveloper #BackendDevelopment #FullStackDeveloper #SoftwareEngineering #Programming #TechCommunity #CodeSmart #DeveloperMindset

🔧 application.properties vs application.yml — Which one should you actually use in Spring Boot? After working on many Spring Boot projects, here's the real difference: application.properties — flat key-value, dead simple: server.port=8080 spring.datasource.url=jdbc:postgresql://localhost:5432/mydb spring.jpa.show-sql=true application.yml — hierarchical YAML, far more readable at scale: server: port: 8080 spring: datasource: url: jdbc:postgresql://localhost:5432/mydb jpa: show-sql: true What you need to know: ✅ YAML handles nested structures and lists much more cleanly ✅ Properties = simpler, zero indentation errors ✅ If BOTH files exist — properties takes precedence over yml ✅ YAML lets you define multiple profiles in ONE file using --- separator ✅ Never store secrets in either — use env vars or Vault My take: Use .yml for complex multi-profile apps. Use .properties for quick setups or when the team prefers flat configs. #Java #SpringBoot #BackendDevelopment #SoftwareEngineering #Programming