DEV Community: Mujuzi Moses 

🚀 Building Spring by Example: Completing the Spring Web (Spring MVC) Module

Mujuzi Moses  — Wed, 02 Sep 2026 10:00:21 +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 10 — Spring Web (Spring MVC). 🎉

The module covers:

DispatcherServlet
Controllers
Request Mapping
Path Variables
Request Parameters
Request Body
Response Body
Model and View
View Resolvers
Exception Handling
Request Scope
Session Scope
Application Scope

One of the things I enjoyed about this module was understanding what actually happens when an HTTP request enters a Spring MVC application.

The DispatcherServlet acts as the front controller, receiving incoming requests and coordinating the request-handling process. Controllers then define how those requests should be handled using mappings such as @GetMapping and @PostMapping.

I also explored different ways of working with request data, including path variables, request parameters, and request bodies, as well as how Spring converts incoming data into Java objects.

The view-related examples helped connect the pieces between a controller, a model, and a view. ModelAndView can be used to return both model data and a logical view name, while ViewResolver determines which actual view should be rendered.

Exception handling was another important part of the module. Using mechanisms such as @ExceptionHandler and @ControllerAdvice, it becomes possible to keep error-handling logic organized instead of putting it directly into every controller.

Finally, I explored Spring's web scopes - request, session, and application scope — and how the lifetime of a bean can be tied to the lifecycle of an HTTP request, user session, or web application.

The goal isn’t just to collect Spring annotations and APIs. I’m trying to understand how Spring works under the hood, how its features fit together, 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: https://gith.ub/dsAQrAU5

🔗 GitLab: https://gitl.ab/gfDEyGH3

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

Next up: Module 11 - Testing - exploring how to test Spring applications, starting with unit testing and the Spring TestContext, followed by @SpringBootTest, @MockBean, @TestConfiguration, and integration testing.

If you’ve worked with Spring MVC before, what’s one part of the request-handling process you think developers commonly misunderstand?

java #springframework #opensource #github #gitlab #learninginpublic #backend #softwareengineering #spring #springmvc

🚀 Building Spring by Example: Completing the Spring Boot Module

Mujuzi Moses  — Thu, 27 Aug 2026 08:50:15 +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 9 — Spring Boot. 🎉

This module focused on the foundations of Spring Boot and covered:

SpringApplication
Auto Configuration
Starter Dependencies
Configuration Properties
Profiles
CommandLineRunner
Actuator

One of the things I enjoyed most about this module was seeing how much Spring Boot does behind the scenes while still allowing us to understand and control what is happening.

I started with SpringApplication, exploring how SpringApplication.run() bootstraps a Spring Boot application and creates the application context.

Then I explored Auto Configuration, which showed how Spring Boot can automatically configure application infrastructure based on the dependencies available on the classpath.

Starter Dependencies were another important piece. Instead of manually adding and managing every dependency needed for a particular feature, Spring Boot starters provide convenient dependency groupings that bring the required libraries together.

I also explored Configuration Properties, which demonstrated how application configuration can be externalized rather than hard-coded into the application.

With Profiles, I looked at how Spring applications can use different configurations depending on the active environment, such as development, testing, or production.

CommandLineRunner introduced a simple way to execute code when the application starts, which is useful for initialization tasks and understanding the application startup lifecycle.

Finally, Actuator showed how Spring Boot applications can expose operational information such as health endpoints. Seeing /actuator/health return an UP status was a nice way to finish the module.

What I’m enjoying about Spring Boot is that it isn't just about reducing configuration.

It provides conventions and sensible defaults while still allowing developers to understand and customize the underlying Spring infrastructure.

The goal of this project isn't just to collect Spring Boot annotations and APIs. I'm trying to understand what Spring is doing underneath the surface, how its features fit together, 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: https://gith.ub/dsAQrAU5

🔗 GitLab: https://gitl.ab/gfDEyGH3

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

Next up: Spring Web (Spring MVC) — exploring DispatcherServlet, controllers, request mapping, request parameters, request bodies, views, exception handling, and request/session/application scopes.

If you've worked with Spring Boot before, what Spring Boot feature made the biggest difference in your day-to-day development?

java #springframework #springboot #opensource #github #gitlab #learninginpublic #backend #softwareengineering #spring

🚀 Building Spring by Example: Completing the Spring Transactions Module

Mujuzi Moses  — Mon, 24 Aug 2026 08:54:17 +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 8 — Transactions. 🎉

The module covers:

@Transactional
Transaction Propagation
Isolation Levels
Rollback Rules
Programmatic Transactions
TransactionProxyFactoryBean

One of the most interesting parts of this module was understanding what actually happens when Spring manages a transaction.

For example, @Transactional makes it possible to declaratively define transaction boundaries without having to manually begin, commit, or roll back transactions in application code.

Transaction propagation introduced another important concept: what should happen when a transactional method calls another transactional method?

I explored propagation behaviors such as REQUIRED and REQUIRES_NEW, and how they affect whether operations participate in the same transaction or run in an independent transaction.

