Jānis Ošs’ Post

🚀 Spring Framework 🌱 | Day 2 – Dependency Injection (DI) Today I understood Dependency Injection not just as a concept… but as a mindset shift 💡 👉 In real life, DI is everywhere. Think about this 👇 ☕ When you order tea in an office You don’t go to the kitchen, buy milk, sugar, tea powder and make it yourself. 👉 Someone provides it to you. 🚗 When you book a cab You don’t build the car or hire a driver manually. 👉 The system injects the service you need. 🏢 In a company project A developer doesn’t create every object manually. 👉 Framework like Spring injects dependencies automatically. 💡 Same happens in Spring Instead of: ❌ Creating objects using "new" We let Spring: ✅ Create objects ✅ Manage them ✅ Inject wherever needed 🔹 How it works internally (simple view): 👉 Spring scans classes 👉 Creates beans in IOC container 👉 Finds dependencies 👉 Injects them using annotations 🔥 Why this matters? - Loose coupling - Easy testing - Clean & scalable code 👉 Small concept, but it completely changes how you build applications. #SpringFramework #Java #BackendDevelopment #LearningJourney #SpringBoot #TechGrowth

🚀 Day 9/100: Spring Boot From Zero to Production Topic: Dependency Injection (DI) If someone asked me to name the three most important things in Spring Boot, Dependency Injection (DI) would definitely be at the top of that list! 🏆 It might sound like a complex technical term, but the concept is actually quite simple once you break it down. The "Old School" Way ❌ Before Spring, if we wanted to use a service inside a controller, we had to manually create the object ourselves: UserService userService = new UserService(); This makes your code "tightly coupled", meaning your controller is now responsible for creating and managing that service. If the service changes, you have to go back and fix it everywhere. The Spring Boot Way (DI) ✅ With Spring, you don't use the new keyword anymore. Instead, you let the IoC Container (like the ApplicationContext) do the heavy lifting. Think of this container as a giant box that holds all your Beans (object instances). When your controller needs that service, you just ask Spring to "inject" it: @Autowired UserService userService; Why is this a game-changer? 🚀 Inversion of Control (IoC): Spring takes over the responsibility of creating and managing the object lifecycle. Cleaner Code: You don't have to write boilerplate code to instantiate objects. Decoupling: Your components don't need to know how to create their dependencies, they just know they'll be there when needed. Reduced Code Size: It keeps your project much more organized and scalable. Basically, Spring is the ultimate manager, it creates the instances, keeps them in the container, and hands them to you exactly where they are needed! See you in next post with more interesting topics. #Java #SpringBoot #SoftwareDevelopment #100DaysOfCode #Backend

🚀 Spring Boot Startup Flow: What Happens Behind the Scenes A Spring Boot application may look simple to start, often with just a single line of code: SpringApplication.run(Application.class, args); But behind the scenes, Spring Boot performs several important steps to bootstrap the entire application. 🔹 Step 1 — SpringApplication.run() is triggered This method starts the complete lifecycle of the Spring Boot application and prepares the framework to initialize all required components. 🔹 Step 2 — Environment Preparation Spring Boot loads configuration from multiple sources such as: • "application.properties" or "application.yml" • Environment variables • Command-line arguments These configurations help the application adapt to different environments like development, testing, or production. 🔹 Step 3 — Creating the Application Context Spring Boot initializes the ApplicationContext, which acts as the central container responsible for managing all Spring Beans and application configurations. 🔹 Step 4 — Component Scanning Spring scans the project packages to detect classes annotated with: "@Component" "@Service" "@Repository" "@Controller" These classes are automatically registered as Beans inside the Application Context. 🔹 Step 5 — Auto Configuration Based on the dependencies added to the project (for example, "spring-boot-starter-web"), Spring Boot automatically configures required components such as: • Embedded Tomcat server • DispatcherServlet • Spring MVC configuration • JSON message converters 🔹 Step 6 — Bean Initialization Spring creates all beans and resolves their dependencies using Dependency Injection, ensuring that components are properly connected. 🔹 Step 7 — Embedded Server Startup Finally, Spring Boot starts the embedded server (Tomcat/Jetty/Undertow), making the application ready to receive HTTP requests. Once the application is running, the request flow typically follows: Client → DispatcherServlet → Controller → Service → Repository → Database Understanding what happens internally helps developers gain deeper insight into Spring Boot architecture, application lifecycle, and request handling. Spring Boot simplifies development, but learning what happens under the hood makes system design and debugging much more effective. #Springboot #Java #BackendDevelopment #SoftwareEngineering #Microservices

🚀 Understanding Spring Boot Project Structure A well-organized Spring Boot project follows a layered and modular architecture, making applications more scalable, maintainable, and testable. 🔹 Controller Handles HTTP requests and exposes REST APIs. It acts as the entry point of the application. 🔹 Service Contains business logic and core functionalities. It processes data between the controller and repository layers. 🔹 Repository Manages data access using JPA/CRUD operations and communicates directly with the database. 🔹 Model (Entity) Represents database tables as Java classes. Each model maps to a specific table. 🔹 DTO (Data Transfer Object) Used to transfer data between layers, ensuring separation between internal models and external APIs. 🔹 Configuration (Config) Defines application configurations such as beans, CORS, and other setup-related components. 🔹 Security Handles authentication and authorization (e.g., Spring Security, JWT). 🔹 Exception Handling Manages global errors and custom exceptions to ensure clean and consistent API responses. 💡 This layered architecture improves code readability, enforces separation of concerns, and makes your application easier to scale and maintain. #SpringBoot #Java #Backend #SoftwareArchitecture #CleanCode #Programming #Developer

