alight

Descendre

Autor est un cadre PHP léger. Créez facilement et rapidement les applications Web reposantes hautes performances. Base de données, cache, gestion des erreurs, journalisation et planification de l'emploi. Concentrez-vous sur la création de solutions pour le processus principal des applications Web. Restez simple et extensible.

Famille descendante

Projet	Description
Descendre	Framework Basic Routage intégré, base de données, mise en cache, etc.
Adming-Admin	Une extension complète du panneau d'administration basé sur Alight. Aucun codage frontal requis.
Dépôt de pointe	Un modèle pour le débutant afin de créer facilement des applications Web par Alight / Alight-Admin.

Exigences

PHP 7.4+

Commencer

• Installation
• Configuration
• Routage
• Base de données
• Mise en cache
• Gestion des erreurs
• Planification d'emploi
• Assistants

Installation

Étape 1: Installer le compositeur

Vous n'avez pas de compositeur? Installez d'abord le compositeur.

Étape 2: Création d'un projet

Utilisation du modèle avec création-project

$ composer create-project juneszh/alight-project {PROJECT_DIRECTORY}

Le modèle de projet contient une structure de dossiers commune, adapté au modèle MVC, veuillez vous référer à: Alight-Project.

Il est facile de personnaliser les dossiers en modifiant la configuration. Mais les tutoriels suivants sont basés sur la configuration du modèle.

Étape 3: Configuration d'un serveur Web

Exemple Nginx (Nginx 1.17.10, PHP 7.4.3, Ubuntu 20.04.3):

 server {
    listen 80 ;
    listen [::]:80;

    root /var/www/{PROJECT_DIRECTORY}/public;

    index index.php;

    server_name {YOUR_DOMAIN};

    location / {
        try_files $uri $uri / /index.php? $query_string ;
    }

    location ~ .php$ {
        include snippets/fastcgi-php.conf;
        fastcgi_pass unix:/var/run/php/php7.4-fpm.sock;
    }
}

Configuration

Toutes les options de configuration du framework Alight seront importées du fichier «config / app.php», que vous devez créer vous-même. Par exemple:

Fichier: config / app.php

 <?php

return [
    ' app ' => [
        ' debug ' => false ,
        ' timezone ' => ' Europe/Kiev ' ,
        ' storagePath ' => ' storage ' ,
        ' domainLevel ' => 2 ,
        ' corsDomain ' => null ,
        ' corsHeaders ' => null ,
        ' corsMethods ' => null ,
        ' cacheAdapter ' => null ,
        ' errorHandler ' => null ,
        ' errorPageHandler ' => null ,
    ],
    ' route ' => ' config/route/web.php ' ,
    ' database ' => [
        ' type ' => ' mysql ' ,
        ' host ' => ' 127.0.0.1 ' ,
        ' database ' => ' alight ' ,
        ' username ' => ' root ' ,
        ' password ' => '' ,
    ],
    ' cache ' => [
        ' type ' => ' file ' ,
    ],
    ' job ' => ' config/job.php ' ,
];

Obtenez des éléments dans la configuration

 <?php

Alight Config:: get ( ' app ' );
Alight Config:: get ( ' app ' , ' storagePath ' );

Configuration disponible

Voir config.php pour plus de détails.

Routage

Avant d'apprendre les règles de routage, vous devez d'abord créer un fichier PHP qui stocke les règles de routage. Étant donné que le cache de routage est mis à jour ou non, il est basé sur le temps de modification du fichier de routage. Par exemple:

Fichier: config / root / web.php

 Alight Route:: get ( ' / ' , ' Controller::index ' );

Fichier: config / app.php

 <?php

return [
    ' route ' => ' config/route/web.php '
    // Also supports multiple files
    // 'route' => ['config/route/web.php', config/route/api.php'] 
];

Soit dit en passant, la configuration de l'itinéraire prend en charge l'importation de fichiers spécifiés pour les sous-domaines :

 <?php

