Spring Boot Auto Configuration: The Magic Behind the Scenes

Complete API Guide (Java + Spring Boot) 🔹 1. What is an API? An API (Application Programming Interface) allows different systems to communicate. 👉 Example: Frontend (Angular) → Backend (Spring Boot API) → Database 🔹 2. Types of APIs REST API (most common) SOAP API GraphQL API gRPC (high-performance microservices) 🔹 3. REST API Principles (Very Important) Stateless Client-Server architecture Cacheable Uniform interface 🔹 4. HTTP Methods GET → Fetch data POST → Create PUT → Update (full) PATCH → Partial update DELETE → Remove 🔹 5. HTTP Status Codes 200 → Success 201 → Created 400 → Bad request 401 → Unauthorized 404 → Not found 500 → Server error 🔹 6. API Design Best Practices ✔️ Use proper naming /api/v1/users ✔️ Use nouns, not verbs ❌ /getUsers ✔️ Versioning (v1, v2) ✔️ Pagination (page, size) ✔️ Filtering & sorting 🔹 7. Request & Response Design ✔️ Use DTOs (not entities) ✔️ Standard response format: {  "status": "success",  "data": {},  "message": "User fetched successfully" } 🔹 8. Exception Handling Use @ControllerAdvice @ExceptionHandler(Exception.class) public ResponseEntity<?> handleException(Exception ex) {   return new ResponseEntity<>("Error occurred", HttpStatus.INTERNAL_SERVER_ERROR); } 🔹 9. Validation Use @Valid @NotNull @Email private String email; 🔹 10. Security (VERY IMPORTANT) ✔️ Spring Security ✔️ JWT Authentication ✔️ OAuth2 👉 Flow: User → Login → Token → API access 🔹 11. API Performance Optimization (🔥 MUST SAY IN INTERVIEW) Caching (Redis) DB query optimization Pagination Async processing (@Async) Connection pooling (HikariCP) GZIP compression 🔹 12. API Documentation ✔️ Swagger / OpenAPI 👉 Helps frontend & testers 🔹 13. Logging & Monitoring Log4j / SLF4J ELK Stack Prometheus + Grafana 🔹 14. Rate Limiting ✔️ Prevent API abuse ✔️ Tools: Bucket4j, API Gateway 🔹 15. API Testing Postman JUnit + MockMvc Integration testing 🔹 16. Microservices API Concepts API Gateway Service Discovery Circuit Breaker (Resilience4j) Load Balancer 🔹 17. Real-Time APIs WebSocket Server-Sent Events (SSE) If interviewer asks: “Tell me about APIs” You say: “API is a way for systems to communicate. In Spring Boot, we build REST APIs using controllers. I focus on proper design, security using JWT,  performance optimization using caching and async processing, and proper exception handling. I also ensure APIs are scalable using microservice architecture.” #Java #Backend #API #Development #software

