Langage de programmation - Free Pascal - Fano Framework

Les premiers pas

La page suivant explique les étapes minimales requises pour configurer une application Web avec Fano Framework fonctionnelle sur une machine de développement.

Prérequis

Linux ou FreeBSD
Free Pascal >= 3.0
git
Fano CLI.
Connexion Internet fonctionnelle.

Créer une application

Assurez-vous que toutes les exigences ci-dessus sont remplies. Exécutez :

fanocli --project-http=Hello
cd Hello
fanocli --controller=Home --route=/
./build.sh
./bin/app.cgi

Exécutez-le depuis un navigateur

Ouvrez un navigateur Web et accédez à http://localhost:20477. Vous devriez voir le texte du contrôleur Home s'afficher dans le navigateur. Félicitations, votre application fonctionne.

Procédure pas à pas des commandes

Examinons chaque commande ci-dessus pour comprendre ce qu'elle fait. La commande suivante indique à Fano CLI de créer un projet d'application Web http dans le répertoire Hello. Le répertoire ne doit pas exister. Lisez Création d'un projet avec Fano CLI pour créer différents projets d'application Web (CGI, FastCGI, SCGI, uwsgi ou http).

fanocli --project-http=Hello

Nous changeons le répertoire actif pour le répertoire Hello nouvellement créé.

cd Hello

Créez un contrôleur nommé HomeController.pas gérant la requête vers la route «/» :

fanocli --controller=Home --route=/

Sans --route=/, par défaut, Fano CLI créera la même route que le nom du contrôleur en minuscules, c'est-à-dire /home. Si vous omettez --route=/, vous ne pourrez accéder à HomeController qu'en utilisant l'URL http://localhost:20477/home au lieu de http://localhost:20477.

Compiler l'application :

./build.sh

Exécuter l'application :

./bin/app.cgi

Par défaut, l'exécutable généré portera le nom app.cgi dans le répertoire bin.

Présentation du répertoire du projet

Fano Framework n'a pas d'avis sur la structure des répertoires de votre projet. Vous pouvez structurer les répertoires et les fichiers de votre projet comme vous le souhaitez. Cependant, Fano CLI crée plusieurs fichiers et répertoires qui suivent certaines hypothèses.

Répertoires

Répertoire	Description
src	Répertoire du code source du projet d'application
bin	Répertoire de sortie des binaires compilés
config	Répertoire de configuration de l'application
resources	Répertoire de ressources d'application, telles que les modèles HTML, SCSS,...
storages	Répertoire des fichiers générés par l'exécution de l'application, tels que les fichiers de session, les journaux,...
tools	Répertoire des scripts d'aide de l'interpréteur de commande, tels que les scripts pour nettoyer les binaires compilés.
public	Répertoire racine du document d'application où résident les ressources publiques telles que les images, les feuilles de style en cascade et les fichiers JavaScript.

Fichiers

Le code source du programme principal est src/app.pas.
L'unité principale src/bootstrap.pas colle tous les modules.
Le contrôleur HomeController.pas dans src/App/Home/Controllers est un code affichant le texte du contrôleur Home.
Le fichier d'inclusion src/Routes/Home/route.inc associe l'URL par défaut / au contrôleur Home.
Le fichier d'inclusion controllers.dependencies.inc dans le répertoire src/Dependencies enregistre la classe d'usine pour le contrôleur Home.

src/app.pas

Il s'agit du code source typique du programme principal de l'application Web étant généré par Fano CLI (les commentaires sont omis par souci de concision) :



program app;

 
uses

 
    {$IFDEF UNIX}

    cthreads,

    {$ENDIF}

    sysutils,

    fano,

    bootstrap;

 
var

    appInstance : IWebApplication;

    cliParams : ICliParams;

    svrConfig : TFpwebSvrConfig;

 
begin

    cliParams := (TGetOptsParams.create() as ICliParamsFactory)

        .addOption('host', 1)

        .addOption('port', 1)

        .build();

    svrConfig.host := cliParams.getOption('host', '127.0.0.1');

    svrConfig.port := cliParams.getOption('port', 20477);

    writeln('Starting application at ', svrConfig.host, ':', svrConfig.port);

 
    svrConfig.documentRoot := getCurrentDir() + '/public';

    svrConfig.serverName := 'http.fano';

    svrConfig.serverAdmin := 'admin@http.fano';

    svrConfig.serverSoftware := 'Fano Framework Web App';

    svrConfig.timeout := 120;

 
    //décommenter les lignes suivantes prend en charge https

    //svrConfig.useTLS := true;

    //svrConfig.tlsKey := '/path/to/ssl/cert/key';

    //svrConfig.tlsCert := '/path/to/ssl/cert/cert';

 
    appInstance := TDaemonWebApplication.create(

        TFpwebAppServiceProvider.create(

            TAppServiceProvider.create(),

            svrConfig

        ),

        TAppRoutes.create()

    );

    appInstance.run();

end.

Le programme principal crée une instance d'application Web et des instances de fournisseur de services pour créer tous les services dont votre application a besoin, puis l'exécuter.

