DEV Community: Mujuzi Moses 

🚀 Building Spring by Example: Completing the Bean Lifecycle Module

Mujuzi Moses  — Thu, 13 Aug 2026 12:00:30 +0000

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 5 — Bean Lifecycle. 🎉

The module covers:

InitializingBean
DisposableBean
@PostConstruct
@PreDestroy
BeanPostProcessor
BeanFactoryPostProcessor
SmartLifecycle

One thing I’ve really enjoyed about this module is seeing how these concepts fit into different stages of the Spring container lifecycle.

For example, @PostConstruct and InitializingBean help with bean initialization, while @PreDestroy and DisposableBean provide ways to perform cleanup.

BeanPostProcessor introduced another interesting part of Spring: processing bean instances before and after initialization. BeanFactoryPostProcessor took that a step further by working with bean definitions before the actual bean instances are created.

And with SmartLifecycle, I explored how Spring can coordinate the startup and shutdown of components that have an active running state.

The goal isn’t just to collect Spring annotations and interfaces. 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: githu.b/mujuzimoses

There’s still a long way to go, but completing another module feels like a good milestone. 🚀

Next up: Events — exploring how Spring components can communicate through application events, including custom events, transactional events, and asynchronous events.

If you’ve worked with Spring before, what’s one part of the Spring bean lifecycle you think developers commonly misunderstand?

java #springframework #opensource #github #learninginpublic #backend #softwareengineering #spring #beanlifecycl

🚀 Building Spring by Example: Completing the Dependency Injection Module

Mujuzi Moses  — Mon, 10 Aug 2026 11:28:16 +0000

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.

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?

java #springframework #opensource #github #learninginpublic #backend #softwareengineering #dependencyinjection

🚀 Building Spring by Example: Completing the Configuration Module

Mujuzi Moses  — Wed, 05 Aug 2026 11:30:29 +0000

When I started building spring-by-example, my goal was simple:

Learn Spring by creating small, focused, runnable examples that explain not just how something works, but why it works.

Since then, the project has grown steadily, and I’ve just completed the Configuration module.

So far, the repository includes examples covering:

✅ Fundamentals

Spring Beans
Dependency Injection
Constructor Injection
Setter Injection
Field Injection
Choosing an Injection Strategy

✅ Bean Scopes (Core)

Singleton Scope
Prototype Scope

✅ Configuration

@Configuration
@bean
@Component
@Service
@Repository
@Controller
@ComponentScan
@import
@ImportResource
XML Configuration
Java Configuration
Mixing XML and Java Configuration

Each example is intentionally small, runnable, and documented so you can focus on understanding one concept at a time without the noise of a large application.

Next up is Dependency Injection, where I’ll be exploring topics like @primary, @Qualifier, collection injection, ObjectProvider, and more.

Building this repository has been a great way to deepen my own understanding while creating something I hope will be useful to others learning Spring.

If you’ve worked with Spring, which concept was your biggest “aha!” moment—or which one took the longest to truly understand?

java #springframework #opensource #github #learninginpublic #backend #softwareengineering

🚀 Building Spring by Example

Mujuzi Moses  — Sun, 26 Jul 2026 09:32:09 +0000

When I started learning Spring, I noticed something about the tutorials I found.

Many 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 decided to start a project called spring-by-example.

Instead of creating one large application, I’m building a collection of small, focused examples—each one exploring a single Spring concept with clear explanations, tests, and documentation.

So far I’ve worked through:

Spring Beans
Dependency Injection
Constructor Injection
Setter Injection
Field Injection
Choosing an Injection Strategy

I’m sharing the journey here as I continue learning. My hope is that, over time, this grows into a resource that helps other developers understand Spring one concept at a time.

If you’ve learned Spring, what concept took you the longest to fully understand?

java #springframework #opensource #github #learninginpublic #backend #softwareengineering