Parmeshwar Metkar’s Post

🚀 Internal Flow of Spring Boot – From “It Works” to “I Understand Why It Works” As a Spring developer, for a long time I used to write: SpringApplication.run(MyApplication.class, args); Application started. Server running. Everything working. But recently I asked myself — 👉 What actually happens behind this single line? And that changed my thinking. 🔄 What Really Happens Internally? When we start a Spring Boot application: 1️⃣ SpringApplication Object is Created It decides the application type: Servlet (Spring MVC) Reactive (WebFlux) Non-web Based on classpath detection. 2️⃣ Initializers & Listeners Are Loaded Spring loads ApplicationContextInitializers and ApplicationListeners (from internal configuration files). This prepares the bootstrapping process. 3️⃣ Environment Preparation Before beans are created: Active profile is decided (dev / prod) application.yml / application.properties is loaded Environment variables are bound Configuration properties are prepared Property binding happens here. 4️⃣ ApplicationContext Creation Spring creates the IoC container. This container: Stores bean definitions Manages lifecycle Handles dependency injection 5️⃣ @EnableAutoConfiguration – The Real Magic @SpringBootApplication includes: @EnableAutoConfiguration Spring checks: ✔ Required classes present? ✔ Required properties enabled? ✔ Bean already defined? Then conditionally creates required beans. That’s why we don’t manually configure: DataSource DispatcherServlet JPA setup Embedded server Spring does it intelligently. 6️⃣ Bean Creation & Lifecycle Now Spring: Instantiates beans Injects dependencies Calls @PostConstruct Applies BeanPostProcessors 7️⃣ Embedded Server Starts Spring Boot automatically starts: Apache Tomcat Jetty Undertow Then registers DispatcherServlet and controllers. Now the application is ready 🚀 💡 My Learning Earlier I was happy that: “Code runs without error.” Now I try to think: “Why does it run? What happens internally?” That difference separates: A coder From a developer From an architect mindset Spring Boot is not magic. It’s intelligent auto-configuration + conditional logic + strong container design. And the more we understand internals, the more confidently we can design real-world systems. If you are learning Spring Boot deeply, let’s connect and discuss internal architecture 💬 #SpringBoot #Java #BackendDevelopment #Learning #SoftwareArchitecture

🚀 Spring Boot Annotations – The Backbone of Every Application Many developers use Spring Boot annotations every day, but very few truly understand where each annotation works internally. I created this simple visual guide to understand the most important Spring Boot annotations and their roles in the application flow. 🔹 @SpringBootApplication – Entry point of the Spring Boot application 🔹 @ComponentScan – Scans and detects Spring components 🔹 @Configuration / @Bean – Defines configuration and beans 🔹 @Controller / @RestController – Handles HTTP requests 🔹 @Service – Contains business logic 🔹 @Repository – Handles database operations 🔹 @Transactional – Manages database transactions 🔹 @Value / @PropertySource – Injects configuration values All these components come together inside the Application Context, which manages the lifecycle of every bean in a Spring Boot application. Understanding this flow helps developers: ✅ Write cleaner architecture ✅ Debug issues faster ✅ Master Spring Boot internals 📌 If you're learning Spring Boot, understanding annotations is the first step toward mastering the framework. #Java #SpringBoot #BackendDevelopment #JavaDeveloper #Programming #SoftwareDevelopment #SpringFramework #TechLearning #Coding Durgesh Tiwari Anshika Singh

🚀 Spring Boot Daily Learning Are you using @Component on every class and wondering why Spring gives you 4 different stereotype annotations? Here's what actually separates them — and why it matters in production. Spring's stereotype annotations all register beans in the IoC container, but they carry different semantic weight and unlock different framework features: @Component // Generic bean — use as last resort @Service // Business logic layer @Repository // Data access layer + exception translation @Controller // MVC presentation layer (with @RestController for REST) The critical difference? @Repository activates Spring's PersistenceExceptionTranslationPostProcessor — it automatically translates low-level JPA/Hibernate exceptions into Spring's unified DataAccessException hierarchy. Your service layer never leaks Hibernate internals. @Service and @Controller signal architectural intent. Spring AOP, Spring Security, and your teammates all rely on these contracts to apply cross-cutting concerns correctly. Using @Component everywhere breaks that contract. Best practice: Always pick the most specific annotation. @Component is for custom infrastructure beans — not business or data code. #Java #SpringBoot #BackendDevelopment #SpringFramework #CleanCode

