minasrouter

Router @ minasrouter

minasrouter ist einfach, schnell und für Routen äußerst gut lesbar. Erstellen und verwalten Sie Ihre Routen in nur wenigen Schritten.

Einfach, schnell und SEHR funktional. minasrouter ist eine PHP-Routenkomponente für MVC-Projekte! Es wurde entwickelt, um die RESTfull-Verben (GET, POST, PUT, PATCH, DELETE) zu abstrahieren und auf einfache Weise im Anwendungscontroller darzustellen.

minasrouter arbeitet und verarbeitet alle Informationen isoliert, was den Prozess für den Entwickler erleichtert und die Entwicklung/den Fortschritt des Projekts beschleunigt.

Einfach, schnell und SEHR funktional. minasrouter ist eine PHP-Routenkomponente für MVC-Projekte! Es wurde entwickelt, um die RESTfull-Verben (GET, POST, PUT, PATCH, DELETE) zu abstrahieren und sie einfach und problemlos im Anwendungscontroller darzustellen.

minasrouter arbeitet und verarbeitet alle Informationen isoliert, was den Prozess für den Entwickler erleichtert und die Entwicklung/den Fortschritt des Projekts beschleunigt.

Highlights @ minasrouter

• In wenigen Minuten können Sie Routen für Ihre Anwendung oder API erstellen (Yes, it really is a few minutes)
• Schnelles und einfaches Middleware-System
• Respektieren Sie die RESTfull-Verben und verfügen Sie über großartige Funktionen, um mit ihnen umzugehen
• Routenanpassung, Regex in dynamischen Parametern und optionalen Parametern
• Spoofing zur Verbalisierung und Datenkontrolle (FormSpoofing)
• Überträgt dynamische Parameter zu Controller-Argumenten
• Einfache Weiterleitung von Gruppen und schnelle Erstellung
• Es verfügt über eine Anforderungsklasse zum Steuern und Arbeiten mit Routendaten

Mit zwei Linien beginnen Sie mit der Routennutzung!

Anwendungsbeispiel

Vielleicht sind Sie jemand, der durch Zuschauen lernt. Sie können auf den Beispielordner zugreifen, der ein Beispiel für die Ordnerarchitektur enthält, wie wir minasrouter verwenden.

Tests

Alle durchgeführten Tests können Sie hier einsehen. Genießen!

Installation

minasrouter ist über Composer require :

minasrouter": "^1.0" }">

 " require " {
    "nicollassilva/ minasrouter " : " ^1.0 "
}

oder im Terminal ausführen:

composer require nicollassilva/ minasrouter

Dokumentation

1.Konfiguration

• Zum öffentlichen Ordner umleiten

• Konfiguration öffentlicher Ordner

• Apache
• Nginx

2. Routen

• Meine erste Route
• RESTfull-Verben

• Anpassung

• Benannte Routen
• Dynamische Parameter (erforderlich und optional)
• Validieren eines dynamischen Parameters

• Middleware

• Legen Sie globale Middlewares fest
• In einer Route anhängen
• Löschen Sie die Middleware

• Routengruppen

• Alle Methoden
• Benannte Gruppe
• Gruppe mit Präfix
• Standard-Namespace-Gruppe
• Standard-Middleware-Gruppe
• Verschachtelte Gruppenmethoden

• Andere

• Routenumleitung
• Route mit individueller Middleware in der Gruppe
• Route mit anderem Namen in der Gruppe
• Fallback-Routen

3. Route anfordern

• Einführung

• Methoden

• RequestPath
• URL anfordern
• Anforderungsheader
• IP-Adresse anfordern
• Daten abrufen
• Anforderungsmethode

Einführung

Um minasrouter verwenden zu können, muss die gesamte Navigationsverwaltung auf die Standardroutendatei Ihres Systems umgeleitet werden, die den gesamten Routenverarbeitungsprozess ausführt und die standardmäßig konfigurierten Daten zurückgibt. Konfigurieren Sie gemäß den folgenden Beispielen und entsprechend Ihrem Server.

Um minasrouter verwenden zu können, muss die gesamte Navigationsverwaltung auf die Standardroutendatei Ihres Systems umgeleitet werden, die den gesamten Routenverarbeitungsprozess übernimmt und die Standardkonfiguration zurückgibt. Konfigurieren Sie gemäß den folgenden Beispielen und entsprechend Ihrem Server.

