Bài 13+: THIẾT KẾ HỆ THỐNG THỰC TẾ – ÁP DỤNG OOP, SOLID VÀ DESIGN PATTERNS

Chào các kiến trúc sư phần mềm! Hôm nay chúng ta sẽ thực hành thiết kế một hệ thống thực tế – Hệ thống quản lý đặt phòng khách sạn. Đây là cơ hội để áp dụng tất cả kiến thức đã học: OOP, SOLID, Design Patterns, Collection, Exception Handling vào một dự án thực tế!

I. PHẦN LÝ THUYẾT

1. Tầm quan trọng của thiết kế hệ thống

Trong phát triển phần mềm thực tế, 70% thành công nằm ở thiết kế, 30% còn lại là code. Một thiết kế tốt giúp:

  • Dễ dàng mở rộng tính năng
  • Dễ bảo trì và fix bug
  • Dễ test và deploy
  • Giảm chi phí phát triển về lâu dài

2. Quy trình thiết kế hệ thống OOP

  1. Phân tích yêu cầu: Hiểu vấn đề cần giải quyết
  2. Xác định đối tượng: Tìm các thực thể trong hệ thống
  3. Thiết kế lớp: Định nghĩa thuộc tính, phương thức
  4. Xác định mối quan hệ: Kế thừa, kết hợp, phụ thuộc
  5. Áp dụng SOLID: Đảm bảo nguyên tắc thiết kế
  6. Sử dụng Design Patterns: Giải quyết vấn đề phổ biến
  7. Thiết kế giao diện (Interface): Định nghĩa hợp đồng

3. Yêu cầu hệ thống quản lý đặt phòng khách sạn

Tính năng cốt lõi:

  1. Quản lý phòng (thêm, sửa, xóa, tìm kiếm)
  2. Quản lý khách hàng
  3. Đặt phòng, hủy đặt phòng
  4. Tính tiền (theo loại phòng, số ngày)
  5. Thống kê, báo cáo

Quy tắc nghiệp vụ:

  • Một phòng không thể được đặt trùng lịch
  • Có các loại phòng: Standard, Deluxe, Suite với giá khác nhau
  • Khách hàng VIP được giảm giá
  • Hủy đặt phòng trước 24h được hoàn tiền 80%

II. PHẦN THỰC HÀNH

Bước 1: Thiết kế lớp cơ bản với OOP

// 1. Enum cho trạng thái và loại
enum RoomType {
    STANDARD, DELUXE, SUITE
}

enum RoomStatus {
    AVAILABLE, OCCUPIED, MAINTENANCE
}

enum BookingStatus {
    CONFIRMED, CHECKED_IN, CHECKED_OUT, CANCELLED
}

// 2. Lớp Room - Đại diện cho phòng khách sạn
class Room {
    private String roomNumber;
    private RoomType type;
    private RoomStatus status;
    private double pricePerNight;
    private int maxOccupancy;
    private List<String> amenities; // Tiện nghi
    
    public Room(String roomNumber, RoomType type, double pricePerNight, 
                int maxOccupancy, List<String> amenities) {
        this.roomNumber = roomNumber;
        this.type = type;
        this.pricePerNight = pricePerNight;
        this.maxOccupancy = maxOccupancy;
        this.amenities = amenities;
        this.status = RoomStatus.AVAILABLE;
    }
    
    // Getters và Setters với validation
    public String getRoomNumber() { return roomNumber; }
    
    public RoomType getType() { return type; }
    
    public double getPricePerNight() { return pricePerNight; }
    public void setPricePerNight(double price) {
        if (price <= 0) throw new IllegalArgumentException("Giá phải > 0");
        this.pricePerNight = price;
    }
    
    public RoomStatus getStatus() { return status; }
    public void setStatus(RoomStatus status) { this.status = status; }
    
    public boolean isAvailable() { return status == RoomStatus.AVAILABLE; }
    
    @Override
    public String toString() {
        return String.format("%s (%s) - $%.2f/đêm - Trạng thái: %s", 
               roomNumber, type, pricePerNight, status);
    }
}

// 3. Lớp Customer - Đại diện cho khách hàng
class Customer {
    private String id;
    private String name;
    private String email;
    private String phone;
    private boolean isVip;
    private LocalDate joinDate;
    
    public Customer(String id, String name, String email, String phone) {
        this.id = id;
        this.name = name;
        this.email = email;
        this.phone = phone;
        this.isVip = false;
        this.joinDate = LocalDate.now();
    }
    
    // Getters và Setters
    public String getId() { return id; }
    public String getName() { return name; }
    public String getEmail() { return email; }
    public boolean isVip() { return isVip; }
    public void setVip(boolean vip) { isVip = vip; }
    
