Schnell scheitern

Grundprinzip

Erkennen und melden Sie Fehler, sobald sie auftreten, und verhindern Sie so, dass sich ungültige Zustände im System verbreiten.

1. Eingabevalidierung

class UserRegistration {
    public function register(array $data): void {
        // Validate all inputs immediately
        $this->validateEmail($data['email']);
        $this->validatePassword($data['password']);
        $this->validateAge($data['age']);

        // Only proceed if all validations pass
        $this->createUser($data);
    }

    private function validateEmail(string $email): void {
        if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
            throw new ValidationException('Invalid email format');
        }
        if ($this->emailExists($email)) {
            throw new DuplicateEmailException('Email already registered');
        }
    }
}

Zweck:

• Verhindert, dass ungültige Daten in das System gelangen
• Spart Ressourcen durch Fehler vor komplexen Vorgängen
• Stellt Benutzern klare Fehlermeldungen zur Verfügung
• Erhält die Datenintegrität

2. Laden der Konfiguration

class AppConfig {
    private array $config;

    public function __construct(string $configPath) {
        if (!file_exists($configPath)) {
            throw new ConfigurationException("Config file not found: $configPath");
        }

        $config = parse_ini_file($configPath, true);
        if ($config === false) {
            throw new ConfigurationException("Invalid config file format");
        }

        $this->validateRequiredSettings($config);
        $this->config = $config;
    }

    private function validateRequiredSettings(array $config): void {
        $required = ['database', 'api_key', 'environment'];
        foreach ($required as $key) {
            if (!isset($config[$key])) {
                throw new ConfigurationException("Missing required config: $key");
            }
        }
    }
}

Zweck:

• Stellt sicher, dass die Anwendung mit einer gültigen Konfiguration startet
• Verhindert Laufzeitfehler aufgrund fehlender Einstellungen
• Macht Konfigurationsprobleme sofort sichtbar
• Vereinfacht das Debuggen von Konfigurationsproblemen

3. Ressourceninitialisierung

class DatabaseConnection {
    private PDO $connection;

    public function __construct(array $config) {
        try {
            $this->validateDatabaseConfig($config);
            $this->connection = new PDO(
                $this->buildDsn($config),
                $config['username'],
                $config['password'],
                [PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION]
            );
        } catch (PDOException $e) {
            throw new DatabaseConnectionException(
                "Failed to connect to database: " . $e->getMessage()
            );
        }
    }

    private function validateDatabaseConfig(array $config): void {
        $required = ['host', 'port', 'database', 'username', 'password'];
        foreach ($required as $param) {
            if (!isset($config[$param])) {
                throw new DatabaseConfigException("Missing $param in database config");
            }
        }
    }
}

Zweck:

• Stellt sicher, dass Ressourcen ordnungsgemäß initialisiert werden
• Verhindert, dass die Anwendung mit ungültigen Ressourcen ausgeführt wird
• Macht Ressourcenprobleme beim Start sichtbar
• Vermeidet kaskadierende Fehler aufgrund ungültiger Ressourcen

4. Externe Serviceanrufe

class PaymentGateway {
    public function processPayment(Order $order): PaymentResult {
        // Validate API credentials
        if (!$this->validateApiCredentials()) {
            throw new ApiConfigurationException('Invalid API credentials');
        }

        // Validate order before external call
        if (!$order->isValid()) {
            throw new InvalidOrderException('Invalid order state');
        }

        try {
            $response = $this->apiClient->charge($order);

            if (!$response->isSuccessful()) {
                throw new PaymentFailedException($response->getError());
            }

            return new PaymentResult($response);
        } catch (ApiException $e) {
            throw new PaymentProcessingException(
                "Payment processing failed: " . $e->getMessage()
            );
        }
    }
}

Zweck:

• Verhindert unnötige API-Aufrufe mit ungültigen Daten
• Spart Zeit und Ressourcen
• Bietet sofortiges Feedback zu API-Problemen
• Gewährleistet die Systemzuverlässigkeit bei Interaktionen mit externen Diensten

5. Datenverarbeitungspipelines

class DataProcessor {
    public function processBatch(array $records): array {
        $this->validateBatchSize($records);

        $results = [];
        foreach ($records as $index => $record) {
            try {
                $this->validateRecord($record);
                $results[] = $this->processRecord($record);
            } catch (ValidationException $e) {
                throw new BatchProcessingException(
                    "Failed at record $index: " . $e->getMessage()
                );
            }
        }

        return $results;
    }

    private function validateBatchSize(array $records): void {
        if (empty($records)) {
            throw new EmptyBatchException('Empty batch provided');
        }

        if (count($records) > 1000) {
            throw new BatchSizeException('Batch size exceeds maximum limit');
        }
    }
}

Zweck:

• Gewährleistet die Datenkonsistenz während der gesamten Verarbeitung
• Verhindert die teilweise Verarbeitung ungültiger Daten
• Macht Datenprobleme frühzeitig sichtbar
• Vereinfacht die Fehlerverfolgung in komplexen Pipelines
• Bewahrt die Datenintegrität über Transformationen hinweg

Vorteile von Fail Fast

1. Frühzeitige Fehlererkennung
2. Saubereres Debuggen
3. Verhindert kaskadierende Ausfälle
4. Erhält die Datenintegrität
5. Verbessert die Systemzuverlässigkeit

Best Practices

1. Verwenden Sie starke Typdeklarationen
2. Implementieren Sie eine gründliche Eingabevalidierung
3. Bestimmte Ausnahmen auslösen
4. Validieren Sie frühzeitig im Prozess
5. Behauptungen in der Entwicklung verwenden
6. Implementieren Sie die richtige Fehlerbehandlung
7. Fehler ordnungsgemäß protokollieren

Wann sollte Fail Fast verwendet werden?

1. Eingabevalidierung
2. Konfiguration wird geladen
3. Ressourceninitialisierung
4. Externe Serviceeinsätze
5. Datenverarbeitungspipelines

Das obige ist der detaillierte Inhalt vonSchnell scheitern. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!