return [
    ' route ' => [
        //Import on any request
        ' * ' => ' config/route/web.php ' , 
        //Import when requesting admin.yourdomain.com
        ' admin ' => ' config/route/admin.php ' , 
        //Import multiple files when requesting api.yourdomain.com
        ' api ' => [ ' config/route/api.php ' , ' config/route/api_mobile.php ' ], 
    ]
];

Utilisation de base

 Alight Route:: get ( $ pattern , $ handler );
// Example
Alight Route:: get ( ' / ' , ' Controller::index ' );
Alight Route:: get ( ' / ' , [ ' Controller ' , ' index ' ]);
// Or try this to easy trigger hints from IDE
Alight Route:: get ( ' / ' , [Controller::class, ' index ' ]);
// With default args
Alight Route:: get ( ' post/list[/{page}] ' , [Controller::class, ' list ' ], [ ' page ' => 1 ]);

// Common HTTP request methods
Alight Route:: options ( ' / ' , ' handler ' );
Alight Route:: head ( ' / ' , ' handler ' );
Alight Route:: post ( ' / ' , ' handler ' );
Alight Route:: delete ( ' / ' , ' handler ' );
Alight Route:: put ( ' / ' , ' handler ' );
Alight Route:: patch ( ' / ' , ' handler ' );

// Map for Custom methods
Alight Route:: map ([ ' GET ' , ' POST ' ], ' test ' , ' handler ' );

// Any for all common methods
Alight Route:: any ( ' test ' , ' handler ' );

Expressions régulières

 // Matches /user/42, but not /user/xyz
Alight Route:: get ( ' user/{id:d+} ' , ' handler ' );

// Matches /user/foobar, but not /user/foo/bar
Alight Route:: get ( ' user/{name} ' , ' handler ' );

// Matches /user/foo/bar as well, using wildcards
Alight Route:: get ( ' user/{name:.+} ' , ' handler ' );

// The /{name} suffix is optional
Alight Route:: get ( ' user[/{name}] ' , ' handler ' );

// Root wildcards for single page app
Alight Route:: get ( ' /{path:.*} ' , ' handler ' );

Nikic / Route rapide gère toutes les expressions régulières dans le chemin de routage. Voir l'utilisation de FastRoute pour plus de détails.

Options

Groupe

 Alight Route:: group ( ' admin ' );
// Matches /admin/role/list
Alight Route:: get ( ' role/list ' , ' handler ' );
// Matches /admin/role/info
Alight Route:: get ( ' role/info ' , ' handler ' );

// Override the group
Alight Route:: group ( ' api ' );
// Matches /api/news/list
Alight Route:: get ( ' news/list ' , ' handler ' );

Personnaliser «tout»

Vous pouvez personnaliser les méthodes contenues dans AlightRoute::any() .

 Alight Route:: setAnyMethods ([ ' GET ' , ' POST ' ]);
Alight Route:: any ( ' only/get/and/post ' , ' handler ' );

Avant le gestionnaire

Si vous souhaitez exécuter un code commun avant le gestionnaire de Route.

 // For example log every hit request
Alight Route:: beforeHandler ([ svc Request::class, ' log ' ]);

Alight Route:: get ( ' test ' , ' handler ' );
Alight Route:: post ( ' test ' , ' handler ' );

Désactiver la mise en cache des routes

Pas recommandé, mais si votre code nécessite:

 // Effective in the current route file
Alight Route:: disableCache ();

Cycle de vie

Toutes les options de routage ne prennent effet que dans le fichier actuel et seront réinitialisées automatiquement par AlightRoute::init() avant l'importation du fichier suivant. Par exemple:

Fichier: config / admin.php

 Alight Route:: group ( ' admin ' );
Alight Route:: setAnyMethods ([ ' GET ' , ' POST ' ]);

// Matches '/admin/login' by methods 'GET', 'POST'
Alight Route:: any ( ' login ' , ' handler ' );

Fichier: config / web.php

 // Matches '/login' by methods 'GET', 'POST', 'PUT', 'DELETE', etc
