Service Layeraka Application Service, Use Case

package com.shop.checkout;

import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class CheckoutService {
    private final ProductRepository products;
    private final OrderRepository orders;
    private final ApplicationEventPublisher events;

    public CheckoutService(ProductRepository products, OrderRepository orders,
                           ApplicationEventPublisher events) {
        this.products = products;
        this.orders = orders;
        this.events = events;
    }

    @Transactional1
    public OrderView placeOrder(PlaceOrderCommand cmd) {
        if (cmd.items().isEmpty()) {
            throw new EmptyCartException(cmd.customerId());
        }
        var order = new Order(cmd.customerId());
        for (var item : cmd.items()) {
            Product p = products.findById(item.productId())
                .orElseThrow(() -> new ProductNotFoundException(item.productId()));
            p.reserve(item.quantity()); // domain rule: throws OutOfStockException2
            order.addLine(p, item.quantity());
        }
        orders.save(order);
        events.publishEvent(new OrderPlaced(order.getId(), order.total()));3
        return OrderView.from(order);
    }

    @Transactional(readOnly = true)4
    public OrderView getOrder(Long id) {
        return orders.findById(id)
            .map(OrderView::from)
            .orElseThrow(() -> new OrderNotFoundException(id));
    }
}

package checkout

import (
	"context"
	"database/sql"
	"errors"
	"fmt"
)

var ErrEmptyCart = errors.New("cart is empty")

// DBTX is satisfied by both *sql.DB and *sql.Tx.
type DBTX interface {1
	ExecContext(ctx context.Context, q string, args ...any) (sql.Result, error)
	QueryRowContext(ctx context.Context, q string, args ...any) *sql.Row
}

type Inventory interface {
	Reserve(ctx context.Context, db DBTX, sku string, qty int) error
}

type Orders interface {
	Create(ctx context.Context, db DBTX, o *Order) error
}

type Service struct {
	db        *sql.DB
	inventory Inventory
	orders    Orders
}

func NewService(db *sql.DB, inv Inventory, o Orders) *Service {
	return &Service{db: db, inventory: inv, orders: o}
}

func (s *Service) PlaceOrder(ctx context.Context, cmd PlaceOrderCmd) (Order, error) {
	if len(cmd.Items) == 0 {
		return Order{}, ErrEmptyCart
	}
	tx, err := s.db.BeginTx(ctx, nil)2
	if err != nil {
		return Order{}, fmt.Errorf("begin: %w", err)
	}
	defer tx.Rollback() // no-op once committed3

	for _, it := range cmd.Items {
		if err := s.inventory.Reserve(ctx, tx, it.SKU, it.Qty); err != nil {4
			return Order{}, fmt.Errorf("reserve %s: %w", it.SKU, err)
		}
	}
	o := Order{CustomerID: cmd.CustomerID, Items: cmd.Items, Status: "PENDING"}
	if err := s.orders.Create(ctx, tx, &o); err != nil {
		return Order{}, fmt.Errorf("create order: %w", err)
	}
	if err := tx.Commit(); err != nil {
		return Order{}, fmt.Errorf("commit: %w", err)
	}
	return o, nil
}