PHP OOP工厂模式和开放/关闭原则

Question

我想用PHP OOP实现PHP通知系统。我有许多通知类型，每个通知将进行自定义工作，并在向用户显示通知之前检查用户设置。我添加通知抽象类以修复所有通知类型的通知行为。

abstract class Notification {     
    private $notificationType;
    
    public function __construct(int $type) {
      $this->notificationType=$type;
    }

    //put your code here
    public abstract function notify(array $user_settings);
}

然后，我使用这样的儿童课程扩展父母通知课：

    class AddRequestNotifiation extends Notification{
        //put your code here
        public function __construct() {
            parent::__construct(1);
        }
        public function notify(array $user_settings) {
            echo "custom ad request work here";
        }
    }

//----
class LikesNotification extends Notification{
    //put your code here
    public function __construct() {
        parent::__construct(2);
    }
    public function notify(array $user_settings) {
        echo "custom likes  work here";
    }
}

现在我想实现工厂模式。

class NotificationFactory {
    //put your code here    
    public static function buildNotification(int $type){
        if($type==1){
            return new AddRequestNotifiation();
        }else if($type==2){
            return new LikesNotification();
        }else{
           throw new Exception("not implemented");
        }
    }
}

然后在index.html中，

$notification= NotificationFactory::buildNotification(1);
$notification->notify([]);

我知道工厂很糟糕，因为它尊重O/C原理，我需要对其进行修改以添加新的通知类型，因此我选择了下面的另一种征用：

class NotificationFactory {
    //put your code here    
    private $notifications=array();
    
    public function addNotificationType(int $type, Notification  $n){
        if(!array_key_exists($type,$this->notifications)){
          $this->notifications[$type]=$n;  
        }
    }
    
    public function buildNotification(int $type):Notification{
        if(!array_key_exists($type,$this->notifications)){
            throw new Exception("Not Implemented");
        }else{
            return $this->notifications[$type];
        } 
    }
}

然后我填充了所有通知类型的工厂。

    spl_autoload_register(function($class){
       include $class .".php";
    });

    // initialisation
    $notification_factory= new NotificationFactory();
    $notification_factory->addNotificationType(1, new AddRequestNotifiation());
    $notification_factory->addNotificationType(2, new LikesNotification());
    // adding new custom notification
    $notification_factory->addNotificationType(12, new CustomNotification());
    
    /// then when Notification arrive
    $notification = $notification_factory->buildNotification(2);
    $notification->notify([]);

有了这种批准的O/C原理，但是使用Befaore的内存和Ressource存在很大的问题，即使我使用它们，我也必须将所有通知类型进行实例化。对此的优化解决方案是什么。

Answer 1

经过一些调查，我发现另一种模式女巫更适合我的要求，即尊重O/C原理，并且不使用太多记忆。这种模式不多使用，也称为代理。
在HAW下，我实现了它：

    interface NotificationInterface {
        //put your code here
        public function notify();
    }

class LikesNotification implements NotificationInterface{
    //put your code here
    public function notify() {
        echo "Likes Notification content".PHP_EOL;
    }    
}

class AddRequestNotification implements NotificationInterface{
    //put your code here
    public function notify() {
        echo "Add Request Notification Content" .PHP_EOL;
    }    
}

然后我使用了通知代理类。为此，我使用魔术PHP方法__call（）Witch Fire（如果类的对象实例都使用类未在类中实现的方法调用）。

class NotificationProxy {    
    //put your code here
    protected $instance;
    
    public function __construct($type) {
       $class=$type."Notification";
       $this->instance=new $class();
    }
    
    public function __call($name, $arguments) {
        return call_user_func_array([$this->instance,$name],$arguments);
    }
}

然后，在index.php中，我仅致电JSON收到的适当通知类：

spl_autoload_register(function($class){
    include $class .".php";
});

/** we get incoming Notification JSON { 'type':'Likes'} **/
$notification_Proxy=new NotificationProxy("Likes");
$notification_Proxy->notify();

/** if incoming Notification JSON has type { 'type':'AddRequest'} **/
$notification_Proxy=new NotificationProxy("AddRequest");
$notification_Proxy->notify();

这就是我希望该解决方案对其他人有帮助。