Alight Route:: any ( ' login ' , ' handler ' );

Services publics

En-tête de contrôle du cache

Envoyez un en-tête de contrôle de cache pour contrôler la mise en cache dans les navigateurs et les caches partagés (CDN) afin d'optimiser la vitesse d'accès aux données non modifiées.

 // Cache one day
Alight Route:: get ( ' about/us ' , ' handler ' )-> cache ( 86400 );
// Or force disable cache
Alight Route:: put ( ' user/info ' , ' handler ' )-> cache ( 0 );

Gestion de l'autorisation des utilisateurs

Nous fournissons un gestionnaire d'autorisation simple pour gérer l'état de connexion des utilisateurs.

 // Define a global authorization verification handler
Alight Route:: authHandler ([ svc Auth::class, ' verify ' ]);

// Enable verification in routes
Alight Route:: get ( ' user/info ' , ' handler ' )-> auth ();
Alight Route:: get ( ' user/password ' , ' handler ' )-> auth ();

// No verification by default
Alight Route:: get ( ' about/us ' , ' handler ' );

// In general, routing with authorization will not use browser cache
// So auth() has built-in cache(0) to force disable cache
// Please add cache(n) after auth() to override the configuration if you need
Alight Route:: get ( ' user/rank/list ' , ' handler ' )-> auth ()-> cache ( 3600 );

Fichier: app / service / auth.php

 namespace svc ;

class Auth
{
    public static function verify ()
    {
        // Some codes about get user session from cookie or anywhere
        // Returns the user id if authorization is valid
        // Otherwise returns 0 or something else for failure
        // Then use Router::getAuthId() in the route handler to get this id again
        return $ userId ;
    }
}

Demander un temps de recharge

Plusieurs fois, les données soumises par l'utilisateur prennent du temps à traiter, et nous ne voulons pas recevoir les mêmes données avant qu'elle ne soit traitée. Nous devons donc définir le temps de recharge de la demande. L'utilisateur recevra une erreur 429 lors de la demande à nouveau dans le temps de recharge.

 // Cooldown only takes effect when authorized
Alight Route:: put ( ' user/info ' , ' handler ' )-> auth ()-> cd ( 2 );
Alight Route:: post ( ' user/status ' , ' handler ' )-> auth ()-> cd ( 2 );

Partage de ressources d'origine inter-originaux (CORS)

Lorsque votre API doit être utilisée pour les demandes AJAX par un site Web tiers (ou votre projet a plusieurs domaines), vous devez envoyer un ensemble d'en-têtes CORS. Pour des raisons spécifiques, veuillez vous référer à: Mozilla Docs.

 // Domains in config will receive the common cors header
Alight Route:: put ( ' share/config ' , ' handler ' )-> cors (); 

// The specified domain will receive the common cors header
Alight Route:: put ( ' share/specified ' , ' handler ' )-> cors ( ' abc.com ' );

// The specified domain will receive the specified cors header
Alight Route:: put ( ' share/specified2 ' , ' handler ' )-> cors ( ' abc.com ' , ' Authorization ' , [ ' GET ' , ' POST ' ]);

// All domains will receive a 'Access-Control-Allow-Origin: *' header
Alight Route:: put ( ' share/all/http ' , ' handler ' )-> cors ( ' * ' ); 

// All domains will receive a 'Access-Control-Allow-Origin: [From Origin]' header
Alight Route:: put ( ' share/all/https ' , ' handler ' )-> cors ( ' origin ' );

Si votre site Web utilise CDN, veuillez utiliser attentivement cet utilitaire. Pour éviter la défaillance de la demande après la mise en cache de l'en-tête par CDN.

Base de données

Alight passe la configuration de la «base de données» vers le Catfan / Medoo directement. Pour des options de configuration spécifiques, veuillez vous référer à Medoo commencez. Par exemple:

Fichier: config / app.php

 <?php

