RouterOne

Routeron

Eine unabhängige, benutzerfreundliche, erweiterbare und einfache Verständnis von PHP-Webanwendungs-URL-Routing-Bibliothek erweitert Ihr Entwicklungs-Toolkit oder lieferte Ihnen ein wenig Inspiration.

Merkmale

• Gruppierte Routen
• Laden von Routen-Map-Dateien
• URL -Domäne unterscheidbar
• Interner Support von Middleware
• Routenpfad -Präfix und Suffix -Anpassung

Anforderungen

• Php> = 7.0
• Eine Implementierung der Klasse-Autoloader hängt von Ihrem bevorzugten Lademechanismus ab, beispielsweise Loaderone (streng genommen ist es nicht erforderlich, nur aus Bequemlichkeit.)

Installation

Laden Sie den Quellcode herunter und platzieren Sie den richtigen Standort Ihres Projektverzeichnisses.

Grundnutzung

Holen Sie sich Router -Objektinstanz

 use RouterOne  Router ;

$ router = Router:: getInstance ();

Erstellen Sie die Routenkarte in einer einzelnen Datei und befinden sich in spezifischem Dir Ihres PRJECT in der Datei $this Informationen finden Sie in der Objektinstanz von Beton $router . Für die HTTP -Anforderungsverben, RouteOne nur Support GET , POST (richten Sie sich nur mit PHPs $ _get & $ _post an, um sich völlig auszudehnen, wenn Sie möchten oder notwendig sind.)

Zum Beispiel Foo.php . Routerone kann mehrere Routen -Map -Dateien unterstützen, z. B. frontend_route_map.php , backend_route_map.php ,.

 // Closure function call
$ this -> get ( ' / ' , function () {
    echo ' Hello! RouterOne ' ;
});

// `WelcomeController::hello()` call
$ this -> get ( ' / ' , [WeclomeController::class, ' hello ' ]);
  

Legen Sie den Verzeichnispfad der Route Map -Datei ein und laden Sie ihn. (Die Standardverwaltung der Routenkartendatei ist .php )

 $ router -> setIncludePath (` YOUR_ROUTE_MAP_FILE_DIR `);
$ router -> load ([ ' Foo ' ]); // Just file's name without extension

Oder rufen Sie so an

 $ router -> setIncludePath (` YOUR_ROUTE_MAP_FILE_DIR `)-> load ([ ' Foo ' ]); // Just file's name without extension

Versand ausführen und alle geladenen Routen aktivieren. Es wird das Ergebnis über die tatsächliche Route zurückgegeben.

 $ res = $ router -> dispatch ();

Erklärt

Fügen Sie eine Route hinzu

Controller Routenaktion:

 // Http GET
$ this -> get ( ' index ' , [ Controllers SiteController::class, ' index ' ]);

// Http POST
$ this -> post ( ' news/add ' , [ Controllers NewsController::class, ' add ' ]);

Schließroutenaktion:

 // Http GET
$ this -> get ( ' index ' , function () {
    /**
    * Some logic process code here
    */
});

// Http POST
$ this -> post ( ' news/add ' , function () {
    /**
    * Some logic process code here
    */
});

Anfrage Parameter

Mit Routenparametern werden dynamische Parameter mit {} verpackt und werden dann nach Reihenfolge des Erscheinens auf die Controller -Methode oder die Clousre -Funktionsparparatur übertragen.

 $ this -> get ( ' test/{param1}/{param2} ' , [ Controllers TestController::class, ' params ' ]);

class TestController
{
    public function params ( $ param1 , $ param2 )
    {
        // Some code ...
    }
}

 $ this -> get ( ' test/{param1}/{param2} ' , function ( $ param1 , $ param2 ) {
    // Some code
});

Middleware

Middleware sollte eine Implementierung MiddleWare RouteMiddleWareInterface sein.

Eine typische Klasse mit mittlerer Ware enthält eine handle() -Methode mit Routenaktion- $action Aktionsparameter, wie unten:

 use RouterOne  MiddleWare  RouteMiddleWareInterface ;

