alight

Posarse

Alight es un marco PHP de peso ligero. Cree fácilmente y rápidamente aplicaciones web de alto rendimiento RESTful. Enrutamiento incorporado, base de datos, almacenamiento en caché, manejo de errores, registro y programación de empleo de bibliotecas de programación de empleo. Concéntrese en crear soluciones para el proceso central de las aplicaciones web. Mantenga simple y extensible.

Familia de encendido

Proyecto	Descripción
Posarse	Enrutamiento de marco básico, base de datos, almacenamiento en caché, etc.
Adhesivo	Una extensión completa del panel de administración basada en la caída. No se requiere codificación frontal.
Proyecto de encendido	Una plantilla para principiantes crea fácilmente aplicaciones web de Alight/Alight-Admin.

Requisitos

PHP 7.4+

Empezando

• Instalación
• Configuración
• Enrutamiento
• Base de datos
• Almacenamiento en caché
• Manejo de errores
• Programación de trabajo
• Ayudantes

Instalación

Paso 1: Instalar compositor

¿No tienes compositor? Instale el compositor primero.

Paso 2: Creación del proyecto

Uso de plantilla con create-project

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

La plantilla del proyecto contiene una estructura de carpeta común, adecuada para el patrón MVC, consulte: Alight-Project.

Es fácil personalizar carpetas modificando la configuración. Pero los siguientes tutoriales se basan en la configuración de la plantilla.

Paso 3: Configuración de un servidor web

Ejemplo de 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;
    }
}

Configuración

Todas las opciones de configuración para el marco Alight se importarán del archivo 'config/app.php', que necesita crear. Por ejemplo:

Archivo: 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 ' ,
];

Obtenga algunos elementos en la configuración

 <?php

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

Configuración disponible

Consulte config.php para más detalles.

Enrutamiento

Antes de aprender las reglas de enrutamiento, debe crear un archivo PHP primero que almacene las reglas de enrutamiento. Debido a que el caché de enrutamiento se actualiza o no, se basa en el tiempo de modificación del archivo de enrutamiento. Por ejemplo:

Archivo: config/ruta/web.php

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

Archivo: config/app.php

 <?php

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

Por cierto, la configuración de ruta admite la importación de archivos especificados para subdominios :

 <?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 ' ], 
    ]
];

Uso básico

 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 ' );

Expresiones regulares

 // 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/Fast-Rutee maneja todas las expresiones regulares en la ruta de enrutamiento. Vea el uso de Fastroute para más detalles.

Opción

Grupo

 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 ' );

Personalizar 'cualquiera'

Puede personalizar los métodos contenidos en AlightRoute::any() .

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

Avellador

Si desea ejecutar algún código común antes del controlador de ruta.

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

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

Deshabilitar el almacenamiento en caché de la ruta

No recomendado, pero si su código requiere:

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

Ciclo vital

Todas las opciones de enrutamiento solo entran en vigencia en el archivo actual y se restablecerán automáticamente por AlightRoute::init() antes de importar el próximo archivo. Por ejemplo:

Archivo: config/admin.php

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

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

Archivo: config/web.php

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

Utilidades

Encabezado de control de caché

Envíe un encabezado de control de caché para controlar el almacenamiento en caché en los navegadores y los cachés compartidos (CDN) para optimizar la velocidad de acceso a los datos no modificados.

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

Manejo de autorización de usuarios

Proporcionamos un controlador de autorización simple para administrar el estado de inicio de sesión del usuario.

 // 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 );

Archivo: 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 ;
    }
}

Solicitar el tiempo de reutilización

Muchas veces los datos enviados por el usuario tardan tiempo en procesarse, y no queremos recibir los mismos datos antes de procesarse. Por lo tanto, necesitamos establecer la solicitud de retroceso de solicitud. El usuario recibirá un error 429 al solicitar nuevamente dentro del enfriamiento.

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

Compartir recursos de origen cruzado (CORS)

Cuando su API necesita ser utilizado para solicitudes AJAX por un sitio web de terceros (o su proyecto tiene múltiples dominios), debe enviar un conjunto de encabezados CORS. Por razones específicas, consulte: 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 su sitio web está utilizando CDN, utilice esta utilidad con cuidado. Para evitar la falla de la solicitud después de que el encabezado se almacena en caché por CDN.

Base de datos

Alight pasa la configuración de 'base de datos' al CATFAN/MEDOO directamente. Para obtener opciones de configuración específicas, consulte Medoo Comenzar. Por ejemplo:

Archivo: 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' => '',
    //     ],
    // ]
];

Uso básico

AlightDatabase::init() es una implementación de instancia estática y única de new MedooMedoo() , por lo que hereda todas las funciones de Medoo() . Una sola instancia hace que cada solicitud se conecte a la base de datos solo una vez y la reutilice, reduciendo efectivamente el número de conexiones de la base de datos.

 // 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 ();

Consulte la documentación de Medoo para obtener detalles de uso.

Almacenamiento en caché

Alight admite múltiples controladores de caché y múltiples interfaces de caché con Symfony/Cache . Las opciones de configuración 'DSN' y 'Opciones' se pasarán al adaptador de caché, más detalles consulte los adaptadores de caché disponibles. Por ejemplo:

Archivo: 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' => [],
    //     ],
    // ]
];

Uso básico (PSR-16)

Al igual que la base de datos, AlightCache::init() es una implementación de instancia estática y única del cliente de caché para mejorar el rendimiento de la solicitud concurrente.

 // 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 ' );

Interfaz 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 ' );

Interfaz nativa

También es compatible con interfaces nativas de Memcached o Redis para usar almacenamiento en caché avanzado:

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

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

Más adaptador

Symfony/Cache admite más de 10 adaptadores, pero solo tenemos 3 de uso común, como el sistema de archivos, Memcached, Redis. Si necesita más adaptadores, puede expandirlo. Por ejemplo:

Archivo: config/app.php

 <?php

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

Archivo: 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 ;
        }
    }
}

Consulte el componente de caché Symfony para obtener más información.

Manejo de errores

Alight atrapa todos los errores a través de AlightApp::start() . Cuando active 'depurar' en la configuración de la aplicación, los errores se emitirán en bonito html (por filp/whoops ) o json.

Archivo: config/app.php

 <?php

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

Manejador personalizado

Cuando desactive la 'depuración' en el entorno de producción, Save simplemente registra errores para presentar y emite el estado HTTP. Puede anular estos comportamientos predeterminados por configuración de la aplicación. Por ejemplo:

Archivo: config/app.php

 <?php

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

Archivo: 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 ;
        }
    }
}

Programación de trabajo

Si necesita ejecutar scripts PHP en el fondo periódicamente.

Paso 1: Configuración de Cron

$ sudo contab -e

Agregue lo siguiente a la línea final:

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

Paso 2: crear empleos

Archivo: 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 ' );

Consejos

Cada controlador ejecuta solo un proceso a la vez, y el tiempo de ejecución máxima predeterminado de un proceso es de 1 hora. Si su controlador necesita un tiempo de ejecución más largo, use TimElimit ().

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

Ayudantes

Ruta de la raíz del proyecto

Alight proporciona AlightApp::root() para estandarizar el formato de las rutas de archivo en el proyecto.

 // 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 ' );

Las rutas de archivo en la configuración se basan en el AlightApp::root() . Por ejemplo:

 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
]);

Respuesta de la API

Alight proporciona AlightResponse::api() para estandarizar el formato de la respuesta de la API.

 HTTP 200 OK

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

Definición de estado:

Estado de http	Error de API	Descripción
200	0	DE ACUERDO
200	1xxx	Errores comerciales generales, solo visite el mensaje al usuario
200	2xxx	Errores comerciales especiales, necesita definir la próxima acción para el usuario
4xx	4xx	Errores del cliente
5xx	5xx	Errores de servidor

Por ejemplo:

 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": {}
// }

Vistas

Alight proporciona AlightResponse::render() para mostrar una plantilla de vista Llame al método Render con la ruta del archivo de plantilla y los datos de plantilla opcional:

Archivo: App/Controller/Pages.php

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

Archivo: App/Ver/Hello.php

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

Archivo: config/ruta/web.php

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

La salida de la página de inicio del proyecto sería:

Hello, Ben!

Otros

También hay algunos ayudantes útiles colocados en diferentes espacios de nombres. Haga clic en el archivo para obtener más detalles:

Espacio de nombres	Archivo
Alight Solicitud	Request.php
Alight Respuesta	Respuesta.php
Alight Utility	Utilidad.php

Créditos

• El compositor requiere
  • nikic/ruta rápida
  • Catfan/Medoo
  • Symfony/caché
  • monólogo/monólogo
  • Filp/Whoops
• Agradecimiento especial
  • Mikecao/vuelo

Licencia

• Licencia de MIT