return [
    ' database ' => [
        ' type ' => ' mysql ' ,
        ' host ' => ' 127.0.0.1 ' ,
        ' database ' => ' alight ' ,
        ' username ' => ' root ' ,
        ' password ' => '' ,
    ],
    // Multiple databases (The first database is default)
    // 'database' => [
    //     'main' => [
    //         'type' => 'mysql',
    //         'host' => '127.0.0.1',
    //         'database' => 'alight',
    //         'username' => 'root',
    //         'password' => '',
    //     ],
    //     'remote' => [
    //         'type' => 'mysql',
    //         'host' => '1.1.1.1',
    //         'database' => 'alight',
    //         'username' => 'root',
    //         'password' => '',
    //     ],
    // ]
];

Utilisation de base

AlightDatabase::init() est une implémentation d'instance statique et unique de new MedooMedoo() , il hérite donc de toutes les fonctions de Medoo() . Une instance unique fait que chaque demande se connecte à la base de données une seule fois et la réutilise, réduisant efficacement le nombre de connexions de base de données.

 // Initializes the default database
$ db =  Alight Database:: init ();
// Initializes others database with key
$ db2 =  Alight Database:: init ( ' remote ' );

$ userList = $ db -> select ( ' user ' , ' * ' , [ ' role ' => 1 ]);
$ userInfo = $ db -> get ( ' user ' , ' * ' , [ ' id ' => 1 ]);

$ db -> insert ( ' user ' , [ ' name ' => ' anonymous ' , ' role ' => 2 ]);
$ id = $ db -> id ();

$ result = $ db -> update ( ' user ' , [ ' name ' => ' alight ' ], [ ' id ' => $ id ]);
$ result -> rowCount ();

Voir la documentation MEDOO pour les détails d'utilisation.

Mise en cache

Alight prend en charge plusieurs pilotes de cache et plusieurs interfaces de cache avec Symfony / Cache . Les options de configuration «DSN» et «Options» seront transmises à l'adaptateur de cache, plus de détails Veuillez vous référer aux adaptateurs de cache disponibles. Par exemple:

Fichier: config / app.php

 <?php

return [
    ' cache ' => [
        ' type ' => ' file ' ,
    ],
    // Multiple cache (The first cache is the default)
    // 'cache' => [
    //     'file' => [
    //         'type' => 'file',
    //     ],
    //     'memcached' => [
    //         'type' => 'memcached',
    //         'dsn' => 'memcached://localhost',
    //         'options' => [],
    //     ],
    //     'redis' => [
    //         'type' => 'redis',
    //         'dsn' => 'redis://localhost',
    //         'options' => [],
    //     ],
    // ]
];

Utilisation de base (PSR-16)

Comme la base de données, AlightCache::init() est une implémentation d'instance statique et unique du client Cache pour améliorer les performances de la demande simultanée.

 // Initializes the default cache
$ cache =  Alight Cache:: init ();
// Initializes others cache with key
$ cache2 =  Alight Cache:: init ( ' redis ' );

// Use SimpleCache(PSR-16) interface
if (! $ cache -> has ( ' test ' )){
    $ cache -> set ( ' test ' , ' hello world! ' , 3600 );
}
$ cacheData = $ cache -> get ( ' test ' );
$ cache -> delete ( ' test ' );

Interface PSR-6

 $ cache6 =  Alight Cache:: psr6 ( ' memcached ' );
$ cacheItem = $ cache6 -> getItem ( ' test ' );
if (! $ cacheItem -> isHit ()){
    $ cacheItem -> expiresAfter ( 3600 );
    $ cacheItem -> set ( ' hello world! ' );
    // Bind to a tag
    $ cacheItem -> tag ( ' alight ' );
}
$ cacheData = $ cacheItem -> get ();
$ cache6 -> deleteItem ( ' test ' );
// Delete all cached items in the same tag
$ cache6 -> invalidateTags ( ' alight ' )

// Or symfony/cache adapter style
$ cacheData = $ cache6 -> get ( ' test ' , function ( $ item ){
    $ item -> expiresAfter ( 3600 );
    return ' hello world! ' ;
});
$ cache6 -> delete ( ' test ' );