    @Override
    public String toString() {
        return String.format("%s - %s (%s) %s", id, name, email, 
               isVip ? "[VIP]" : "");
    }
}

// 4. Lớp Booking - Đại diện cho đặt phòng
class Booking {
    private String bookingId;
    private Customer customer;
    private Room room;
    private LocalDate checkInDate;
    private LocalDate checkOutDate;
    private BookingStatus status;
    private double totalAmount;
    private LocalDateTime bookingTime;
    
    public Booking(String bookingId, Customer customer, Room room,
                  LocalDate checkInDate, LocalDate checkOutDate) {
        if (checkInDate.isAfter(checkOutDate)) {
            throw new IllegalArgumentException("Ngày check-in phải trước check-out");
        }
        
        this.bookingId = bookingId;
        this.customer = customer;
        this.room = room;
        this.checkInDate = checkInDate;
        this.checkOutDate = checkOutDate;
        this.status = BookingStatus.CONFIRMED;
        this.bookingTime = LocalDateTime.now();
        this.totalAmount = calculateTotalAmount();
    }
    
    // Tính tổng tiền dựa trên số đêm và loại khách hàng
    private double calculateTotalAmount() {
        long nights = ChronoUnit.DAYS.between(checkInDate, checkOutDate);
        double baseAmount = nights * room.getPricePerNight();
        
        // Giảm giá cho VIP
        if (customer.isVip()) {
            baseAmount *= 0.9; // Giảm 10%
        }
        
        return baseAmount;
    }
    
    // Hủy đặt phòng
    public double cancelBooking() {
        if (status == BookingStatus.CANCELLED) {
            throw new IllegalStateException("Đặt phòng đã bị hủy trước đó");
        }
        
        LocalDateTime now = LocalDateTime.now();
        long hoursUntilCheckIn = ChronoUnit.HOURS.between(now, 
            checkInDate.atStartOfDay());
        
        double refundAmount = 0;
        if (hoursUntilCheckIn >= 24) {
            refundAmount = totalAmount * 0.8; // Hoàn 80%
        }
        
        this.status = BookingStatus.CANCELLED;
        return refundAmount;
    }
    
    // Check-in
    public void checkIn() {
        if (status != BookingStatus.CONFIRMED) {
            throw new IllegalStateException("Chỉ có thể check-in khi đã xác nhận");
        }
        this.status = BookingStatus.CHECKED_IN;
        room.setStatus(RoomStatus.OCCUPIED);
    }
    
    // Check-out
    public void checkOut() {
        if (status != BookingStatus.CHECKED_IN) {
            throw new IllegalStateException("Chỉ có thể check-out khi đã check-in");
        }
        this.status = BookingStatus.CHECKED_OUT;
        room.setStatus(RoomStatus.AVAILABLE);
    }
    
    // Getters
    public String getBookingId() { return bookingId; }
    public Customer getCustomer() { return customer; }
    public Room getRoom() { return room; }
    public LocalDate getCheckInDate() { return checkInDate; }
    public LocalDate getCheckOutDate() { return checkOutDate; }
    public BookingStatus getStatus() { return status; }
    public double getTotalAmount() { return totalAmount; }
    
    @Override
    public String toString() {
        return String.format("Booking %s: %s - %s (%s đến %s) - $%.2f - %s",
               bookingId, customer.getName(), room.getRoomNumber(),
               checkInDate, checkOutDate, totalAmount, status);
    }
}

Bước 2: Áp dụng SOLID Principles

// 1. SRP - Tách các responsibility riêng biệt

// Interface cho Room Repository (DAO Pattern)
interface RoomRepository {
    void addRoom(Room room);
    Room findRoomByNumber(String roomNumber);
    List<Room> findAvailableRooms(RoomType type, LocalDate date);
    List<Room> getAllRooms();
    void updateRoom(Room room);
    void deleteRoom(String roomNumber);
}

// Interface cho Booking Service
interface BookingService {
    Booking createBooking(Customer customer, String roomNumber, 
                         LocalDate checkIn, LocalDate checkOut);
    void cancelBooking(String bookingId);
    void checkIn(String bookingId);
    void checkOut(String bookingId);
    List<Booking> getCustomerBookings(String customerId);
}

// Interface cho Pricing Strategy (Strategy Pattern)
interface PricingStrategy {
    double calculatePrice(Room room, long nights, Customer customer);
}

// 2. OCP - Mở rộng dễ dàng

// Base Pricing Strategy
class StandardPricingStrategy implements PricingStrategy {
    @Override
    public double calculatePrice(Room room, long nights, Customer customer) {
        return nights * room.getPricePerNight();
    }
}

