Langage de programmation - Free Pascal - Fano Framework

Travailler avec un routeur

Routeur et route

Dans Fano Framework, une route est une règle d'association entre le modèle de chemin d'URL, la méthode HTTP et le code la gérant. Le routeur gère une ou plusieurs routes et fait correspondre le chemin d'URL de la demande, en extrait les données et sélectionne le code les gérant (instance de gestionnaire de demande, c'est-à-dire le contrôleur). Le routeur est toute classe implémentant l'interface IRouter.

Création d'une route pour la méthode GET



Var

    router:IRouter;

    handler:IRequestHandler;

...

router.get('/', handler);

Création d'un itinéraire pour la méthode POST



router.post('/submit', handler);

Création d'un itinéraire pour la méthode PUT



router.put('/submit', handler);

Création d'un itinéraire pour la méthode DELETE



router.delete('/submit', handler);

Création d'un itinéraire pour la méthode PATCH



router.patch('/submit', handler);

Création d'un itinéraire pour la méthode HEAD



router.head('/', handler);

Création d'un itinéraire pour la méthode OPTIONS



router.options('/', handler);

Créer un itinéraire pour plusieurs méthodes



router.map(['GET', 'POST'], '/', handler);

Créer un itinéraire pour toutes les méthodes



router.any('/', handler);

Itinéraire avec paramètres

Un itinéraire peut avoir des paramètres comme indiqué dans l'exemple suivant :



router.get('/user/{username}', myUserHandler);

router.get('/products/{id}/{productSlug}', productList);

Correspondance de route

Si nous avons la configuration de la route suivante :



Var

    router:IRouter;

    myAppHandler, anotherAppHandler:IRequestHandler;

...

 
//Requête GET

router.get('/my/app', myAppHandler);

 
//Requête POST

router.post('/another/app', anotherAppHandler);

Si le nom d'hôte de votre application est exemple.com et que le client ouvre http://exemple.com/mon/app via un navigateur, notre application recevra la méthode GET de la requête pour les ressources /mon/app. Le routeur fera correspondre la méthode HTTP et l'URL et renverra myAppHandler en tant que code chargé de gérer cette requête.

Si le client ouvre http://exemple.com/autre/app via un navigateur, notre application recevra la méthode GET de la requête pour les ressources /autre/app. Le routeur trouvera une correspondance avec /autre/app mais comme il n'est enregistré que pour la requête POST, une exception EMethodNotAllowed sera générée avec le code d'erreur HTTP 405.

Si le client ouvre http://exemple.com/pas/existe via un navigateur, notre application recevra la méthode GET de la requête pour les ressources /pas/existe. Le routeur ne trouvera aucune correspondance. Si cela se produit, une exception ERouteHandlerNotFound sera générée avec le code d'erreur HTTP 404.

Créer des routes d'application avec le générateur de routes

Pour créer des routes d'application, vous devez créer une classe implémentant l'interface IRouteBuilder :



IRouteBuilder=Interface

    ['{46016416-B249-4258-B76A-7F5B55E8348D}']

 
    (*!----------------------------------------------

        * créer des routes d'application

        * ----------------------------------------------

        * @param cntr instance de conteneur de dépendances

        * @param rtr instance de routeur

        *-----------------------------------------------*)

    Procedure buildRoutes(const cntr:IDependencyContainer; Const rtr:IRouter);

End;

Le Fano Framework fournit une classe abstraite de base TRouteBuilder dont vous pouvez étendre et implémenter sa méthode buildRoutes() et la transmettre lors de la création d'une instance d'application comme indiqué dans le code suivant :



TAppRoutes=Class(TRouteBuilder)

 Public

    Procedure buildRoutes(

        const container : IDependencyContainer;

        const router : IRouter

    ); override;

End;

...

Procedure TAppRoutes.buildRoutes(

    Const container:IDependencyContainer;

    Const router:IRouter

);

Begin

   //Inscrivez tous les itinéraires ici

   router.get('/', handler);

End;

Ensuite, créez son instance et transmettez-la au constructeur de l'application.



appInstance:=TCgiWebApplication.create(

    TAppServiceProvider.create(),

    TAppRoutes.create()

);

Si vous utilisez Fano CLI pour créer des applications Web, vous remarquerez peut-être que les itinéraires sont séparés en un ou plusieurs fichiers d'inclusion étant insérés dans une classe chargée de créer des itinéraires d'application, comme indiqué dans l'exemple suivant :



Procedure TAppRoutes.buildRoutes(

    Const container:IDependencyContainer;

    Const router:IRouter

);

Begin

    {$INCLUDE Routes/routes.inc}

