Trennung von Belangen (SoC)

Wichtige Implementierungsbeispiele

1. Trennung der Datenbankebene

// Bad - Mixed concerns
class User {
    public function save() {
        $db = new PDO('mysql:host=localhost;dbname=app', 'user', 'pass');
        $stmt = $db->prepare("INSERT INTO users (name, email) VALUES (?, ?)");
        $stmt->execute([$this->name, $this->email]);
    }
}

// Good - Separated database logic
class User {
    private string $name;
    private string $email;
}

class UserRepository {
    private PDO $db;

    public function save(User $user) {
        $stmt = $this->db->prepare("INSERT INTO users (name, email) VALUES (?, ?)");
        $stmt->execute([$user->getName(), $user->getEmail()]);
    }
}

Das gute Beispiel trennt die Datenstruktur (Benutzer) von der Speicherlogik (UserRepository). Dies macht den Code wartbarer und ermöglicht das Ändern der Speichermethode, ohne die Benutzerklasse zu ändern.

2. Validierungstrennung

// Bad - Mixed validation and business logic
class Order {
    public function process() {
        if (empty($this->items)) {
            throw new Exception('Order cannot be empty');
        }
        if ($this->total getItems())) {
            $errors[] = 'Order cannot be empty';
        }
        if ($order->getTotal() 



<p>Die Validierungslogik wird in eine dedizierte Validatorklasse verschoben, sodass sich die Order-Klasse auf die Geschäftslogik konzentrieren kann.</p>

<h3>
  
  
  3. Ansichts-/Vorlagentrennung
</h3>



<pre class="brush:php;toolbar:false">// Bad - Mixed HTML and logic
class ProductPage {
    public function show($id) {
        $product = $this->getProduct($id);
        echo "<h1 id="product-gt-name">{$product->name}</h1>";
        echo "<p>Price: ${$product->price}</p>";
    }
}

// Good - Separated presentation
class ProductController {
    public function show($id) {
        $product = $this->productRepository->find($id);
        return $this->view->render('product/show', ['product' => $product]);
    }
}

// product/show.php template
<h1 id="htmlspecialchars-product-gt-name-gt">= htmlspecialchars($product->name) ?></h1>
<p>Price: $= htmlspecialchars($product->price) ?></p>

Das gute Beispiel trennt die Anzeigelogik in Vorlagen, wodurch der Code wartbarer wird und Designer unabhängig arbeiten können.

4. Trennung der Serviceschicht

// Bad - Mixed business logic
class OrderController {
    public function checkout() {
        $order = new Order($_POST['items']);
        $payment = new Payment($_POST['card']);
        $payment->process();
        $order->updateStatus('paid');
        $email = new EmailService();
        $email->sendConfirmation($order);
    }
}

// Good - Separated services
class OrderService {
    private PaymentService $paymentService;
    private EmailService $emailService;

    public function processOrder(Order $order, PaymentData $paymentData): void {
        $this->paymentService->process($paymentData);
        $order->updateStatus('paid');
        $this->emailService->sendConfirmation($order);
    }
}

class OrderController {
    public function checkout() {
        $this->orderService->processOrder($order, $paymentData);
    }
}

Die Serviceschicht verwaltet komplexe Geschäftslogik und sorgt dafür, dass sich der Controller auf die Anforderungsbearbeitung konzentriert.

5. Konfigurationstrennung

// Bad - Hardcoded configuration
class EmailSender {
    private $host = 'smtp.example.com';
    private $port = 587;

    public function send($message) {
        // Sending logic using hardcoded values
    }
}

// Good - Separated configuration
// config/mail.php
return [
    'host' => 'smtp.example.com',
    'port' => 587
];

class EmailSender {
    private array $config;

    public function __construct(array $config) {
        $this->config = $config;
    }

    public function send($message) {
        // Sending logic using config values
    }
}

Die Konfiguration ist von der Implementierung getrennt, wodurch der Code flexibler und wartbarer wird. Einstellungen können geändert werden, ohne den Code zu ändern.

Das obige ist der detaillierte Inhalt vonTrennung von Belangen (SoC). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!