January 24, 2025

Story of Tim the Toy Store Owner

Once upon a time, there was a toy store owner named Tim. Tim loved his toy store, but he had a big problem. Every day, many customers came to buy toys, and some customers tried to grab the same toy at the same time. Sometimes, they even fought over who should get it!

To solve this, Tim hired a helper called Spring Boot. Spring Boot was very smart and had a magical book called the Transaction Book, which helped manage all the buying and selling.

What’s a Transaction?

Tim’s helper explained:
"A transaction is like a deal we promise to complete fully or not at all. If something goes wrong in the middle, I will undo everything so that nobody gets confused."

For example:

  • If a customer wants to buy a teddy bear but forgets to pay, Spring Boot ensures the teddy bear goes back to the shelf.
  • If Tim takes money but doesn’t deliver the toy, the money is returned.

This promise was called ACID (like a magic spell):

  • Atomicity: All or nothing happens.
  • Consistency: The rules are always followed.
  • Isolation: No two customers mess up each other’s transactions.
  • Durability: Once a deal is done, it stays done!

The Problem with Customers Fighting

One day, two customers, Anna and Ben, saw the last blue robot toy on the shelf. Both ran to grab it. If Anna grabbed it first, Ben should wait, right? But sometimes, Ben would grab it halfway, and they both got upset. Tim called this a dirty read because Ben read something Anna hadn’t finished yet.

Spring Boot said, “I have an idea! I’ll make rules about who can touch the toys and when.”

Rules of Isolation

Spring Boot introduced different levels of toy rules (isolation levels):

  1. READ_COMMITTED (Polite Rule):
    Anna can pick the robot and decide whether to buy it or not. Ben waits until Anna is done before touching it. No dirty fights!

  2. REPEATABLE_READ (Careful Rule):
    If Anna touches the robot, Ben can't even peek at it until Anna finishes her decision. This ensures no confusion, even if Anna changes her mind.

  3. SERIALIZABLE (Strict Rule):
    Only one person is allowed in the toy aisle at a time. Anna picks, decides, and leaves. Then Ben can enter. Nobody can fight, but it’s slow because only one customer is allowed.

Row Lock: Protecting One Toy

One day, another problem happened. Anna wanted a toy car, but Ben also wanted to buy it. To avoid this, Spring Boot said:
"I will lock the toy car while Anna decides. Ben will have to wait until Anna finishes buying it."

This was called a row lock. It protected just one toy.

Table Lock: Protecting All Toys

One Saturday, Tim wanted to rearrange all the toys in the store. He didn’t want anyone to touch the toys while he was working. Spring Boot said:
"No problem! I will lock the entire toy store until you're done."

This was called a table lock.

Example 1: Single Toy Lock

Anna wants to buy a toy car. Spring Boot locks that car for Anna so no one else can grab it until she finishes.


@Transactional
public void buyToy(Long toyId, int quantity) {
    Toy toy = toyRepository.findByIdWithLock(toyId); // Lock the toy
    toy.setQuantity(toy.getQuantity() - quantity);   // Update the quantity
    toyRepository.save(toy);
}

Example 2: Locking the Whole Store

Tim wants to move all toys around. Spring Boot locks the whole store, so no one can buy toys until Tim finishes.


@Transactional
public void rearrangeStore() {
    entityManager.createNativeQuery("LOCK TABLE toys IN EXCLUSIVE MODE").executeUpdate();
    // Perform the rearrangement
}

What Happens If We Don’t Lock?

If Spring Boot didn’t lock the toys:

  1. Anna and Ben might both buy the same robot, leading to confusion.
  2. Tim might rearrange the toys while customers are shopping, making a mess.

How Spring Boot Helps

Spring Boot explained how he kept things in order:

  1. Transactions: He made sure deals were all or nothing.
  2. Isolation Levels: He stopped customers from seeing unfinished business.
  3. Row Locks: He protected one toy at a time.
  4. Table Locks: He protected all toys when necessary.

Extra Example: Fixing a Robot Issue

One day, a robot toy broke, and Tim wanted to fix it before selling it.


@Transactional(isolation = Isolation.READ_COMMITTED)
public void fixRobotToy(Long toyId) {
    Toy toy = toyRepository.findByIdWithLock(toyId);
    toy.setCondition("Fixed");
    toyRepository.save(toy);
}

What Tim Learned

Tim realized that using Spring Boot's magic made everything run smoothly. No more fights between customers, no more broken promises, and no more confusion in his toy store.

This story shows how Spring Boot helps manage transactions and locks to keep everything fair and safe, just like in a real toy store! If you’re working on your own "store" (application), Spring Boot is your helpful partner to make sure nothing goes wrong.

Let me know if you want to add more details or examples! 😊

Posted by
Labels: , ,