End;

Il s'agit simplement d'une convention utilisée par les outils CLI Fano car elle est simple à générer.

Le Fano Framework veille à ce que vous fournissiez une classe implémentant IRouteBuilder. Il ne se soucie pas de la manière dont vous l'implémentez. Vous êtes donc libre de composer la classe de création d'itinéraire comme bon vous semble.

Par exemple, vous pouvez créer une implémentation IRouteBuilder distincte pour chaque fonctionnalité pour une meilleure organisation du code, puis les composer à l'aide de la classe TCompositeRouteBuilder comme indiqué dans l'exemple ci-dessous :



TUsersRoutes=Class(TRouteBuilder)

 Public

    Procedure buildRoutes(

        Const container:IDependencyContainer;

        Const router:IRouter

    ); override;

End;

...

Procedure TUsersRoutes.buildRoutes(

    Const container:IDependencyContainer;

    Const router:IRouter

);

Begin

    //Enregistrer les itinéraires associés aux utilisateurs ici

End;

Pour les itinéraires de fonctionnalités de produit :



TProductRoutes=Class(TRouteBuilder)

public

    Procedure buildRoutes(

        Const container:IDependencyContainer;

        Const router:IRouter

    ); override;

End;

...

Procedure TProductRoutes.buildRoutes(

    Const container:IDependencyContainer;

    Const router:IRouter

);

Begin

    //Enregistrer les produits liés aux itinéraires ici

End;

Et lorsque vous créez une application, vous les composez comme suit :



appInstance:=TCgiWebApplication.create(

    TAppServiceProvider.create(),

    TCompositeRouteBuilder.create([

        TUserRoutes.create(),

        TProductRoutes.create()

    ]);

);

Veuillez noter que TCompositeRouteBuilder est une implémentation intégrée d'IRouteBuilder composant une ou plusieurs instances d'IRouteBuilder en une seule.

Définir le nom de la route ou les intergiciels avec l'interface IRoute

Toutes les méthodes enregistrant le gestionnaire de requêtes telles que get(), post(),.., renvoient une instance de l'interface IRoute que vous pouvez utiliser pour attribuer un nom à la route ou attacher un intergiciel. Le code suivant répertorie toutes les méthodes de cette interface :



Function setName(Const routeName:shortstring):IRoute;

Function getName():shortstring;

Function add(Const amiddleware:IMiddleware):IRoute;

Par exemple pour définir le nom de la route et attacher un middleware :



var authOnlyMiddleware : IMiddleware;

...

router.post('/user/submit', handler).setName('create-user').add(authOnlyMiddleware);

Obtenir le paramètre de la route

Le troisième paramètre de la méthode handleRequest() de l'interface IRequestHandler donne une instance de l'interface IRouteArgsReader pour permettre à l'application de récupérer les paramètres de la route.

Si vous avez le modèle de route /maroute/{name} et que vous accédez à la route via l'URL http://exemple.com/maroute/jean, vous pouvez obtenir la valeur du paramètre name comme suit :



Function TMyController.handleRequest(

    Const request:IRequest;

    Const response:IResponse;

    Const args:IRouteArgsReader

):IResponse;

Var

    arg:TPlaceholder;

Begin

    arg:=args.getArg('name');

    //arg.name = 'name', arg.value = 'jean'

End;

Si vous êtes intéressé uniquement par sa valeur, vous pouvez appeler getValue() et passer le nom de paramètre. Il renvoie la valeur sous forme de chaîne de caractères :



Var name:String;

...

name:=args.getValue('name'); //name = 'jean'

ou avec une syntaxe simplifiée de type tableau :



name:=args['name']; //name = 'jean'

Les codes ci-dessus imprimeront une sortie identique comme suit :



name:=args.getArg('name').value;

Vous pouvez obtenir tous les paramètres de route en utilisant la méthode getArgs() :



Function TMyController.handleRequest(

    Const request:IRequest;

    Const response:IResponse;

    Const args:IRouteArgsReader

):IResponse;

Var placeHolders:TArrayOfPlaceholders;

    arg:TPlaceholder;

    i:integer;

Begin

    placeHolders:=args.getArgs();

    For i:=0 to length(placeholders)-1 do Begin

        arg:=placeholders[i];

    End;

End;

Créer une instance de routeur

Le Fano Framework est fourni avec une implémentation de routeur de base, la classe TRouter, implémentant l'interface IRouter :



container.add('router', TSimpleRouterFactory.create());

