Spring Framework Basics

🔍 What Is It?

Spring Framework is the core programming model behind most modern Java backend applications built with Spring Boot. It is not the same thing as Spring Boot. Spring Framework provides the container, bean model, dependency injection, AOP, transaction support, web stack, and integration features. Spring Boot sits on top of that foundation and removes much of the manual setup.

The most important idea is the Spring container. The container, usually represented by ApplicationContext, creates and manages application objects called beans. Instead of every controller, service, and repository creating dependencies manually with new, Spring resolves the dependency graph and wires the objects together for you.

Quick Facts

• →Spring Framework is the core foundation behind Spring Boot.
• →It provides IoC and Dependency Injection through the Spring container.
• →Spring Boot reduces configuration, but it still runs on Spring Framework internally.
• →Important modules include Core, Beans, Context, AOP, MVC, JDBC, ORM, and Transaction.
• →Many production issues around beans, startup, profiles, and wiring require Spring Framework knowledge.
• →This is one of the most frequently asked backend and Spring Boot interview topics.

🎯 Why Do We Need It?

Without Spring, developers manually create and wire objects, pass dependencies around, choose lifecycle rules themselves, and keep configuration logic scattered across the codebase. That may feel manageable in a tiny project, but it becomes painful in real systems with controllers, services, repositories, validators, security filters, event handlers, schedulers, and multiple environments.

Spring gives teams a consistent way to manage object creation, configuration, transactions, web flow, and infrastructure integration. Spring Boot makes the setup much faster, but knowing the underlying framework is still important when the application context fails, the wrong bean gets injected, a profile changes behavior, or a transaction does not behave as expected.

Why this matters in real work

• →It helps you understand how controllers, services, repositories, and configuration classes are connected.
• →It helps you debug missing beans, circular dependencies, bean conflicts, and configuration mistakes.
• →It helps you explain Spring Boot behavior clearly in interviews, design discussions, and production troubleshooting.

🏗️ What Happens in Real Projects?

In real backend projects, teams usually experience Spring Framework through Spring Boot rather than through raw XML configuration. The framework still does the heavy lifting behind the scenes.

You see it in:

• →Backend APIs where controllers receive requests and delegate to services
• →Microservices where configuration, health, dependency wiring, and startup order matter
• →Enterprise applications with many modules, reusable components, and shared libraries
• →Transaction-heavy systems where service methods coordinate database work safely
• →Security-enabled applications where filters, authentication, and authorization depend on bean configuration
• →Data-driven applications where repositories, entity managers, and transaction boundaries must align correctly

A typical production flow looks like this: controllers handle HTTP requests, services hold business logic, repositories access the database, configuration classes define important beans, and the Spring container wires everything together so the application starts as one managed system.

⚙️ How It Works

1. Developers write classes such as @Controller, @RestController, @Service, @Repository, or @Configuration.
2. Spring scans those packages or registers classes explicitly and turns them into beans.
3. The ApplicationContext creates those beans and manages their lifecycle.
4. Dependencies are injected automatically, usually through constructor injection.
5. Spring Boot adds auto-configuration, starter dependencies, and sensible defaults on top of the same container.
6. The application starts with controllers, services, repositories, and infrastructure components already connected and ready to use.

That is why a Spring Boot application feels simple on the surface: Boot reduces setup, but Spring Framework still owns the bean graph, dependency resolution, and runtime behavior.

💻 Example

Manual wiring versus Spring-managed wiring — A beginner-friendly comparison that shows why dependency injection matters in real Spring Boot controllers and services.

public class UserService {
    public String getUserName(Long id) {
        return "User-" + id;
    }
}

public class UserController {
    private final UserService userService = new UserService();

    public String getUser(Long id) {
        return userService.getUserName(id);
    }
}

🤔 Common Confusions

🚨 Common Production Issues

✅ Best Practices

🏛️ Architect's Note

💬 Frequently Asked Questions

🎯 Key Takeaways

🔗 Related Topics

🎯 Practice this topic in interviews

↗ Where this topic fits