Can You Build a Mini Spring Framework from Scratch? A Step‑by‑Step Guide

What Spring Can Do

Spring is a framework designed to simplify enterprise‑level application development by using bean‑based programming, dependency injection (DI) and aspect‑oriented programming (AOP) to achieve inversion of control (IOC).

IOC (Inversion of Control)

IOC means the container creates and manages objects instead of the developer using the new keyword, allowing automatic injection of dependencies.

DI (Dependency Injection)

DI is the concrete implementation of IOC in Spring, letting the framework inject required objects into beans.

AOP (Aspect‑Oriented Programming)

AOP separates cross‑cutting concerns (e.g., logging, transaction management) into reusable modules called aspects.

Creating a Hello World with SpringBoot

Using SpringBoot reduces configuration dramatically. The steps are:

Create a Maven project and add spring-boot-starter-parent and spring-boot-starter-web dependencies.

Create a HelloController class with @RestController and @GetMapping("/demo") that returns "Hello:" + name.

Create the main application class annotated with @SpringBootApplication.

Run the application and access http://localhost:8080/hello/demo?name=YourName to see the greeting.

SpringBoot’s auto‑configuration and embedded Tomcat allow the demo to run without any XML configuration.

What If Spring Is Not Available?

When Spring is absent, we must use the raw Servlet API to map URLs, manage objects, and handle requests manually.

Developing with Pure Servlets

Add servlet-api, commons-lang3, and fastjson dependencies, set packaging to war.

Create web.xml defining a servlet named helloServlet and mapping it to /hello/*.

Implement HelloServlet extending HttpServlet, overriding doGet and doPost to write Hello: {name} to the response.

Package the WAR, deploy it to Tomcat, and access http://localhost:8080/hello?name=YourName.

This approach requires a lot of boilerplate configuration for each servlet.

Simulating Spring with a Mini Framework

To illustrate Spring’s core ideas without the full framework, we build a tiny version that supports only basic IOC, DI, and request mapping.

Define custom annotations: @WolfController, @WolfService, @WolfAutowired, @WolfGetMapping, and @WolfRequestParam.

Create a MyDispatcherServlet that loads a configuration file ( application.properties with basePackages), scans the package for annotated classes, instantiates them, stores them in an IOC container, performs dependency injection, and builds a handlerMappingMap linking URLs to controller methods.

Implement HandlerMapping to hold request URL, target object, method, and parameter metadata.

Write a sample HelloController using @WolfController and @WolfGetMapping("/hello"), injecting HelloService with @WolfAutowired, and handling a request parameter @WolfRequestParam("name").

After deploying the servlet, accessing http://localhost:8080////hello?name=YourName returns the expected greeting, demonstrating that the mini‑framework reproduces Spring’s essential behavior.

Conclusion

The article walks through Spring’s core features, shows how to build a simple application with SpringBoot, then explains how to achieve the same result using raw Servlets and a handcrafted mini‑Spring framework, highlighting the convenience Spring provides.