Object-Oriented Design: Từ Requirements Đến Clean Code

┌──────────────────────────────────────────────┐
│  Class Name: Order                           │
├──────────────────────┬───────────────────────┤
│  Responsibilities    │  Collaborators        │
│                      │                       │
│  - Calculate total   │  - OrderItem          │
│  - Apply discount    │  - DiscountPolicy     │
│  - Track status      │  - PaymentGateway     │
│  - Generate invoice  │  - InvoiceService     │
│                      │                       │
└──────────────────────┴───────────────────────┘

┌──────────────────────────────────────────────┐
│  Class Name: ShoppingCart                    │
├──────────────────────┬───────────────────────┤
│  Responsibilities    │  Collaborators        │
│                      │                       │
│  - Add item          │  - Book               │
│  - Remove item       │  - CartItem           │
│  - Calculate subtotal│                       │
│  - Apply discount    │  - DiscountCode       │
│  - Create order      │  - Order              │
│                      │                       │
└──────────────────────┴───────────────────────┘
 
┌──────────────────────────────────────────────┐
│  Class Name: Order                           │
├──────────────────────┬───────────────────────┤
│  Responsibilities    │  Collaborators        │
│                      │                       │
│  - Store line items  │  - OrderItem          │
│  - Calculate total   │  - DiscountCode       │
│  - Track status      │                       │
│  - Confirm placement │  - NotificationService│
│                      │                       │
└──────────────────────┴───────────────────────┘

// TypeScript — Information Expert
 
// ❌ Sai: Class bên ngoài tính tổng order
class OrderCalculator {
  calculateTotal(order: Order): number {
    let total = 0;
    for (const item of order.items) {
      total += item.price * item.quantity;
    }
    return total - order.discount;
  }
}
 
// ✅ Đúng: Order tự tính tổng (nó có data)
class Order {
  private items: OrderItem[] = [];
  private discount: number = 0;
 
  getTotal(): number {
    const subtotal = this.items.reduce(
      (sum, item) => sum + item.getSubtotal(), 0
    );
    return subtotal - this.discount;
  }
}
 
class OrderItem {
  constructor(
    private product: Product,
    private quantity: number
  ) {}
 
  getSubtotal(): number {
    return this.product.price * this.quantity;
  }
}

# Python — Information Expert
 
# ❌ Sai: Hàm bên ngoài tính tổng
def calculate_order_total(order):
    total = sum(item.price * item.quantity for item in order.items)
    return total - order.discount
 
# ✅ Đúng: Order biết cách tính tổng của chính nó
class Order:
    def __init__(self):
        self._items: list[OrderItem] = []
        self._discount: float = 0
 
    def get_total(self) -> float:
        subtotal = sum(item.get_subtotal() for item in self._items)
        return subtotal - self._discount
 
class OrderItem:
    def __init__(self, product: Product, quantity: int):
        self._product = product
        self._quantity = quantity
 
    def get_subtotal(self) -> float:
        return self._product.price * self._quantity

// TypeScript — Creator
 
// ❌ Sai: Factory bên ngoài cho objects liên quan chặt
class OrderItemFactory {
  static create(product: Product, qty: number): OrderItem {
    return new OrderItem(product, qty);
  }
}
 
// ✅ Đúng: ShoppingCart tạo OrderItems (nó aggregate chúng)
class ShoppingCart {
  private items: CartItem[] = [];
 
  addItem(product: Product, quantity: number): void {
    const existing = this.items.find(
      item => item.product.id === product.id
    );
    if (existing) {
      existing.quantity += quantity;
    } else {
      this.items.push(new CartItem(product, quantity));
    }
  }
}

// TypeScript — Controller
 
// ❌ Sai: UI trực tiếp thao tác domain objects
class CheckoutButton {
  onClick(): void {
    const order = new Order();
    order.addItems(cart.getItems());
    order.applyDiscount(discountCode);
    paymentGateway.charge(order.getTotal());
    emailService.sendConfirmation(order);
    inventory.reduce(order.getItems());
  }
}
 
// ✅ Đúng: Use case controller điều phối workflow
class CheckoutController {
  constructor(
    private orderService: OrderService,
    private paymentGateway: PaymentGateway,
    private notificationService: NotificationService
  ) {}
 
