Week 9 of #100DaysOfCode: A Week of Deep Spring Learning

Introduction

This week, I decided to slow down and go deeper into the Spring Framework.

Instead of focusing heavily on building new features, I spent most of my time understanding what happens behind the scenes in the framework I use to build backend applications.

I explored concepts around Spring AOP, JDBC, Caching, Reactive Programming, and Concurrency, learning not just how to use these features, but the problems they are designed to solve.

Alongside my learning, I continued applying for backend engineering opportunities, preparing myself for technical interviews, and staying consistent with my #100DaysOfCode journey.

Some of these topics were challenging and unfamiliar, but they gave me a much better perspective on how modern backend applications can be designed to be more efficient, responsive, scalable, and maintainable.

Here’s a look at what I learned throughout the week.

"Success is the sum of small efforts, repeated day in and day out."

— Robert Collier

Day 52: Understanding Spring Caching

Today, I started learning Spring Caching and how caching can be used to improve application performance.

What I Learned

• What caching is and where it can be used
• How Spring's Cache Abstraction works
• The role of Cache and CacheManager
• Different cache providers
• How caching can reduce repeated executions and unnecessary database calls
• How Spring uses the Proxy Pattern to apply caching behavior
• How caching can be enabled using annotations or XML configuration
• The different caching annotations, including @Cacheable, @CachePut, @CacheEvict, @Caching, and @CacheConfig
• How Spring uses AOP and Around Advice to implement caching

One thing that stood out to me was that caching is another example of how Spring uses AOP to separate cross-cutting concerns from business logic. Instead of putting caching logic directly inside my business methods, Spring can apply it around those methods through proxies.

I'm also beginning to understand that caching isn't simply about storing data. The application needs to decide what should be cached, how the cache should be configured, and when cached data should be updated or removed.

Challenges I Faced

The main challenge was understanding how the different parts of Spring's caching abstraction work together, especially the relationship between the cache, CacheManager, proxies, and AOP.

I also had to differentiate between the responsibilities of annotations such as @Cacheable, @CachePut, and @CacheEvict.

Day 53: Complete reading Spring Caching

Today, I continued learning Spring Caching, building on what I learned the previous day.

What I Learned

• How to enable Spring's caching abstraction using @EnableCaching
• The roles of @Cacheable, @CachePut, and @CacheEvict
• How to configure cache storage
• Caching best practices
• How Spring uses AOP and Around Advice to apply caching behavior

One thing that became clearer to me was how Spring handles caching behind the scenes. Instead of adding caching logic directly into business methods, Spring uses AOP to apply the caching behavior through proxies.

This helped me connect caching with what I previously learned about cross-cutting concerns and Spring AOP.

Day 54: Getting Started with Reactive Design Patterns

Today, I started learning Reactive Design Patterns in Spring and focused on why reactive programming has become important for modern applications.

What I Learned

• Why reactive programming is needed
• The difference between blocking and non-blocking calls
• The principles of reactive systems
• Responsiveness, resilience, scalability, and message-driven architecture
• How reactive systems are designed to handle large numbers of concurrent requests

What stood out to me was that modern applications need to handle much higher traffic and concurrency than traditional systems were designed for. Reactive programming provides an approach for building systems that can remain responsive and efficient under these conditions.

This was mainly an introduction to the reactive programming model, and it gave me a foundation for understanding how Spring supports reactive applications.

Day 55: Understanding Reactive Streams and Spring Web Reactive

Today, I continued learning Reactive Programming with Spring, going deeper into how reactive applications handle asynchronous data and concurrent requests.

What I Learned

• What Reactive Streams are
• The concept of back-pressure
• The Reactor framework
• The four Reactive Streams interfaces: Publisher, Subscriber, Subscription, and Processor
• Spring's Web Reactive module
• The differences between Spring MVC and Spring Web Reactive
• How blocking and non-blocking request handling differ

One concept that stood out to me was back-pressure. It allows a consumer to control how much data it can handle from a producer, helping prevent the system from becoming overloaded.

I also learned that Spring Web Reactive is designed around non-blocking request processing, which makes it suitable for applications that need to handle many concurrent operations efficiently.

Day 56: Completing Reactive Design Patterns

Today, I completed the Reactive Design Patterns chapter and went deeper into how Spring builds reactive web applications.

What I Learned

• The functional programming model for reactive applications
• RouterFunction and HandlerFunction
• Working with Mono and Flux
• Creating reactive servers using Reactor and Tomcat
• Using Spring WebClient for reactive client-side communication
• Reactive request and response body conversion using Encoder and Decoder
• How Spring supports both annotation-based and functional programming models
• How reactive applications handle data using non-blocking streams

Completing this chapter helped me connect the different concepts I had learned over the past few days, from reactive systems and back-pressure to Reactive Streams, Reactor, and Spring Web Reactive.

It was one of the more unfamiliar areas I've studied so far, but I now have a much better understanding of how Spring approaches asynchronous and non-blocking applications.

Day 57: Getting Started with Concurrency Design Patterns

Today, I started learning Concurrency Design Patterns in Spring, focusing on how these patterns help applications handle multiple tasks and requests concurrently.

What I Learned

• What concurrency means in software development
• How concurrency patterns relate to multithreaded applications
• The Active Object Pattern
• The Monitor Object Pattern
• How concurrency patterns help manage concurrent method execution

The Active Object and Monitor Object patterns introduced me to different approaches for managing concurrent operations and synchronizing access to objects.

This was just the beginning of the chapter, but it gave me a foundation for understanding how applications can handle multiple operations at the same time.

Goals for Week 10

As I move into Week 10, I want to become more intentional about turning the concepts I've been learning into practical skills.

Here are my goals for Week 10:

• Practice LeetCode consistently and improve my problem-solving skills
• Continue doing mock technical interviews and work on explaining my thought process
• Keep applying for backend engineering opportunities
• Continue learning and practicing Spring Security
• Build practical examples using the Spring concepts I've studied
• Review Java, Data Structures, and Algorithms for technical interviews
• Continue learning Python for scripting and fast prototyping
• Improve and revisit some of my existing projects
• Stay consistent with #100DaysOfCode and continue documenting my journey

This past week, I continued my Spring learning by studying Spring Caching, Reactive Design Patterns, and Concurrency Design Patterns. I also completed the Reactive Design Patterns chapter and started exploring how concurrency patterns help applications handle multiple operations and requests.

A lot of these topics have challenged me to think beyond simply writing code and start understanding what happens behind the scenes in modern applications.

Going forward, I want to spend more time building, practicing, and testing my understanding instead of only consuming information. I also want to use active recall more consistently so I can actually remember and explain the concepts I'm learning.

I'm still working toward becoming a stronger backend engineer, improving my problem-solving skills, and becoming more confident when facing technical interviews.

There is still a lot to learn, but I'm taking it one step at a time.

Let's keep building. 💙

LinkedIn:
https://www.linkedin.com/in/onatade-abdulmajeed/

X (Twitter):
https://x.com/spider337761