DEV Community: Abdulfatai Abdulwasiu Aremu

System Design Basics 🍕 + Spring Boot

Abdulfatai Abdulwasiu Aremu — Tue, 23 Sep 2025 22:23:05 +0000

System Design Basics 🍕 + Spring Boot

Abdulfatai Abdulwasiu Aremu ・ Sep 22

#programming #springboot #java #systemdesign

System Design Basics 🍕 + Spring Boot

Abdulfatai Abdulwasiu Aremu — Mon, 22 Sep 2025 22:31:21 +0000

I explained System Design to my friend using a pizza shop 🍕
Turns out it’s the easiest way to get Scalability, Latency, Throughput, Consistency, and Availability!

1️ Scalability – More chefs, more pizzas

@RestController
class PizzaController {
    @GetMapping("/order")
    String orderPizza() { return "🍕 Pizza ready!"; }
}

1 instance = 10 orders/min
10 instances = 100 orders/min

2️ Latency – How long until your pizza arrives?

@GetMapping("/order")
String orderPizza() throws InterruptedException {
    Thread.sleep(3000); // 3 sec delay
    return "🍕 Pizza ready after wait!";
}

Delays = unhappy customers

3️ Throughput – Pizzas per minute

Run a load test:

ab -n 1000 -c 50 http://localhost:8080/order

One endpoint, but throughput depends on kitchen “power.”

4️ Consistency – Pizza means pizza

@RestController
class PizzaController {
    @GetMapping("/order")
    String orderPizza() {
        return Math.random() > 0.7 ? "🍝 Pasta?" : "🍕 Pizza";
    }
}

Users want the same result every time!

5️ Availability – Always open

@GetMapping("/health")
String health() { return "✅ I’m alive!"; }

Service stays open, even if one instance crashes.

Takeaway

System design is like running a pizza shop 🍕

Scalability → more chefs
Latency → wait time
Throughput → orders per min
Consistency → pizza = pizza
Availability → always open

What’s your favorite system design analogy?

⚙️ Mastering Transactions in Java Spring Boot: A Developer's Guide

Abdulfatai Abdulwasiu Aremu — Fri, 16 May 2025 01:04:04 +0000

Imagine this: you're transferring money from one bank account to another. The amount gets debited from your account, but due to a power outage or system crash, it never reaches the recipient. Now both parties are at a loss.
That's exactly the kind of problem transactions solve. In this guide, we'll dive deep into what transactions are, how Spring Boot makes them easy to implement, and walk through a practical bank transfer example to see them in action.

🧠 Understanding Transactions
A transaction in software terms is a sequence of operations performed as a single logical unit of work. The operations must either all succeed or all fail together — no middle ground. This approach ensures the integrity and consistency of data, especially in mission-critical systems like banking, inventory management, or order processing.

To enforce this, transactions are built around the ACID principles:

*Atomicity * ensures that either all steps in a transaction happen or none do.
Consistency guarantees that the database stays in a valid state before and after the transaction.
Isolation keeps transactions from interfering with each other while executing simultaneously.
Durability ensures that once a transaction is completed, the changes are permanently saved—even if the system crashes right after.

🚀 Transaction Management in Spring Boot
Spring Boot uses a simple and powerful annotation called @Transactional to wrap a method in a transaction. Once you annotate a service method, Spring handles all the behind-the-scenes magic like opening a transaction, committing it if successful, or rolling it back in case of failure.
But how does this work practically? Let’s go through an example step by step.

🏦 Building a Bank Transfer Example
Let’s assume we’re building a small banking system. A user should be able to transfer money from one account to another. If anything goes wrong during the process, we want the whole transaction to roll back.

Step 1: Define the Account Entity

@Entity
public class Account {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String owner;
    private Double balance;

    // Getters and setters
}

This is a simple JPA entity that represents a bank account with an owner and a balance.
Step 2: Create the Repository

public interface AccountRepository extends JpaRepository<Account, Long> {
}

The repository gives us CRUD access to the Account data.
Step 3: Write the Service Layer with Transactions

@Service
public class BankService {

