Este guia passo a passo irá te ensinar a construir uma aplicação CRUD utilizando PHP, MySQL e o framework Lithe. Abordaremos desde a configuração do banco de dados até a implementação de controladores para gerenciar operações CRUD.
Configuração do Ambiente
Antes de iniciar, assegure-se de ter o Composer instalado em sua máquina. O Composer é uma ferramenta essencial para gerenciar dependências em projetos PHP. Caso não tenha o Composer, você pode baixá-lo e instalá-lo a partir do site oficial do Composer.
Criando um Novo Projeto Lithe
Para criar um novo projeto com o framework Lithe, abra o terminal e execute o seguinte comando:
composer create-project lithephp/lithephp crud-app
Isso criará um diretório chamado crud-app, onde todos os arquivos do projeto Lithe serão instalados. Após a instalação, navegue para o diretório do projeto:
cd crud-app
Configurando o Banco de Dados
Agora, você precisa configurar a conexão com o banco de dados. Localize o arquivo .env na raiz do projeto. Este arquivo armazena as variáveis de ambiente que o Lithe usará durante a execução.
No arquivo .env, defina suas variáveis de conexão ao banco de dados conforme o exemplo abaixo:
DB_CONNECTION_METHOD=mysqli
DB_CONNECTION=mysql
DB_HOST=localhost
DB_NAME=lithe
DB_USERNAME=root
DB_PASSWORD=
DB_SHOULD_INITIATE=true
Detalhes das Variáveis
-
DB_CONNECTION_METHOD: Método de conexão (neste caso,
mysqli). -
DB_CONNECTION: Tipo de banco de dados (por exemplo,
mysql). -
DB_HOST: Endereço do servidor de banco de dados (normalmente
localhostpara desenvolvimento local). -
DB_NAME: Nome do banco de dados que será utilizado (por exemplo,
lithe). -
DB_USERNAME: Nome de usuário para acessar o banco de dados (padrão
rootpara muitas configurações locais). - DB_PASSWORD: Senha do usuário do banco de dados (deixe em branco se não houver).
- DB_SHOULD_INITIATE: Define se o banco de dados deve ser iniciado automaticamente ao iniciar a aplicação.
Após configurar o arquivo .env, você estará pronto para prosseguir com a criação da aplicação CRUD.
Com essas variáveis, o Lithe se conecta automaticamente ao banco de dados. Isso é feito pelo arquivo de configuração em src/database/config/database.php, que contém o seguinte método:
use Lithe\Database\Manager as DB;
return DB::initialize();
Esse método retorna a conexão do banco de dados, que será usada pela constante DB_CONNECTION.
Criando Migrações
Após configurar o banco de dados, o próximo passo é criar a estrutura do banco de dados. Para isso, utilizamos o comando make:migration do Lithe. Execute o seguinte comando para criar uma migração:
php line make:migration CreateUsersTable
Isso criará um arquivo de migração dentro do diretório src/database/migrations/, com um nome no formato YYYY_MM_DD_HHMMSS_CreateUsersTable.php.
A migração criada terá a seguinte estrutura:
return new class
{
/**
* Executa as migrações.
*
* @param mysqli $db
* @return void
*/
public function up(mysqli $db): void
{
$query = "
CREATE TABLE IF NOT EXISTS users (
id INT(11) AUTO_INCREMENT PRIMARY KEY,
name VARCHAR(255) NOT NULL,
email VARCHAR(255) UNIQUE NOT NULL,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
)
";
$db->query($query);
}
/**
* Reverte as migrações.
*
* @param mysqli $db
* @return void
*/
public function down(mysqli $db): void
{
$query = "DROP TABLE IF EXISTS users";
$db->query($query);
}
};
Após definir a estrutura da migração, execute o comando a seguir para aplicar as migrações e criar a tabela no banco de dados:
php line migrate
Criando um Modelo
Para gerar um modelo que interaja com a tabela users, execute o seguinte comando:
php line make:model User
Isso criará um arquivo em src/models, que servirá como base para manipular os dados do usuário. O modelo gerado se parecerá com isso:
namespace App\Models;
class User
{
// Aqui vai a lógica do modelo
}
Métodos CRUD no Modelo
Adicione métodos estáticos para realizar operações CRUD usando mysqli e a constante DB_CONNECTION.
Create (Criar)
Para inserir um novo usuário, adicione este método:
public static function create(array $data): bool
{
$stmt = DB_CONNECTION->prepare("INSERT INTO users (name, email) VALUES (?, ?)");
$stmt->bind_param('ss', $data['name'], $data['email']);
return $stmt->execute();
}
Read (Ler)
Para buscar usuários, implemente os métodos a seguir:
public static function all(): array
{
return DB_CONNECTION->query("SELECT * FROM users")->fetch_all(MYSQLI_ASSOC);
}
public static function find(int $id): ?array
{
$stmt = DB_CONNECTION->prepare("SELECT * FROM users WHERE id = ?");
$stmt->bind_param('i', $id);
$stmt->execute();
return $stmt->get_result()->fetch_assoc() ?: null;
}
Update (Atualizar)
Para atualizar um usuário existente:
public static function update(int $id, array $data): bool
{
$stmt = DB_CONNECTION->prepare("UPDATE users SET name = ?, email = ? WHERE id = ?");
$stmt->bind_param('ssi', $data['name'], $data['email'], $id);
return $stmt->execute();
}
Delete (Excluir)
E para excluir um usuário:
public static function delete(int $id): bool
{
$stmt = DB_CONNECTION->prepare("DELETE FROM users WHERE id = ?");
$stmt->bind_param('i', $id);
return $stmt->execute();
}
Controladores Básicos
Para gerar rapidamente um novo controlador, execute o comando line make:controller. Todos os controladores gerados são armazenados no diretório src/http/controllers:
php line make:controller UserController
Um controlador pode ter qualquer número de métodos públicos que responderão às requisições HTTP. Veja um exemplo de implementação básica para a tabela users:
namespace App\Http\Controllers;
use App\Models\User;
use Lithe\Http\Request;
use Lithe\Http\Response;
class UserController
{
/**
* Mostra o perfil de um usuário específico.
*/
public function show(Request $req, Response $res)
{
$id = $req->param('id');
return $res->view('user.profile', [
'user' => User::find($id)
]);
}
/**
* Cria um novo usuário.
*/
public function store(Request $req, Response $res)
{
$data = (array) $req->body(); // Obtém todos os dados do pedido
User::create($data);
return $res->redirect('/users'); // Redireciona para a lista de usuários
}
/**
* Atualiza um usuário existente.
*/
public function update(Request $req, Response $res)
{
$id = $req->param('id');
$data = (array) $req->body(); // Obtém todos os dados do pedido
User::update($id, $data);
return $res->redirect('/users'); // Redireciona para a lista de usuários
}
/**
* Exclui um usuário.
*/
public function delete(Request $req, Response $res)
{
$id = $req->param('id');
User::delete($id);
return $res->redirect('/users'); // Redireciona para a lista de usuários
}
}
Adicionando Visualizações
Para exibir as informações dos usuários, crie arquivos de visualização no diretório src/views. Um exemplo de arquivo pode ser user/profile.php, onde você irá construir a interface de exibição dos dados do usuário.
Iniciando a Aplicação
Para começar a desenvolver com o Lithe, você precisa criar uma nova instância da classe Lithe\App no arquivo src/App.php e definir as rotas.
use App\Http\Controllers\UserController;
$app = new \Lithe\App;
$app->get('/users/:id', [UserController::class, 'show']);
$app->post('/users', [UserController::class, 'store']);
$app->put('/users/:id', [UserController::class, 'update']);
$app->delete('/users/:id', [UserController::class, 'delete']);
Rodando a Aplicação
Após definir as rotas, é fundamental chamar o método listen() para iniciar o servidor. Você pode fazer isso no mesmo arquivo src/App.php:
$app->listen();
E para rodar a aplicação, utilize o comando:
php line serve
Isso inicializa um servidor local que você pode acessar em http://localhost:8000.
Agora que sua aplicação CRUD está configurada e em execução, você poderá acessar as rotas de usuários diretamente no seu navegador. Para visualizar a lista de usuários ou interagir com as funções que você implementou, basta acessar:
http://localhost:8000/users
Essa rota permitirá que você visualize todos os usuários cadastrados e realize operações como criar, atualizar ou excluir registros conforme as funcionalidades que você implementou nos controladores.
Claro! Aqui está a seção de conclusão com a documentação do Lithe incluída:
Conclusão
Com esses passos, você já possui uma aplicação CRUD funcional usando PHP, MySQL e o framework Lithe. Agora, você pode expandir essa base para adicionar mais recursos e funcionalidades conforme sua necessidade.
Para mais informações sobre como utilizar o Lithe, consulte a documentação oficial do Lithe. A documentação abrange desde a configuração inicial até recursos avançados, ajudando você a aproveitar ao máximo o potencial do framework.
Divirta-se programando!
Top comments (0)