🌱 𝗨𝗻𝗱𝗲𝗿𝘀𝘁𝗮𝗻𝗱𝗶𝗻𝗴 𝗦𝗽𝗿𝗶𝗻𝗴 𝗕𝗼𝗼𝘁 𝗕𝗲𝘆𝗼𝗻𝗱 𝗝𝘂𝘀𝘁 𝗕𝘂𝗶𝗹𝗱𝗶𝗻𝗴 𝗔𝗣𝗜𝘀 Spring Boot makes it very convenient to get a backend service up and running quickly. But building reliable systems requires understanding what happens internally, not just using annotations and defaults. Some aspects that become important while designing real backend applications: • How dependency injection manages object creation and wiring • Understanding bean lifecycle and the role of application context • How transaction boundaries impact data consistency • Structuring controller, service, and repository layers for maintainability • Designing APIs with proper validation, error handling, and clear responsibilities As systems grow, clarity in structure and behaviour becomes more valuable than speed of development. Frameworks help accelerate delivery — but deeper understanding helps build scalable and stable systems. #SpringBoot #BackendEngineering #Java #SoftwareArchitecture #SystemDesign

🔗 Understanding @Autowired in Spring Boot While building my Spring Boot project, I explored how different components are connected without manually creating objects. 🔹 What is @Autowired? It is used for Dependency Injection, which allows Spring to automatically provide the required objects instead of creating them manually using "new". 💡 Why is it useful? It helps in writing cleaner and loosely coupled code, making applications easier to manage and scale. For example, instead of creating a service object inside a controller, Spring injects it automatically using @Autowired. Understanding this concept gave me a better idea of how Spring manages objects internally 💻 #SpringBoot #Java #DependencyInjection #BackendDevelopment #TechLearning

🚀 What is Dependency Injection in Spring Boot? While learning Spring Boot, one concept that really improved my understanding of backend development was Dependency Injection (DI). At first, the name sounded complicated, but the idea is actually simple. 👉 Dependency Injection means letting Spring create and manage objects instead of creating them manually. Without Dependency Injection UserService userService = new UserService(); Here the class is responsible for creating the object itself, which creates tight coupling. With Dependency Injection in Spring Boot @Autowired private UserService userService; Now Spring automatically creates and injects the object when the application starts. Why is Dependency Injection important? ✔ Reduces tight coupling between classes ✔ Makes code easier to test ✔ Improves maintainability ✔ Helps build scalable applications This is one of the key concepts that makes Spring Boot powerful for backend development. #Java #SpringBoot #BackendDevelopment #LearningInPublic #Coding

Why I’m choosing Spring Modulith over traditional Multi-Module Maven setups ? 🚀 We’ve all been there: a project starts as a "simple monolith" but quickly turns into a "big ball of mud" where everything depends on everything. In my recent project, I decided to move away from the traditional modular approach and embrace Spring Modulith. Here’s why it’s a game-changer for Java developers: 1. Goodbye, "POM Hell" (Reducing XML Overload) 📉 In a traditional Maven multi-module project, every new module needs its own pom.xml, its own entry in the parent POM, and manual dependency management. The Modulith way: I kept everything in a single artifact. No more jumping between 10 different pom.xml files. Modularity is handled at the package level, meaning less boilerplate and more coding. 2. Enforced Boundaries (The "Architect in a Box") 🛡️ Traditional modules often leak internals because someone eventually makes a class public. The Modulith way: Spring Modulith treats sub-packages as "hidden" by default. It uses a verification tool (ApplicationModules.verify()) that actually fails my tests if one module tries to access the private internals of another. It’s like having a senior architect reviewing my imports in real-time. 3. Event-Driven by Default 💡 Instead of modules calling each other directly (tight coupling), I used Spring Modulith’s event publication registry. The Benefit: If the "Order" module finishes, it just publishes an event. The "Inventory" module picks it up. They don't need to know each other exist. 4. Automatic Documentation 📚 It generates PlantUML diagrams automatically based on the actual code structure. No more outdated architecture docs! The Verdict: Spring Modulith gives me the "Clean Architecture" I want without the operational nightmare of 20 different microservices or the XML-heavy overhead of Maven multi-modules. If you’re building a Spring Boot app today, stop splitting your JARs and start modularizing your domains! #Java #SpringBoot #SoftwareArchitecture #SpringModulith #CleanArchitecture #BackendDevelopment #FullStack

🚀 Most developers hear “ApplicationContext”… but don’t truly understand it. If you’re using Spring Boot, this is the MOST important concept. Let’s simplify it 👇 👉 What is ApplicationContext? It’s the heart of Spring Boot. A container that: ✔ Creates objects (beans) ✔ Manages their lifecycle ✔ Injects dependencies automatically --- 💡 Example: @Service public class OrderService {} @RestController public class OrderController { private final OrderService orderService; public OrderController(OrderService orderService) { this.orderService = orderService; } } 👉 You never created OrderService manually… right? That’s ApplicationContext doing the magic ✨ --- ⚙️ What actually happens internally? 1️⃣ Spring scans your project 2️⃣ Finds @Service, @Component, etc. 3️⃣ Creates objects (beans) 4️⃣ Stores them in ApplicationContext 5️⃣ Injects them wherever needed --- 🔥 Real-world impact: Without ApplicationContext: ❌ You manually create objects ❌ You manage dependencies yourself ❌ Code becomes tightly coupled With Spring: ✅ Loose coupling ✅ Cleaner code ✅ Easy testing --- 📌 Key Takeaway: ApplicationContext = Brain of Spring Boot Everything revolves around it. Follow for more such deep dives 🚀 #SpringBoot #Java #BackendDevelopment #SoftwareEngineer