La classe TSimpleRouterFactory crée une instance de routeur prenant en charge l'analyse des paramètres de route. Vous pouvez également utiliser la classe TRouterFactory créeant une instance de routeur ne prenant pas en charge le paramètre de route, mais étant plus rapide lors de la correspondance de l'URL de la demande :



container.add('router', TRouterFactory.create());

Si vous n'avez besoin que d'un modèle de chemin d'URL statique, vous devez l'utiliser.

Si vous créez un fournisseur de services d'application hérité de TBasicAppServiceProvider, il créera un routeur par défaut à l'aide de la classe TSimpleRouterFactory étant suffisante pour la plupart des applications.

Remplacer l'instance du routeur

Si vous souhaitez remplacer le routeur par une implémentation différente, vous pouvez remplacer la méthode buildRouter() de TBasicAppServiceProvider. Par exemple :



TMyAppProvider=Class(TBasicAppServiceProvider)

 Private

    fRouterMatcher:IRouteMatcher;

 Public

    Function getRouteMatcher():IRouteMatcher; override;

    Function buildRouter(Const cntr:IDependencyContainer):IRouter; override;

End;

...

Function TMyAppProvider.buildRouter(Const cntr:IDependencyContainer):IRouter;Begin

    ctnr.add('router', TRouterFactory.create());

    result:=ctnr['router'] as IRouter;

    fRouteMatcher:=Result as IRouteMatcher;

End;

 
Function TMyAppProvider.getRouteMatcher():IRouteMatcher;Begin

    Result:=fRouteMatcher;

End;

Notez que IRouteMatcher est une interface chargée de faire correspondre l'URL de la demande et TRouter l'implémente.

PARTAGER CETTE PAGE SUR

Dernière mise à jour : Vendredi, le 18 octobre 2024

	ABAP/4
	Ada
	Assembleur
	Assembly & bytecode
	ASP (Active Server Pages)
	Basic
	C
	C++
	C# (C Sharp)
	Cobol
	ColdFusion
	Fortran
	HTML
	Java
	JavaScript
	LISP
	Logo
	LotusScript
	Oberon
	Pascal
	Perl
	PHP
	PL/1
	Prolog
	Python
	Rebol
	REXX
	Ruby
	Rust
	SAS
	NoSQL
	SQL
	Swift
	X++ (Axapta)

	Assembleur 370
	Assembleur 1802
	Assembleur 4004
	Assembleur 6502
	Assembleur 6800
	Assembleur 68000
	Assembleur 8080 et 8085
	Assembleur 8089
	Assembleur 80x86
	Assembleur AGC4
	Assembleur ARM
	Assembleur DPS 8000
	Assembleur i860
	Assembleur Itanium
	Assembleur MIPS
	Assembleur PDP-11
	Assembleur PowerPC
	Assembleur RISC-V
	Assembleur SPARC
	Assembleur SuperH
	Assembleur UNIVAC I
	Assembleur VAX
	Assembleur Z80
	Assembleur Z8000
	Assembleur z/Architecture

	CIL
	Jasmin
	LLVM
	MSIL
	Parrot
	P-Code (PCode)
	SWEET16

	ASP 1.0
	ASP 2.0
	ASP 3.0
	ASP.NET

	ABasiC (Amiga)
	Adam SmartBASIC
	Altair BASIC
	AmigaBASIC (Amiga)
	AMOS Basic (Amiga)
	Atari Basic (Atari 400, 600 XL, 800, 800XL)
	Basic Apple II (Integer BASIC/APPLESOFT)
	Basic Commodore 64 (CBM-BASIC)
	Basic Commodore 128 (BASIC 7.0)
	Basic Commodore VIC-20 (CBM-BASIC 2.0)
	Basic Coco 1 (Color Basic)
	Basic Coco 2 (Extended Color Basic)
	Basic Coco 3 (Extended Color Basic 2.0)
	BASICA (PC DOS)
	Basic Pro
	BBC BASIC
	Blitz BASIC (Amiga)
	DarkBASIC
	Dartmouth BASIC
	GFA-Basic (Atari ST/Amiga)
	GWBASIC (MS-DOS)
	Liberty BASIC
	Locomotive BASIC (Amstrad CPC)
	MSX-Basic
	Omikron Basic (Atari ST)
	Oric Extended Basic
	Power Basic
	Quick Basic/QBasic (MS-DOS)
	Sinclair BASIC (ZX80, ZX81, ZX Spectrum)
	ST BASIC (Atari ST)
	Turbo Basic
	Vintage BASIC
	VBScript
	Visual Basic (VB)
	Visual Basic .NET (VB .NET)
	Visual Basic pour DOS
	Yabasic

Section courante

A propos

Section administrative du site