hexacore
1.0.0
O Hexacore é uma pequena estrutura PHP baseada no padrão MVC. Inicialmente um projeto pessoal para melhorar meu PHP com padrões de design e os novos recursos do Php 7.0+
Eu acho que este projeto pode ser útil para uma pessoa que deseja aprender PHP e ter uma melhor compreensão do padrão de MVC.
Para uma implantação mais fácil, você pode usar o Docker e o Docker-Comppose:
Após a instalação do Docker e Docker-Compome, você só precisa executar o seguinte comando na raiz do projeto
$ docker-compose upO site deve então estar em execução em http: // localhost.
Você também pode usar esta estrutura com um wamp/lâmpada/xamp
Depois de criar um banco de dados com o MySQL, você pode vinculá -lo à estrutura com o arquivo de conficutação localizado em app/config/database.json
{
"dbname" : " myDB " ,
"host" : " db " ,
"port" : 3306 ,
"user" : " hexacore " ,
"password" : " test "
}Como eu disse anteriormente, o hexacore segue o padrão MVC, significa que o aplicativo está dividido em 3 partes:
A primeira coisa a fazer para exibir a página inicial é criar um indexController .
Esta é a maneira mais simples de fazer isso:
<?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 ! " );
}
} Um controlador deve se estender da classe Controller !!
Por padrão, o indexController e a ação do índice (a função) não são necessários no URL. A página inicial pode ser alcançada por http: // localhost e http: // localhost/index/index. Portanto, a sequência após a primeira / na URL refere -se ao controlador e à outra string a ação.
O trabalho da estrutura permite que você insira a variável no URL Avec, o controlador e a ação, como mostrado aqui:
http://localhost/user/get/athena
Você pode lidar com a variável diretamente como um parâmetro de sua ação, obtenha a 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 ! " );
}
}Você pode adicionar tantos parâmetros quanto desejar.
Você também pode obter essas variáveis com a maneira padrão ( http://localhost/user/get?name=athena ) com o objeto de solicitação:
<?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 ! " );
}
}O hexacore usa o PHP também para modelar. O controlador possui um método detectado para renderizar os arquivos 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 renderizará o arquivo index.php diretamente no arquivo de modelo base.php . Você pode modificar o arquivo de modelo no App/src/view/base/php .
Como desenvolvedor, você só precisa especificar o caminho do seu arquivo (como mostrado user/index.php ), mas também onde colocá -lo no arquivo base.php .
Por exemplo:
...
< main >
< ?php echo $block1; ? >
</ main >
...Você pode usar o hexacore para persistir dados. Por padrão, ele usa o banco de dados MySQL.
Você pode configurar o nome do banco de dados e o acesso no App/config/database.json do arquivo de configuração.json
{
"dbname" : " myHexacoreDb " ,
"host" : " db " ,
"port" : 3306 ,
"user" : " Athena " ,
"password" : " myDatabasePassword "
}Os dados do banco de dados podem ser recuperados no 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
]);
}
} A classe ModelRepository retornará um objeto modelo, neste exemplo um modelo de usuário.
Para poder obter todos os dados dos usuários, você primeiro precisa criar um modelo. O modelo deve descrever os dados que você deseja armazenar usando propriedades privadas. O modelo é uma classe que implementa ManageableModelInterface . Isso permite que o hexacore interaja com a base de dados dele através deste modelo e o lide com um objeto pré-criado, como ModelManager .
Exemplo :
<?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 ;
}
} Você precisa criar uma tabela correspondente no seu banco de dados MySQL com os mesmos campos (aqui id e name ) e User do nome da tabela.
Vimos anteriormente que o ModelRepository poderia ser usado para recuperar dados do banco de dados. Agora, para criar e atualizar um modelo, podemos usar o 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 " ));
}
} Com ModelManager você também pode excluir ou atualizar um 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 projeto é desenvolvido para se divertir e não pode ser atualizado, mas vejo muitos quartos para melhorias:
Para o futuro, mais testes em vários ambientes são necessários, por exemplo, no NGINX Web Server.
Além disso, não tenho certeza de que o Auth and Firewall será utilizável no futuro.