// VIP Pricing Strategy (mở rộng từ Standard)
class VipPricingStrategy implements PricingStrategy {
    private static final double VIP_DISCOUNT = 0.1; // 10% giảm
    
    @Override
    public double calculatePrice(Room room, long nights, Customer customer) {
        double basePrice = nights * room.getPricePerNight();
        return customer.isVip() ? basePrice * (1 - VIP_DISCOUNT) : basePrice;
    }
}

// Seasonal Pricing Strategy (thêm mới dễ dàng)
class SeasonalPricingStrategy implements PricingStrategy {
    private Map<Month, Double> seasonalMultipliers;
    
    public SeasonalPricingStrategy() {
        seasonalMultipliers = new HashMap<>();
        seasonalMultipliers.put(Month.DECEMBER, 1.5); // Giáng sinh
        seasonalMultipliers.put(Month.JUNE, 1.2);     // Mùa hè
        seasonalMultipliers.put(Month.JULY, 1.2);
        seasonalMultipliers.put(Month.AUGUST, 1.2);
    }
    
    @Override
    public double calculatePrice(Room room, long nights, Customer customer) {
        double basePrice = nights * room.getPricePerNight();
        double multiplier = seasonalMultipliers.getOrDefault(
            LocalDate.now().getMonth(), 1.0);
        
        double finalPrice = basePrice * multiplier;
        
        // Áp dụng giảm giá VIP nếu có
        if (customer.isVip()) {
            finalPrice *= 0.9;
        }
        
        return finalPrice;
    }
}

// 3. LSP - Các subclass thay thế được

// Base Discount Strategy
abstract class DiscountStrategy {
    public abstract double applyDiscount(double amount, Customer customer);
    
    // Template Method Pattern
    public final double calculateFinalPrice(double amount, Customer customer) {
        validateAmount(amount);
        double discounted = applyDiscount(amount, customer);
        return applyTax(discounted);
    }
    
    protected void validateAmount(double amount) {
        if (amount <= 0) {
            throw new IllegalArgumentException("Số tiền phải > 0");
        }
    }
    
    protected double applyTax(double amount) {
        return amount * 1.1; // Thuế 10%
    }
}

// Percentage Discount
class PercentageDiscountStrategy extends DiscountStrategy {
    private double percentage;
    
    public PercentageDiscountStrategy(double percentage) {
        if (percentage < 0 || percentage > 100) {
            throw new IllegalArgumentException("Phần trăm phải từ 0-100");
        }
        this.percentage = percentage;
    }
    
    @Override
    public double applyDiscount(double amount, Customer customer) {
        return amount * (1 - percentage / 100);
    }
}

// Fixed Amount Discount
class FixedAmountDiscountStrategy extends DiscountStrategy {
    private double fixedAmount;
    
    public FixedAmountDiscountStrategy(double fixedAmount) {
        this.fixedAmount = fixedAmount;
    }
    
    @Override
    public double applyDiscount(double amount, Customer customer) {
        return Math.max(0, amount - fixedAmount);
    }
}

// 4. ISP - Interface nhỏ, chuyên biệt

// Interface cho Notifications
interface EmailNotifier {
    void sendConfirmationEmail(String email, String bookingId);
    void sendCancellationEmail(String email, String bookingId);
}

interface SMSNotifier {
    void sendSMS(String phone, String message);
}

interface PushNotifier {
    void sendPushNotification(String deviceId, String message);
}

// 5. DIP - Phụ thuộc vào abstraction

// Booking Service phụ thuộc vào interfaces
class HotelBookingService implements BookingService {
    private final RoomRepository roomRepository;
    private final PricingStrategy pricingStrategy;
    private final EmailNotifier emailNotifier;
    private final Map<String, Booking> bookings;
    
    // Constructor Injection
    public HotelBookingService(RoomRepository roomRepository,
                              PricingStrategy pricingStrategy,
                              EmailNotifier emailNotifier) {
        this.roomRepository = roomRepository;
        this.pricingStrategy = pricingStrategy;
        this.emailNotifier = emailNotifier;
        this.bookings = new HashMap<>();
    }
    