🚀 Spring Boot Series – Part 6: What Happens When You Click the RUN Button in a Spring Boot Application? We do it every day: Write code → click Run → application starts. But what actually happens behind the scenes? 🤔 Let’s break it down step by step 👇 1️⃣ JVM starts the application When you click Run, the Java Virtual Machine (JVM) starts your Java program and looks for the main() method. 2️⃣ SpringApplication.run() gets executed This is the line that bootstraps the entire Spring Boot application. SpringApplication.run(MyApplication.class, args); 3️⃣ Spring Boot detects @SpringBootApplication Spring Boot detects the main annotation and understands that it needs to configure, auto-configure, and scan your application. 4️⃣ Spring Boot prepares the startup Spring Boot now prepares important things like: • ApplicationContext • Environment • Listeners • Initializers 5️⃣ ApplicationContext is created Spring creates the ApplicationContext, which is the Spring Container that manages all beans. 6️⃣ The environment is prepared Spring Boot reads configuration from: • application.properties / application.yml • Environment variables • Command-line arguments • Profiles 7️⃣ Component scanning and bean loading happen Spring scans classes annotated with: • @Component • @Service • @Repository • @Controller • @RestController • @Configuration It also processes @Bean methods and identifies what beans need to be created. 8️⃣ Auto Configuration kicks in Spring Boot checks the dependencies available on the classpath and automatically configures required beans. For example: • Web dependency → web-related beans • JPA dependency → data-related beans 9️⃣ ApplicationContext is refreshed At this stage, Spring actually starts creating beans, injecting dependencies, and initializing the application. This is where the application starts taking real shape in memory. 🔟 Embedded server starts If it is a web application, Spring Boot starts the embedded server (usually Tomcat). Now your application is capable of handling requests. 1️⃣1️⃣ Application is fully ready At this point: ✔ Beans are created ✔ Dependencies are injected ✔ Configuration is loaded ✔ Server is running 👉 Your Spring Boot application is now ready to serve requests. 🎯 Key Takeaway When you click Run, Spring Boot does much more than just execute your code. 👉 It creates the Spring container, reads configurations, scans components, applies auto-configuration, creates beans, injects dependencies, starts the server, and prepares the application to serve requests. Have you ever explored what actually happens inside SpringApplication.run() before? 🔍 In the next post of this series, we’ll explore Maven. Stay tuned. 💡 Save this post for future reference if you found it helpful. #SpringBoot #SpringFramework #Java #BackEndDevelopment #SoftwareEngineering #Programming #TechCommunity

The Spring ecosystem can be confusing because it has many overlapping pieces. Here's the core idea: Spring Framework is the foundation that everything else builds on. Everything else is either a module of it, built on top of it, or an alternative approach within it. Now let me explain the key relationships that confuse most people - especially what's an alternative of what vs what builds on what. Spring Framework vs Spring Boot - Spring Framework is the actual engine: it gives you the IoC container (which manages your beans/objects), Dependency Injection, AOP, and all the core machinery. Spring Boot sits on top and eliminates all the manual configuration - it reads your classpath and auto-configures things. You almost never use bare Spring Framework today; you use Spring Boot, which in turn uses Spring Framework underneath. Spring Web MVC vs Spring WebFlux - these ARE true alternatives This is the biggest architectural choice in modern Spring: Spring Web MVC uses the traditional Servlet API (one thread per request, blocking I/O). It's powered by a DispatcherServlet - a single front controller that receives every HTTP request and routes it to the right @Controller. This is the classic, battle-tested approach. ~90% of Spring apps use this. Spring WebFlux is the reactive alternative. Instead of threads waiting for DB calls to return, it uses non-blocking I/O with Project Reactor (Mono<T> for 0/1 result, Flux<T> for 0/N results). You choose this for high-concurrency scenarios (thousands of connections) or when integrating with reactive data sources. REST API is not a framework - it's a style. You build REST APIs using either MVC or WebFlux with @RestController. JPA vs Hibernate vs Spring Data JPA - layered, not alternatives JDBC is the raw Java API to talk to databases (SQL queries, ResultSets - very verbose). JPA (Jakarta Persistence API) is a specification/standard that defines how ORM should work. It's just an interface - no implementation. Hibernate is the most popular implementation of JPA. It does the actual heavy lifting: generates SQL, manages sessions, and handles caching. Spring Data JPA wraps Hibernate and adds magic repositories - you just write findByEmailAndStatus(...) as a method signature and Spring generates the SQL. This is what you use in most Spring Boot apps. Spring Data R2DBC is the reactive alternative to Spring Data JPA - use this with WebFlux when you need async DB calls. Servlet API vs Reactive API - the underlying pipe The Servlet API (Jakarta Servlet) is the Java standard that defines how web servers handle HTTP requests. Spring MVC is built on it. The Reactive Streams API (implemented by Project Reactor) is a different standard for async/non-blocking data streams. Spring WebFlux is built on that instead. They cannot be mixed in the same request pipeline. #Java #spring #javadeveloper #opentowork

