hexacore
1.0.0
Hexacore est un minuscule cadre PHP basé sur le motif MVC. Initialement un projet personnel pour améliorer mon PHP avec les modèles de conception et les nouvelles fonctionnalités de PHP 7.0+
Je pense que ce projet peut être utile pour la personne qui souhaite apprendre PHP et mieux comprendre le modèle MVC.
Pour un déploiement plus facile, vous pouvez utiliser Docker et Docker-Compose:
Après l'installation de Docker et Docker-Compose, il vous suffit d'exécuter la commande suivante à la racine du projet
$ docker-compose upLe site Web devrait ensuite être exécuté sur http: // localhost.
Vous pouvez également utiliser ce framework avec un wamp / lamp / xamp
Après avoir créé une base de données avec MySQL, vous pouvez le lier au framework avec le fichier de configuration situé dans l'application / config / database.json
{
"dbname" : " myDB " ,
"host" : " db " ,
"port" : 3306 ,
"user" : " hexacore " ,
"password" : " test "
}Comme je l'ai dit plus tôt, Hexacore suivent le modèle MVC, cela signifie que l'application est divisée en 3 parties:
La première chose à faire pour afficher la page d'accueil est de créer un indexController .
C'est la façon la plus simple de le faire:
<?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 contrôleur doit s'étendre de la classe Controller !!
Par défaut, IndexController et Index Action (la fonction) ne sont pas nécessaires dans l'URL. La page d'accueil peut ensuite être atteinte par http: // localhost et http: // localhost / index / index. Par conséquent, la chaîne après le premier / dans l'URL se réfère au contrôleur et à l'autre chaîne l'action.
Le travail de cadre vous permet d'insérer une variable dans l'URL AVEC le contrôleur et l'action comme indiqué ici:
http://localhost/user/get/athena
Vous pouvez ensuite gérer la variable directement en tant que paramètre de votre action Get de la classe 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 ! " );
}
}Vous pouvez ajouter autant de paramètres que vous le souhaitez.
Vous pouvez également obtenir ces variables avec la voie standard ( http://localhost/user/get?name=athena ) avec l'objet de demande:
<?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 utilise également PHP pour les modèles. Le contrôleur a une méthode détectée pour rendre la vue à partir des fichiers 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 " );
}
} Ce code rendra le fichier index.php directement dans le fichier de modèle base.php . Vous pouvez modifier le fichier de modèle dans App/src/view/base/php .
En tant que développeur, il vous suffit de spécifier le chemin de votre fichier (comme le montrez user/index.php ), mais aussi où le mettre dans le fichier base.php .
Par exemple:
...
< main >
< ?php echo $block1; ? >
</ main >
...Vous pouvez utiliser hexacore pour persister des données. Par défaut, il utilise la base de données MySQL.
Vous pouvez configurer le nom et l'accès de la base de données dans le fichier de configuration App/config/database.json
{
"dbname" : " myHexacoreDb " ,
"host" : " db " ,
"port" : 3306 ,
"user" : " Athena " ,
"password" : " myDatabasePassword "
}Les données de la base de données peuvent être récupérées dans le contrôleur:
<?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 classe ModelRepository renverra un objet modèle, dans cet exemple un modèle d'utilisateur.
Pour pouvoir obtenir toutes les données des utilisateurs, vous devez d'abord créer un modèle. Le modèle doit décrire les données que vous souhaitez stocker à l'aide de propriétés privées. Le modèle est une classe qui implémente ManageableModelInterface . Cela permet à Hexacore d'interagir avec la base de données HE via ce modèle et de le gérer facilement avec un objet pré-créé tel que ModelManager .
Exemple :
<?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 ;
}
} Vous devez créer une table correspondante dans votre base de données MySQL avec les mêmes champs (ICI id et name ) et le nom de la table User .
Nous avons vu plus tôt que ModelRepository pourrait être utilisé pour récupérer des données de la base de données. Maintenant, pour créer et mettre à jour un modèle, nous pouvons utiliser 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 " ));
}
} Avec ModelManager vous pouvez également supprimer ou mettre à jour un modèle.
<?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 " );
}
}Ce projet est développé pour le plaisir et peut ne pas être mis à jour, mais je vois beaucoup de pièces à améliorer:
Pour le futur, plus de test sur plusieurs environnements sont requis par exemple sur le serveur Web Nginx.
De plus je ne suis pas sûr que Auth et le pare-feu soient utilisables à l'avenir.