    @Override
    public Booking createBooking(Customer customer, String roomNumber,
                                LocalDate checkIn, LocalDate checkOut) {
        // Kiểm tra phòng có tồn tại và available
        Room room = roomRepository.findRoomByNumber(roomNumber);
        if (room == null) {
            throw new IllegalArgumentException("Phòng không tồn tại: " + roomNumber);
        }
        if (!room.isAvailable()) {
            throw new IllegalStateException("Phòng không khả dụng: " + roomNumber);
        }
        
        // Kiểm tra xem phòng đã được đặt trong khoảng thời gian này chưa
        if (isRoomBooked(roomNumber, checkIn, checkOut)) {
            throw new IllegalStateException("Phòng đã được đặt trong khoảng thời gian này");
        }
        
        // Tạo booking
        String bookingId = generateBookingId();
        long nights = ChronoUnit.DAYS.between(checkIn, checkOut);
        double totalAmount = pricingStrategy.calculatePrice(room, nights, customer);
        
        Booking booking = new Booking(bookingId, customer, room, checkIn, checkOut) {
            @Override
            public double getTotalAmount() {
                return totalAmount;
            }
        };
        
        // Lưu booking
        bookings.put(bookingId, booking);
        room.setStatus(RoomStatus.OCCUPIED);
        
        // Gửi email xác nhận
        emailNotifier.sendConfirmationEmail(customer.getEmail(), bookingId);
        
        return booking;
    }
    
    private boolean isRoomBooked(String roomNumber, LocalDate checkIn, LocalDate checkOut) {
        return bookings.values().stream()
            .filter(b -> b.getRoom().getRoomNumber().equals(roomNumber))
            .filter(b -> b.getStatus() != BookingStatus.CANCELLED)
            .anyMatch(b -> datesOverlap(b.getCheckInDate(), b.getCheckOutDate(), 
                                       checkIn, checkOut));
    }
    
    private boolean datesOverlap(LocalDate start1, LocalDate end1,
                                LocalDate start2, LocalDate end2) {
        return start1.isBefore(end2) && start2.isBefore(end1);
    }
    
    private String generateBookingId() {
        return "BK" + System.currentTimeMillis();
    }
    
    @Override
    public void cancelBooking(String bookingId) {
        Booking booking = bookings.get(bookingId);
        if (booking == null) {
            throw new IllegalArgumentException("Booking không tồn tại: " + bookingId);
        }
        
        double refundAmount = booking.cancelBooking();
        
        // Gửi email hủy
        emailNotifier.sendCancellationEmail(
            booking.getCustomer().getEmail(), bookingId);
        
        System.out.printf("Đã hủy booking %s. Hoàn tiền: $%.2f%n", 
                         bookingId, refundAmount);
    }
    
    // Các phương thức khác...
}

Bước 3: Sử dụng Design Patterns

// 1. Factory Pattern cho Room Creation
interface RoomFactory {
    Room createRoom(String roomNumber, RoomType type);
}

class StandardRoomFactory implements RoomFactory {
    @Override
    public Room createRoom(String roomNumber, RoomType type) {
        List<String> amenities = Arrays.asList("TV", "WiFi", "Mini-bar");
        double price = 100.0;
        int maxOccupancy = 2;
        
        return new Room(roomNumber, type, price, maxOccupancy, amenities);
    }
}

class DeluxeRoomFactory implements RoomFactory {
    @Override
    public Room createRoom(String roomNumber, RoomType type) {
        List<String> amenities = Arrays.asList("TV", "WiFi", "Mini-bar", 
                                               "Jacuzzi", "Sea View");
        double price = 200.0;
        int maxOccupancy = 3;
        
        return new Room(roomNumber, type, price, maxOccupancy, amenities);
    }
}

class SuiteRoomFactory implements RoomFactory {
    @Override
    public Room createRoom(String roomNumber, RoomType type) {
        List<String> amenities = Arrays.asList("TV", "WiFi", "Mini-bar", 
                                               "Jacuzzi", "Sea View", 
                                               "Living Room", "Kitchen");
        double price = 500.0;
        int maxOccupancy = 4;
        
        return new Room(roomNumber, type, price, maxOccupancy, amenities);
    }
}

// Room Factory Creator (Abstract Factory Pattern)
class RoomFactoryCreator {
    public static RoomFactory getFactory(RoomType type) {
        switch (type) {
            case STANDARD: return new StandardRoomFactory();
            case DELUXE: return new DeluxeRoomFactory();
            case SUITE: return new SuiteRoomFactory();
            default: throw new IllegalArgumentException("Loại phòng không hỗ trợ");
        }
    }
}

// 2. Singleton Pattern cho Hotel Manager
class HotelManager {
    private static volatile HotelManager instance;
    private final Map<String, Room> rooms;
    private final Map<String, Customer> customers;
    private final Map<String, Booking> bookings;
    
    private HotelManager() {
        rooms = new HashMap<>();
        customers = new HashMap<>();
        bookings = new HashMap<>();
        System.out.println("Hotel Manager đã được khởi tạo");
    }
    
    public static HotelManager getInstance() {
        if (instance == null) {
            synchronized (HotelManager.class) {
                if (instance == null) {
                    instance = new HotelManager();
                }
            }
        }
        return instance;
    }
    
