java 41 lines · 6 steps

How @Transactional guards a Spring checkout

A Spring service coordinates inventory, payment, and loyalty in one atomic transaction that rolls back on any failure.

Explained by highlit

Spring Intermediate dependency-injection transactions atomicity domain-model exceptions

1@Service
2public class OrderCheckoutService {
3 
  private final OrderRepository orderRepository;
  private final InventoryRepository inventoryRepository;
  private final PaymentGateway paymentGateway;
  private final LoyaltyService loyaltyService;
8 
  public OrderCheckoutService(OrderRepository orderRepository,
                              InventoryRepository inventoryRepository,
                              PaymentGateway paymentGateway,
                              LoyaltyService loyaltyService) {
      this.orderRepository = orderRepository;
      this.inventoryRepository = inventoryRepository;
      this.paymentGateway = paymentGateway;
      this.loyaltyService = loyaltyService;
  }
18 
  @Transactional
  public Order checkout(CheckoutRequest request) {
      Order order = orderRepository.save(Order.pending(request.customerId()));
22 
      for (LineItem item : request.items()) {
          int remaining = inventoryRepository.decrementStock(item.sku(), item.quantity());
          if (remaining < 0) {
              throw new InsufficientStockException(item.sku());
          }
          order.addLine(item);
      }
30 
      PaymentResult payment = paymentGateway.charge(request.customerId(), order.totalAmount());
      if (!payment.approved()) {
          throw new PaymentDeclinedException(payment.declineCode());
      }
35 
      order.markPaid(payment.transactionId());
      loyaltyService.awardPoints(request.customerId(), order.totalAmount());
38 
      return orderRepository.save(order);
  }
41}

01 / 01

STEP 01

Walkthrough

Space play ←→ step click any line

Three takeaways

1Wrapping a multi-step workflow in @Transactional makes any thrown exception roll back every prior write automatically.
2Constructor injection keeps collaborators final and makes the service's dependencies explicit and testable.
3Throwing domain exceptions mid-flow is the mechanism that aborts the whole transaction rather than leaving partial state.

Related explainers

typescript

import { registerLocaleData } from '@angular/common';
import localeFr from '@angular/common/locales/fr';
import localeFrExtra from '@angular/common/locales/extra/fr';
import localeDe from '@angular/common/locales/de';

Locale-aware bootstrapping in Angular

i18n localization dependency-injection

Intermediate 8 steps

typescript

import { Module } from '@nestjs/common';
import { ConfigModule } from '@nestjs/config';
import * as Joi from 'joi';

Validating env config at boot in NestJS

configuration schema-validation environment-variables

Intermediate 8 steps

php

<?php
 
namespace App\Services\Checkout;

Validating coupons with Laravel's Pipeline

pipeline chain of responsibility transactions

Intermediate 7 steps

java

@Component
@Converter
public class EncryptedStringConverter implements AttributeConverter<String, String> {

Transparent column encryption in Spring & JPA

encryption aes-gcm jpa-converter

Advanced 10 steps

typescript

import { Inject, Injectable, Logger } from '@nestjs/common';
import { CACHE_MANAGER } from '@nestjs/cache-manager';
import { Cache } from 'cache-manager';
import { InjectRepository } from '@nestjs/typeorm';

A cache-aside country lookup in NestJS

cache-aside dependency-injection batch-lookup

Intermediate 8 steps

java

package com.acme.billing.config;
 
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.ConfigurationProperties;