class AuthCheckMiddleWare implements RouteMiddleWareInterface
{
    public static function handle ( $ action )
    {
        if ( ! AdminUser::Logged) {
            exit ( ' Please login first. ' );
        }
        
        $ action ();
    }
}

In einigen Fällen möchten Sie möglicherweise einen Prozess nach der extremen Route Action durchführen. Stellen Sie einfach die Middle-War-Logik hinter $action() auf.

 use RouterOne  MiddleWare  RouteMiddleWareInterface ;

class AfterMiddleWare implements RouteMiddleWareInterface
{
    public static function handle ( $ action )
    {
        $ action ();
        
        echo ' This text will print after route action excuted. ' ;
    }
}

Wenn MiddleWare () über die middleware() -Methoden mit Middle Ware und CAN über grouped () von Router middleware() verfügt, verfügt die erste Parameter mit middle-ware und unterstützt hier mehr Middle-Wares, und die andere ist eine Verschlussfunktion, die gemeinsame Routenzuordnung enthalten.

 $ this -> middleware (
    [
        AuthCheckMiddleWare::class,
        ...
        . . .
    ], function () {
        $ this -> get ( ' admin/index ' , [ Controllers  Admin AdminController::class, ' index ' ]);
        $ this -> get ( ' admin/news/list ' , [ Controllers  Admin NewsController::class, ' list ' ]);
        . . .
        . . .
});

Kann auch nested

 $ this ->middleware(
    [
        OuterMiddleWare::class,
        
    ], function () {
        . . .
        
        $ this ->middleware([
            InnerMiddleWare::class
        ], function () {
            $ this ->get(...
            $ this ->post(...
            . . .
        });
        
        ...
        . . .
});

Präfix & Suffix

prefix() und suffix() -Methode sind ebenfalls grouped Routen, sie können praktische Präfix und Suffix zu bestimmten Routen bequem hinzufügen.

Fügen Sie das Präfix static/ hinzu, dann werden urls ': // domain/static/page1', '// domain/static/Seite 2' übereinstimmen.

 $ this -> prefix ( ' static/ ' , function () {
    $ this -> get ( ' page1 ' , ...);
    $ this -> get ( ' page2 ' , ...);
    . . .
});

Fügen Sie das the hinzu, dann werden urls ': // domain/thePage1', '// domain/thePage2' übereinstimmen.

 $ this -> prefix ( ' the ' , function () {
    $ this -> get ( ' page1 ' , ...);
    $ this -> get ( ' page2 ' , ...);
    . . .
});

Fügen Sie das Suffix .html hinzu, wie prefix() mithilfe der Suffix .html, dann wechselt die URL zu ': //domain/page1.html'.

 $ this -> suffix ( ' .html ' , function () {
    $ this -> get ( ' page1 ' , ...);
    . . .
    . . .
});

Zwischen prefix() und suffix() können sich gegenseitig nested .

 $ this -> prefix ( ' static/ ' , function () {
    $ this -> get ( ' page1 ' , ...);  // request url '://domain/static/page1' matched here
    . . .
    
    $ this -> suffix ( ' .html ' , function () {
        $ this -> get ( ' page2 ' ,  ...); // request url '://domain/static/page2.html' matched here
    });
});

Domain einschränken

Wenn Ihre Anwendung über mehrere URL -Domäne verfügt, kann domain() -Methode diese Domäne unterscheiden und die Anforderung an die entsprechende Routengruppe leiten.

 $ this -> domain ( ' www.hereisyoursite.com ' , function () { // PC Pages
    $ this -> get ( ' index ' , ...);
    . . .
});
            
$ this -> domain ( ' m.hereisyoursite.com ' , function () { // Mobile Pages
    $ this -> get ( ' index ' , ...);
    . . .
    
});



$ this -> domain ( ' new.hereisyoursite.com ' , function () { // Current Domain routes
    $ this -> get ( ' index ' , ...);
    . . .
});
            
$ this -> domain ( ' old.hereisyoursite.com ' , function () { // Legacy Domain routes
    $ this -> get ( ' index ' , ...);
    . . .
    
});