Isolation levels then showed another side of transaction management: how concurrent transactions interact with data and what kinds of visibility and consistency guarantees they provide.

Rollback rules were another useful area to explore. A transaction does not necessarily roll back for every exception automatically, so understanding how Spring determines whether a transaction should be rolled back is important when designing transactional services.

I also explored programmatic transactions, which provide more explicit control over transaction boundaries when declarative transaction management isn't the right fit.

Finally, I looked at TransactionProxyFactoryBean, an older Spring approach to applying transaction management through proxies. It was especially useful for understanding how Spring's transaction infrastructure evolved and how it connects to the proxy concepts explored in the previous AOP module.

The goal isn’t just to collect Spring annotations and APIs. I’m trying to understand how the Spring container works, how its features fit together, 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/sbe

🔗 GitLab: gitla.b/sbe

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

Next up: Spring JDBC — continuing to explore how Spring works with databases and how its abstractions simplify database access.

If you’ve worked with Spring before, what part of Spring's transaction management do you think developers commonly misunderstand?

java #springframework #opensource #github #gitlab #learninginpublic #backend #softwareengineering #spring #transactions

🚀 Building Spring by Example: Completing the Spring AOP Module

Mujuzi Moses  — Thu, 20 Aug 2026 10:02:15 +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 7 — Spring AOP. 🎉

The module covers:

What is AOP?
JDK Dynamic Proxies
CGLIB Proxies
Creating an Aspect
Before Advice
After Advice
After Returning Advice
Around Advice
Pointcuts
Advice Ordering

One of the most interesting parts of this module was understanding that Spring AOP is built around proxies.

Before getting into Spring's AOP abstractions, I explored JDK Dynamic Proxies and CGLIB proxies separately. That made it easier to understand what Spring is doing behind the scenes when it creates an AOP proxy around a Spring-managed bean.

For example, instead of manually creating a proxy, Spring can use an aspect such as:

@Aspect
public class LoggingAspect {

    @Before("execution(* com.springbyexample.GreetingService.greet(..))")
    public void beforeGreeting() {
        System.out.println("Before greeting");
    }
}

Spring then uses the pointcut to determine which method calls should receive that behavior.

That led into another important concept: advice.

I explored several different types of advice:

@Before — runs before the target method.
@After — runs after the method invocation completes.
@AfterReturning — runs when the method returns successfully.
@Around — surrounds the target invocation and gives the advice control over when the target executes through ProceedingJoinPoint.

Around advice was particularly interesting because proceed() determines whether the target method actually gets invoked.

I also explored pointcuts, which helped clarify an important distinction:

Pointcut
    ↓
Where should the advice apply?

Advice
    ↓
What should happen?

For example:

@Before("execution(* com.springbyexample.GreetingService.greet(..))")

uses the pointcut to tell Spring which method should be intercepted.

Finally, I looked at advice ordering.

When multiple aspects apply to the same method, @Order can be used to control their precedence. Lower order values have higher precedence, and the ordering becomes especially interesting when looking at how @Before and @After advice execute around the target method.

One of the things I wanted to understand through these examples was not just how to write an aspect, but what is actually happening when a method call goes through Spring AOP:

Caller
   ↓
Spring AOP Proxy
   ↓
Pointcut matching
   ↓
Ordered Advice
   ↓
Target Method
   ↓
Ordered Advice
   ↓
Return value

That connects nicely with the earlier proxy examples and makes Spring AOP feel much less like "magic."

The goal of spring-by-example isn't just to collect Spring annotations and APIs.

I'm trying to understand how the Spring container works, how its features fit together, 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

🔗 GitLab

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

Next up: Spring Transactions — continuing the journey by exploring another important part of the Spring ecosystem.

If you’ve worked with Spring AOP before, what concept do you think is the most difficult for developers to understand: proxies, pointcuts, advice, or advice ordering?

java #springframework #opensource #github #gitlab #learninginpublic #backend #softwareengineering #spring #aop

🚀 Building Spring by Example: Completing the Spring Events Module

Mujuzi Moses  — Sun, 16 Aug 2026 15:57:40 +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 6 — Events. 🎉

The module covers:

Publishing Events
Listening for Events
Custom Events
Transactional Events
Async Events

One thing I’ve really enjoyed about this module is seeing how Spring’s event system can help decouple different parts of an application.

For example, ApplicationEventPublisher allows one component to publish an event without needing to know which components will respond to it. @EventListener then provides a simple way for other components to react to those events.

I also explored custom events, which made it possible to model application-specific events such as an order being created.

Transactional events introduced another interesting concept: controlling when an event listener should run in relation to a transaction. With @TransactionalEventListener, event handling can be tied to transaction phases such as after a successful commit.

Finally, @Async showed how event listeners can be processed asynchronously, allowing the publisher to continue without waiting for the listener to finish.

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: Spring AOP — exploring Aspect-Oriented Programming, proxies, aspects, advice, pointcuts, and how Spring applies cross-cutting concerns.

If you’ve worked with Spring before, what’s one part of Spring’s event system you think developers commonly misunderstand?

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

🚀 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.

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