Building User API with Spring Boot and Java

🧠 Ever wondered how REST APIs actually work behind the scenes? I developed a Spring Boot sample project to gain hands-on experience in backend development from scratch. 🔧 Tech Stack: • Java 21 • Spring Boot • Maven ✨ What this project covers: • Creating REST APIs from scratch • Clean architecture (Controller → Service → Repository) • Handling API requests and responses • Beginner-friendly structure for learning and gaining hands-on experience in backend development. • No database setup required This project can be a great starting point for anyone who wants to learn how real-world API-based applications are built, without worrying about database configuration in the beginning. 🚀 Next Improvements: • Database integration (MySQL) • JWT Authentication • Centralized exception handling for better error management • Pagination support for handling large datasets • Swagger Documentation 🔗 GitHub Repository: https://lnkd.in/gD6Gj8f2 #Java #SpringBoot #BackendDevelopment #RESTAPI #BeginnerFriendly #LearningInPublic

Clean REST API in Spring Boot (Best Practice) 🚀 Here’s a simple structure you should follow 👇 📁 Controller - Handles HTTP requests 📁 Service - Business logic 📁 Repository - Database interaction Example 👇 @RestController @RequestMapping("/users") public class UserController { @Autowired private UserService userService; @GetMapping("/{id}") public User getUser(@PathVariable Long id) { return userService.getUserById(id); } } 💡 Why this matters: ✔ Clean code ✔ Easy testing ✔ Better scalability ⚠️ Avoid: Putting everything inside controller ❌ Structure matters more than code 🔥 Follow for more practical backend tips 🚀 #SpringBoot #Java #CleanArchitecture #Backend

What actually happens when you hit a Spring Boot API? In my previous post, I explained how Spring Boot works internally. Now let’s go one level deeper 👇 What happens when a request hits your application? --- Let’s say you call: 👉 GET /users Here’s the flow behind the scenes: 1️⃣ Request hits embedded server (Tomcat) Spring Boot runs on an embedded server that receives the request. --- 2️⃣ DispatcherServlet takes control This is the core of Spring MVC. It acts like a traffic controller. --- 3️⃣ Handler Mapping DispatcherServlet finds the correct controller method for the request. --- 4️⃣ Controller Execution Your @RestController handles the request → Calls service layer → Fetches data from DB --- 5️⃣ Response conversion Spring converts the response into JSON using Jackson. --- 6️⃣ Response sent back Finally, the client receives the response. --- Why this matters? Understanding this flow helps in: ✔ Debugging production issues ✔ Writing better APIs ✔ Improving performance Spring Boot hides complexity… But knowing what’s inside makes you a better backend developer. More deep dives coming #Java #SpringBoot #BackendDevelopment #Microservices

Think Spring is just one framework? 🤔 It’s actually a collection of powerful modules 🚀 🔹 Spring Core 🔹 Spring Data JPA 🔹 Spring MVC 🔹 Spring Boot 🔹 Spring AOP 🔹 Spring Security 🔹 Spring Cloud But here’s what most beginners miss 👇 👉 If you don’t understand Spring Core, everything else feels hard So let’s simplify it 💡 🔹 IoC (Inversion of Control) 👉 Spring takes control of object creation 🔹 Dependency Injection (DI) 👉 No tight coupling, no manual wiring 🔹 Beans 👉 Objects managed by Spring 🔹 Application Context 👉 The container that runs everything 🔹 Autowiring 👉 Automatically connects dependencies 🔹 Bean Scope 👉 Defines how long objects live 🔹 Annotations 👉 @Component, @Autowired, @Service, @Repository ✨ Learn Spring Core once… and the rest of Spring starts making sense Next → Let’s master Dependency Injection 👀 #springframework #springcore #springboot #java #backenddeveloper

I used to think Spring Boot was just “another framework”… Until I actually started building with it. 🚀 Here are the core concepts of Spring Boot that completely changed how I see backend development: 👇 🔹 Auto-Configuration No more manual setup. Add a dependency → Spring Boot configures it for you. 🔹 Starter Dependencies Instead of adding 10 dependencies, you just use one: 👉 spring-boot-starter-web 🔹 Embedded Server No need for external Tomcat. Just run your app and it works. 🔹 Dependency Injection (DI) Spring manages objects for you → cleaner, loosely coupled code. 🔹 Inversion of Control (IoC) You don’t control object creation anymore — Spring does. 🔹 Spring MVC Architecture Controller → Service → Repository → Database (Simple, structured, scalable) 🔹 Spring Data JPA No need to write SQL for basic operations. Just use interfaces. 🔹 application.properties All configurations in one place → clean and manageable. 💡 What I realized: Spring Boot isn’t about writing less code… It’s about writing better, scalable code faster. What concept confused you the most when you started Spring Boot? 🤔 #Java #SpringBoot #BackendDevelopment #LearningInPublic #CodingJourney

