WatishWEB
1.0.0
SWOOLE, Php
git clone https://github.com/Watish/WatishWEBcomposer create-project watish/watishweb:dev-masterDie Eintragsdatei des Projekts lautet project /bin/coserver.php
swoole-cli ./bin/CoServer.php php ./bin/CoServer.php
Erstellen Sie eine neue Klasse im SRC/Controller -Verzeichnis. Hier definieren wir sie als Hellocontroller
<?php
namespace Watish WatishWEB Controller ;
use Watish Components Attribute Path ;
use Watish Components Struct Request ;
class HelloController
{
#[Path( ' / ' )]
public function index ( Request $ request ) : array
{
return [
" msg " => " hello world "
];
}
}Starten Sie nach dem Speichern das Projekt und besuchen Sie http://127.0.0.1:9502/, um zu sehen
{ "msg" : " hello world " }Ist es nicht sehr einfach?
Im Gegensatz zum herkömmlichen PHP-FPM-Formular gibt es zwischen mehreren Prozessen eine Speicherisolierung , was bedeutet, dass der durch den Prozess A festgelegte variable Prozess B nicht abgerufen werden kann. Zusätzlich ist die Anfrage nicht isoliert . Das heißt, zwei Anfragen unter demselben Prozess, obwohl die Verarbeitungslogik in verschiedenen Coroutinen verarbeitet wird, wenn beide globale Variable A geändert werden, wird die globale Variable zweimal geändert.
Weitere Informationen finden Sie in den Programmieranweisungen im SWOOLE -Dokument #critische Fehler
Verwenden Sie Watish Komponenten enthält Kontext , um die oben genannten Probleme effektiv zu vermeiden
Der Kontext ist eine statische Klasse, die nicht nur einfache Get- und Set -Methoden bietet, sondern auch Globalset, GlobalGet und andere Methoden des Multi-Arbeiter-Prozesses globale Variablen durch Prozesskommunikation.
Hinweis: Multi-Arbeiter-Prozess Global Variable-Einstellung (Kontext :: Global_set usw.) wird asynchron implementiert, basierend auf Unixsocket. Es kann die Konsistenz von Daten in einem bestimmten Zeitpunkt nicht garantieren. Hier können Sie Watish Komponenten utils Table verwenden, eine eingekapselte KV -Speichertabelle für die SWOOLE Tabelle , die jede Ressourcenreihe voll ausnutzen und die Serialisierung der Schließung unterstützen kann.
Wenn der Browser eine Anfrage an den Server sendet, ruft der Server die Handlungsmethode auf und beurteilt dann, ob die angeforderte Route über den Routing -Scheduler vorliegt. Die Routing-Parameter existieren, verkapseln Sie sie zu Watish Komponenten struct request und geben Sie sie in den Global Middleware-> Local Middleware-> Controller weiter
Zwei Möglichkeiten zur Registrierung von Routing
Hinweis: Sie müssen die ** register_route_auto ** an true in **/config/server.php ** ändern
. . .
" register_route_auto " => true
...Das Präfix ist eine Klassenanmerkung , die das Präfix der Route unter dieser Klasse definiert.
#[Prefix(string $ prefix )]Pfad ist eine Methode -Annotation , die den Routing -Pfad definiert
#[Path(string $ path ,array $ methods )]Nehmen Sie eine Kastanie:
<?php
namespace Watish WatishWEB Controller ;
use Watish Components Attribute Middleware ;
use Watish Components Attribute Path ;
use Watish Components Attribute Prefix ;
use Watish Components Struct Request ;
use Watish WatishWEB Middleware TestMiddleware ;
#[Prefix( ' /hello ' )]
class HelloController
{
#[Path( ' /index ' )]
public function index ( Request $ request ) : array
{
return [
" msg " => " hello world "
];
}
#[Path( ' /user/{name} ' ,[ ' GET ' , ' POST ' ])]
#[Middleware([TestMiddleware::class])]
public function msg ( Request $ request ) : array
{
return [
" msg " => " hello " . $ request -> route ( ' name ' )
];
}
}Der obige Code wird wie folgt weitergeleitet
| Weg | Regler | Verfahren | Middleware |
|---|---|---|---|
| /Hallo/Index | Hellocontroller@index | BELIEBIG | keiner |
| /hallo/user/{name} | Hellocontroller@msg | Holen Sie sich, posten | Testmiddleware |
Der Pfad zur Routing -Konfigurationsdatei lautet: project/config/Route.php
Verwenden Sie die oben genannten Kastanien wieder, dann sollte die obige Routing -Konfiguration wie folgt sein
<?php
use Watish Components Includes Route ;
use Watish WatishWEB Controller HelloController ;
function do_register_global_middleware ( Route $ route ): void
{
/**
$route->register_global_middleware(CorsMiddleware::class);
*/
}
function do_register_routes ( Route $ route ): void
{
$ route -> register ( ' /hello/index ' ,[HelloController::class, ' index ' ],[],[]);
$ route -> register ( ' /hello/user/{name} ' ,[HelloController::class, ' msg ' ],[TestMiddleware: class ],[ ' GET ' , ' POST ' ]);
}Registrieren Sie die Methodenübertragungsparameter wie folgt
Watish Components Includes Route-> register (string $ path , array $ callback , array $ before_middlewares , array $ methods )Hinweis: Middleware muss die Middleware -Schnittstelle implementieren
Annotation registrieren
Sie können die globale Middleware -Registrierung mithilfe von GlobalMiddleware -Annotationen implementieren
Zum Beispiel:
<?php
namespace Watish WatishWEB Middleware ;
use Watish Components Attribute GlobalMiddleware ;
use Watish Components Struct Request ;
use Watish Components Struct Response ;
#[GlobalMiddleware]
class CorsMiddleware implements MiddlewareInterface
{
public function handle ( Request $ request , Response $ response ): void
{
$ response -> header ( " Access-Control-Allow-Origin " , " * " );
$ response -> header ( " Access-Control-Allow-Credentials " , true );
}
}Registrieren Sie sich per Route
Der Konfigurationsdateipfad lautet: project/config/Route.php
<?php
use Watish Components Includes Route ;
use Watish WatishWEB Controller HelloController ;
use Watish WatishWEB Middleware CorsMiddleware ;
function do_register_global_middleware ( Route $ route ): void
{
$ route -> register_global_middleware (CorsMiddleware::class);
}
function do_register_routes ( Route $ route ): void
{
$ route -> register ( ' /hello/index ' ,[HelloController::class, ' index ' ],[],[]);
$ route -> register ( ' /hello/user/{name} ' ,[HelloController::class, ' msg ' ],[],[ ' GET ' , ' POST ' ]);
}Annotation registrieren
Mit Middleware können Sie einen Controller oder eine Methode mit Anmerkungen versehen
#[Middleware(array $ middlewares )]Erstellen Sie zuerst eine Testmiddleware
<?php
namespace Watish WatishWEB Middleware ;
use Watish Components Struct Request ;
use Watish Components Struct Response ;
class TestMiddleware implements MiddlewareInterface
{
public function handle ( Request $ request , Response $ response )
{
$ response -> header ( " test " , " test " );
}
}Dann ändern Sie Hellocontroller
<?php
namespace Watish WatishWEB Controller ;
use Watish Components Attribute Middleware ;
use Watish Components Attribute Path ;
use Watish Components Attribute Prefix ;
use Watish Components Struct Request ;
use Watish WatishWEB Middleware TestMiddleware ;
#[Prefix( ' /hello ' )]
class HelloController
{
#[Path( ' /index ' )]
#[Middleware([TestMiddleware::class])]
public function index ( Request $ request ) : array
{
return [
" msg " => " hello world "
];
}
#[Path( ' /user/{name} ' ,[ ' GET ' , ' POST ' ])]
#[Middleware([TestMiddleware::class])]
public function msg ( Request $ request ) : array
{
return [
" msg " => " hello " . $ request -> route ( ' name ' )
];
}
}Wie oben erwähnt, haben die Indexmethode und die MSG -Methode lokale Middleware testMiddleware
Natürlich kann der obige Code so geschrieben werden und fügen Sie Hellocontroller direkt Middleware -Anmerkungen hinzu
<?php
namespace Watish WatishWEB Controller ;
use Watish Components Attribute Middleware ;
use Watish Components Attribute Path ;
use Watish Components Attribute Prefix ;
use Watish Components Struct Request ;
use Watish WatishWEB Middleware TestMiddleware ;
#[Prefix( ' /hello ' )]
#[Middleware([TestMiddleware::class])]
class HelloController
{
#[Path( ' /index ' )]
public function index ( Request $ request ) : array
{
return [
" msg " => " hello world "
];
}
#[Path( ' /user/{name} ' ,[ ' GET ' , ' POST ' ])]
public function msg ( Request $ request ) : array
{
return [
" msg " => " hello " . $ request -> route ( ' name ' )
];
}
}Über Konfigurationsdatei registrieren
Weitere Informationen finden Sie in der Registrierungsmethode für Konfigurationsdatei -Routing im Parameter "Routing -Abschnitt Register", nicht hier Details
Der Controller ist der Kern des gesamten Geschäftsprojekts, der für die Bearbeitung von Anfragen, das Aufrufen von Diensten und die Rückgabe von Daten verantwortlich ist
Einfach, keine Beschreibung
Geben Sie zusammen mit Abhängigkeitsinjektion eine Kastanie:
<?php
namespace Watish WatishWEB Controller ;
use Watish Components Attribute Inject ;
use Watish Components Attribute Middleware ;
use Watish Components Attribute Path ;
use Watish Components Attribute Prefix ;
use Watish Components Struct Request ;
use Watish WatishWEB Middleware TestMiddleware ;
use Watish WatishWEB Service BaseService ;
#[Prefix( ' /hello ' )]
#[Middleware([TestMiddleware::class])]
class HelloController
{
#[Inject(BaseService::class)]
public BaseService $ baseService ;
#[Path( ' /index ' )]
public function index ( Request $ request ) : array
{
return [
" msg " => $ this -> baseService -> toArray ([ " Hello " , ' World ' ])
];
}
#[Path( ' /user/{name} ' ,[ ' GET ' , ' POST ' ])]
public function msg ( Request $ request ) : array
{
return [
" msg " => " hello " . $ request -> route ( ' name ' )
];
}
}HINWEIS: Die Injektion der Baumethode wird vorerst nicht unterstützt und wird in Zukunft verbessert (Grabenlöcher)
Postleitzahl direkt
<?php
namespace Watish WatishWEB Service ;
use Watish Components Attribute Async ;
use Watish Components Attribute Inject ;
use Watish Components Utils Logger ;
class TestService
{
#[Inject(BaseService::class)]
public BaseService $ baseService ;
#[Async]
public function asyncHello (): void
{
Logger:: info ( " Hello " );
}
public function hello ( string $ name ) : string
{
return " hello { $ name }" ;
}
}Im Dienst kann noch eine Abhängigkeitsinjektion durchgeführt werden. Darüber hinaus kann die Methode asynchrones kommentiert werden (beachten Sie, dass die von Async kommentierte Methode vom Typ sein muss), um es zu einer asynchronen Methode zu machen
Befehlsklassendateien werden in Project/SRC/Befehl/gespeichert/
HINWEIS: Die Befehlsklasse erfordert die Implementierung des Befehlsinterface -Schnitts
Befehlsklassen können nur Befehle mit Anmerkungen registrieren
Der Beispielcode lautet wie folgt:
<?php
namespace Watish WatishWEB Command ;
use Watish Components Attribute Command ;
use Watish Components Utils Logger ;
#[Command( " hello " , " command " )]
class HelloCommand implements CommandInterface
{
public function handle (): void
{
Logger:: info ( " Hello " );
}
}Der obige Code kann auf folgende Weise ausgeführt werden
SWOOLE-CLI
swoole-cli ./bin/CoServer.php command:helloPhp
php ./bin/CoServer.php command:hello
Annotation der Befehlsnutzung
Command (string $ command , string $ prefix = " command " )Die Aufgabenklasse wird in Projekt/SRC/Task/ gespeichert
Hinweis: Alle Task -Klassen müssen TaskInterface implementieren
Die Aufgabenklasse unterstützt nur die Registrierung zeitgesteuerter Aufgaben mithilfe von Crontab -Annotation .
Der Beispielcode lautet wie folgt:
<?php
namespace Watish WatishWEB Task ;
use Watish Components Attribute Crontab ;
use Watish Components Utils Logger ;
#[Crontab( " * * * * * " )]
class HelloTask implements TaskInterface
{
public function execute (): void
{
Logger:: info ( " Hello " , " HelloTask " );
}
}Dies ist eine zeitgesteuerte Aufgabe, die jede Sekunde Hallo ausgibt
So verwenden Sie Crontab Annotation
Crontab (string $ rule )Wo Regel ein Standard -Crontab -Ausdruck ist
Hinweis: Es gibt vorerst nur MySQL, Redis (kann es selbst hinzufügen)
In diesem Framework werden Verbindungspools verwendet, um MySQL- und Redis -Verbindungen aufrechtzuerhalten, und vervollständigt die Erstellung des Verbindungspools zu Beginn des Starts. Jetzt muss es nur noch in der Geschäftslogik verwendet werden.
** Watish Komponenten enthält Datenbank :: Mysql () ** Gibt eine Kapselung des Laravel -Abfragekonstruktors zurück (weshalb die zugrunde liegende PDO -Logik, ohne Unterschied in der normalen Verwendung)
Watish Komponenten enthält Datenbank :: Redis () gibt einen Predis -Client zurück
Bitte konfigurieren Sie zuerst die Datenbank! Konfigurationsdatei: project/config/database.php
Das Framework verwendet die folgenden Komponenten und fördert einige Komponenten
Unter dem Namespace Watish Komponenten Konstruktor wird eine schnelle Konstruktion einiger Komponenten bereitgestellt
AsyncTaskConstructor :: Make () Asynchroner Aufgabenbereitstellung
LocalFileSystemConstructor :: GetFilesystem () Lokaler Dateisystemkonstruktor
ValidatorConstructor :: make (Array $ data, Array $ Regeln) Validator Constructor
Vielen Dank an die hervorragenden Komponentenentwickler
Testumgebung: Ubuntu22.0.4 LTS
Testhardware: Virtual Machine (VirtualBox) 6C6T, 8192M, Virtualisierungsunterstützung aktivieren
Testwerkzeug: Apachebench
This is ApacheBench, Version 2.3 <$Revision: 1879490 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/
Benchmarking 127.0.0.1 (be patient)
Server Software: swoole-http-server
Server Hostname: 127.0.0.1
Server Port: 9502
Document Path: /hello/user/test
Document Length: 20 bytes
Concurrency Level: 3000
Time taken for tests: 2.040 seconds
Complete requests: 30000
Failed requests: 0
Total transferred: 7680000 bytes
HTML transferred: 600000 bytes
Requests per second: 14708.19 [#/sec] (mean)
Time per request: 203.968 [ms] (mean)
Time per request: 0.068 [ms] (mean, across all concurrent requests)
Transfer rate: 3677.05 [Kbytes/sec] received
Connection Times (ms)
min mean[+/-sd] median max
Connect: 0 83 17.3 85 125
Processing: 32 109 41.6 102 380
Waiting: 0 79 40.0 71 362
Total: 107 193 37.8 189 457
Percentage of the requests served within a certain time (ms)
50% 189
66% 200
75% 205
80% 208
90% 224
95% 236
98% 344
99% 389
100% 457 (longest request)
HINWEIS: Achten Sie nicht zu sehr auf die Leistung. Die eigentliche Geschäftslogik ist oft kompliziert. Drucktests auf der Demo können nichts angeben (Bilder)
Wenn es einfach zu bedienen ist, können Sie auf einen Stern klicken. Wenn Sie Fragen haben, erwähnen Sie bitte das Problem. Der Autor wird es aktiv beibehalten.
Aktualisiert am 2022-12-28 16:01
Bitte führen Sie zuerst die Komponistinstallation aus
