Null Object pattern w Javie – Jak pozbyć się NullPointerException

NullPointerException to prawdopodobnie najczęstszy wyjątek w Javie. Każdy programista go zna, każdy się z nim męczy. A co jeśli powiem Ci, że można go w dużej mierze wyeliminować używając prostego wzorca projektowego?

Dlaczego to ważne

Sprawdzenia if (object != null) zaśmiecają kod i są częstą przyczyną błędów. Wzorzec Null Object wprowadza eleganckie rozwiązanie – zamiast null używamy obiektu o „pustym” zachowaniu. Kod staje się czytelniejszy, bezpieczniejszy i łatwiejszy w utrzymaniu.

Problem z null w Javie

Zacznijmy od typowego problemu. Masz serwis do obsługi użytkowników i chcesz wysłać powiadomienie:

public class UserService {
    private NotificationService notificationService;
    
    public void processUser(User user) {
        // Sprawdzenia null wszędzie!
        if (user != null) {
            if (user.getEmail() != null) {
                if (notificationService != null) {
                    notificationService.sendEmail(user.getEmail(), "Welcome!");
                }
            }
        }
        
        // Jeszcze więcej logiki z null checks...
        if (user != null && user.getPreferences() != null) {
            // Przetwarzanie preferencji
        }
    }
}

Czym jest wzorzec Null Object

Null Object to wzorzec projektowy który rozwiązuje problem sprawdzeń null. Zamiast zwracać null, zwracamy obiekt który implementuje ten sam interfejs, ale ma „puste” zachowanie.

Podstawowa struktura wygląda tak:

// 1. Interfejs definiujący operacje
public interface NotificationService {
    void sendEmail(String email, String message);
    void sendSMS(String phone, String message);
}

// 2. Konkretna implementacja
public class EmailNotificationService implements NotificationService {
    @Override
    public void sendEmail(String email, String message) {
        System.out.println("Sending email to: " + email);
        // Prawdziwa logika wysyłania
    }
    
    @Override
    public void sendSMS(String phone, String message) {
        System.out.println("Sending SMS to: " + phone);
        // Prawdziwa logika wysyłania
    }
}

// 3. Null Object - "nic nie robi"
public class NullNotificationService implements NotificationService {
    @Override
    public void sendEmail(String email, String message) {
        // Nic nie rób - ale nie rzucaj wyjątku
    }
    
    @Override
    public void sendSMS(String phone, String message) {
        // Nic nie rób - ale nie rzucaj wyjątku  
    }
}

Implementacja w praktyce

Teraz możemy przepisać nasz UserService bez sprawdzeń null:

public class UserService {
    private NotificationService notificationService;
    
    public UserService(NotificationService notificationService) {
        // Jeśli null, użyj Null Object
        this.notificationService = notificationService != null ? 
            notificationService : new NullNotificationService();
    }
    
    public void processUser(User user) {
        // Brak sprawdzeń null!
        notificationService.sendEmail(user.getEmail(), "Welcome!");
        
        // Kod jest czytelniejszy i prostszy
        processUserPreferences(user.getPreferences());
    }
    
    private void processUserPreferences(UserPreferences preferences) {
        // Tutaj też możemy użyć Null Object pattern
        preferences.applyTheme(); // Bez sprawdzania czy preferences != null
    }
}

Wzorzec Factory dla Null Objects

Często warto stworzyć fabrykę która zwraca odpowiedni obiekt:

public class NotificationServiceFactory {
    private static final NotificationService NULL_SERVICE = new NullNotificationService();
    
    public static NotificationService create(boolean emailEnabled) {
        if (emailEnabled) {
            return new EmailNotificationService();
        }
        return NULL_SERVICE; // Zamiast null
    }
    
    public static NotificationService nullObject() {
        return NULL_SERVICE;
    }
}

Kiedy używać wzorca Null Object

Dobre przypadki użycia:

• Logowanie: NullLogger gdy nie chcesz logować
• Powiadomienia: NullNotifier gdy powiadomienia są wyłączone
• Cache: NullCache gdy cache jest wyłączony
• Walidacja: NullValidator gdy walidacja nie jest potrzebna

Kiedy NIE używać:

• Gdy null ma znaczenie semantyczne (np. „nie znaleziono”)
• Gdy potrzebujesz różnych reakcji na brak obiektu
• Gdy „nic nie robienie” może maskować prawdziwe problemy

Przykład z życia – Logger

Klasyczny przykład to system logowania:

public interface Logger {
    void info(String message);
    void error(String message);
    void debug(String message);
}

public class ConsoleLogger implements Logger {
    @Override
    public void info(String message) {
        System.out.println("INFO: " + message);
    }
    
    @Override
    public void error(String message) {
        System.err.println("ERROR: " + message);
    }
    
    @Override
    public void debug(String message) {
        System.out.println("DEBUG: " + message);
    }
}

public class NullLogger implements Logger {
    @Override
    public void info(String message) { /* nic */ }
    
    @Override
    public void error(String message) { /* nic */ }
    
    @Override
    public void debug(String message) { /* nic */ }
}

// Użycie
public class OrderService {
    private Logger logger;
    
    public OrderService(boolean loggingEnabled) {
        this.logger = loggingEnabled ? 
            new ConsoleLogger() : new NullLogger();
    }
    
    public void processOrder(Order order) {
        logger.info("Processing order: " + order.getId());
        
        // Logika biznesowa
        
        logger.info("Order processed successfully");
    }
}

Zalety i wady wzorca

Przydatne zasoby:

• Oracle Java 8 Documentation
• Null Object Pattern – Refactoring Guru
• Special Case Pattern – Martin Fowler

Czy używasz już wzorca Null Object w swoich projektach? A może masz pytania o jego implementację? Podziel się w komentarzach!