Interface native

Prend également en charge les interfaces natives Memcached ou Redis pour l'utilisation de la mise en cache avancée:

 $ memcached =  Alight Cache:: memcached ( ' memcached ' );
$ memcached -> increment ( ' increment ' );

$ redis =  Alight Cache:: redis ( ' redis ' );
$ redis -> lPush ( ' list ' , ' first ' );

Plus d'adaptateur

Symfony / Cache prend en charge plus de 10 adaptateurs, mais nous n'avons que 3 intégrés couramment utilisés, tels que le système de fichiers, Memcached, Redis. Si vous avez besoin de plus d'adaptateurs, vous pouvez l'étendre. Par exemple:

Fichier: config / app.php

 <?php

return [
    ' app ' => [
        ' cacheAdapter ' => [ svc Cache::class, ' adapter ' ],
    ],
    ' cache ' => [
        // ...
        ' apcu ' => [
            ' type ' => ' apcu '
        ],
        ' array ' => [
            ' type ' => ' array ' ,
            ' defaultLifetime ' => 3600
        ]
    ]
];

Fichier: app / service / cache.php

 namespace svc ;

use Symfony  Component  Cache  Adapter  ApcuAdapter ;
use Symfony  Component  Cache  Adapter  ArrayAdapter ;
use Symfony  Component  Cache  Adapter  NullAdapter ;

class Cache
{
    public static function adapter ( array $ config )
    {
        switch ( $ config [ ' type ' ]) {
            case ' apcu ' :
                return new ApcuAdapter ();
                break ;
            case ' array ' :
                return new ArrayAdapter ( $ config [ ' defaultLifetime ' ]);
            default :
                return new NullAdapter ();
                break ;
        }
    }
}

Voir le composant de cache Symfony pour plus d'informations.

Gestion des erreurs

Alight attrape toutes les erreurs via AlightApp::start() . Lors de l'activation de «débogage» dans la configuration de l'application, les erreurs seront sorties dans jolie HTML (par filp / whoops ) ou JSON.

Fichier: config / app.php

 <?php

return [
    ' app ' => [
        ' debug ' => true ,
    ]
];

Gestionnaire personnalisé

Lorsque vous éteignez le «débogage» dans l'environnement de production, allumez simplement les erreurs de connexion pour fichier et publier l'état HTTP. Vous pouvez remplacer ces comportements par défaut par configuration de l'application. Par exemple:

Fichier: config / app.php

 <?php

return [
    ' app ' => [
        ' errorHandler ' => [ svc Error::class, ' catch ' ],
        ' errorPageHandler ' => [ svc Error::class, ' page ' ],
    ]
];

Fichier: app / service / error.php

 namespace svc ;

class Error
{
    public static function catch ( Throwable $ exception )
    {
        // Some code like sending an email or using Sentry or something
    }

    public static function page ( int $ status )
    {
        switch ( $ status ) {
            case 400 :
                // Page code...
                break ;
            case 401 :
                // Page code...
                break ;
            case 403 :
                // Page code...
                break ;
            case 404 :
                // Page code...
                break ;
            case 500 :
                // Page code...
                break ;
            default :
                // Page code...
                break ;
        }
    }
}

Planification d'emploi

Si vous devez exécuter périodiquement des scripts PHP en arrière-plan.

Étape 1: Configuration de Cron

$ sudo contab -e

Ajoutez ce qui suit à la ligne de fin:

 * * * * * sudo -u www-data /usr/bin/php /var/www/{PROJECT_DIRECTORY}/app/scheduler.php >> /dev/null 2>&1

Étape 2: Créer des emplois

Fichier: config / job.php

 Alight Job:: call ( ' handler ' )-> minutely ();
