Spring Framework

 Introduction to Spring Framework

In the fast-evolving world of Java development, the Spring Framework has become one of the most reliable and dominant tools for building software. It is known for being powerful, flexible, and easy to integrate, making it a favorite among both beginners and expert developers.

Whether you're building a simple web app, an enterprise-level CRM system, or a cloud-native microservice, Spring provides all the tools you need to make your project scalable, maintainable, and modular.

What is the Spring Framework?

The Spring Framework is an open-source, modular, and lightweight framework designed to simplify the development of Java-based enterprise applications.

It was introduced by Rod Johnson in 2002 as a response to the heavy and complex Java EE architecture (like EJB). Today, Spring has evolved into a complete ecosystem that not only supports traditional Java apps, but also REST APIs, cloud-based services, microservices, and reactive programming.

Real-Life Analogy

Imagine building a house. Without a proper framework, you'd have to place every brick by hand, design the plumbing yourself, and run all the wires manually. But with a ready-made construction framework, everything from plumbing to electric wiring is pre-managed — you just focus on what your house should look like.

In the same way, Spring handles the repetitive tasks, so you can focus on writing clean and meaningful business logic.

Core Goals of the Spring Framework

The Spring Framework was designed with simplicity, modularity, and maintainability in mind. Here’s what it aims to achieve:

1. Simplify Java Development

Traditionally, Java enterprise applications required a lot of boilerplate code, complex configurations, and heavy tools like EJB. Spring simplifies all of this by offering easy-to-use annotations, configuration options, and automatic dependency wiring.

Example:

Instead of writing this:

Connection conn = DriverManager.getConnection(...);

PreparedStatement stmt = conn.prepareStatement(...);

Spring lets you do this:

@Autowired

DataSource dataSource;

It takes care of the wiring and setup internally.

2. Promote Loose Coupling with Dependency Injection (DI)

Spring’s Inversion of Control (IoC) container automatically injects dependencies between classes. This means one class does not need to create objects of another class—it just asks Spring to supply what it needs.

Example:

class Engine {

    public void start() {

        System.out.println("Engine started.");

    }

}

class Car {

    private Engine engine;

    // Spring injects Engine object here

    public Car(Engine engine) {

        this.engine = engine;

    }

    public void drive() {

        engine.start();

        System.out.println("Car is moving.");

    }

}

This reduces tight connections between components, making the code easier to test, maintain, and replace.

---

3. Eliminate Boilerplate Code

Spring minimizes the need for repetitive code. It offers out-of-the-box features like:

• Object-relational mapping (ORM) integrations

• Transaction management

• Declarative validation

• REST API setup with just annotations

You write less code, get more done, and keep your code cleaner.

---

4.  Enable Easy Integration with Other Technologies

Spring is not a closed system. It’s built to work well with others:

• Databases: MySQL, PostgreSQL, Oracle, etc.

• ORM frameworks: Hibernate, JPA

• Messaging: RabbitMQ, Kafka

• Testing frameworks: JUnit, Mockito

• APIs: REST, SOAP

• Cloud platforms: AWS, Azure, GCP

Spring doesn’t force you to follow a strict path. Instead, it adapts to your tech stack.

---

Why Students Should Learn Spring

Benefit	Description
Industry Standard	Used by most companies in Java projects
Job-Oriented	Helps in interviews and job roles involving backend development
Better Design Understanding	Teaches clean architecture and design principles
Scalable & Modular	Prepares you for real-world enterprise or microservice projects

---

The Spring Framework is more than just a library—it’s a powerful toolbox that lets you develop modern, reliable, and well-structured Java applications without reinventing the wheel.

As a student or beginner Java developer, learning Spring will give you an edge in understanding how professional-grade applications are designed, tested, and deployed.

 Spring Core Basics-Spring Dependency Injection concepts

One of the foundational pillars of the Spring Framework is the concept of Dependency Injection (DI). If you're new to Spring, understanding how DI works is the first and most important step toward mastering modern Java development using Spring.

