hexacore
1.0.0
Hexacore es un pequeño marco PHP basado en el patrón MVC. Inicialmente, un proyecto personal para mejorar mi PHP con patrones de diseño y las nuevas características de PHP 7.0+
Creo que este proyecto puede ser útil para la persona que desea aprender PHP y comprender mejor el patrón MVC.
Para una implementación más fácil, puede usar Docker y Docker-Compose:
Después de la instalación de Docker y Docker-Compose, solo necesita ejecutar el siguiente comando en la raíz del proyecto
$ docker-compose upEl sitio web debería ejecutarse en http: // localhost.
También puede usar este marco con un wamp/lámpara/xamp
Después de crear una base de datos con MySQL, puede vincularla al marco con el archivo de confitación ubicado en App/Config/Database.json
{
"dbname" : " myDB " ,
"host" : " db " ,
"port" : 3306 ,
"user" : " hexacore " ,
"password" : " test "
}Como dije antes, Hexacore sigue el patrón MVC, significa que la aplicación se divide en 3 partes:
Lo primero que debe hacer para mostrar la página de inicio es crear un indexController .
Esta es la forma más sencilla de hacer eso:
<?php
namespace App Controller ;
use Hexacore Core Controller ;
use Hexacore Core Response ResponseInterface ;
use Hexacore Core Response Response ;
class IndexController extends Controller
{
public function index (): ResponseInterface
{
return new Response ( " Hello world ! " );
}
} ¡Un controlador tiene que extenderse desde la clase Controller !
Por defecto, IndexController y la acción de índice (la función) no son necesarias en la URL. La página de inicio se puede alcanzar tanto por http: // localhost como http: // localhost/index/index. Por lo tanto, la cadena después de la primera / en la URL consulte el controlador y la otra cadena la acción.
El trabajo de cuadro le permite insertar la variable Get en la URL AVEC el controlador y la acción como se muestra aquí:
http://localhost/user/get/athena
Luego puede manejar la variable directamente como un parámetro de su acción Get de la clase UserController :
<?php
namespace App Controller ;
use Hexacore Core Controller ;
use Hexacore Core Response ResponseInterface ;
use Hexacore Core Response Response ;
class UserController extends Controller
{
public function get ( String $ name ): ResponseInterface
{
return new Response ( " Welcome $ name ! " );
}
}Puede agregar tantos parámetros Get como desee.
También puede obtener estas variables con la forma estándar ( http://localhost/user/get?name=athena ) con el objeto de solicitud:
<?php
namespace App Controller ;
use Hexacore Core Controller ;
use Hexacore Core Response ResponseInterface ;
use Hexacore Core Response Response ;
class UserController extends Controller
{
public function get (): ResponseInterface
{
//for a post variable submitted
//$this->request->getPost("var");
$ name = $ this -> request -> getQuery ( " var " );
return new Response ( " Welcome $ name ! " );
}
}Hexacore usa PHP también para plantillas. El controlador tiene un método detenido para representar la vista desde los archivos PHP.
<?php
namespace App Controller ;
use Hexacore Core Controller ;
use Hexacore Core Response Response ;
class UserController extends Controller
{
public function index (): Response
{
return $ this -> render ( " user/index.php " );
}
} Este código representará el archivo index.php directamente en el archivo de plantilla base.php . Puede modificar el archivo de plantilla en App/src/view/base/php .
Como desarrollador, solo necesita especificar la ruta de su archivo (como se muestra user/index.php ), pero también dónde colocarlo en el archivo base.php .
Por ejemplo:
...
< main >
< ?php echo $block1; ? >
</ main >
...Puede usar Hexacore para persistir en datos. Por defecto, usa la base de datos MySQL.
Puede configurar el nombre y el acceso de la base de datos en el archivo de configuración App/config/database.json
{
"dbname" : " myHexacoreDb " ,
"host" : " db " ,
"port" : 3306 ,
"user" : " Athena " ,
"password" : " myDatabasePassword "
}Los datos de la base de datos se pueden recuperar en el controlador:
<?php
namespace App Controller ;
use Hexacore Core Controller ;
use Hexacore Core Model Repository ModelRepository ;
use Hexacore Core Response ResponseInterface ;
use App Model User ;
class UserController extends Controller
{
public function index ( ModelRepository $ modelRepository ): ResponseInterface
{
// to get all users
$ allUsers = $ modelRepository -> setModel (User::class)-> findAll ();
// to get the user with the id 1
$ user = $ modelRepository -> findById ( 1 );
return $ this -> render ( " user/index.php " , [
" users " => $ allUsers ,
" user " => $ user
]);
}
} La clase ModelRepository devolverá un objeto modelo, en este ejemplo un modelo de usuario.
Para poder obtener todos los datos de los usuarios, primero necesita crear un modelo. El modelo debe describir los datos que desea almacenar utilizando propiedades privadas. El modelo es una clase que implementa ManageableModelInterface . Esto permite que Hexacore interactúe con la base de datos de HE a través de este modelo y lo maneje fácilmente con un objeto pre-creado como ModelManager .
Ejemplo :
<?php
namespace App Model ;
use Hexacore Core Model ManageableModelInterface ;
class User implements ManageableModelInterface
{
private $ id ;
private $ name ;
public function getId () : ? int
{
return $ this -> id ;
}
public function setId ( int $ id ) : ManageableModelInterface
{
$ this -> id = $ id ;
return $ this ;
}
} Debe crear una tabla correspondiente en su base de datos MySQL con los mismos campos (aquí id y name ) y User de nombre de tabla.
Vimos anteriormente que ModelRepository podría usarse para recuperar datos de la base de datos. Ahora para crear y actualizar un modelo, podemos usar ModelManager.
<?php
namespace App Controller ;
use Hexacore Core Controller ;
use Hexacore Core Model Manager ModelManager ;
use Hexacore Core Response ResponseInterface ;
use Hexacore Core Response Redirect RedirectionResponse ;
use Hexacore Helpers Url ;
use App Model User ;
class UserController extends Controller
{
public function create ( ModelManager $ modelManager , string $ name , Url $ url ): ResponseInterface
{
// create a new user with a personal name
$ user = new User ();
$ user -> setName ( $ name );
// actually insert the new user in the database
$ modelManager -> persist ( $ user );
// redirection to another page
return new RedirectionResponse ( $ url -> baseUrl ( " user " ));
}
} Con ModelManager también puede eliminar o actualizar un modelo.
<?php
namespace App Controller ;
use Hexacore Core Controller ;
use Hexacore Core Model Manager ModelManager ;
use Hexacore Core Response ResponseInterface ;
use App Model User ;
class UserController extends Controller
{
/**
* For a resource like : user/update/{id}/{name}
* Example of the query :
* http://www.yourwebsite.com/user/update/1/zeus
*/
public function update ( ModelManager $ modelManager , User $ user , string $ name ): ResponseInterface
{
// the $user value will be a User object with data from the user number id
// we change the user name
$ user -> setName ( $ name );
// we persist this change in the database
$ modelManager -> persist ( $ user );
return new Response ( " User updated " );
}
/**
* For a resource like : user/delete/{id}
* Example of the query :
* http://www.yourwebsite.com/user/delete/1
*/
public function delete ( ModelManager $ modelManager , User $ user ): ResponseInterface
{
// again $user will be a User Model corresponding to the user with
// the id, 1 in the example.
// delete a specific user in the database
$ modelManager -> delete ( $ user );
return new Response ( " User deleted " );
}
}Este proyecto se desarrolla por diversión y puede no actualizarse, pero veo muchas habitaciones para mejorar:
Para el futuro, se requieren más pruebas en varios entornos, por ejemplo, en el servidor web Nginx.
Además, no estoy seguro de que Auth and Firewall se pueda usar en el futuro.