Hi everyone 👋 📌 Spring Boot Annotation Series Part 18 – @PostMapping The @PostMapping annotation is used to handle HTTP POST requests in a Spring Boot application. It is part of the Spring Framework and is mainly used to create new resources in REST APIs. 🔹 What is @PostMapping? @PostMapping is a shortcut for: @RequestMapping(method = RequestMethod.POST) It makes the code cleaner and more readable. 🔹 When Do We Use POST? ✔ To create new data ✔ To submit form data ✔ To send request body (JSON/XML) ✔ When data is modified on the server Example use cases: Create a new user Place an order Register a customer Submit login details 🔹 Basic Example - @RestController @RequestMapping("/api/users") public class UserController { @PostMapping public String createUser(@RequestBody String user) { return "User created: " + user; } } 👉 Handles: POST http://localhost:8080/api/users 🔹 In Simple Words @PostMapping handles create operations in REST APIs. When a POST request hits the URL, Spring executes the mapped method and processes the request body. #SpringBoot #Java #RESTAPI #BackendDevelopment #InterviewPreparation #LearningInPublic

Today I built a complete REST API from scratch. No tutorials. No copy-paste. Just understanding each concept before writing each line. Here is what I built today for DShopFlow — my inventory management platform for small shops: → Product Entity — a Java class that became a real PostgreSQL table automatically. Zero SQL written. → Repository Layer — 5 lines of code that gave me save, find, update, and delete operations for free. → Service Layer — where business logic lives. Stock checks, validation, timestamps. → Controller Layer — 5 HTTP endpoints that React will talk to. The moment that hit different? I wrote a Java class with some annotations. Started the application. Opened pgAdmin. A real database table appeared — columns, constraints, everything — without writing a single line of SQL. That is JPA. That is why Spring Boot is powerful. I also made real mistakes today: → YAML indentation error that crashed the server → Compiler error from calling a getter with an argument → SSH key saved in the wrong folder Every mistake taught me something the tutorial would have skipped. The API is now tested in Postman. All 5 endpoints are working: POST → create product → 201 Created GET → all products → 200 OK GET → single product → 200 OK PUT → update product → 200 OK DELETE → remove product → 204 No Content Code is live on GitHub. Building continues. If you are learning Spring Boot, stop copying tutorials. Understand each line before you write it. Slow is smooth. Smooth is fast. #SpringBoot #BuildInPublic #DShopFlow #Java #LearningInPublic #FullStack #Pakistan

🚀 Day 6/100: Spring Boot From Zero to Production Topic: @SpringBootApplication Annotation Your setup is done, your dependencies are added, and now you are ready to write some actual code and business logic. It all begins from your Main Class. This class usually carries the name of your application and contains a main function, the exact point where the execution begins. But there is one very important part of this main class: the @Annotation. In simple terms, an annotation is metadata written after an @ sign. it tells the compiler and the framework specific information about your code. In our case, the star of the show is @SpringBootApplication. This is a "Meta-Annotation," meaning it’s a powerful 3-in-1 combo that keeps your code clean and organized: 1. @Configuration This marks the class as a source of bean definitions. It tells Spring that this class can contain methods annotated with @Bean. In the old days of Spring, you had to manage everything in bulky XML files. With this, we use pure Java to define our infrastructure. 2. @EnableAutoConfiguration This is the "secret sauce" that makes Spring Boot feel like magic. The Role: It tells Spring Boot to start adding beans based on what it finds on your classpath. If it sees h2.jar, it sets up an in-memory database for you. No more Boilerplate Nightmares. You don't have to manually set up a Data Source unless you want to override the defaults. 3. @ComponentScan 🔍 Think of this as the "Search Party" for your project. It tells Spring to hunt for other components, configurations, and services in your packages. It specifically looks for: @Component @Service @Repository @RestController The Scope: By default, it scans the package containing your main class and all sub-packages. This is why we always keep the main class in the root package! We’ve cracked open the entry point of every Spring Boot app. 🔓 See you in the next post. #Java #SpringBoot #SoftwareDevelopment #100DaysOfCode #Backend

🚀 New Spring Boot Auditing Tutorial — Live on YouTube! 👉 https://lnkd.in/g9dBRdTw In this lecture, I walked through implementing Auditing in Spring Boot using Spring Data JPA — complete with real code and a working demo. No more manually updating timestamps! Now you can automatically track: ✔️ createdAt ✔️ lastModifiedAt ✔️ (Optional) createdBy / modifiedBy I covered: ✨ Enabling JPA Auditing ✨ Using @CreatedDate & @LastModifiedDate ✨ Implementing AuditorAware ✨ Full coding demo This is part of my Spring Boot backend learning series — focused on practical implementation, best practices, and real-world readiness. Whether you’re: 🔹 Preparing for Backend Developer roles 🔹 Learning Spring Boot from the ground up 🔹 Building scalable Java APIs This lecture will give you clarity and confidence 🚀 I’d love to hear your thoughts — drop a comment after watching! #SpringBoot #Java #BackendDevelopment #SpringDataJPA #Hibernate #SoftwareEngineering #YouTubeLecture