TDaemonWebApplication et TFpWebAppServiceProvider sont des classes intégrées fournies par Fano Framework pour prendre en charge la création d'applications Web http de longue durée utilisant la bibliothèque de serveur http Fpweb de Free Pascal.

Selon le paramètre que vous utilisez pour créer un projet avec Fano CLI, il peut finir par utiliser TIndyAppServiceProvider, TMhdAppServiceProvider, TFastCgiAppServiceProvider, TScgiAppServiceProvider, TUwsgiAppServiceProvider pour une application Web http basée sur le serveur http Indy, le serveur http libmicrohttpd, FastCGI, SCGI, l'application Web uwsgi respectivement.

TAppServiceProvider et TAppRoutes sont deux classes spécifiques à votre application étant responsables de la création de tous les services et itinéraires requis par votre application. Les deux sont déclarées dans l'unité bootstrap.pas

src/bootstrap.pas

Ce fichier typique est généré par Fano CLI (les commentaires sont omis par souci de concision) pour permettre à l'application d'initialiser tous les services et itinéraires dont elle a besoin.



unit bootstrap;

 
interface

 
uses

 
    fano;

 
type

 
    TAppServiceProvider = class(TDaemonAppServiceProvider)

    protected

 
    public

        procedure register(const container : IDependencyContainer); override;

    end;

 
    TAppRoutes = class(TRouteBuilder)

    public

        procedure buildRoutes(

            const container : IDependencyContainer;

            const router : IRouter

        ); override;

    end;

 
implementation

 
uses

    sysutils,

    HomeControllerFactory;

 
 
 
    procedure TAppServiceProvider.register(const container : IDependencyContainer);

    begin

        {$INCLUDE Dependencies/dependencies.inc}

    end;

 
    procedure TAppRoutes.buildRoutes(

        const container : IDependencyContainer;

        const router : IRouter

    );

    begin

        {$INCLUDE Routes/routes.inc}

    end;

end.

TAppServiceProvider est une classe qui implémente l'interface IServiceProvider ayant un nom de méthode register(). Elle sera appelée par Fano Framework lors de l'initialisation et recevra une instance du conteneur de dépendances. Dans cette méthode, vous initialisez tous les services requis par votre application. TAppServiceProvider hérite de TDaemonAppServiceProvider configurant les services communs pour les applications Web de longue durée.

TAppRoutes est une classe implémentant l'interface IRouteBuilder ayant une méthode buildRoutes() à implémenter. Elle hérite de TRouteBuilder, une classe abstraite implémentant cette interface. L'application crée des routes dans la méthode buildRoutes().

Pour simplifier la création de ce fichier, Fano CLI utilise deux fichiers d'inclusion principaux dependencies.inc et routes.inc.

src/Dependencies/dependencies.inc

Les extraits suivants montrent le contenu typique de ce fichier (les commentaires sont omis pour des raisons de concision). Chaque ligne contient des fichiers spécifiques à un usage particulier :



{$INCLUDE main.dependencies.inc}

{$INCLUDE middlewares.dependencies.inc}

{$INCLUDE models.dependencies.inc}

{$INCLUDE views.dependencies.inc}

{$INCLUDE controllers.dependencies.inc}

Par exemple, dans controllers.dependencies.inc, vous pouvez avoir le code suivant :



container.add('homeController', THomeControllerFactory.create());

enregistrant la classe d'usine pour le contrôleur domestique à l'aide de la clef homeController.

src/Routes/routes.inc

Il s'agit d'un fichier d'itinéraires typique généré par Fano CLI comme indiqué ci-dessous :



{$INCLUDE Home/routes.inc}

Qui à leur tour incluent d'autres fichiers. Par exemple, src/Routes/Home/routes.inc peut contenir le code suivant :



router.get('/', container.get('homeController') as IRequestHandler);

Le code ci-dessus enregistre la route / avec la méthode GET sur l'instance du contrôleur domestique.

src/App/Home/Controllers/HomeController.pas

Ce code de contrôleur typique est généré par Fano CLI (les commentaires sont omis pour des raisons de concision). Il hérite de TAbstractController étant une classe abstraite implémentant l'interface IRequestHandler possédant une méthode handleRequest().



unit HomeController;

 
interface

 
{$MODE OBJFPC}

{$H+}

 
uses

 
    fano;

 
type

 
    THomeController = class(TAbstractController)

    public

        function handleRequest(

            const request : IRequest;

            const response : IResponse;

            const args : IRouteArgsReader

        ) : IResponse; override;

    end;

 
implementation

 
    function THomeController.handleRequest(

        const request : IRequest;

        const response : IResponse;

        const args : IRouteArgsReader

    ) : IResponse;

    begin

        response.body().write('Home controller');

        result := response;

    end;

 
end.

Lorsque la requête du navigateur Internet route «/», la méthode handleRequest() est appelée, affichant le contrôleur Home dans le navigateur.

La méthode handleRequest() reçoit la requête, la réponse et l'instance de paramètre de route que vous pouvez utiliser, par exemple, pour lire le paramètre de chaîne de caractères de requête.

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

Section courante

A propos

Section administrative du site