    // Quản lý phòng
    public void addRoom(Room room) {
        rooms.put(room.getRoomNumber(), room);
    }
    
    public Room findAvailableRoom(RoomType type, LocalDate date) {
        return rooms.values().stream()
            .filter(r -> r.getType() == type)
            .filter(Room::isAvailable)
            .findFirst()
            .orElse(null);
    }
    
    // Quản lý khách hàng
    public void addCustomer(Customer customer) {
        customers.put(customer.getId(), customer);
    }
    
    // Quản lý booking
    public Booking createBooking(Customer customer, Room room, 
                                LocalDate checkIn, LocalDate checkOut) {
        if (!room.isAvailable()) {
            throw new IllegalStateException("Phòng không khả dụng");
        }
        
        String bookingId = "BK" + System.currentTimeMillis();
        Booking booking = new Booking(bookingId, customer, room, checkIn, checkOut);
        
        bookings.put(bookingId, booking);
        room.setStatus(RoomStatus.OCCUPIED);
        
        return booking;
    }
    
    // Thống kê
    public Map<RoomType, Long> getRoomTypeStatistics() {
        return rooms.values().stream()
            .collect(Collectors.groupingBy(Room::getType, Collectors.counting()));
    }
    
    public double getTotalRevenue() {
        return bookings.values().stream()
            .filter(b -> b.getStatus() == BookingStatus.CHECKED_OUT)
            .mapToDouble(Booking::getTotalAmount)
            .sum();
    }
}

// 3. Observer Pattern cho Room Status Changes
interface RoomStatusObserver {
    void update(Room room, RoomStatus oldStatus, RoomStatus newStatus);
}

class RoomStatusNotifier {
    private List<RoomStatusObserver> observers = new ArrayList<>();
    
    public void addObserver(RoomStatusObserver observer) {
        observers.add(observer);
    }
    
    public void removeObserver(RoomStatusObserver observer) {
        observers.remove(observer);
    }
    
    public void notifyObservers(Room room, RoomStatus oldStatus, RoomStatus newStatus) {
        for (RoomStatusObserver observer : observers) {
            observer.update(room, oldStatus, newStatus);
        }
    }
}

// Concrete Observers
class MaintenanceScheduler implements RoomStatusObserver {
    @Override
    public void update(Room room, RoomStatus oldStatus, RoomStatus newStatus) {
        if (newStatus == RoomStatus.MAINTENANCE) {
            System.out.println("Lên lịch bảo trì cho phòng: " + room.getRoomNumber());
        }
    }
}

class HouseKeepingNotifier implements RoomStatusObserver {
    @Override
    public void update(Room room, RoomStatus oldStatus, RoomStatus newStatus) {
        if (newStatus == RoomStatus.AVAILABLE && oldStatus == RoomStatus.OCCUPIED) {
            System.out.println("Yêu cầu dọn phòng: " + room.getRoomNumber());
        }
    }
}

// 4. Decorator Pattern cho Room Amenities
interface RoomDecorator {
    String getDescription();
    double getAdditionalCost();
}

class BasicRoom implements RoomDecorator {
    @Override
    public String getDescription() {
        return "Phòng cơ bản";
    }
    
    @Override
    public double getAdditionalCost() {
        return 0;
    }
}

abstract class RoomDecoratorBase implements RoomDecorator {
    protected RoomDecorator wrappedRoom;
    
    public RoomDecoratorBase(RoomDecorator room) {
        this.wrappedRoom = room;
    }
    
    @Override
    public String getDescription() {
        return wrappedRoom.getDescription();
    }
    
    @Override
    public double getAdditionalCost() {
        return wrappedRoom.getAdditionalCost();
    }
}

class SeaViewDecorator extends RoomDecoratorBase {
    public SeaViewDecorator(RoomDecorator room) {
        super(room);
    }
    
    @Override
    public String getDescription() {
        return wrappedRoom.getDescription() + ", View biển";
    }
    
    @Override
    public double getAdditionalCost() {
        return wrappedRoom.getAdditionalCost() + 50.0;
    }
}

class JacuzziDecorator extends RoomDecoratorBase {
    public JacuzziDecorator(RoomDecorator room) {
        super(room);
    }
    
    @Override
    public String getDescription() {
        return wrappedRoom.getDescription() + ", Bồn Jacuzzi";
    }
    
    @Override
    public double getAdditionalCost() {
        return wrappedRoom.getAdditionalCost() + 100.0;
    }
}

class BreakfastDecorator extends RoomDecoratorBase {
    public BreakfastDecorator(RoomDecorator room) {
        super(room);
    }
    
    @Override
    public String getDescription() {
        return wrappedRoom.getDescription() + ", Bao ăn sáng";
    }
    
