When I started learning Spring, I noticed something about many of the tutorials I found.
They often showed how to use a feature, but not always why it worked or when you should choose one approach over another.
I learn best by building things and documenting what I discover, so I started a project called spring-by-example.
The idea is simple: instead of building one large application, I’m creating a collection of small, focused examples where each example explores a specific Spring concept with clear explanations, tests, and documentation.
I’m happy to say that I’ve now completed Module 4 — Dependency Injection. 🎉
The module covers:
- @primary
- @Qualifier
- Collection Injection
- @Order
- Map Injection
- ObjectProvider
- Optional Dependencies
- Circular Dependencies
- Bean Aliases
One thing I’ve really enjoyed about this module is seeing how these concepts build on each other.
For example, @primary and @Qualifier help resolve multiple candidates, while collection and map injection let us work with multiple beans. ObjectProvider introduces more flexible bean retrieval, and examples like circular dependencies show what can go wrong when the dependency graph isn’t designed carefully.
The goal isn’t just to collect Spring annotations. I’m trying to understand how the Spring container works and why these features exist, one concept at a time.
The project is open source, and I’m continuing to build it as I learn:
🔗 GitHub: github
There’s still a long way to go, but completing another module feels like a good milestone. 🚀
Next up: Bean Lifecycle — understanding how Spring creates, initializes, and destroys beans.
If you’ve worked with Spring before, what’s one dependency injection concept you think developers commonly misunderstand?
Top comments (0)