Most backend codebases become hard to change for the same reason. The business logic knows too much about the infrastructure. After working with Spring Boot services in production, I've seen this pattern consistently. A service that started clean slowly becomes a system where changing the database means touching the core logic. Where adding a new endpoint breaks something unrelated. Where testing requires spinning up half the infrastructure. Hexagonal Architecture solves exactly that. The idea is simple: your core domain should not depend on anything external. Not the database. Not the HTTP layer. Not Kafka. Not Spring annotations scattered through your business logic. What that means in practice: • Your use cases are pure Java. No framework dependencies. • Ports define what your application needs, not how it gets it. • Adapters handle the external world: REST, Kafka, JPA, anything. What changes when you apply it: • You can test your business logic without a database • You can swap an adapter without touching the domain • New developers understand where business rules live The mistake most teams make is treating it as over-engineering. It's not. It's separating what your system does from how it does it. When your domain depends on Spring, you don't have a domain. You have infrastructure with business logic mixed in. Are you applying any of this in your current codebase? #Backend #Java #SpringBoot #HexagonalArchitecture #SoftwareEngineering #SystemDesign #CleanArchitecture

 How SpringBoot Makes Backend Development Feel Like Magic No complexity. Just a folder structure… and boom —you're manipulating data. Here’s the reality: Traditional backend setup used to mean: Heavy XML configs Complex dependency management Hours of setup before writing your first API SpringBoot changed the game. One starter folder structure Auto-configuration Embedded server (no external Tomcat needed) Annotations that actually make sense You literally: Create a Spring Boot project Define a @RestController Add @Autowired service/repo Run it And just like that — you’re handling HTTP requests, talking to a DB, and returning JSON. No ceremony. No boilerplate hell. Spring Boot didn't just simplify backend — it made it fun again. If you’ve been avoiding backend because of the "complexity" — try Spring Boot once. You’ll see. 💬 Agree? Or still think backend is hard? Let’s talk 👇 #SpringBoot #Java #BackendDevelopment #CodingSimplified #TechMadeSimple

🚀 Spring Boot – User API Upgrade (Full CRUD) Took my mini project to the next level by implementing complete CRUD operations in Spring Boot. 🧠 What I added: ✔️ GET "/users" → Fetch all users ✔️ PUT "/user/{id}" → Update user ✔️ DELETE "/user/{id}" → Delete user 💡 Now the API supports full lifecycle operations: Create • Read • Update • Delete 🔁 Architecture in action: Controller → Service → In-memory data → JSON response 🧪 Tested all endpoints using Postman and verified the complete flow. ⚠️ Also understood the importance of proper error handling (next step: exception handling instead of returning null). 💻 DSA Practice: • Move zeros to end (array manipulation) • First non-repeating character (HashMap concept) ✨ This step helped me understand how real backend systems manage and manipulate data efficiently. #SpringBoot #Java #BackendDevelopment #RESTAPI #CRUD #DSA #LearningInPublic #SoftwareEngineering

Everything failed… but the database still got updated 🙃. Recently, while working on a feature in Spring Boot project, I used @Transactional annotation assuming it would rollback the entire operation if something failed. But during testing, I noticed something strange, even after an exception, some data was still getting saved. That’s when I started digging deeper. I realized that @Transactional doesn’t always behave the way we expect: - It rolls back only for unchecked exceptions (RuntimeException) by default. - If the method call happens within the same class, it might not work due to proxy behavior. - Catching exceptions without rethrowing can prevent rollback. In my case, I was catching the exception and not rethrowing it. So Spring thought everything was fine and committed the transaction. Once I fixed that, the rollback worked as expected. Annotations make things easier… but understanding how they actually work makes you a better developer. #Java #SpringBoot #BackendDevelopment #Transactional #LearningInPublic #SoftwareEngineering #Database #SpringJPA #DataManagement

Spring Boot feels like magic… until you understand what is actually happening behind the scenes. One concept that confused me for a long time: 👉 Auto Configuration in Spring Boot At first, it really feels magical. "I just added a dependency… and everything started working 😄" No XML. No manual bean setup. No configuration chaos. Just run the app → it works. But then one question hits: How does Spring Boot decide what to configure and what to ignore? The answer is Auto Configuration Spring Boot tries to automatically configure your application based on what it finds in the classpath and your setup. Example: * Add H2 DB → in-memory DB gets configured * Add MySQL driver → DataSource changes automatically * Define your own bean → Spring backs off But here is the real insight most people miss: 👉 Auto Configuration is NOT magic. It is powered by Conditional logic Spring Boot constantly evaluates conditions like: * Is a class present in classpath? * Has the user already defined a bean? * Is a property set in application.yml? Based on that, it decides: 👉 "Should I create this bean… or skip it?" This is implemented using: * @ConditionalOnClass * @ConditionalOnMissingBean * @ConditionalOnProperty So the mental model becomes: Auto Configuration = what happens automatically Conditional Annotations = why it happens What I realized later is: Spring Boot does not remove control from you. It gives you smart defaults… and steps aside when you take control. That is why it feels magical at first but becomes obvious once you understand the design. #SpringBoot #Java #SpringFramework #Microservices #TechCareers #BuildInPublic