Introduction to Spring Framework

🚀 Level 1: Core Spring concepts

Spring Framework Adventure!

Welcome, Hero! Ready to build amazing Java apps? Join Springy and unlock the powers of IoC, Beans, and Dependency Injection!

"Let's play and learn!"

Spring Exploration Maps

Select a map folder to explore the fundamental elements of the Spring Framework ecosystem.

Definition

The Spring Framework is a powerful, lightweight, and incredibly modular application framework for building Enterprise Java applications.

Before Spring, enterprise developers struggled with massive, heavy architectures like EJB (Enterprise JavaBeans) which forced boilerplate code. Spring broke these chains by introducing lightweight, POJO (Plain Old Java Object) structures.

Awesome Spring Perks:

Lightweight core

Saves computing power. Basic Spring version is only about 2MB in size.

Modular Architecture

Use only what you need (e.g., just MVC or just database tools) without loading everything else!

Testing Friendly

Since objects are loosely linked, it's super simple to write mock unit tests.

Boilerplate Vanisher

Reduces tedious repetitive code like JDBC database setup, exception handling, and transaction blocks.

Spring is built like a delicious layered cake of independent modules. You don't have to eat the whole cake; you can just select your favorite layers!

Enterprise Layer: Spring AOP, Security, Messaging

Web Layer (MVC): Handles client HTTP requests, REST APIs & UI

Data Access Layer: JDBC, ORM (Hibernate), Transactions

Core Container (Base): Beans, Core, Context, SpEL (The Heart of Spring)

💡 The Foundation: Core Container

This foundation layer contains the Spring Beans and BeanFactory / ApplicationContext. Together, they act as the kitchen where all software objects are cooked, assembled, and delivered!

🔄 IoC (Inversion of Control)

Normally, a programmer writes code that directly controls object creation with the new operator.

Manual: Car myCar = new Car();

Under **IoC**, control is inverted! The system or a container manages and serves those objects automatically. You ask for a car, and Spring hands you one ready to drive!

🔌 DI (Dependency Injection)

DI is the specific design pattern that implements IoC. It **injects** dependent objects directly into other objects upon construction.

Constructor Injection: Dependencies are passed directly during object creation (Most Recommended!).

Setter Injection: Dependencies are delivered via standard setter methods.

💡

Pixar Analogy for Dependency Injection

Imagine building a Lego Pixar Castle. Instead of you traveling across town to craft each plastic block yourself (which represents direct coupling), you have a friendly helper (Spring Container) who fetches all matching bricks and places them exactly where they need to go. You just focus on organizing the design!

Spring supports three primary styles to tell it how to configure and wire up your application components together:

Legacy

1. XML Config

Configuration instructions written strictly inside XML schemas.

Modern

2. Annotations

Adding tags (like @Component) right on top of Java code.

Recommended

3. Java Config

Using special configuration Java classes with @Configuration.

The Interactive Blueprint Lab

Toggle between annotation and Java class setups to see exactly how clean Spring framework configurations look.

Java Style Code

// Step 1: Tell Spring this class is a managed Bean
@Component
public class Engine {
    public void start() {
        System.out.println("VROOOM! Engine is active!");
    }
}

// Step 2: Inject the Engine dependency into our Car Bean automatically
@Component
public class Car {

    @Autowired // Spring automatically matches the Engine bean here!
    private Engine engine;

    public void drive() {
        engine.start();
        System.out.println("Car is speeding ahead!");
    }
}

// Step 1: Create a central Configuration class acting as a blueprint room
@Configuration
public class AppConfig {

    @Bean // Registers "Engine" bean to container
    public Engine engine() {
        return new Engine();
    }

    @Bean // Injects registered engine bean into Car constructor
    public Car car() {
        return new Car(engine());
    }
}

IoC "Bean Constructor" Lab

Play container master! Configure your custom components below, hit the button, and watch them materialize inside the Spring ApplicationContext container!

🛠️ Design a Bean Blueprint

Bean ID Name

Component Class Type DatabaseConnector.class EmailService.class NotificationManager.class SecurityFilter.class

Bean Scope

Singleton Prototype

🏢 Spring ApplicationContext (IoC Container)

Container Empty

Create and inject beans on the left to power up this Spring engine!

Springy's Tips

"Hey! Did you know? In Spring, a 'Bean' is simply any Java class object that Spring creates, manages, and feeds into your program!"

Mini-Game

Autowire Connector

Click an object on the left, then click its corresponding **matching dependency** on the right to auto-wire them! Let's build a runnable system.

Component Needs

Available Beans

Select a component first!

Knowledge Duel Score: 0/3

Spring Master Quiz

Loading Question...

🏆

Amazing Job, Spring Cadet!

You scored 3/3 on your initial introduction test. Keep compiling!

© 2026 Sarthak Education