Shopping CartShopping Cart

giỏ đang hoạt độngactive carts

200K

giỏ đang hoạt độngactive carts

thao tác giỏ lúc cao điểmcart operations at peak

~2K/s

thao tác giỏ lúc cao điểmcart operations at peak

p99 thêm vào giỏp99 to add to cart

< 50 ms

p99 thêm vào giỏp99 to add to cart

TTL giỏ khách vãng laiguest cart TTL

7 ngày / 7 days

TTL giỏ khách vãng laiguest cart TTL

Cart Service giữ giỏ khách vãng lai trong Redis hash có TTL và giỏ của người đã đăng nhập trong PostgreSQL. Giá và tồn kho luôn hỏi Catalog khi xem giỏ hoặc trước khi chuyển sang Checkout. Chọn “Giá đổi trước khi thanh toán” để xem cảnh báo và bước xác nhận.The Cart Service keeps guest carts in a Redis hash with a TTL and signed-in carts in PostgreSQL. Price and stock are always fetched from the Catalog when the cart is viewed or before handing over to Checkout. Pick “Price changed before checkout” to see the warning and the confirmation step.

1. 1

   Lưu giá trong giỏStoring price in the cart

   Giá lưu lúc thêm sẽ cũ. Giỏ chỉ lưu product_id và số lượng; giá lấy từ catalog khi xem và khi thanh toán. price_seen nếu có chỉ dùng để cảnh báo.A price saved at add time goes stale. The cart stores product_id and quantity; prices come from the catalog for display and checkout. A price_seen column, if any, only drives warnings.

   ProxyDecorator
2. 2

   Hai tab cùng đổi số lượngTwo tabs changing a quantity

   Đọc rồi ghi lại sẽ mất một lượt. Redis dùng HINCRBY nguyên tử; giỏ trong DB dùng UPDATE qty = qty + ? hoặc cột version.Read-then-write loses an update. Redis uses atomic HINCRBY; the DB cart uses UPDATE qty = qty + ? or a version column.

   Repository
3. 3

   Gộp giỏ khi đăng nhậpMerging carts on sign-in

   Cộng dồn dễ gấp đôi khi gọi lại. Lấy số lượng lớn hơn cho sản phẩm trùng, cắt theo giới hạn, ghi trong một transaction rồi mới xoá giỏ khách.Adding quantities doubles them on a retry. Keep the larger quantity for shared products, clamp to the limits, write in one transaction, then delete the guest cart.

   Unit of WorkRepository
4. 4

   Giỏ phình to, bị lạm dụngBloated or abused carts

   Giới hạn 50 dòng, 10 cái mỗi dòng và TTL cho giỏ khách. Bot tạo hàng triệu giỏ thì Redis tự dọn khi hết hạn.Limit to 50 lines, 10 units per line, and a TTL on guest carts. When bots create millions of carts, Redis clears them as they expire.

   Specification
5. 5

   Giỏ bị bỏ quênAbandoned carts

   Mỗi thay đổi cập nhật last_activity_at. Job quét giỏ không động tới sau 24 giờ, phát CartAbandoned; worker gửi email nhắc, mỗi giỏ tối đa một lần.Every change updates last_activity_at. A job finds carts idle for 24 hours and emits CartAbandoned; a worker sends a reminder, at most once per cart.

   Observer

Giỏ khách vãng lai trên Redis: thêm hàng có giới hạn, tăng nguyên tử bằng HINCRBY, gia hạn TTL; gộp vào DB khi đăng nhập theo cách gọi lại không sai.A guest cart in Redis: add items within limits, increase atomically with HINCRBY, extend the TTL; merge into the DB on sign-in in a way that is safe to retry.

@Service
@RequiredArgsConstructor
public class GuestCartService {
    private static final Duration TTL = Duration.ofDays(7);1
    private static final int MAX_LINES = 50;
    private static final int MAX_QTY = 10;

    private final StringRedisTemplate redis;
    private final CatalogClient catalog;
    private final CartRepository carts;

    public void addItem(String cartId, String productId, int qty) {
        if (!catalog.isSellable(productId)) throw new ProductUnavailableException(productId);
        String key = "cart:" + cartId;
        HashOperations<String, String, String> h = redis.opsForHash();
        if (!h.hasKey(key, productId) && h.size(key) >= MAX_LINES)2
            throw new CartFullException(MAX_LINES);
        long now = h.increment(key, productId, qty);    // HINCRBY3
        if (now > MAX_QTY) {
            h.increment(key, productId, -qty);          // undo our own increment
            throw new QuantityLimitException(MAX_QTY);
        }
        redis.expire(key, TTL);                         // sliding expiry
    }

    public void mergeOnLogin(String guestCartId, long userId) {
        String key = "cart:" + guestCartId;
        Map<String, String> guest = redis.<String, String>opsForHash().entries(key);
        carts.mergeMax(userId, guest, MAX_QTY);  // one tx: ON CONFLICT … GREATEST4
        redis.delete(key);                       // after commit; a retry is harmless
    }
}

const (1
	cartTTL  = 7 * 24 * time.Hour
	maxLines = 50
	maxQty   = 10
)

type GuestCarts struct {
	rdb     *redis.Client
	catalog Catalog
	carts   CartRepo
}

func (c *GuestCarts) AddItem(ctx context.Context, cartID, productID string, qty int64) error {
	if !c.catalog.IsSellable(ctx, productID) {
		return ErrProductUnavailable
	}
	key := "cart:" + cartID
	exists, err := c.rdb.HExists(ctx, key, productID).Result()
	if err != nil {
		return err
	}
	if !exists && c.rdb.HLen(ctx, key).Val() >= maxLines {
		return ErrCartFull
	}
	now, err := c.rdb.HIncrBy(ctx, key, productID, qty).Result()2
	if err != nil {
		return err
	}
	if now > maxQty {
		c.rdb.HIncrBy(ctx, key, productID, -qty) // undo our own increment
		return ErrQuantityLimit
	}
	return c.rdb.Expire(ctx, key, cartTTL).Err()
}

func (c *GuestCarts) MergeOnLogin(ctx context.Context, cartID string, userID int64) error {
	key := "cart:" + cartID
	guest, err := c.rdb.HGetAll(ctx, key).Result()
	if err != nil || len(guest) == 0 {
		return err
	}
	if err := c.carts.MergeMax(ctx, userID, guest, maxQty); err != nil {3
		return err // guest cart kept, safe to retry
	}
	return c.rdb.Del(ctx, key).Err()
}

Mỗi pattern mở bài học tương ứng trong menu Pattern.Each one opens its lesson in the Patterns menu.