  checkout(cart: ShoppingCart, discountCode?: string): Order {
    const order = this.orderService.createFromCart(cart);
 
    if (discountCode) {
      order.applyDiscount(discountCode);
    }
 
    this.paymentGateway.charge(order.getTotal());
    this.notificationService.sendConfirmation(order);
 
    return order;
  }
}

// TypeScript — Polymorphism (GRASP)
 
// ❌ Sai: Logic điều kiện dựa trên type
class ShippingCalculator {
  calculate(order: Order): number {
    if (order.type === "standard") {
      return order.weight * 5;
    } else if (order.type === "express") {
      return order.weight * 10 + 15;
    } else if (order.type === "overnight") {
      return order.weight * 20 + 30;
    }
    return 0;
  }
}
 
// ✅ Đúng: Mỗi shipping type biết cách tính của mình
interface ShippingStrategy {
  calculate(weight: number): number;
}
 
class StandardShipping implements ShippingStrategy {
  calculate(weight: number): number {
    return weight * 5;
  }
}
 
class ExpressShipping implements ShippingStrategy {
  calculate(weight: number): number {
    return weight * 10 + 15;
  }
}
 
class OvernightShipping implements ShippingStrategy {
  calculate(weight: number): number {
    return weight * 20 + 30;
  }
}

# Python — Indirection
 
# ❌ Sai: Order coupling trực tiếp với tax API bên ngoài
class Order:
    def calculate_tax(self) -> float:
        response = requests.get(f"https://tax-api.com/rate?state={self.state}")
        rate = response.json()["rate"]
        return self.get_subtotal() * rate
 
# ✅ Đúng: TaxService làm trung gian giữa Order và external API
class TaxService:
    def __init__(self, api_client: TaxApiClient):
        self._api_client = api_client
 
    def calculate_tax(self, subtotal: float, state: str) -> float:
        rate = self._api_client.get_rate(state)
        return subtotal * rate
 
class Order:
    def __init__(self, tax_service: TaxService):
        self._tax_service = tax_service
 
    def get_tax(self) -> float:
        return self._tax_service.calculate_tax(
            self.get_subtotal(), self.state
        )

// Java — Pure Fabrication
 
// Không có "PersistenceManager" nào trong domain e-commerce thực tế,
// nhưng nó là abstraction hữu ích cho design
 
public interface OrderRepository {
    void save(Order order);
    Optional<Order> findById(String id);
    List<Order> findByCustomer(String customerId);
}
 
public class PostgresOrderRepository implements OrderRepository {
    private final DataSource dataSource;
 
    @Override
    public void save(Order order) {
        // SQL insert logic — không phải domain concern
    }
 
    @Override
    public Optional<Order> findById(String id) {
        // SQL select logic
    }
}

// TypeScript — Protected Variations
 
// Payment provider sẽ thay đổi theo thời gian — protect against that
interface PaymentGateway {
  charge(amount: number, token: string): PaymentResult;
  refund(transactionId: string, amount: number): RefundResult;
}
 
class StripeGateway implements PaymentGateway {
  charge(amount: number, token: string): PaymentResult {
    // Stripe-specific implementation
  }
  refund(transactionId: string, amount: number): RefundResult {
    // Stripe-specific refund
  }
}
 
class PayPalGateway implements PaymentGateway {
  charge(amount: number, token: string): PaymentResult {
    // PayPal-specific implementation
  }
  refund(transactionId: string, amount: number): RefundResult {
    // PayPal-specific refund
  }
}
 
// Đổi payment provider không cần thay đổi business logic
class CheckoutService {
  constructor(private paymentGateway: PaymentGateway) {}
 
  processPayment(order: Order, paymentToken: string): void {
    const result = this.paymentGateway.charge(
      order.getTotal(), paymentToken
    );
    order.markAsPaid(result.transactionId);
  }
}

// TypeScript — Ví Dụ Coupling
 
// ✅ Message Coupling (Tốt nhất): Chỉ biết tên method
class OrderService {
  notify(order: Order): void {
    this.notifier.send(order.getCustomerEmail(), "Order confirmed");
  }
}
 
// ⚠️ Data Coupling: Truyền primitive data
class ShippingService {
  calculateCost(weight: number, distance: number): number {
    return weight * 0.5 + distance * 0.1;
  }
}
 