☕ Spring Boot – Code Structure & Best Practices Explained When building a Spring Boot application, there is no strict code layout enforced by the framework. However, following best practices ensures proper auto-configuration, component scanning, and maintainability. As described in the document (Page 1), let’s understand the recommended structure. 🔹 Avoid Default Package (Page 1) A class without a package declaration belongs to the default package. ❌ Not recommended in Spring Boot ❌ Can cause issues with: Auto Configuration Component Scan 📌 Best Practice: Use reversed domain naming convention, such as: com.tutorialspoint.myproject This keeps the application organized and prevents configuration issues. 🔹 Typical Spring Boot Layout (Page 2) The image on Page 2 shows a clean project structure: com └── tutorialspoint └── myproject ├── Application.java ├── model │ └── Product.java ├── dao │ └── ProductRepository.java ├── controller │ └── ProductController.java └── service └── ProductService.java 📌 Explanation: ✔ model → Contains entity classes ✔ dao → Data access layer ✔ service → Business logic layer ✔ controller → Handles HTTP requests ✔ Application.java → Main entry point This layered architecture improves clarity and scalability. 🔹 Application.java (Page 3) As shown on Page 3, the main class must include: ✔ @SpringBootApplication annotation ✔ main() method ✔ SpringApplication.run() Example: package com.tutorialspoint.myproject; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; @SpringBootApplication public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } } 💡 Following a proper package structure ensures smooth component scanning, better maintainability, and scalable enterprise-level Spring Boot applications. #SpringBoot #Java #BackendDevelopment #FullStackJava #Microservices #JPA #RESTAPI #SoftwareArchitecture #AshokIT

🚀 Today I Learned – Spring Framework Core Concepts Understanding Tight Coupling vs Loose Coupling in Spring Today I learned an important concept in backend development: Coupling. 🔴 Tight Coupling When one class directly depends on another class by creating its object using new, it is called tight coupling. Example: If OrderService directly creates PaymentService, then any change in PaymentService can affect OrderService. ❌ Difficult to modify ❌ Hard to test ❌ Less flexible 🟢 Loose Coupling In loose coupling, classes depend on abstraction (interface) instead of concrete implementation. Spring achieves this using: ✔ Dependency Injection (DI) ✔ @Autowired ✔ IoC Container Example: OrderService depends on PaymentService interface, and Spring injects the actual implementation. ✅ Easy to maintain ✅ Easy to test (mocking possible) ✅ More scalable and flexible 💡 Conclusion: Loose coupling makes applications more modular and maintainable. That’s why Spring Framework promotes Dependency Injection. Learning how good architecture decisions improve real-world applications step by step Another core concepts are - 🔹 Annotations – Learned how annotations like @Component, @Service, @Repository, and @Controller help in reducing XML configuration and make the code cleaner and more readable. 🔹 Beans – Understood how Spring manages objects as beans inside the IoC container and controls their lifecycle. 🔹 Dependency Injection (DI) – Learned how Spring injects dependencies automatically to reduce tight coupling between classes. 🔹 @Autowired – Practiced how @Autowired automatically injects required dependencies without manual object creation. 🔹 IoC (Inversion of Control) – Understood how control of object creation is given to the Spring container instead of the developer. 🔹 Bean Scopes – Explored different scopes like Singleton and Prototype. Spring makes Java application development much more modular, maintainable, and scalable. Excited to go deeper into Spring Boot and build real-world REST APIs next #Java #SpringFramework #SpringBoot #BackendDevelopment #LearningJourney #SoftwareEngineer

Day 07 – Spring Boot Auto Configuration (How Spring Boot Reduces Boilerplate Code) =============================================== One of the biggest reasons developers prefer Spring Boot is Auto Configuration. Before Spring Boot, configuring a Spring application required a lot of manual setup. Developers had to configure: • Database connections • Transaction management • Dispatcher servlet • View resolvers • Bean configurations This resulted in a lot of boilerplate configuration code. Spring Boot simplified using Auto Configuration. What is Auto Configuration? Auto Configuration means: Spring Boot automatically configures the application based on the dependencies present in the project. In simple terms: Add the dependency → Spring Boot configures it automatically. If you add the Spring Web dependency: <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> Spring Boot automatically configures: • Embedded Tomcat server • DispatcherServlet • REST controllers • JSON conversion You don’t need to configure them manually. * Another Example (Database) If you add JPA dependency and database configuration: spring.datasource.url=jdbc:mysql://localhost:3306/test spring.datasource.username=root spring.datasource.password=1234 Spring Boot automatically configures: • DataSource • EntityManager • Transaction Manager This saves a lot of development time. How Does It Work Internally? Auto Configuration works using: • @EnableAutoConfiguration • Conditional configuration • Classpath dependency checking Spring Boot checks: “If this dependency exists, configure the related components automatically.” * Today’s Learning Spring Boot reduces configuration complexity and lets developers focus on business logic instead of setup code. That is why Spring Boot became the most widely used framework for building Java backend and microservices applications. Tomorrow: Spring Boot Starter Dependencies – Why They Make Development Faster #Java #SpringBoot #SpringFramework #BackendDevelopment #Microservices #LearningInPublic