Zum öffentlichen Ordner umleiten

 RewriteEngine on
Options All -Indexes

RewriteCond %{HTTPS} on
RewriteCond %{HTTP_HOST} (www.)?localhost
RewriteRule (.*) https:// %{HTTP_HOST} [L,R=301]

RewriteCond %{REQUEST_URI} !public/
RewriteRule (.*) /public/$1 [L]

Apache

 RewriteEngine On
# Options All -Indexes

# Handle Authorization Header
RewriteCond %{HTTP:Authorization} .
RewriteRule .* - [E=HTTP_AUTHORIZATION:%{HTTP:Authorization}]

# URL Rewrite
RewriteCond %{SCRIPT_FILENAME} !-f
RewriteCond %{SCRIPT_FILENAME} !-d
RewriteRule ^(.*)$ index.php?route=/$1 [L,QSA]

# ## Do not use the settings below if you are using developing in a local environment, use only in production.

# # WWW Redirect
# RewriteCond %{HTTP_HOST} !^www. [NC]
# RewriteRule ^ https://www.%{HTTP_HOST}%{REQUEST_URI} [L,R=301]

# # HTTPS Redirect
# RewriteCond %{HTTP:X-Forwarded-Proto} !https
# RewriteCond %{HTTPS} off
# RewriteRule ^ https://%{HTTP_HOST}%{REQUEST_URI} [L,R=301]

Nginx

 location / {
  if ( $script_filename !~ "-f" ){
    rewrite ^(.*)$ /index.php?route=/ $1 break;
  }
}

Die erste Route

So starten Sie die Komponenten:

minasrouterRouterRoute; // The second argument is optional. It separates the Controller and Method from the string // Example: "Controller@method" Route::start("http://yourdomain.com", "@"); Route::get("/", function() { // ... }); // ... all routes here // You will put all your routes before this function Route::execute();">

 <?php
    require __DIR__ . " /../vendor/autoload.php " ;
    
use minasrouter  Router  Route ;

// The second argument is optional. It separates the Controller and Method from the string
// Example: "Controller@method"
Route:: start ( " http://yourdomain.com " , " @ " );

Route:: get ( " / " , function () {
    // ...
});

// ... all routes here

// You will put all your routes before this function
Route:: execute ();

RESTfull-Verben

Methoden:

Funktion	Parameter	Parameter	Parameter
erhalten	Zeichenfolge $uri	$Rückruf
Post	Zeichenfolge $uri	$Rückruf
setzen	Zeichenfolge $uri	$Rückruf
Patch	Zeichenfolge $uri	$Rückruf
löschen	Zeichenfolge $uri	$Rückruf
übereinstimmen	Array $httpVerbs	Zeichenfolge $uri	$Rückruf
beliebig	Zeichenfolge $uri	$Rückruf

Beispiel:

Route:: get ( ' /users ' , [ App  Controllers User::class, ' index ' ]);
Route:: post ( ' /users ' , [ App  Controllers User::class, ' store ' ]);
Route:: put ( ' /users/{id} ' , [ App  Controllers User::class, ' update ' ]);
Route:: patch ( ' /users/{id} ' , [ App  Controllers User::class, ' update ' ]);
Route:: delete ( ' /users/{id} ' , [ App  Controllers User::class, ' delete ' ]);

// The router allows you to register routes that respond to any HTTP verb:
Route:: any ( ' / ' , function () {
    // ...
});

// Sometimes you may need to register a route that responds to multiple HTTP verbs:
Route:: match ([ " GET " , " POST " ], " / " , function () {
    // ...
});

Benannte Routen

Methoden:

Funktion	Parameter
Name	Zeichenfolge $name
zum	Zeichenfolge $name

Beispiel:

Route:: get ( " /users/create " , function () {
    // ...
})-> name ( " user.create " );

Route:: get ( " /users/2 " , function () {
    // ...
})-> as ( " user.show " );

Dynamische Parameter (erforderlich und optional)

Route:: get ( " / " , function () {
    // ...
})-> name ( " web.index " );

Route:: get ( " /user/{id} " , function ( $ id ) {
    echo $ id ;
})-> name ( " user.show " );