***********Logging in springboot ******** ‎Log means print , what ever happened in the application, ‎ ‎Logging use to track the application, monitor the application, debug the application or we can say that it use for investigation inside the application. ‎ ‎Let's try to under stand by an example, ‎Suppose we have created on api, and if anything gone wrong inbyhe application, then logging help us to identify thay wrong thing and help to remove it. ‎ ‎Log in Springboot : ‎When ever we create any api and run the application then, on console we see something like tomcat started on 8080 , like this so many things we might able to see, those all are nothing but, log only, means we logging (tracking) our entire application. ‎ ‎Components that contains the springnoot log : ‎--Date ‎-- time in millisecond ‎-- log frame work ‎-- log level and etc. ‎ ‎***** java provides so many logging framework to handle these log, even we can configure these framework by ourself  also. ‎ ‎1. logback (by default used by starter dependency in spring boot) ‎2.  log4j2 ‎3. Log with Lombok ‎4. SLF4j(simple log fasad for java) ‎ ‎Components of each log framework: ‎i . Logger : catch the message ‎ii.  Formater : formate the message catch by logger ‎iii.  handller : it print the message on console formated by formatet. ‎ ‎Level of logs : ‎   TRACE ‎   DEBUG ‎   INFO ( By default level used by log back in spring boot) ‎   WARN ‎   ERROR ‎ ‎Trace is root of log level when we set the log as TRACE then it will show the entire level of lih, TRACE, DEBUG, INFO, WARM and ERROR ‎ ‎When we set DEBUG : DEBUG, INFO, WARN, ERROR ‎ ‎When we set INFO : INFO, WARN, ERROR ‎When we set WARN : WARN, ERROR ‎when we set ERROR : then it shows only ERROR level log and it is minimum log which print on console. ‎ ‎Log in the form of file : ‎Generally logs prints on console, but we can print and save in file also and can share this log file with any one ‎ ‎To achieve this navigatebto the application. Properties file and write ‎log.file.path=log/ ‎log.file.name=log/application.log ‎Then one filder will be created in the same directory and inside that folder one log file will create named application.log ‎This file wi contains all the log printed on the console. ‎ ‎Color of logs: ‎Even we can control the color of log also to print on console ‎To achieve this navigate to application.properties file and write ‎spring.output.ansi.enable=always ‎ ‎Color of different log levels: ‎TRACE : green🟢 ‎DEBUG : green🟢 ‎INFO : green🟢 ‎WARN : yellow🟡 ‎ERROR : red🔴 ‎ ‎This is what I learned about log in spring boot and understand the real meaning and each line of logs printed on console before it, not only me, I can guarantee that many java developer are just think it as its application behavior, leave it do not focus on these thing, but believe in java everything the given with prove ‎ ‎Whaybi realize that lov is mostly being used for debugging the application.

