PHP Slim Framework Créer Contrôleur

Je suis en création d'une API à l'aide de la Slim framework. Actuellement, je utiliser un seul fichier à créer la voie et de passer une fermeture à elle:

$app->get('/', function($req, $resp){
//Code...
})

Mais je me rends compte que mon dossier a connu une croissance rapide. Ce que je veux faire est d'utiliser des contrôleurs de la place, donc je vais avoir une classe de contrôleur et il suffit de passer l'instance/méthodes statiques pour la route, comme ci-dessous

class HomeController
{
   public static function index($req, $resp){}
}

et passer ensuite la fonction de la route

$app->get('/', HomeController::index);

J'ai essayé ceci, mais il ne fonctionne pas, et je me demande si il ya une manière que je peux l'utiliser pour gérer mes fichiers.

OriginalL'auteur James Okpe George | 2015-12-30

  1. 9

    Tournez le régulateur dans un foncteur:

    class HomeController
{
    public function __invoke($req, $resp) {}
}

    puis route comme ceci:

    $app->get('/', HomeController::class);

    Pour référence, voir

    Le dossier qui est utilisé pour ajouter un contrôleur ?

    OriginalL'auteur localheinz

  2. 2

    PHP 5.6
    Slim 2.6.2 

    require 'vendor/autoload.php';

class HelloController {
    public static function index()  {
        global $app;

        echo "<pre>";
        var_dump($app->request);
        echo "</pre>";
    }
}

$app = new \Slim\Slim();
$app->get('/', 'HelloController::index');
$app->run();

    Mise à jour: PHP 5.6 Slim 3.0.0

    require 'vendor/autoload.php';

class HelloController {
    public static function hello(\Slim\Http\Request $req, \Slim\Http\Response $response, $args)  {
        echo "<pre>";
        var_dump($args);
        echo "</pre>";
    }
}

$app = new \Slim\App();
$app->get('/hello/{name}', 'HelloController::hello');
$app->run();

    Le problème avec la classe de routage basé sur la Slim 3.0 est l'accès à $this/$app. Je pense que vous aurez besoin d'utiliser global $app pour y accéder.

    Dans mon projet de compagnie-je utiliser les groupes de routes avec require_once. Quelque chose comme

    $app->group('/dashboard', function () {
    $this->group('/auctions', function () use ($app){
        require_once('routes/dashboard/auctions.php');
    });
    $this->group('/rss', function () {
        require_once('routes/dashboard/rss.php');
    });
    $this->group('/settings', function () {
        require_once('routes/dashboard/settings.php');
    });
});

    Ne semble pas que la beauté qu'elle pourrait l'être avec les classes pures, mais fonctionne comme prévu avec toutes les fonctionnalités accessibles sans code supplémentaire.

    Si vous sous-classe slim\application et inclure le fichier de route à l'intérieur, alors vous pouvez utiliser $this de façon constante tout au long de la route de configuration. J'ai ajouté un exemple ici stackoverflow.com/questions/41981048/... en outre, il serait possible d'avoir un itinéraire de configuration de la classe qui prend la Demande en tant que constructeur de dépendance
    lorsque vous utilisez le bon espace de noms et d'utiliser composer, vous ne devez pas appeler require() sur votre propre parce que autoload.php va le faire pour vous.

    OriginalL'auteur CrazyCrow

  3. 2

    Lisse & court chemin pour utiliser un contrôleur comme un objet (pas de manière statique)

    dans index.php

    namespace MyApp;

use \Psr\Http\Message\ServerRequestInterface as Request;
use \Psr\Http\Message\ResponseInterface as Response;

require __DIR__ . '/../vendor/autoload.php';

$app->get('/myroute', [new Controller\MyClass, 'get']); //<=== that is pretty short  and neat
$app->post('/myroute', [new Controller\MyClass, 'post']);
$app->map(['GET', 'POST'], '/myotherrout', [new Controller\MyOtherClass, 'run']);

    Contrôleur/Maclasse :

    namespace MyApp\Controller;

class MyClass{

    public function __construct(){
       //some code
    }

    public function get(\Slim\Http\Request $request, \Slim\Http\Response $response, $args = []) {
       //some super foobar code
    }

    public function post(\Slim\Http\Request $request, \Slim\Http\Response $response, $args = []) {
       //some other code
    }

    Le Contrôleur\Maclasse est résolu grâce à l'utilisation du PSR autoload

    Contrôleur/MyOtherClass :

    namespace MyApp\Controller;

class MyOtherClass{

    public function __construct(){
       //some code
    }

    public function run(\Slim\Http\Request $request, \Slim\Http\Response $response, $args = []) {
       //some amazing foobar code
    }
    Très joli, en effet! Merci! Comment voulez-vous injecter un service directement dans le contrôleur sans passer par le conteneur à l'aide de cette?
    Bien que cela fonctionne, contrôleur de la création de l'instance devrait être fait à l'intérieur de dépendance conteneur d'inscription

    OriginalL'auteur Cedric

  4. 2

    Voici un exemple:

    Contrôleur de

    <?php

use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Message\ResponseInterface;
use Psr\Log\LoggerInterface;

/**
 * @property LoggerInterface $logger;
 */
class Controller
{
    /**
     * @var LoggerInterface
     */
    protected $logger

    /**
     * @param LoggerInterface $logger
     */
    public function __construct($logger)
    {
        $this->logger = $logger;
    }

    public function action(ServerRequestInterface $request, ResponseInterface $response, $args=[])
    {
        $this->logger->info((string)$request->getUri());
        /* some actions */
        return $response;
    }
}

    Application

    <?php

use Slim\App;
use Slim\Container;
use Psr\Container\ContainerInterface;

$autoloader = require(__DIR__.'/vendor/autoload.php');

$container = new Container();

$container['logger'] = function($container) {
    return new Logger();
}

$container['some.controller'] = function ($container) {
    /**
     * @var ContainerInterface $container
     */
    $logger = $container->get('logger');

    return new Controller($logger);
};

$app = new App($container);
$app->get('/some/route', 'some.controller:action');

$app->run();

    Profit!

    Cette méthode est décrite dans la documentation cliquez sur moi

    Je vous vois passer $logger pour le contrôleur, si vous ne voulez pas passer le conteneur?
    le passage d'un conteneur à un contrôleur est une mauvaise pratique. voir en.wikipedia.org/wiki/Single_responsibility_principle et en.wikipedia.org/wiki/Dependency_injection
    Je vous entends. Vous avez raison, que le récipient est trop grand pour glisser dans vos classes.

    OriginalL'auteur Ivan Dudarev

  5. 1

    Nikic Rapide de l'Itinéraire est très minime routeur, de sorte que certaines des subtilités de la plus grande de cadres sont supprimés. Voici une solution de base:

    routes.php

    use \Psr\Http\Message\ServerRequestInterface as Request;
use \Psr\Http\Message\ResponseInterface as Response;

$app->get('/', function($req, $resp, $args) use ($app){return FooBar::asdf($app, $req, $resp);});

    contrôleur
    utiliser \Psr\Http\Message\ServerRequestInterface de la Demande;
    utiliser \Psr\Http\Message\ResponseInterface comme Réponse;

    class FooBar{
    static public function asdf(Slim\App $app, Request $req, Response $resp, $args = [])
    {
        return $resp->withJson(['asf']);
    }
}

    OriginalL'auteur user3791372