What is Spring Core?

At the heart of the Spring Framework lies the Spring Core module, which provides the backbone for the entire Spring ecosystem. It includes:

• IoC (Inversion of Control) container

• Dependency Injection

• Bean creation and lifecycle management

Spring Core helps developers build loosely coupled, highly testable, and maintainable applications by removing tight connections between components.

What is Dependency Injection (DI)?

Definition:

Dependency Injection is a design pattern where one object (a dependency) is injected into another object instead of being created by the receiving object itself.

This approach leads to:

• Loose coupling between classes

• Easier unit testing

• Better separation of concerns

---

Real-Life Analogy

Imagine you are a driver, and you need a car to drive. Now:

• Without DI: You go and build the car yourself every time.

• With DI: Someone hands you the car, ready to use. You just drive it.

Spring acts like a car dealership that gives you everything you need — you don’t build anything from scratch.

---

Types of Dependency Injection in Spring

Type	Description
Constructor Injection	Dependencies are passed via constructor
Setter Injection	Dependencies are set using setter methods
Field Injection	Dependencies are injected directly into class fields (with annotations)

 Example 1: Constructor Injection

// Engine.java

public class Engine {

    public void start() {

        System.out.println("Engine started.");

    }

}

// Car.java

public class Car {

    private Engine engine;

    // Constructor Injection

    public Car(Engine engine) {

        this.engine = engine;

    }

    public void drive() {

        engine.start();

        System.out.println("Car is moving.");

    }

}

// AppConfig.java

@Configuration

public class AppConfig {

    @Bean

    public Engine engine() {

        return new Engine();

    }

    @Bean

    public Car car() {

        return new Car(engine());

    }

}

// MainApp.java

public class MainApp {

    public static void main(String[] args) {

        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

        Car car = context.getBean(Car.class);

        car.drive();

    }

}

Output:

Engine started.

Car is moving.

How Spring Manages This?

Spring creates the Engine object and injects it into the Car using the configuration in AppConfig. The IoC container handles this process.

Example 2: Setter Injection

public class Student {

    private String name;

    // Setter Injection

    public void setName(String name) {

        this.name = name;

    }

    public void show() {

        System.out.println("Hello, I am " + name);

    }

}

XML Configuration (if not using annotations):

<bean id="student" class="com.example.Student">

    <property name="name" value="Amit"/>

</bean>

Field Injection

Field Injection means that Spring directly injects dependencies into fields (variables) of a class without using constructors or setters. This is done using annotations like @Autowired, @Inject, or @Resource directly above the field.

Syntax Example:

@Component

public class Car {

    @Autowired

    private Engine engine;

    public void drive() {

        engine.start();

        System.out.println("Car is driving...");

    }

}




@Autowired tells Spring to automatically inject an available Engine bean into this field.

No need for a constructor or setter method.

Full Working Example: Field Injection in Spring

Step 1: Define the Dependency Class

@Component

public class Engine {

    public void start() {

        System.out.println("Engine started!");

    }

}

Step 2: Inject into Main Class Using Field Injection

@Component

public class Car {

    @Autowired

    private Engine engine;

    public void drive() {

        engine.start();

        System.out.println("Car is moving!");

    }

}

Step 3: Configure and Run

@Configuration

@ComponentScan(basePackages = "com.example")

public class AppConfig { }

public class MainApp {

    public static void main(String[] args) {

        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

        Car car = context.getBean(Car.class);

        car.drive();

    }

}

Output:

Engine started!

Car is moving!

Benefits of Field Injection

Advantage	Description
✅ Less Code	No need for constructor or setter
✅ Easy to Read	Focus only on behavior, not wiring
✅ Clean Class Structure	Keeps code minimal and concise

Disadvantages of Field Injection

Limitation	Why it matters
❌ Not Test-Friendly	Harder to inject mock objects during unit testing
❌ Violates Encapsulation	Fields are injected externally and may not be obvious to developers
❌ No Final Fields	You can’t make injected fields final since they are injected later