// ⚠️ Stamp Coupling: Truyền cả object nhưng chỉ dùng một phần
class EmailService {
  sendConfirmation(order: Order): void {
    // Chỉ dùng email và orderId, nhưng nhận cả Order
    this.send(order.customerEmail, `Order ${order.id} confirmed`);
  }
}
 
// ❌ Control Coupling: Truyền flag điều khiển behavior
class ReportGenerator {
  generate(data: SalesData, format: "pdf" | "csv" | "html"): void {
    if (format === "pdf") { /* ... */ }
    else if (format === "csv") { /* ... */ }
    else if (format === "html") { /* ... */ }
  }
}
 
// ❌ Content Coupling (Tệ nhất): Truy cập trực tiếp internal
class BadAuditor {
  audit(order: Order): void {
    // Chọc vào internal state — phá vỡ encapsulation
    const items = (order as any)._internalItems;
    const rawDiscount = (order as any)._discountValue;
  }
}

// TypeScript — Ví Dụ Cohesion
 
// ❌ Coincidental Cohesion (Tệ nhất): Method không liên quan gộp chung
class Utilities {
  formatDate(date: Date): string { /* ... */ }
  calculateTax(amount: number): number { /* ... */ }
  sendEmail(to: string, body: string): void { /* ... */ }
  compressImage(path: string): Buffer { /* ... */ }
}
 
// ❌ Logical Cohesion: Liên quan theo danh mục, không theo mục đích
class DataParser {
  parseJSON(data: string): object { /* ... */ }
  parseXML(data: string): object { /* ... */ }
  parseCSV(data: string): object { /* ... */ }
  parseYAML(data: string): object { /* ... */ }
}
 
// ⚠️ Temporal Cohesion: Liên quan vì xảy ra cùng thời điểm
class ApplicationStartup {
  initialize(): void {
    this.loadConfig();
    this.connectDatabase();
    this.startServer();
    this.registerRoutes();
    this.warmCache();
  }
}
 
// ✅ Functional Cohesion (Tốt nhất): Mọi thứ phục vụ một mục đích
class PasswordHasher {
  private readonly saltRounds = 12;
 
  async hash(password: string): Promise<string> {
    return bcrypt.hash(password, this.saltRounds);
  }
 
  async verify(password: string, hash: string): Promise<boolean> {
    return bcrypt.compare(password, hash);
  }
}

// TypeScript — Tell, Don't Ask
 
// ❌ Ask: Kéo data ra, rồi tự quyết bên ngoài
function processOrder(order: Order): void {
  const total = order.getTotal();
  const status = order.getStatus();
  if (status === "pending" && total > 0) {
    order.setStatus("processing");
    paymentService.charge(total, order.getPaymentToken());
    order.setStatus("paid");
  }
}
 
// ✅ Tell: Để order tự xử lý state transition
class Order {
  process(paymentService: PaymentService): void {
    if (!this.canBeProcessed()) {
      throw new Error("Order cannot be processed");
    }
    this.status = "processing";
    paymentService.charge(this.total, this.paymentToken);
    this.status = "paid";
  }
 
  private canBeProcessed(): boolean {
    return this.status === "pending" && this.total > 0;
  }
}

# Python — Law of Demeter
 
# ❌ Vi phạm: Chọc xuyên qua objects (train wreck)
def get_city(order):
    return order.get_customer().get_address().get_city()
 
# ✅ Tuân thủ Demeter: Hỏi collaborator trực tiếp
class Order:
    def get_shipping_city(self) -> str:
        return self._customer.get_shipping_city()
 
class Customer:
    def get_shipping_city(self) -> str:
        return self._address.city

// Java — Composition over Inheritance
 
// ❌ Inheritance: Tight coupling, fragile hierarchy
public class LoggingOrderService extends OrderService {
    @Override
    public Order createOrder(Cart cart) {
        logger.info("Creating order...");
        Order order = super.createOrder(cart);
        logger.info("Order created: " + order.getId());
        return order;
    }
}
 
// ✅ Composition: Flexible, swappable, testable
public class LoggingOrderService implements OrderService {
    private final OrderService delegate;
    private final Logger logger;
 