    @Override
    public double getAdditionalCost() {
        return wrappedRoom.getAdditionalCost() + 30.0;
    }
}

// 5. Repository Pattern cho Data Access
class InMemoryRoomRepository implements RoomRepository {
    private Map<String, Room> rooms = new HashMap<>();
    
    @Override
    public void addRoom(Room room) {
        rooms.put(room.getRoomNumber(), room);
    }
    
    @Override
    public Room findRoomByNumber(String roomNumber) {
        return rooms.get(roomNumber);
    }
    
    @Override
    public List<Room> findAvailableRooms(RoomType type, LocalDate date) {
        return rooms.values().stream()
            .filter(r -> r.getType() == type)
            .filter(Room::isAvailable)
            .collect(Collectors.toList());
    }
    
    @Override
    public List<Room> getAllRooms() {
        return new ArrayList<>(rooms.values());
    }
    
    @Override
    public void updateRoom(Room room) {
        if (rooms.containsKey(room.getRoomNumber())) {
            rooms.put(room.getRoomNumber(), room);
        } else {
            throw new IllegalArgumentException("Phòng không tồn tại");
        }
    }
    
    @Override
    public void deleteRoom(String roomNumber) {
        rooms.remove(roomNumber);
    }
}

Bước 4: Xây dựng hệ thống hoàn chỉnh

// Main Application - Kết hợp tất cả lại
public class HotelManagementSystem {
    public static void main(String[] args) {
        System.out.println("=== HỆ THỐNG QUẢN LÝ KHÁCH SẠN ===\n");
        
        try {
            // 1. Khởi tạo các thành phần
            HotelManager hotelManager = HotelManager.getInstance();
            
            // 2. Tạo phòng sử dụng Factory Pattern
            createRoomsWithFactory(hotelManager);
            
            // 3. Tạo khách hàng
            Customer customer1 = new Customer("C001", "Nguyễn Văn A", 
                                            "a@email.com", "0901111111");
            customer1.setVip(true);
            
            Customer customer2 = new Customer("C002", "Trần Thị B", 
                                            "b@email.com", "0902222222");
            
            hotelManager.addCustomer(customer1);
            hotelManager.addCustomer(customer2);
            
            // 4. Setup Observer Pattern
            setupRoomStatusObservers();
            
            // 5. Tạo booking
            System.out.println("\n=== TẠO BOOKING ===");
            Room availableRoom = hotelManager.findAvailableRoom(RoomType.DELUXE, 
                                                               LocalDate.now());
            if (availableRoom != null) {
                LocalDate checkIn = LocalDate.now().plusDays(1);
                LocalDate checkOut = checkIn.plusDays(3);
                
                Booking booking = hotelManager.createBooking(customer1, 
                                                           availableRoom, 
                                                           checkIn, checkOut);
                System.out.println("Tạo booking thành công: " + booking);
                System.out.printf("Tổng tiền: $%.2f%n", booking.getTotalAmount());
            }
            
            // 6. Sử dụng Decorator Pattern
            System.out.println("\n=== DECORATOR PATTERN ===");
            RoomDecorator basicRoom = new BasicRoom();
            RoomDecorator luxuryRoom = new SeaViewDecorator(
                new JacuzziDecorator(
                    new BreakfastDecorator(basicRoom)
                )
            );
            
            System.out.println("Mô tả: " + luxuryRoom.getDescription());
            System.out.println("Chi phí thêm: $" + luxuryRoom.getAdditionalCost());
            
            // 7. Thống kê
            System.out.println("\n=== THỐNG KÊ ===");
            Map<RoomType, Long> stats = hotelManager.getRoomTypeStatistics();
            stats.forEach((type, count) -> 
                System.out.println(type + ": " + count + " phòng"));
            
            // 8. Xử lý ngoại lệ
            testExceptionHandling(hotelManager);
            
        } catch (Exception e) {
            System.err.println("Lỗi hệ thống: " + e.getMessage());
            e.printStackTrace();
        }
    }
    
    private static void createRoomsWithFactory(HotelManager hotelManager) {
        System.out.println("=== TẠO PHÒNG VỚI FACTORY PATTERN ===");
        
        // Tạo các loại phòng khác nhau
        RoomFactory standardFactory = RoomFactoryCreator.getFactory(RoomType.STANDARD);
        RoomFactory deluxeFactory = RoomFactoryCreator.getFactory(RoomType.DELUXE);
        RoomFactory suiteFactory = RoomFactoryCreator.getFactory(RoomType.SUITE);
        
        // Tạo và thêm phòng
        hotelManager.addRoom(standardFactory.createRoom("101", RoomType.STANDARD));
        hotelManager.addRoom(standardFactory.createRoom("102", RoomType.STANDARD));
        hotelManager.addRoom(deluxeFactory.createRoom("201", RoomType.DELUXE));
        hotelManager.addRoom(deluxeFactory.createRoom("202", RoomType.DELUXE));
        hotelManager.addRoom(suiteFactory.createRoom("301", RoomType.SUITE));
        
        System.out.println("Đã tạo 5 phòng với các loại khác nhau");
    }
    