Route:: get ( " /post/{id?} " , function ( $ id ) {
    if (! $ id ) {
        // ...
    }
    
    // ...
})-> name ( " post.show " );

Validierung eines dynamischen Parameters

Methoden:

Funktion	Parameter	Parameter
Wo	Array $params
whereParam	Zeichenfolge $param	String $regex
woNummer	Zeichenfolge $param
woAlpha	Zeichenfolge $param
whereAlphaNumeric	Zeichenfolge $param
whereUuid	Zeichenfolge $param

Beispiel:

Route:: get ( " /user/{id} " , [ App  Controllers UserController::class, " show " ])
    -> name ( " user.show " )
    -> where ([ " id " => " [0-9]+ " ]);

// whereParam is alias of where method
Route:: get ( " /profile/{slug} " , [ App  Controllers UserController::class, " profile " ])
    -> name ( " user.profile " )
    -> whereParam ( " id " , " [0-9]+ " );

Route:: get ( " /book/{id} " , [ App  Controllers BookController::class, " show " ])
    -> name ( " book.show " )
    -> whereNumber ( " id " );

Middleware

Die Arbeit mit Middleware ist hier ziemlich einfach. Wir müssen lediglich die vollständigen Namen der Klassen übergeben oder sie als global festlegen, und von dort aus verwenden wir ihren Alias.

Legen Sie globale Middlewares fest

HINWEIS: Es ist wichtig, dass Sie alle Routen unten platzieren. Bei Routen oberhalb dieser Klasse sind diese Middlewares nicht global.

Route:: globalMiddlewares ([
    ' isLogged ' =>  App  Middlewares isLogged::class,
    ' isAdmin ' =>  App  Middlewares isAdmin::class
]);

// ... all routes

In einer Route anhängen

Sie können die Middleware-Methode verwenden, um einer Route Middleware zuzuweisen.

Route:: get ( " /musics " , function () {
    // ...
})-> middleware ( " isLogged " );

Route:: get ( " /musics " , function () {
    // ...
})-> middleware ([ " isLogged " ]);

Sie können der Route mehrere Middleware zuweisen, indem Sie der Middleware-Methode ein Array von Middleware-Namen übergeben.

Route:: get ( " /musics " , function () {
    // ...
})-> middleware ( " first, second " );

Route:: get ( " /movies " , function () {
    // ...
})-> middleware ([ " first " , " second " ]);

Bei der Zuweisung von Middleware können Sie auch den vollständig qualifizierten Klassennamen übergeben:

 use App  Middlewares  VerifyCsrfToken ;

Route:: get ( " /series " , function () {
    // ...
})-> middleware (VerifyCsrfToken::class);

Route:: get ( " /series " , function () {
    // ...
})-> middleware ( App  Middlewares VerifyCsrfToken::class);

Löschen Sie die Middleware

Manchmal erstellen Sie eine Gruppe von Routen mit Middleware, möchten aber, dass nur eine oder einige Routen keine bestimmte Middleware haben. Das ist möglich.

Route:: middleware ([ ' auth ' , ' api ' ])-> group ( function () {
    Route:: get ( ' / ' , function () {
        // All middlewares will works in this route
    });
    
    Route:: get ( ' /no-api ' , function () {
        // Only the auth middleware works here
    })-> withoutMiddleware ( ' api ' );
});

Routengruppen

Alle Methoden:

Funktion	Parameter	::Funktion	->Funktion
Namensraum	Zeichenfolge $namespace	Ja	Ja
Präfix	Zeichenfolge $präfix	Ja	Ja
Name	Zeichenfolge $name	Ja	Ja
Middleware	String $middlewares	Ja	Ja

Gruppenmethoden können statisch oder normal aufgerufen werden. Vergessen Sie nicht, eine Funktionsgruppe aufzurufen, um sie als Routen innerhalb des Abschlusses einzufügen.

Beispiele:

benannte Gruppe

Route:: name ( " admin. " )-> group ( function () {
    Route:: get ( " / " , function () {
        // admin.index
    })-> name ( " index " );
});

vorangestellte Gruppe

Route:: prefix ( " admin/ " )-> group ( function () {
    Route:: get ( " /index " , function () {
        // http://localhost/admin/index
    })-> name ( " index " );
});