    public LoggingOrderService(OrderService delegate, Logger logger) {
        this.delegate = delegate;
        this.logger = logger;
    }
 
    @Override
    public Order createOrder(Cart cart) {
        logger.info("Creating order...");
        Order order = delegate.createOrder(cart);
        logger.info("Order created: " + order.getId());
        return order;
    }
}

// TypeScript — Interface-based design
 
// ❌ Phụ thuộc vào implementation detail
class OrderProcessor {
  private db: PostgresDatabase;
  private mailer: SmtpMailer;
 
  process(order: Order): void {
    this.db.insertRow("orders", order.toRow());
    this.mailer.sendSmtpMessage(order.email, "Order confirmed");
  }
}
 
// ✅ Phụ thuộc vào interface — implementation có thể thay đổi thoải mái
class OrderProcessor {
  constructor(
    private repository: OrderRepository,
    private notifier: Notifier
  ) {}
 
  process(order: Order): void {
    this.repository.save(order);
    this.notifier.notify(order.email, "Order confirmed");
  }
}

// ❌ Over-designed: Support 5 format export "phòng khi cần"
interface ExportStrategy { /* ... */ }
class JSONExporter implements ExportStrategy { /* ... */ }
class XMLExporter implements ExportStrategy { /* ... */ }
class CSVExporter implements ExportStrategy { /* ... */ }
class PDFExporter implements ExportStrategy { /* ... */ }
class ExcelExporter implements ExportStrategy { /* ... */ }
 
// ✅ Vừa đủ: Chỉ build thứ cần ngay bây giờ
class ReportExporter {
  exportToCSV(report: Report): string {
    // Format duy nhất khách hàng yêu cầu
    return report.rows.map(row => row.join(",")).join("\n");
  }
}
// Khi nào cần PDF, LÚC ĐÓ mới thêm strategy pattern

// TypeScript — Hệ Thống Quản Lý Thư Viện
 
// Domain Objects
class Book {
  constructor(
    public readonly id: string,
    public readonly title: string,
    public readonly author: string,
    public readonly isbn: string,
    private available: boolean = true
  ) {}
 
  isAvailable(): boolean {
    return this.available;
  }
 
  markBorrowed(): void {
    if (!this.available) {
      throw new Error(`Book "${this.title}" is not available`);
    }
    this.available = false;
  }
 
  markReturned(): void {
    this.available = true;
  }
}
 
class Loan {
  private static readonly FINE_PER_DAY = 0.50;
  private static readonly LOAN_PERIOD_DAYS = 14;
  private returnedAt?: Date;
 
  public readonly dueDate: Date;
 
  constructor(
    public readonly book: Book,
    public readonly borrowedAt: Date = new Date()
  ) {
    this.dueDate = new Date(borrowedAt);
    this.dueDate.setDate(this.dueDate.getDate() + Loan.LOAN_PERIOD_DAYS);
  }
 
  isOverdue(now: Date = new Date()): boolean {
    if (this.returnedAt) return false;
    return now > this.dueDate;
  }
 
  // Information Expert: Loan có due date và return date
  calculateFine(now: Date = new Date()): number {
    if (!this.isOverdue(now)) return 0;
    const overdueDays = Math.ceil(
      (now.getTime() - this.dueDate.getTime()) / (1000 * 60 * 60 * 24)
    );
    return overdueDays * Loan.FINE_PER_DAY;
  }
 
  markReturned(): void {
    this.returnedAt = new Date();
    this.book.markReturned();
  }
 
  isActive(): boolean {
    return !this.returnedAt;
  }
}
 
class Member {
  private static readonly MAX_LOANS = 3;
  private loans: Loan[] = [];
 
  constructor(
    public readonly id: string,
    public readonly name: string,
    public readonly email: string
  ) {}
 
  // Creator: Member aggregate Loans
  borrow(book: Book): Loan {
    if (this.getActiveLoans().length >= Member.MAX_LOANS) {
      throw new Error(`Member "${this.name}" has reached the borrowing limit`);
    }
    book.markBorrowed();
    const loan = new Loan(book);
    this.loans.push(loan);
    return loan;
  }
 
