Cześć!

Napisałem prosty Page Controller(jeśli można to tak nazwać) - namespace->class->method. Zastanawiam się nad parametrami metody przekazywanymi w url przy użyciu Reflection Api - mam na myśli akcje w postaci:

/user/show/{id_usera} - które trzeba skądś wziąć

Nie wiem, czy to aby mądre(bezpieczne), czy też nie można by zrobić tego inaczej - łatwiej.
Ogólnie rzecz biorąc proszę też o ocenę całości, jakąś podpowiedź, co mogę zmienić, dodać, czy też całość jest nie tak i naprowadzenie na jakąś inną koncepcję.

PageController:

[PHP] pobierz, plaintext 
<?php
 
class PageController extends AbstractController
{
    /**
     * @var array
     * @Description :
     */
    private $path = [];
 
    /**
     * @var array
     * @Description : store function class parameters if exist
     */
    private $paramters = [];
 
    /**
     * @Constructor : PageController
     * @param : $namespace
     * @Description : collect the address path from @Class Request
     *                induction @Method init to create the path
     */
    public function __construct($namespace)
    {
        $path = new Request();
        $this->init($path, $namespace);
    }
 
    /**
     * @Method : init
     * @param Request : $address - initializes address path
     * @param : $namespace - namespace of class which will be including
     * @Description : create controller path and his action + params if exists
     *                induction @Method doIfExist for the action
     */
    private function init(Request $address, $namespace)
    {
        $this->path = $address->getAll();
 
        if (!empty($namespace)) {
            $namespace = filter_var($namespace, FILTER_SANITIZE_STRING);
        }
 
        $controller = $namespace.$this->path[0];
        $controller = str_replace("/", "\\", $controller);
        !empty($this->path[1]) ? $action = $this->path[1] : $action = '';
 
        $quantity = count($this->path);
 
        if ($quantity > 2) {
            for ($i=2; $i<$quantity; $i++) {
                $this->paramters[] = $this->path[$i];
            }
            $this->doIfExist($controller, $action, $this->paramters);
        } else {
            $this->doIfExist($controller, $action);
        }
    }
 
    /**
     * @Method : doIfExist
     * @param : $controller - class path with namespace
     * @param : $action - class action
     * @param : null $other - action parameters
     * @Description : check that @Class $controller and his @Method $action are exist
     *                ...
     */
    private function doIfExist($controller, $action, $other=null)
    {
        if (class_exists($controller) && method_exists($controller, $action)) {
            $controller = new $controller();
 
            // Odzielić
            $reflection = new \ReflectionClass($controller);
            $method = $reflection->getMethod($action);
            $params = $method->getParameters();
 
            //dodać ilość parametrów
            if (!empty($params) && !empty($other)) {
                $controller->$action($other);
            } else {
                $controller->$action();
            }
 
        } else {
            self::error404();
        }
    }
}
 
// uzycie
new PageController('namespace/');
 
[PHP] pobierz, plaintext 

Request:

[PHP] pobierz, plaintext 
<?php
 
class Request
{
    /**
     * @const : string
     * @Description : store default application path
     */
    const DEFAULT_PATH = 'index';
 
    /**
     * @var : array
     * @Description : store address elements from PATH_INFO
     */
    private $feedback = [];
 
    /**
     * @Constructor : Request
     * @Arguments : none
     * @Description : induction @Method init
     */
    public function __construct()
    {
        $this->init();
    }
 
    /**
     * @Method : init
     * @Arguments : none
     * @Description : Function which initialize address table @var $feedback
     */
    private function init()
    {
        $path_info = trim($_SERVER['PATH_INFO'], '/');
        if (!empty($path_info)) {
            $this->feedback = explode('/',$path_info);
            $count = count($this->feedback);
 
            for ($i=0; $i<$count; $i++) {
                $this->feedback[$i] = filter_var($this->feedback[$i], FILTER_SANITIZE_STRING);
            }
        } else {
            $this->setBasic();
        }
    }
 
    /**
     * @Method : setBasic
     * @Arguments : none
     * @Description : Function to set default path(class and method), if PATH_INFO does not exist
     */
    private function setBasic()
    {
        if (empty($this->feedback[0]) && empty($this->feedback[1])) {
            $this->feedback[0] = static::DEFAULT_PATH;
            $this->feedback[1] = static::DEFAULT_PATH;
        }
    }
 
    /**
     * @Method : getAll
     * @Arguments : none
     * @Description : Function return address path @var $feedback
     * @return array
     */
    public function getAll()
    {
        return $this->feedback;
    }
}
[PHP] pobierz, plaintext 

Pozdrawiam,
szubi

Koncepcja nie jest zła, ale o bezpieczeństwie będzie decydowało to, co chcesz osiągnąć. W przypadku takiego kontrolera warto obsłużyć wartość domyślną (/user/show), wartość błędną (/user/show/wrongId) itp. Co do bezpieczeństwa, niestety, ale musisz uważać. Newralgiczne elementy umieść poza routerem, umieść wszystkie dozwolone z zewnątrz obiekty w jakiejś zbiorczej przestrzeni nazw, kontroler niech z definicji odwołuje się tylko do tej przestrzeni (pamiętaj, że możesz tworzyć namespace w wielu poziomach, niech tu będzie np. '\\ForWeb\\'.$namespace wtedy z poziomu klas wywyoływanych z kontrolera będziesz miał dojście do klas 'niewidocznych' dla postronnych