Standard-Namespace-Gruppe

Route:: namespace ( " AppControllers " )-> group ( function () {
    Route:: get ( " /user/{id} " , [ " User " , " show " ])-> name ( " show " );
    // AppControllersUser
});

Standard-Middleware-Gruppe

Route:: middleware ( App  Middlewares isLogged::class)-> group ( function () {
    Route:: get ( " /user/{id} " , [ " User " , " show " ])-> name ( " show " );
});

Verschachtelte Gruppenmethoden

Route:: namespace ( " AppControllersAdmin " )
    -> middleware ([ " isLogged " , " isAdmin " ])
    -> name ( " admin. " )
    -> prefix ( " admin " )
    -> group ( function () {
    // ...
});

Andere

Route mit individueller Middleware in der Gruppe

Sie können Routen mit einzelnen Middlewares innerhalb einer Routengruppe verwenden.

Route:: namespace ( " isLogged " )-> group ( function () {
    Route:: get ( " /posts " , function () {
        // ...
    })-> middleware ( " isAdmin " );
    
    // ...
});

Route mit anderem Namen in der Gruppe

Möglicherweise möchten Sie eine Route, bei der Sie den Gruppennamen ignorieren. Dazu können Sie den zweiten Parameter der Namensmethode verwenden.

Route:: name ( " admin. " )-> group ( function () {
    Route:: get ( " /posts " , function () {
        // name: app.posts
    })-> name ( " app.posts " , true );
});

Routenumleitung

Methoden:

Funktion	Parameter	Parameter	Parameter
umleiten	Zeichenfolge $uri	Zeichenfolge $redirect	Int $statusCode = 302
permanentRedirect	Zeichenfolge $uri	Zeichenfolge $redirect

Beispiel:

 // Returns 302 status code by default.
Route:: redirect ( " /here " , " /there " );

Route:: redirect ( " /here " , " /there " , 301 );

// permanentRedirect always returns 301
Route:: permanentRedirect ( " /here " , " /there " );

// You can return an existing route
Route:: redirect ( " /index " , " web.index " );

Fallback-Routen

Die Fallback-Route ist verantwortlich, wenn mit dieser URL-Adresse keine Route registriert ist. Immer wenn keine vom Benutzer angeforderte Route vorhanden ist, wird die Fallback-Route aufgerufen.

Route:: fallback ( function () {
    echo ' Route error! ' ;
    // ...
});

HINWEIS: Seien Sie vorsichtig, wenn Sie zu einer vorhandenen Route umleiten möchten. Wenn diese dynamische Argumente enthält, wird der gesamte reguläre Ausdruck zurückgegeben und ein Fehler verursacht.

Seien Sie vorsichtig, wenn Sie auf eine vorhandene Route umleiten, denn wenn diese über dynamische Argumente verfügt, wird der gesamte reguläre Ausdruck zurückgegeben und ein Fehler zurückgegeben.

Route anfordern

Jedes Mal, wenn die Route aufgerufen wird und die Closure- oder Controller-Methode aufgerufen wird, haben Sie als Parameter eine Instanz von minasrouter HttpRequest. Wenn die Route über dynamische Parameter (obligatorisch oder optional) verfügt, müssen diese vor dem Empfang der Request-Instanz übergeben werden.

Funktion	Parameter	Parameter
getParams
Weg
URL
fullUrl
Kopfzeile	Zeichenfolge $header	Zeichenfolge $default
hasHeader	Zeichenfolge $header
IP
Abfrage	?String $query	?String $default
alle	?String $außer
getMethod
istMethode	Zeichenfolge $expectedMethod

Die dynamischen Parameter der Route werden zusammen mit einer Instanz von Request direkt in der Methode übergeben.

Beispiel:

minasrouterHttpRequest; Route::get("/", function(Request $request)) { // ... }); Route::get("/user/{id}", function($id, Request $request)) { // ... }); Route::get("/posts/{slug?}", function($slug, Request $request)) { // ... }); Route::get("/book/{slug}", function($slug, Request $request) { // Retrieving all dynamic parameters print_r($request->getParams()); }); ">

 use  minasrouter  Http  Request ;

Route:: get ( " / " , function ( Request $ request )) {
   // ... 
});