  returnBook(book: Book): number {
    const loan = this.loans.find(
      l => l.book.id === book.id && l.isActive()
    );
    if (!loan) {
      throw new Error(`No active loan found for "${book.title}"`);
    }
    const fine = loan.calculateFine();
    loan.markReturned();
    return fine;
  }
 
  getActiveLoans(): Loan[] {
    return this.loans.filter(loan => loan.isActive());
  }
 
  getOverdueLoans(): Loan[] {
    return this.getActiveLoans().filter(loan => loan.isOverdue());
  }
}
 
// Pure Fabrication: Không có domain counterpart
class Catalog {
  private books: Map<string, Book> = new Map();
 
  addBook(book: Book): void {
    this.books.set(book.id, book);
  }
 
  search(query: string): Book[] {
    const lower = query.toLowerCase();
    return Array.from(this.books.values()).filter(
      book =>
        book.title.toLowerCase().includes(lower) ||
        book.author.toLowerCase().includes(lower) ||
        book.isbn.includes(lower)
    );
  }
 
  getAvailableBooks(): Book[] {
    return Array.from(this.books.values()).filter(b => b.isAvailable());
  }
}
 
// Protected Variations: Phương thức notification có thể thay đổi
interface Notifier {
  send(to: string, subject: string, message: string): Promise<void>;
}
 
// Controller: Điều phối use case borrow
class LibraryService {
  constructor(
    private catalog: Catalog,
    private notifier: Notifier
  ) {}
 
  async borrowBook(member: Member, bookId: string): Promise<Loan> {
    const book = this.catalog.search(bookId)[0];
    if (!book) throw new Error("Book not found");
 
    const loan = member.borrow(book);
 
    await this.notifier.send(
      member.email,
      `Book Borrowed: ${book.title}`,
      `Due date: ${loan.dueDate.toLocaleDateString()}`
    );
 
    return loan;
  }
 
  async returnBook(member: Member, bookId: string): Promise<number> {
    const book = this.catalog.search(bookId)[0];
    if (!book) throw new Error("Book not found");
 
    const fine = member.returnBook(book);
 
    if (fine > 0) {
      await this.notifier.send(
        member.email,
        "Overdue Fine",
        `You owe $${fine.toFixed(2)} for late return of "${book.title}"`
      );
    }
 
    return fine;
  }
}

// ❌ Anemic: Domain object chỉ là túi data
class Order {
  id: string;
  items: OrderItem[];
  status: string;
  discount: number;
}
 
// Mọi logic nằm ngoài object
class OrderService {
  calculateTotal(order: Order): number { /* ... */ }
  applyDiscount(order: Order, code: string): void { /* ... */ }
  canBeCancelled(order: Order): boolean { /* ... */ }
  cancel(order: Order): void { /* ... */ }
}
 
// ✅ Rich: Domain object sở hữu behavior của nó
class Order {
  private items: OrderItem[] = [];
  private status: OrderStatus = "pending";
  private discount: number = 0;
 
  getTotal(): number { /* ... */ }
  applyDiscount(policy: DiscountPolicy): void { /* ... */ }
  cancel(): void {
    if (this.status !== "pending") {
      throw new Error("Only pending orders can be cancelled");
    }
    this.status = "cancelled";
  }
}

// ❌ Premature: Chỉ có một implementation
interface IUserRepository { /* ... */ }
interface IUserService { /* ... */ }
interface IUserValidator { /* ... */ }
abstract class BaseUserHandler { /* ... */ }
class UserRepositoryFactory { /* ... */ }
class UserServiceImpl implements IUserService { /* ... */ }
 
// ✅ Vừa đủ: Concrete class, extract interface KHI cần polymorphism
class UserRepository {
  save(user: User): void { /* ... */ }
  findById(id: string): User | null { /* ... */ }
}

# ❌ Feature Envy: Method này thuộc về Order, không phải ReportGenerator
class ReportGenerator:
    def generate_order_summary(self, order: Order) -> str:
        total = sum(item.price * item.qty for item in order.items)
        tax = total * order.tax_rate
        shipping = order.weight * order.shipping_rate
        return f"Total: {total + tax + shipping}"
 
# ✅ Chuyển logic đến nơi có data
class Order:
    def get_summary(self) -> str:
        return f"Total: {self.get_total()}"
 
    def get_total(self) -> float:
        return self._subtotal() + self._tax() + self._shipping()