    private static void setupRoomStatusObservers() {
        System.out.println("\n=== SETUP OBSERVER PATTERN ===");
        
        RoomStatusNotifier notifier = new RoomStatusNotifier();
        notifier.addObserver(new MaintenanceScheduler());
        notifier.addObserver(new HouseKeepingNotifier());
        
        System.out.println("Đã setup observers cho thay đổi trạng thái phòng");
    }
    
    private static void testExceptionHandling(HotelManager hotelManager) {
        System.out.println("\n=== TEST EXCEPTION HANDLING ===");
        
        try {
            // Test validation
            Customer invalidCustomer = new Customer("C003", "", "invalid", "");
            hotelManager.addCustomer(invalidCustomer);
            
        } catch (IllegalArgumentException e) {
            System.out.println("Bắt được IllegalArgumentException: " + e.getMessage());
            
        } catch (Exception e) {
            System.err.println("Lỗi không mong muốn: " + e.getClass().getName());
        }
        
        // Test booking phòng đã đầy
        try {
            Room room = hotelManager.findAvailableRoom(RoomType.STANDARD, 
                                                      LocalDate.now());
            if (room != null) {
                // Đặt phòng 2 lần để gây lỗi
                Customer customer = new Customer("C004", "Test", "test@test", "0903333333");
                hotelManager.addCustomer(customer);
                
                LocalDate checkIn = LocalDate.now().plusDays(1);
                LocalDate checkOut = checkIn.plusDays(2);
                
                // Booking lần 1
                hotelManager.createBooking(customer, room, checkIn, checkOut);
                
                // Booking lần 2 - sẽ fail
                hotelManager.createBooking(customer, room, checkIn, checkOut);
            }
        } catch (IllegalStateException e) {
            System.out.println("Bắt được IllegalStateException: " + e.getMessage());
        }
    }
}

// Additional: Report Generator với Template Method Pattern
abstract class ReportGenerator {
    // Template Method
    public final void generateReport() {
        System.out.println("=== BÁO CÁO ===");
        System.out.println("Ngày tạo: " + LocalDateTime.now());
        System.out.println("Người tạo: Hệ thống");
        
        generateHeader();
        generateBody();
        generateFooter();
        
        System.out.println("=== KẾT THÚC BÁO CÁO ===");
    }
    
    protected abstract void generateHeader();
    protected abstract void generateBody();
    protected abstract void generateFooter();
}

class RevenueReportGenerator extends ReportGenerator {
    private List<Booking> bookings;
    
    public RevenueReportGenerator(List<Booking> bookings) {
        this.bookings = bookings;
    }
    
    @Override
    protected void generateHeader() {
        System.out.println("BÁO CÁO DOANH THU");
        System.out.println("=================");
    }
    
    @Override
    protected void generateBody() {
        double totalRevenue = bookings.stream()
            .filter(b -> b.getStatus() == BookingStatus.CHECKED_OUT)
            .mapToDouble(Booking::getTotalAmount)
            .sum();
        
        long totalBookings = bookings.stream()
            .filter(b -> b.getStatus() != BookingStatus.CANCELLED)
            .count();
        
        long cancelledBookings = bookings.stream()
            .filter(b -> b.getStatus() == BookingStatus.CANCELLED)
            .count();
        
        System.out.printf("Tổng doanh thu: $%.2f%n", totalRevenue);
        System.out.println("Tổng số booking: " + totalBookings);
        System.out.println("Số booking đã hủy: " + cancelledBookings);
        
        // Thống kê theo loại phòng
        Map<RoomType, Double> revenueByType = bookings.stream()
            .filter(b -> b.getStatus() == BookingStatus.CHECKED_OUT)
            .collect(Collectors.groupingBy(
                b -> b.getRoom().getType(),
                Collectors.summingDouble(Booking::getTotalAmount)
            ));
        
        System.out.println("\nDoanh thu theo loại phòng:");
        revenueByType.forEach((type, revenue) -> 
            System.out.printf("  %s: $%.2f%n", type, revenue));
    }
    
    @Override
    protected void generateFooter() {
        System.out.println("\n---");
        System.out.println("Đây là báo cáo tự động");
    }
}

III. CÂU HỎI VÀ BÀI TẬP