Route:: get ( " /user/{id} " , function ( $ id , Request $ request )) {
   // ... 
});

Route:: get ( " /posts/{slug?} " , function ( $ slug , Request $ request )) {
   // ... 
});

Route:: get ( " /book/{slug} " , function ( $ slug , Request $ request ) {
    // Retrieving all dynamic parameters
    print_r ( $ request -> getParams ());
});

Die Request-Methode ist die Methode, die alle Ihre Formulardaten, Abfrageparameter, dynamischen Routenparameter und den gesamten Anforderungsheader enthält.

Anforderungsmethoden

Abrufen des Anforderungspfads

Die Pfadmethode gibt die Pfadinformationen der Anfrage zurück. Wenn die eingehende Anfrage also auf http://localhost/foo/bar abzielt, gibt die Pfadmethode foo/bar zurück:

 $ uri = $ request -> path ();

Abrufen der Anforderungs-URL

Um die vollständige URL für die eingehende Anfrage abzurufen, können Sie die Methoden url oder fullUrl verwenden. Die URL -Methode gibt die URL ohne die Abfragezeichenfolge zurück, während die fullUrl -Methode die Abfragezeichenfolge enthält:

 $ url = $ request -> url ();

$ urlWithQueryString = $ request -> fullUrl ();

Header anfordern

Mit der Header-Methode können Sie einen Anforderungsheader von der minasrouter HttpRequest- Instanz abrufen. Wenn der Header in der Anfrage nicht vorhanden ist, wird null zurückgegeben. Die Header-Methode akzeptiert jedoch ein optionales zweites Argument, das zurückgegeben wird, wenn der Header in der Anfrage nicht vorhanden ist:

 $ value = $ request -> header ( " Header-Name " );

$ value = $ request -> header ( " Header-Name " , " default " );

Die Methode hasHeader kann verwendet werden, um festzustellen, ob die Anfrage einen bestimmten Header enthält:

 if ( $ request -> hasHeader ( " Header-Name " )) {
    // ...
}

Die Methode „bearerToken“ kann verwendet werden, um ein Bearer-Token aus dem Authorization-Header abzurufen. Wenn kein solcher Header vorhanden ist, wird null zurückgegeben.

 $ token = $ request -> bearerToken ();

IP-Adresse anfordern

Die IP -Methode kann verwendet werden, um die IP-Adresse des Clients abzurufen, der die Anfrage an Ihre Website gestellt hat:

 $ ipAddress = $ request -> ip ();

Daten abrufen

Die Abfragemethode ruft nur Werte aus der Abfragezeichenfolge ab:

 $ id = $ request -> query ( " id " );

Wenn die angeforderten Abfragezeichenfolgenwertdaten nicht vorhanden sind, wird das zweite Argument dieser Methode zurückgegeben:

 $ developer = $ request -> query ( " developer " , " Nicollas " );

Sie können die Abfragemethode ohne Argumente aufrufen, um alle Abfragezeichenfolgenwerte abzurufen.

 $ query = $ request -> query ();

Sie können direkt auf queryStrings und Eingabedaten zugreifen, wie auf Eigenschaften der Request-Klasse.

minasrouter"> $title = $request->title;">

 // http://localhost/?foo=bar

$ foo = $ request -> foo ;

// <input type="text" name="title" value=" minasrouter ">

$ title = $ request -> title ;

Mit der all-Methode können Sie alle Eingabedaten der eingehenden Anfrage als Array abrufen. Diese Methode kann unabhängig davon verwendet werden, ob die eingehende Anfrage von einem HTML-Formular stammt oder eine XHR-Anfrage ist. Wenn Sie einige Daten ungültig machen möchten, können Sie sie als zweiten Parameter übergeben.

 $ data = $ request -> all ();

// all, except csrf_token, page
$ data = $ request -> all ( " csrf_token, page " );

Abrufen der Anforderungsmethode

Die getMethod -Methode gibt das HTTP-Verb für die Anfrage zurück. Sie können die Methode isMethod verwenden, um zu überprüfen, ob das HTTP-Verb mit einer bestimmten Zeichenfolge übereinstimmt:

 $ httpMethod = $ request -> getMethod ();

if ( $ request -> isMethod ( ' POST ' )) {
    // ...
}