欢迎来到PHP SOLID重构大师班！（轻松诙谐版）

大家好，欢迎来到今天的讲座！今天我们要聊的是如何用PHP中的SOLID原则来优化和重构代码。如果你还在写那种“一坨泥”的代码，那今天的内容可能会让你大开眼界。别担心，我会尽量让这堂课轻松有趣，毕竟编程不就是为了快乐嘛！

---

什么是SOLID？

SOLID是面向对象设计的五大原则的缩写，每个字母都代表一个重要的原则：

• S – Single Responsibility Principle (单一职责原则)
• O – Open/Closed Principle (开闭原则)
• L – Liskov Substitution Principle (里氏替换原则)
• I – Interface Segregation Principle (接口隔离原则)
• D – Dependency Inversion Principle (依赖倒置原则)

听起来很复杂？别急，我们一个个拆解，用PHP代码来讲解。

---

第一节课：单一职责原则 (SRP)

问题场景

假设你正在写一个简单的用户管理系统，你的代码可能看起来像这样：

class User {
    public $name;
    public $email;

    public function __construct($name, $email) {
        $this->name = $name;
        $this->email = $email;
    }

    public function save() {
        // 数据库保存逻辑
        echo "Saving user to database...n";
    }

    public function sendWelcomeEmail() {
        // 发送邮件逻辑
        echo "Sending welcome email to $this->email...n";
    }
}

这段代码的问题是什么？User类既负责保存数据，又负责发送邮件。这违反了单一职责原则。

解决方案

我们可以将不同的职责拆分成独立的类：

class User {
    public $name;
    public $email;

    public function __construct($name, $email) {
        $this->name = $name;
        $this->email = $email;
    }
}

class UserRepository {
    public function save(User $user) {
        echo "Saving user {$user->name} to database...n";
    }
}

class EmailService {
    public function sendWelcomeEmail(User $user) {
        echo "Sending welcome email to {$user->email}...n";
    }
}

// 使用示例
$user = new User("Alice", "alice@example.com");
(new UserRepository())->save($user);
(new EmailService())->sendWelcomeEmail($user);

现在每个类只负责一件事，代码更清晰易懂。

---

第二节课：开闭原则 (OCP)

问题场景

假设你在写一个订单系统，支持多种支付方式。初始代码可能是这样的：

class Order {
    public function processPayment($type) {
        if ($type === 'credit_card') {
            echo "Processing credit card payment...n";
        } elseif ($type === 'paypal') {
            echo "Processing PayPal payment...n";
        }
    }
}

如果以后要添加新的支付方式，比如比特币，你需要修改processPayment方法。这违反了开闭原则。

解决方案

使用策略模式：

interface PaymentStrategy {
    public function pay();
}

class CreditCardPayment implements PaymentStrategy {
    public function pay() {
        echo "Processing credit card payment...n";
    }
}

class PayPalPayment implements PaymentStrategy {
    public function pay() {
        echo "Processing PayPal payment...n";
    }
}

class Order {
    private $paymentStrategy;

    public function setPaymentStrategy(PaymentStrategy $strategy) {
        $this->paymentStrategy = $strategy;
    }

    public function processPayment() {
        $this->paymentStrategy->pay();
    }
}

// 使用示例
$order = new Order();
$order->setPaymentStrategy(new CreditCardPayment());
$order->processPayment();

$order->setPaymentStrategy(new PayPalPayment());
$order->processPayment();

现在新增支付方式时，只需实现PaymentStrategy接口，无需修改现有代码。

---

第三节课：里氏替换原则 (LSP)

问题场景

假设你有一个Vehicle类，派生出Car和Bicycle类：

class Vehicle {
    public function drive() {
        echo "Driving...n";
    }
}

class Car extends Vehicle {
    public function drive() {
        echo "Driving a car...n";
    }
}

class Bicycle extends Vehicle {
    public function drive() {
        throw new Exception("Bicycles cannot drive!");
    }
}

问题来了：Bicycle重写了drive方法并抛出异常，这违反了里氏替换原则。

解决方案

重新设计继承关系：

class Vehicle {
    public function move() {
        echo "Moving...n";
    }
}

class Car extends Vehicle {
    public function move() {
        echo "Driving a car...n";
    }
}

class Bicycle extends Vehicle {
    public function move() {
        echo "Riding a bicycle...n";
    }
}

// 使用示例
$car = new Car();
$car->move();

$bicycle = new Bicycle();
$bicycle->move();

现在子类可以安全地替代父类。

---

第四节课：接口隔离原则 (ISP)

问题场景

假设你有一个Printer接口：

interface Printer {
    public function printDocument();
    public function scanDocument();
    public function faxDocument();
}

对于只能打印的设备来说，强制实现scanDocument和faxDocument显然是多余的。

解决方案

拆分接口：

interface PrintOnly {
    public function printDocument();
}

interface ScanOnly {
    public function scanDocument();
}

interface FaxOnly {
    public function faxDocument();
}

class BasicPrinter implements PrintOnly {
    public function printDocument() {
        echo "Printing document...n";
    }
}

class AllInOnePrinter implements PrintOnly, ScanOnly, FaxOnly {
    public function printDocument() {
        echo "Printing document...n";
    }

    public function scanDocument() {
        echo "Scanning document...n";
    }

    public function faxDocument() {
        echo "Faxing document...n";
    }
}

现在每个设备只实现它需要的功能。

---

第五节课：依赖倒置原则 (DIP)

问题场景

假设你有一个ReportGenerator类直接依赖于Database类：

class Database {
    public function fetchData() {
        return "Data from database";
    }
}

class ReportGenerator {
    private $database;

    public function __construct() {
        $this->database = new Database();
    }

    public function generate() {
        echo "Generating report with data: " . $this->database->fetchData() . "n";
    }
}

问题是：ReportGenerator紧耦合于Database，难以测试或更换数据源。

解决方案

引入接口：

interface DataSource {
    public function fetchData();
}

class Database implements DataSource {
    public function fetchData() {
        return "Data from database";
    }
}

class FileDataSource implements DataSource {
    public function fetchData() {
        return "Data from file";
    }
}

class ReportGenerator {
    private $dataSource;

    public function __construct(DataSource $dataSource) {
        $this->dataSource = $dataSource;
    }

    public function generate() {
        echo "Generating report with data: " . $this->dataSource->fetchData() . "n";
    }
}

// 使用示例
$report = new ReportGenerator(new Database());
$report->generate();

$report = new ReportGenerator(new FileDataSource());
$report->generate();

现在ReportGenerator可以灵活切换数据源。

---

总结

通过应用SOLID原则，我们可以写出更清晰、更可维护的PHP代码。虽然这些原则听起来很高大上，但它们的核心思想其实很简单：让代码更灵活、更易于扩展和测试。

希望今天的课程对你有所帮助！如果你觉得有趣，记得点赞支持哦！下次见啦~ 😄