Alight Job:: call ( ' handler ' )-> hourly ();
Alight Job:: call ( ' handler ' )-> daily ();
Alight Job:: call ( ' handler ' )-> weekly ();
Alight Job:: call ( ' handler ' )-> monthly ();
Alight Job:: call ( ' handler ' )-> yearly ();
Alight Job:: call ( ' handler ' )-> everyMinutes ( 5 );
Alight Job:: call ( ' handler ' )-> everyHours ( 2 );
Alight Job:: call ( ' handler ' )-> date ( ' 2022-08-02 22:00 ' );

Conseils

Chaque gestionnaire exécute un seul processus à la fois, et l'exécution maximale par défaut d'un processus est de 1 heure. Si votre gestionnaire a besoin d'un runtime plus long, utilisez Timelimit ().

 Alight Job:: call ( ' handler ' )-> hourly ()-> timeLimit ( 7200 ); // 7200 seconds 

Assistants

Chemin de racine du projet

Alight fournit AlightApp::root() pour standardiser le format des chemins de fichier dans le projet.

 // Suppose the absolute path of the project is /var/www/my_project/
 Alight App:: root ( ' public/favicon.ico ' ); // /var/www/my_project/public/favicon.ico

// Of course, you can also use absolute path files with the first character  '/'
 Alight App:: root ( ' /var/data/config/web.php ' );

Les chemins de fichier dans la configuration sont tous basés sur le AlightApp::root() . Par exemple:

 Alight App:: start ([
    ' route ' => ' config/route/web.php ' ,     // /var/www/my_project/config/route/web.php
    ' job ' => ' config/job.php '          // /var/www/my_project/config/job.php
]);

Réponse de l'API

Alight fournit AlightResponse::api() pour standardiser le format de la réponse de l'API.

 HTTP 200 OK

{
    " error " : 0 ,      // API error code
    " message ": " OK ", // API status description
    " data": {}       // Object data
}

Définition de l'état:

Statut http	Erreur de l'API	Description
200	0	D'ACCORD
200	1xxx	Erreurs commerciales générales, afficher le message à l'utilisateur uniquement
200	2xxx	Erreurs commerciales spéciales, besoin de définir la prochaine action pour l'utilisateur
4xx	4xx	Erreurs du client
5xx	5xx	Erreurs de serveur

Par exemple:

 Alight Response:: api ( 0 , null , [ ' name ' => ' alight ' ]);
// Response:
// HTTP 200 OK
//
// {
//     "error": 0,
//     "message": "OK",
//     "data": {
//         "name": "alight"
//     }
// }

 Alight Response:: api ( 1001 , ' Invalid request parameter. ' );
// Response:
// HTTP 200 OK
//
// {
//     "error": 1001,
//     "message": "Invalid request parameter.",
//     "data": {}
// }

 Alight Response:: api ( 500 , ' Unable to connect database. ' );
// Response:
// HTTP 500 Internal Server Error
//
// {
//     "error": 500,
//     "message": "Unable to connect database.",
//     "data": {}
// }

Vues

Alight fournit AlightResponse::render() pour afficher un modèle de vue Appelez la méthode de rendu avec le chemin d'accès du fichier de modèle et des données de modèle facultatives:

Fichier: app / contrôleur / pages.php

 namespace ctr ;
class Pages
{
    public static function index ()
    {
         Alight Response:: render ( ' hello.php ' , [ ' name ' => ' Ben ' ]);
    }
}

Fichier: app / vue / hello.php

<h1>Hello, <?= $ name ?> !</h1>

Fichier: config / root / web.php

 Alight Route:: get ( ' / ' , [ ctr Pages::class, ' index ' ]);

La sortie de la page d'accueil du projet serait:

Hello, Ben!

Autres

Il existe également des aides utiles placés dans différents espaces de noms. Veuillez cliquer sur le fichier pour plus de détails:

Espace de noms	Déposer
Autoriser Demande	Request.php
Auto réponse	Réponse.php
Auto Utility	Utility.php

Crédits

• Le compositeur nécessite
  • Nikic / Route rapide
  • Catfan / Medoo
  • Symfony / Cache
  • monologue / monologue
  • filp / whoops
• Merci spécial
  • mikecao / vol

Licence

• Licence MIT