    @Autowired
    private AccountRepository repository;

    @Transactional
    public void transfer(Long fromAccountId, Long toAccountId, Double amount) {
        Account sender = repository.findById(fromAccountId)
                .orElseThrow(() -> new RuntimeException("Sender account not found"));

        Account receiver = repository.findById(toAccountId)
                .orElseThrow(() -> new RuntimeException("Receiver account not found"));

        if (sender.getBalance() < amount) {
            throw new RuntimeException("Insufficient funds");
        }

        sender.setBalance(sender.getBalance() - amount);
        receiver.setBalance(receiver.getBalance() + amount);

        repository.save(sender);
        repository.save(receiver);

        // Simulate an error to trigger rollback
        // throw new RuntimeException("Simulated transfer failure");
    }
}

Here’s the heart of it: the @Transactional annotation ensures that if any exception occurs during the transfer (even after the first save), Spring will automatically roll back all database changes. This prevents half-completed operations that could lead to corrupted data.
Step 4: Expose the Transfer Endpoint

@RestController
public class BankController {

    @Autowired
    private BankService bankService;

    @PostMapping("/transfer")
    public ResponseEntity<String> transfer(@RequestParam Long from,
                                           @RequestParam Long to,
                                           @RequestParam Double amount) {
        bankService.transfer(from, to, amount);
        return ResponseEntity.ok("Transfer successful");
    }
}

When a user calls this endpoint, money is transferred from one account to another — and if something fails, it fails safely.

🔁 What Happens on Failure?
If the service method throws a RuntimeException (or an unchecked exception), Spring catches it and triggers a rollback. That means any balance changes, even if saved, are undone before being committed to the database.
If you want to roll back on checked exceptions (like IOException), you’ll need to explicitly specify:

@Transactional(rollbackFor = IOException.class)

This tells Spring to treat those exceptions as fatal and rollback-worthy too.

🛡️ Best Practices for Transactions

Always place @Transactional on service layer methods, not controllers or repositories.
Avoid complex logic inside transactional methods; keep them focused and minimal.
Be careful with lazy-loaded entities — once the transaction closes, those proxies can’t fetch additional data.
Use logging or monitoring to track transaction boundaries during debugging.

🎨 Visual Flow: Transaction in Action

Client ➜ /transfer
        ↓
BankController ➜ Calls BankService.transfer()
        ↓
@Transactional boundary starts
        ↓
1. Debit sender
2. Credit receiver
3. Save both accounts
        ↓
Error? ➜ Rollback changes
Success? ➜ Commit transaction

🧪 How to Test Transactions
Testing transaction rollbacks is just as important as implementing them.

@SpringBootTest
public class BankServiceTest {

    @Autowired
    private BankService bankService;

    @Test
    void testTransactionRollback() {
        // Create mock accounts with balances
        // Attempt to transfer with forced exception
        // Assert balances are unchanged
    }
}

You can simulate a failure during a transfer and ensure balances are reverted. This confirms that transactions are working correctly.

🎯 Final Thoughts
With just a few annotations and the right architecture, Spring Boot makes transaction management seamless. Whether you're building a simple app or a distributed enterprise system, transactions help ensure your data stays reliable and consistent.

By understanding how @Transactional works and how to structure your service layers properly, you can build robust applications that fail gracefully.

[Boost]

Abdulfatai Abdulwasiu Aremu — Fri, 16 May 2025 00:59:57 +0000

Design Patterns in Spring: Making Your Code Elegant and Maintainable

Abdulfatai Abdulwasiu Aremu — Thu, 24 Apr 2025 19:06:01 +0000

Introduction
Imagine you're building a house. Would you start hammering nails without a blueprint? Probably not. You'd use proven architectural designs to ensure the house is strong, scalable, and easy to maintain.
Software development is no different. We use design patterns proven solutions to recurring problems to make our applications more structured and maintainable. And if you're working with Spring Framework, you're already using some of these patterns, whether you realize it or not!
In this article, we'll explore essential design patterns used in Spring, how they work, and why they matter. We'll break them down with relatable analogies and real-world examples.
1. Singleton Pattern – The One and Only
What is it?
The Singleton Pattern ensures that a class has only one instance and provides a global access point to it.
Where is it used in Spring?
In Spring’s Bean Scope, by default, all beans are Singletons. That means Spring creates only one instance of a bean and reuses it throughout the application.
Real-world analogy:
Think of a president of a country. There is only one at a time, and everyone relies on that one leader. Similarly, Spring keeps a single instance of a bean for efficiency.