Phần A: Phân tích thiết kế (10 phút)

  1. Câu 1: Hệ thống trên đã áp dụng những nguyên lý SOLID nào? Chỉ ra cụ thể.
  2. Câu 2: Những Design Patterns nào được sử dụng? Mỗi pattern giải quyết vấn đề gì?
  3. Câu 3: Làm thế nào để thêm tính năng “đặt dịch vụ thêm” (spa, ăn uống) vào hệ thống?
  4. Câu 4: Cách xử lý concurrent booking cho cùng một phòng?
  5. Câu 5: Làm thế nào để mở rộng hệ thống hỗ trợ nhiều chi nhánh khách sạn?

Phần B: Bài tập thực hành (30 phút)

Bài 1: Thêm tính năng Loyalty Program

Thiết kế hệ thống Loyalty Program:

  1. Khách hàng tích điểm khi đặt phòng
  2. Các cấp độ: Bronze, Silver, Gold, Platinum
  3. Mỗi cấp độ có ưu đãi khác nhau
  4. Tự động nâng cấp cấp độ khi đủ điểm

Yêu cầu:

  • Sử dụng Strategy Pattern cho ưu đãi từng cấp độ
  • Sử dụng Observer Pattern để thông báo nâng cấp
  • Tuân thủ OCP để dễ thêm cấp độ mới

Bài 2: Hệ thống Dynamic Pricing

Implement dynamic pricing:

  1. Giá thay đổi theo demand (cao điểm, thấp điểm)
  2. Giá thay đổi theo số phòng còn trống
  3. Giá thay đổi theo thời gian đặt (last-minute discount)

Yêu cầu:

  • Sử dụng Strategy Pattern cho các thuật toán pricing
  • Sử dụng Factory Pattern để tạo pricing strategy
  • Sử dụng Observer Pattern để theo dõi occupancy rate

Bài 3: Booking Validation Rules

Thêm validation rules phức tạp:

  1. Khách hàng dưới 18 tuổi cần người lớn đi cùng
  2. Không cho phép đặt quá 30 ngày
  3. Phòng Suite cần đặt trước 48h
  4. Khách VIP được đặt trước 60 ngày

Yêu cầu:

  • Sử dụng Chain of Responsibility Pattern
  • Mỗi rule là một handler trong chain
  • Dễ dàng thêm/xóa rule

Phần C: Thử thách nâng cao (25 phút)

Bài 4: Microservices Architecture

Thiết kế lại hệ thống thành microservices:

  1. Service 1: Room Management
  2. Service 2: Customer Management
  3. Service 3: Booking Service
  4. Service 4: Payment Service
  5. Service 5: Notification Service

Yêu cầu:

  • Định nghĩa API cho mỗi service
  • Sử dụng Repository Pattern cho mỗi service
  • Sử dụng Circuit Breaker Pattern cho inter-service communication
  • Sử dụng API Gateway Pattern

Bài 5: Real-time Dashboard

Tạo dashboard real-time:

  1. Hiển thị occupancy rate theo thời gian thực
  2. Hiển thị revenue trong ngày
  3. Hiển thị top customers
  4. Alert khi occupancy > 90%

Yêu cầu:

  • Sử dụng Observer Pattern để cập nhật real-time
  • Sử dụng Singleton Pattern cho dashboard manager
  • Sử dụng Decorator Pattern để thêm widget mới
  • Sử dụng Strategy Pattern cho các loại chart khác nhau

IV. TÓM TẮT BÀI HỌC

  • Thiết kế hệ thống: Phân tích -> Thiết kế -> Implement
  • Áp dụng OOP: Đóng gói, Kế thừa, Đa hình, Trừu tượng
  • Áp dụng SOLID: 5 nguyên tắc vàng cho thiết kế tốt
  • Áp dụng Design Patterns: Factory, Singleton, Observer, Strategy, Decorator, Repository
  • Xử lý thực tế: Exception handling, Validation, Business rules

Bài học quan trọng:

  • Design trước khi code
  • Ưu tiên flexibility và maintainability
  • Sử dụng patterns đúng chỗ, không lạm dụng
  • Code cho người đọc, không chỉ cho máy

“Một kiến trúc sư giỏi không chỉ biết vẽ bản vẽ đẹp, mà còn biết tính toán để tòa nhà đứng vững qua mưa gió. Một developer giỏi cũng vậy – code không chỉ chạy được, mà còn phải dễ thay đổi và mở rộng.”

P.S.: Thử thách đặc biệt: Hãy thiết kế hệ thống Booking.com thu nhỏ với đầy đủ tính năng: tìm kiếm phòng, so sánh giá, đánh giá, recommendation, và loyalty program. Chia sẻ UML diagram và giải thích design decisions của bạn!

Comments are closed.