🚨 Debugging a tricky @Transactional issue in Spring Boot + Hibernate Recently, I encountered a subtle but impactful issue while working on a backend workflow involving database updates — and it’s something many developers might run into without realizing it. 🔍 The Problem We were intermittently hitting: 👉 StaleObjectStateException At first glance, everything looked correct: • Entities were being re-fetched from the database • Transactions were properly defined • No obvious concurrency issues Yet, the error kept occurring. 🧠 Root Cause (What was actually happening) The issue boiled down to how Hibernate manages its first-level cache (Persistence Context) and how @Transactional(propagation = REQUIRES_NEW) behaves. Here’s a simplified flow: 1️⃣ Outer Transaction • Fetches an entity • Entity is now managed in the Hibernate session (version = 1) 2️⃣ Inner Transaction (REQUIRES_NEW) • Updates the same entity • Database version becomes 2 • Transaction commits successfully 3️⃣ Back to Outer Transaction • Still holds old version (1) in memory • Hibernate is still tracking this entity 4️⃣ A SELECT query is executed • Hibernate triggers auto-flush • Attempts to update the entity using version = 1 • Database has version = 2 💥 Result → StaleObjectStateException ⚠️ Why re-fetching didn’t help? Even after fetching the entity again: • Hibernate returned the same cached instance • Because it already existed in the persistence context 👉 So we were still working with stale data 🛠️ The Fix We explicitly cleared the persistence context to stop Hibernate from tracking the stale entity: entityManager.detach(entity); or entityManager.clear(); This ensured: • The entity is no longer managed • No dirty checking is triggered • No unintended auto-flush occurs 💡 Key Learnings ✔️ Hibernate’s first-level cache can cause unexpected issues in multi-transaction flows ✔️ REQUIRES_NEW creates a separate transaction and persistence context ✔️ Outer transactions do NOT automatically refresh their state ✔️ Even a simple SELECT can trigger an auto-flush 🚫 Common Pitfalls • Assuming re-fetch always hits the database • Ignoring persistence context behavior • Mixing multiple transaction scopes with shared entities ✅ Best Practices • Detach or clear entities when crossing transaction boundaries • Prefer DTOs instead of passing entities between layers • Use refresh() when you need the latest DB state • Be mindful of auto-flush behavior 🎯 One-line takeaway When using REQUIRES_NEW, always consider that your outer transaction may still hold stale data in its persistence context. This experience reinforced an important lesson: 👉 Understanding how Hibernate manages state internally is crucial for building reliable systems. Curious to know — have you faced similar issues in your projects?