Example:
@Component
public class AppConfig {
    public AppConfig() {
        System.out.println("Singleton Bean Initialized");
    }
}

This bean is automatically a singleton. Spring ensures that only one instance of AppConfig is created.

2. Factory Pattern – The Master Builder
What is it?
The Factory Pattern provides a way to create objects without specifying their exact class.
Where is it used in Spring?
Spring’s BeanFactory and ApplicationContext follow the Factory Pattern by creating and managing beans.
Real-world analogy:
Imagine a car factory where you order a car, but you don’t build it yourself. The factory takes care of the complex assembly. Similarly, Spring creates and configures objects for you.
Example:

@Configuration
public class AppConfig {
    @Bean
    public Car getCar() {
        return new Car("Tesla Model X");
    }
}

Here, Spring acts as a factory and provides an instance of Car when needed.

3. Proxy Pattern – The Bodyguard
What is it?
A Proxy Pattern provides an object that acts as a substitute for another object, controlling access to it.
Where is it used in Spring?
Spring uses proxies in AOP (Aspect-Oriented Programming) and Transaction Management.
Real-world analogy:
A celebrity’s bodyguard screens people before they reach the celebrity. Similarly, proxies can restrict, enhance, or log interactions before reaching the actual object.
Example (AOP Proxy):

@Aspect
@Component
public class LoggingAspect {
    @Before("execution(* com.example.service.*.*(..))")
    public void logMethodCall() {
        System.out.println("Method is being called");
    }
}

Here, an AOP proxy intercepts method calls and logs them before execution.

4. Template Method Pattern – The Recipe
What is it?
The Template Method Pattern defines the skeleton of an algorithm and lets subclasses fill in specific details.
Where is it used in Spring?
Spring’s JdbcTemplate, RestTemplate, and TransactionTemplate follow this pattern.
Real-world analogy:
Think of a cooking recipe. The general steps (boil water, add ingredients, cook) remain the same, but the specific ingredients and spices can vary.
Example (JdbcTemplate):

@Autowired
private JdbcTemplate jdbcTemplate;

public void saveUser(User user) {
    String sql = "INSERT INTO users (name, email) VALUES (?, ?)";
    jdbcTemplate.update(sql, user.getName(), user.getEmail());
}

Here, JdbcTemplate handles database interactions so you don’t have to write boilerplate JDBC code.

5. Observer Pattern – The News Reporter
What is it?
The Observer Pattern allows objects (observers) to listen for changes in another object (subject).
Where is it used in Spring?
Spring’s ApplicationEventPublisher follows this pattern to enable event-driven programming.
Real-world analogy:
A news channel broadcasts updates. Subscribers (observers) receive the updates when something new happens.
Example:

@Component
public class UserCreatedEvent extends ApplicationEvent {
    public UserCreatedEvent(Object source) {
        super(source);
    }
}


@Component
public class UserCreatedListener implements ApplicationListener<UserCreatedEvent> {
    @Override
    public void onApplicationEvent(UserCreatedEvent event) {
        System.out.println("User created event received");
    }
}

Here, UserCreatedListener listens for UserCreatedEvent and takes action when it occurs.

Conclusion
Spring makes heavy use of design patterns to ensure clean, scalable, and efficient code. Whether it's Singletons for efficiency, Factories for object creation, Proxies for security, Template Methods for reducing boilerplate, or Observers for event-driven programming, these patterns help developers build robust applications effortlessly.
By understanding these patterns, you can write better, more maintainable Spring applications and appreciate the elegance of Spring’s design. Next time you write a Spring application, take a moment to recognize these patterns at work!
Happy coding! 🚀