Spring Framework (Core) From Zero
Here's a secret that makes Spring Boot stop being magic:
Spring Boot is just core Spring with the configuration written for you. Every @Bean Boot
auto-creates, every component it wires, every default it sets - that's plain Spring Framework underneath,
which Boot generates based on what's on your classpath. This guide is the one where you write that
configuration yourself. It's more typing and less convenience - and that's exactly the point. Once
you've assembled a Spring app by hand, Boot's "magic" becomes "oh, that's the thing I now know how to do,
done automatically."
This is a roots guide: it's about understanding, not about the fastest way to ship (Boot is that).
But the payoff is large - you'll debug Spring apps with X-ray vision, understand error messages that
baffle Boot-only developers, and see why @Transactional and @Async behave the way they do. We build
the mental model first the whole way: the container, beans, injection, lifecycle, and the proxies that
make the annotations work.
📝 This assumes Java (classes, interfaces, generics, annotations) and is far more valuable after Spring Boot From Zero - do Boot first to be productive, then this to understand it. New to frameworks generally? What a Framework Even Is.
How to read this
Read in order - it assembles a small app by hand (a notification service, then a web layer), revealing one piece of "what Boot does for you" per phase. Phases carry difficulty badges.
The phases
Part 1 - The container (🟢 Basic → 🟡)
- Spring Without Boot - Why Core Spring? 🟢 — what Spring is vs Boot, and standing up an
ApplicationContextby hand. - The IoC Container & ApplicationContext 🟡 — the container deeply: what it is, how it bootstraps, what a "bean" really means.
- Defining Beans: @Configuration & @Bean 🟡 — declaring beans by hand (the explicit version of Boot's auto-config) vs component scanning.
Part 2 — Wiring & lifecycle (🟡 → 🔴)
4. Dependency Injection, Deep 🟡 — constructor/setter/field injection, @Autowired resolution, @Qualifier/@Primary, ambiguity.
5. Bean Scopes & Lifecycle 🔴 — singleton/prototype/web scopes, lazy beans, the full lifecycle, and BeanPostProcessor.
6. Spring AOP & Proxies 🔴 — aspect-oriented programming, and how proxies make @Transactional/@Async actually work (with the self-invocation gotcha explained at the root).
Part 3 — Web & beyond (🟡 → 🟢)
7. Spring MVC Without Boot 🟡 — the DispatcherServlet, @Controller, and the web config Boot auto-wires.
8. From Core Spring to Spring Boot 🟢 — tie it all back: Boot = core Spring + auto-config + starters + embedded server. The magic, fully seen.
After this, re-read the Spring Boot guide — every annotation you used there will now have a visible mechanism underneath it. That's the whole goal.