Đóng thay đổi, mở tương lai!

Nếu hỏi đâu là nguyên tắc quan trọng nhất trong lập trình phần mềm (SOLID) thì OpenClose chính là nguyên tắc quan trọng nhất. Nguyên tắc này nhắc nhở chúng ta rằng hãy hạn chế tối việc thay đổi những thứ đang chạy ổn định và nếu phải cập nhật thì hãy tìm cách mở rộng thay vì thay đổi source code. Hệ thống có mở rộng được hay không, giảm thiểu chi phí nâng cấp hệ thống được bao nhiêu và trình độ của lập trình viên cao hay thấp chính là ở kỹ năng để đáp ứng nguyên tắc này.

Vấn đề trong thực tế

Với con mắt của người tạo ra những dòng code thì nó là đẹp, gọn gàng, nhưng khi đưa chính source code đó cho những người khác thì nó lại trở thành một mớ hỗn độn, hãy tưởng tượng bạn có 1 tính năng cập nhật mật khẩu, và hiện tại code là thế này:

public class AuthenService {
    public void refreshToken(String username) {}
    public void logout(String username) {}
    public void updatePassword(String username, String password) {
        if(password.length < 6) {
            throw new InvalidPasswordException("password's too short");
        }
        if(password.length > 36) {
            throw new InvalidPasswordException("password's too long");
        }
        User user = userService.getUserByName(username);
        user.setPassword(password);
        userService.saveUser(user);
    }
}

Nhìn code vẫn rất gọn gàng đúng không mọi người? Thế nhưng đột nhiên chúng ta nhận được yêu cầu là: mật khẩu phải không được trùng với 3 mật khẩu đã đổi trước đó và lúc này chúng ta sẽ cần cập nhật code:

public class AuthenService {
    public void refreshToken(String username) {}
    public void logout(String username) {}
    public void updatePassword(String username, String password) {
        if(password.length < 6) {
            throw new InvalidPasswordException("password's too short");
        }
        if(password.length > 36) {
            throw new InvalidPasswordException("password's too long");
        }
        Set<UpdatePasswordHistory> updatePasswordHistories = 
                updatePasswordHistoryRepository.findPasswordUpdateHistories(username, 3);
        Set<String> updatedPasswords = updatePasswordHistories.stream()
                .map(it -> it.getPassword())
                .collect(Collectors.toSet())
        if(updatedPasswords.contains(password)) {
            throw new InvalidPasswordException("new password can not be same last 3 updated passwords");
        }
        User user = userService.getUserByName(username);
        user.setPassword(password);
        userService.saveUser(user);
    }
}

Việc update code thế này đã làm thay đổi hàm updatePassword trong lớp AuthenService và nó dẫn đến hệ lụy là chúng ta sẽ phải đi test lại toàn bộ các tính năng có trong lớp AuthenService để chắc chắn rằng sẽ không có sự nhầm lẫn nào và không có lỗi xảy ra. Thêm nữa là lớp AuthenService ngày càng dài ra và càng ngày càng rối. Một câu chuyện có thật là bọn mình đã từng phải maintain 1 lớp UpdateUserAction, lớp này đã lên đến hàng nghìn dòng, cứ mỗi lần nhận được task update nghiệp vụ cho lớp này là tất cả anh em đều đẩy đưa nhau, chẳng ai muốn làm vì sợ lỗi, và sự thực là lỗi đã xảy ra làm block toàn bộ luồng update user, thật may nó mới chỉ diễn ra trên bản Beta.

Giải quyết vấn đề

Vậy để đóng việc thay đổi lớp AuthenService và dễ mở rộng về sau này thì làm thế nào? Đơn giản thôi, hãy sử dụng Composite designpattern và ChainOfResponsibility design pattern để tách việc kiểm tra password ra chỗ khác, nó như này:

public class PasswordValidator {
    private final List<Validator> validators;
    public PasswordValidator() {
        this.validators = Arrays.asList(
            new PasswordLengthValidator(),
            new PasswordHistoryValidator()
        );
    }
    public void validatePassword(String username, String password) {
        validators.forEach(it -> it.validate(username, password));
    }
    private class PasswordHistoryValidator implements Validator {
        public void validate() {
            Set<UpdatePasswordHistory> updatePasswordHistories = 
                updatePasswordHistoryRepository.findPasswordUpdateHistories(username, 3);
            Set<String> updatedPasswords = updatePasswordHistories.stream()
                    .map(it -> it.getPassword())
                    .collect(Collectors.toSet())
            if(updatedPasswords.contains(password)) {
                throw new InvalidPasswordException("new password can not be same last 3 updated passwords");
            }
        }
    }
    private class PasswordLengthValidator implements Validator {
        public void validate() {
            if(password.length < 6) {
                throw new InvalidPasswordException("password's too short");
            }
            if(password.length > 36) {
                throw new InvalidPasswordException("password's too long");
            }
        }
    }
    private interface Validator {
        void validate(String username, String password);
    }
}

Và lớp AuthenService sẽ không cần phải thay đổi nếu như có thêm những nghiệp vụ về password nữa.

public class AuthenService {
    public void refreshToken(String username) {}
    public void logout(String username) {}
    public void updatePassword(String username, String password) {
        passwordValidator.validate(username, password);
        User user = userService.getUserByName(username);
        user.setPassword(password);
        userService.saveUser(user);
    }
}

Tổng kết

Nguyên tắc này rất quan trọng đối việc phát triển phần mềm, nếu có thể hãy làm nó ngay từ đầu, còn nếu bạn đang vội thì hãy dành 1 phase refactor code để sửa code của mình theo hướng Open/Close này nhé. DesignPattern sẽ là công cụ giúp ích cho bạn rất nhiều đấy. Và đây chỉ là bài đầu tiên nói về nguyên tắc này thôi nhé, 🙂

Tham khảo

1. wiki
2. solid design open closed principle