[DevNote] Re-skill from SpringBoot to .Net Quick Quick . . . VS Studio <-> IntelliJ NuGet [packages.config] (nuget.org) <-> Maven [pom.xml] / Gradle [build.gradle] (mvnrepository.com) VS_Project [config.ini] (Controller[WinForm] *.cs, View[WinForm] *.Designer.cs) <-> Root Package [applicaiton.yml] ([JavaFX/Swing] *.java, [JForm] *.form) VS_Project.View[Web] (*.asp/*.cshtml/*.aspx, Blazor) <-> Resources/View Package (*.jsp/*.xhtml/*.jspx, JSF) VS_Project.Middleware[Web] <-> ServletFilter/ControllerAdvide Package VS_Project.Controller[Web] (ActionFilter) <-> Controller Package (AOP) VS_Project.Common <-> Constant/Config Package VS_Project.Service (Decorator/Proxy) <-> Service Package (AOP) VS_Project.DAL <-> Repository Package (EF_CORE.LINQ : HIBERNATE.JPA, DbContext/ADO.NET : JDBC) VS_Project.Model <-> Entity Package   /// OPTION 1 - TransactionScope using (var scope = new TransactionScope(  TransactionScopeOption.Required,  new TransactionOptions  {  IsolationLevel = IsolationLevel.ReadCommitted  })) {  // CALL MANY DAL / SERVICE  _orderDal.InsertOrder(order);  _certificateDal.UpdateGeneratePdfFlag(id, "Y");  _mailDal.InsertMailQueue(order);  // COMMIT  scope.Complete(); } // If throw exception → auto rollback   /// OPTION 2 - TransactionScope (Async) using (var scope = new TransactionScope(  TransactionScopeAsyncFlowOption.Enabled)) {  await DoDbWorkAsync();  scope.Complete(); }   /// OPTION 3 - EF6 DbContextTransaction using (var db = _dbFactory.CreateDbContext()) using (var tx = db.Database.BeginTransaction()) {  try  {  db.SEC_USER.Add(user);  db.SaveChanges();  db.OTHER_TABLE.Add(entity);  db.SaveChanges();  tx.Commit();  }  catch  {  tx.Rollback();  throw;  } }   /// OPTION 4 - OracleTransaction / ADO.NET var conn = new OracleConnection(cs); conn.Open(); var tx = conn.BeginTransaction(); try {  // ExecuteCommand  tx.Commit(); } catch {  tx.Rollback(); } Noted : https://lnkd.in/ggpnYYSM

🚨 If you think '@NotNull' validates user input… You’re already behind. Most Spring Boot devs don’t understand the difference between these 👇 🔥 Core Annotations (Explained Simply) 👉 @NonNull (Lombok) * Adds runtime null check → throws NPE * ❌ NOT validation * ✔ Use for internal code safety 👉 `@NotNull` (Bean Validation) * Blocks only `null` * ❌ Allows `""` and `" "` * ✔ Use when field must exist (not necessarily meaningful) 👉 `@NotEmpty` * Blocks `null` + empty (`""`) * ❌ Allows `" "` * ✔ Use for collections / basic presence 👉 `@NotBlank` * Blocks `null`, `""`, `" "` * ✔ Ensures meaningful input * ✔ Best for user-facing fields ⚠️ Biggest Misconception Validation annotations DO NOT control DB storage. 🔥 Real Production Case “Field optional, but DB should NEVER store NULL” ✔ Correct approach: * Allow optional input * Convert `null → ""` in **service layer** * Enforce DB: `NOT NULL DEFAULT ''` 🧠 Annotation Categories (Interview Favorite) 👉 JPA `@Entity @Table @Id @Column` 👉 Hibernate `@CreationTimestamp @UpdateTimestamp` 👉 Bean Validation `@NotNull @NotBlank @Size @Email` 👉 Lombok `@Data @Builder @NonNull` #Interview #Questions (FAANG-Level + Real Interviews) 1. Why is `@NotNull` not enough for validating user input? 2. Difference between `@NotEmpty` and `@NotBlank`? 3. What exactly does Lombok `@NonNull` do at compile/runtime? 4. Do validation annotations affect database values? Why? 5. Where should null → "" conversion happen in a layered architecture? 6. Why does validation sometimes NOT trigger in Spring controllers? 7. Difference between JPA and Hibernate annotations? 8. Can Hibernate work without JPA? How? 9. When should you store NULL vs empty string in DB design? 10. What happens if `@NotEmpty List<String>` contains null elements? 11. Difference between `@Size` and `@NotEmpty`? 12. Can `@Column(nullable = false)` replace `@NotNull`? Why/why not? 13. What is the role of `@Valid` vs `@Validated` in Spring? 14. How does method-level validation work in Spring Boot? 15. What happens if both DB constraint and validation annotation conflict? 16. Is `@NotBlank` applicable to non-String fields? Why? 17. How do you validate nested objects in a DTO? 18. What is the difference between DTO validation and Entity validation? 19. Why is putting validation annotations on Entity sometimes discouraged? 20. How would you design validation for partial updates (PATCH requests)? 21. Can you create custom validation annotations? How? 22. What is fail-fast vs fail-safe validation? 23. How does Hibernate Validator integrate with Spring Boot automatically? 24. What are groups in validation and when are they used? 📌 Follow for real backend engineering insights #Java #SpringBoot #Backend #InterviewPrep #SoftwareEngineering #Developers

🚀 Day 85 – Building a Spring + Hibernate CRUD Application Hello everyone, I’m Nagu Mulampaka, currently learning Java Full Stack Development, and I’m excited to share that I recently built a Spring and Hibernate project to manage employee data. This project was a key step in my learning, helping me understand real-world application design using layered architecture, ORM frameworks, and Spring features. 🔍 Overview I developed a Java-based backend application that performs complete CRUD operations (Create, Read, Update, Delete) on employee records stored in a MySQL database. It demonstrates how modern Java applications use frameworks like Spring and Hibernate to simplify development and improve maintainability. Key Concepts Learned and Implemented: 1️⃣ Entity Layer (Model Design): ● Created an Employee class mapped to a database table using JPA annotations (@Entity, @Table, @Id, @Column). ● Encapsulated fields like id, empname, address, contact, and experience. ● Followed proper Java Bean conventions with constructors, getters, and setters. 2️⃣ DAO Layer (Data Access Layer): ● Defined EmployeeDao interface to declare database operations. ● Implemented EmployeeDaoImpl using Spring’s HibernateTemplate. Performed operations like: ✔ Save employee ✔ Update employee ✔ Delete employee ✔ Fetch by ID ✔ Fetch all records ● Used @Transactional to ensure data consistency and transaction safety. This layer manages database operations separately, making the application easy to maintain and update. 3️⃣ Business Layer (Service Layer): ● Implemented EmployeeBusiness and EmployeeBusinessImpl. ● Used @Autowired for dependency injection, allowing loose coupling between layers. 4️⃣ Spring Configuration (Using XML-based Configuration): ✔️ Component Scanning → Automatically detects DAO & Service classes ✔️ DataSource Configuration → Connects application with MySQL database ✔️ SessionFactory → Integrates Hibernate with Spring ✔️ Hibernate Properties → Dialect, SQL logging ✔️ HibernateTemplate → Simplifies ORM operations ✔️ Transaction Manager → Handles transactions using @Transactional 5️⃣ Main Application (App.java) – Entry Point of the System In my Spring + Hibernate application, the App.java class serves as the starting point of the application. It is responsible for initializing the application, loading the Spring configuration, and executing business operations such as: ✔ Inserting employee records ✔ Updating employee details ✔ Deleting records ✔ Fetching and displaying all employees ➤ Core Concepts I Strengthened ● Object-Relational Mapping (ORM) with Hibernate ● Understanding the difference between Hibernate and JDBC ● Transaction Management using @Transactional ● Real-world CRUD operations implementation 👉 GitHub Repository: https://lnkd.in/g8ZnJCyg #Java #SpringFramework #Hibernate #FullStackDeveloper #BackendDevelopment #MySQL #Maven #LearningJourney #SoftwareEngineering #DailyLearning #OpenToWork 🚀

**Adopting Quarkus after years of Spring Boot** After years working with Spring Boot, I recently started using Quarkus on real projects. Not just hype. The shift is deeper and architectural. At first glance, both solve the same problems: REST, DI, persistence, security, cloud. But the real difference is not features. It’s when errors appear and how predictable the system is. Spring Boot is flexible and runtime-driven (auto-config, scanning, reflection). You move fast, but some issues appear late (integration or prod). Quarkus flips the model: build-time first, fail fast, less implicit behavior, more deterministic system. It validates early: • injection • configuration • wiring • integrations Result: less runtime logic, fewer surprises. --- **Build-time vs runtime (real impact)** Spring → validates late Quarkus → validates early In practice: • missing config → build error • invalid JPA mapping → early detection • ambiguous injection → build fails Dev loop changes completely. Spring: fast start, delayed issues Quarkus: stricter start, immediate feedback --- **Minimal example** Spring Boot: @Service class PaymentServiceV1 {} @Service class PaymentServiceV2 {} @Autowired PaymentService service → app starts → ambiguity handled later Quarkus: @ApplicationScoped @Named("v1") class PaymentServiceV1 {} @ApplicationScoped @Named("v2") class PaymentServiceV2 {} @Inject PaymentService service → build fails immediately Fix: @Inject @Named("v1") PaymentService service Same feature: Spring tolerates Quarkus enforces --- **What changes in practice** • clearer dependencies • fewer hidden bugs • faster debugging • more stable production At first: more friction Then: more control --- **Architecture impact** Spring: • runtime-heavy • implicit behavior • strong ecosystem Quarkus: • deterministic • explicit wiring • reduced reflection (native friendly) --- **Execution model** Spring (MVC): • blocking • 1 thread per request Quarkus: • reactive + non-blocking (Vert.x) • better scalability if used correctly But: blocking code in non-blocking flow = performance issues --- **Persistence** Both use Hibernate. Spring: • repository pattern • flexible Quarkus (Panache): • less boilerplate • faster for simple CRUD • needs discipline --- **Cloud & native** Spring = cloud compatible Quarkus = cloud-native by design • fast startup • low memory • native (GraalVM) ready --- **Reality check** Spring: • huge ecosystem • best for complex/legacy Quarkus: • more predictable • better for microservices But requires: • discipline • understanding of model --- **My takeaway** Not about performance. It’s about predictability. Less “why in prod?” More “I know why” --- Have you tried Quarkus in production? --- #Java #Quarkus #SpringBoot #Backend #SoftwareArchitecture #Microservices #CloudNative #GraalVM #TechLead #SoftwareEngineering

Spring Boot Roadmap PHASE 1 - Basics • Creating a spring boot project using spring initializr • Maven and gradle build tools • Annotations • Profiles and environment-specific configurations • @getmapping, @postmapping, @putmapping, @deletemapping • Handling path variables and request parameters • Setting up database connection (h2, mysql, postgresql) • Using jparepository and crudrepository • Introduction to spring boot devtools • Enabling hot reloading • Spring batch, scheduling and cron expressions PHASE 2 - Intermediate • Using @controlleradvice and @exceptionhandler • Custom error responses and exception classes • Global exception handling • Basic authentication • Configuring security for apis • Implementing jwt (json web tokens) for stateless authentication • Introduction to hateoas • Versioning rest apis (uri, parameter, headers) • Unit testing with junit and mockito • Writing integration tests with spring boot test • Testing restful services with mockmvc • Exploring actuator endpoints • Creating custom health indicators PHASE 3 - Advanced • Using @profile annotation • Configuring environment-specific beans • Switching profiles for different environments • Setting up a spring cloud project • Key components of spring cloud • Setting up eureka server • Registering microservices with eureka • Service discovery in action • Introduction to api gateway • Setting up spring cloud gateway • Configuring routes and filters • Setting up spring cloud config server • Managing configuration in a centralized repository • Configuring spring boot applications to use config server PHASE 4 - Microservices • Introduction to inter-service communication • Using resttemplate for synchronous communication • Using feign client for simplified service calls • Setting up resilience4j • Configuring circuit breakers, retry in microservices • Introduction to distributed tracing This roadmap guide you through the essential skills and concepts. ➤ Watch Resources : Shrayansh Jain 1. Advantage of Spring boot over traditional Spring MVC: - https://lnkd.in/gbHYBdFJ 2. What is Layered Architecture: - https://lnkd.in/gdstJnet 3. Maven Lifecycle: - https://lnkd.in/gjYygKX7 4. Spring boot REST Api Annotations: - https://lnkd.in/gGYpinzs 5. Bean Lifecycle and loC: - https://lnkd.in/g6PCbj5U 6. Dependency Injection: - https://lnkd.in/gMBUFDxC 7. Bean Scope: - https://lnkd.in/gita68gc 8. How Profiling works in Spring boot: - https://lnkd.in/gNJ69SuD 9. How you will initialize bean conditionally: - https://lnkd.in/gB-_M5sN 10. Dynamic Initialization of Bean: - https://lnkd.in/gaerePEh Preparing for interviews? Start revising these today 𝗜’𝘃𝗲 𝗽𝗿𝗲𝗽𝗮𝗿𝗲𝗱 𝗶𝗻 𝗗𝗲𝗽𝘁𝗵 𝗝𝗮𝘃𝗮 𝗦𝗽𝗿𝗶𝗻𝗴𝗯𝗼𝗼𝘁 𝗯𝗮𝗰𝗸𝗲𝗻𝗱 𝗚𝘂𝗶𝗱𝗲, 𝟏𝟬𝟬𝟬+ 𝗽𝗲𝗼𝗽𝗹𝗲 𝗮𝗿𝗲 𝗮𝗹𝗿𝗲𝗮𝗱𝘆 𝘂𝘀𝗶𝗻𝗴 𝗶𝘁. 𝗚𝗲𝘁 𝘁𝗵𝗲 𝗴𝘂𝗶𝗱𝗲 𝗵𝗲𝗿𝗲: https://lnkd.in/dfhsJKMj keep learning, keep sharing ! #java #backend #javaresources