Usamos cookies para medir audiência e melhorar sua experiência. Você pode aceitar ou recusar a qualquer momento. Veja sobre o iMasters.
Bom, tentei postar este tutorial no imaster como artigo, mas recusaram, pois , disseram que era muito básico, então estarei postando aqui para toda a comunidade.
Aprenderemos neste tutorial que será divido em 4 partes, como criar um CRUD usando o PHP-OO com MySQL em arquitetura MVC.
Para muitos o MVC no PHP somente é possível com a utilização de um framework, então nesse tutorial não iremos utilizar nenhum framework.
Vamos começar o mini curso com a INCLUSÃO (INSERT) de registros em um banco de dados e essa primeira parte será a base para as outras 3 (DELETE, UPDATE e SELECT).
Primeiramente vamos criar uma pequena base de dados para fazermos nossos testes, essa base no nosso caso chama-se crud, neste banco criaremos uma tabela chamada cadastro, contendo os seguintes campos: id_cadastro, nome, idade e telefone. Para facilitar segue abaixo o SQL:
CREATE TABLE `crud`.`cadastro` (
`id_cadastro` int(10) unsigned NOT NULL AUTO_INCREMENT,
`nome` varchar(45) NOT NULL,
`idade` int(10) unsigned NOT NULL,
`telefone` varchar(12) NOT NULL,
PRIMARY KEY (`id_cadastro`)
) ENGINE=InnoDB AUTO_INCREMENT=12 DEFAULT CHARSET=latin1;Após criado o bando de dados e a tabela, vamos para a estrutura de diretórios onde ficarão os arquivos do nosso CRUD.
Criaremos as seguintes pastas:
/view
/controller
/model
Na camada visão (ou pasta view) ficarão todos os nossos arquivos de interação do nosso CRUD, como: formulários de cadastros, listas entre outros.
Na camada controle (ou pasta controller) ficarão todos os nossos arquivos de intermediação entre a camada de visão e persistência do nosso CRUD, nessa camada que serão feitas todas as validações do CRUD.
Na camada de persistência (ou pasta model) ficarão todos os arquivos que fazem interação diretamente com o banco de dados.
Fora de todas as camadas irá ficar o arquivo que contém o menu do sistema, nesse tutorial terá apenas o link de inclusão.
Como é um arquivo bem simples segue o código:
<html>
<title>CRUD PHP OO Modelo MVC</title>
</head>
<body>
<input type="button" onClick="document.location='view/cad_cadastro.php'" value="Novo"><br />
</body>
</html>No código acima colocamos um botão que dará acesso à pagina cad_cadastro.php que se encontra dentro da camada de visão (view), salve-o com o nome menu.php
Feito isso, vamos para a segunda parte do sistema, criar a visão que será o arquivo cad_cadastro.php e salvá-lo dentro da pasta view.
Este também é um arquivo contendo somente HTML então não darei explicações do mesmo, segue o código:
<html>
<title>CRUD PHP OO Modelo MVC</title>
</head>
<body>
<form action="../controller/CadastroController.php" method="post">
<input type="hidden" name="acao" value="incluir">
Nome: <br /><input type="text" size="30" name="nome"><br />
Idade: <br /><input type="text" size="5" name="idade"><br />
Telefone: <br /><input type="text" size="15" name="telefone">
<p><input type="submit" value="Gravar"> <input type="button" value="Voltar" onClick="document.location='../menu.php'"></p>
</form>
</body>
</html>No código apresentado, na tag form colocamos no action o caminho do arquivo que será enviado os dados preenchidos pelo usuário, no nosso caso teremos que sair do diretório view e entrar no diretório controller: ../controller/CadastroController.php este caminho será o controle da aplicação.
Agora vamos quebrar um pouco a ordem dos arquivos, pois teremos que criar a classe que fará todas as transações com o banco de dados, a nossa "DAO".
Vou mostrar o código pronto e depois explicar como tudo funciona, salve-o como Banco.php dentro da pasta model:
<?php
class Banco {
private $sql;
private $query;
private $result;
private $host;
private $usuario;
private $senha;
private $banco;
public $tabela;
public $campos; // array
public $valores; // array
private $linhas;
private $camposQuery = null;
private $valoresQuery = null;
public function __construct() {
$this->conexao();
}
private function conexao() {
$this->host = "localhost";
$this->usuario = "root";
$this->senha = "";
$this->banco = "crud";
mysql_connect($this->host, $this->usuario, $this->senha);
mysql_select_db($this->banco);
}
private function montaQuery($tipo) {
$cont = count($this->campos);
for($i = 0; $i < $cont; $i++) {
if($i < $cont - 1) {
if($tipo == 1) {
$this->camposQuery .= $this->campos[$i] .", ";
$this->valoresQuery .= "'" .$this->valores[$i] ."', ";
}
} else {
if($tipo == 1) {
$this->camposQuery .= $this->campos[$i];
$this->valoresQuery .= "'" . $this->valores[$i] ."'";
}
}
}
}
public function inserirRegistro() {
$this->montaQuery(1);
$this->sql = "INSERT INTO ".$this->tabela." (".$this->camposQuery.") VALUES (".$this->valoresQuery.")";
$this->query = mysql_query($this->sql);
$this->result = mysql_affected_rows();
return $this->result;
}
}
?>Dada a classe acima, vemos que é uma classe comum em php, vamos para a explicação:
Declaramos alguns dos seus atributos como "private" e outros como "public", o detalhe é que os públicos serão acessados de fora da classe (em uma classe que herdará suas propriedades e métodos). Os atributos são:
public $tabela - irá receber o nome da tabela que será feita a inclusão no banco de dados, no nosso caso "cadastro".
public $campos - irá receber um array de valores com os nomes dos campos existentes na tabela.
public $valores - irá receber um array de valores com os valores reais que serão inseridos no banco de dados.
Os outros atributos são de uso comum dentro da classe.
public function __construct() {
$this->conexao();
}Método construtor que irá realizar a conexão com o banco de dados sempre que a classe for instanciada.
private function conexao() {
...
}
Método responsável pela conexão com o banco de dados, configure as propriedades: $this->host, $this->usuario, $this->senha e $this->banco de acordo com suas necessidades.
private function montaQuery($tipo) {
...
}Método responsável em montar a estrutura do sql, de acordo com o tipo de ação que será passada a ele, nesse caso a ação será 1, que é uma inclusão.
Na sequência do método, ele faz uma contagem de quantos elementos contém o array que foi passado na propriedade $this->campos, monta um laço de índice igual a quantidade de campos, em seguida faz um teste para saber o último campo do array, para não jogar uma vírgula no final da string. Emfim faz a montagem da strings e atribui às suas devidas propriedades: $this->camposQuery e $this->valoresQuery, o resultado ficará, respectivamente, da seguinte forma: $this->camposQuery = nome, idade, telefone; e $this->valoresQuery = 'fulano','34','(61)3333-3333'.
public function inserirRegistro() {
....
}Método responsável em incluir um registro no banco de dados.
Primeiro ele executa o método montaQuery(), passando como parâmetro o valor 1 que se trata de uma inclusão;
Monta uma string que será o sql para execução (observe que nesse momento passamos as propriedades) : $this->camposQuery e $this->valoresQuery, para a criação da string;
Após a geração da string, a mesma é executada pela função mysql_query();
Fazemos uma contagem das linhas afetadas na transação, com a função mysql_affected_rows(), para sabermos se a query foi executada com sucesso;E por fim retornamos as linhas afetadas na execução do método, retorno o qual será usado na classe de controle.
Assim finalizamos nossa classe Banco.php a nossa "DAO", que deverá ser salva na pasta (model).
Agora vamos partir para a nossa classe de modelo
Da mesma forma mostrarei o código e darei a explicação:
<?php
require_once("Banco.php");class Cadastro extends Banco {
private $nome;
private $idade;
private $telefone;
public function setNome($string) {
$this->nome = $string;
}
public function setIdade($int) {
$this->idade = $int;
}
public function setTelefone($string) {
$this->telefone = $string;
}
public function getNome() {
return $this->nome;
}
public function getIdade() {
return $this->idade;
}
public function getTelefone() {
return $this->telefone;
}
public function incluir() {
$this->tabela = "cadastro";
$this->campos = array("nome", "idade", "telefone");
$this->valores = array($this->getNome(),$this->getIdade(),$this->getTelefone());
$result = $this->inserirRegistro();
return $result;
}
}
?>
Primeiro incluímos a classe Banco.php em nossa classe que se chamará Cadastro.php;
A nossa classe Cadastro irá herdar os atributos e métodos da classe Banco;Criamos os atributos privados da classe $nome, $idade e $telefone e os encapsulamos através dos "set e get" conforme a sequência dos métodos.
public function incluir() {
....
}
Este método é encarregado de passar os valores "setados" pelo controle, para a "DAO" onde será efetuada a transação no banco de dados;Como nossa classe "class Cadastro extends Banco" herda os atributos de Banco, então podemos acessar diretamente os mesmos:
$this->tabela = "cadastro"; - Informa a tabela que serão gravadas as informações;
$this->campos = array("nome", "idade", "telefone"); - Informa um array com os campos da tabela que serão gravadas as informações;
$this->valores = array($this->getNome(),$this->getIdade(),$this->getTelefone()); - Passa um array com os valores recebidos através dos métodos "get";
$result = $this->inserirRegistro(); - Executa o método inserirRegistro(), que está na classe Banco, armazenando o resultado das linhas afetadas na variável $result;E por fim dá um retorno no método, este armazenará a quantidade de linhas afetadas na consulta e será avaliado no controle.
Partiremos agora para a classe de controle do nosso sistema.
Da mesma forma mostrarei o código e após as explicações:
<?php
require_once("../model/Cadastro.php"); private $cadastro;
public function __construct() {
$this->cadastro = new Cadastro();
$acao = $_POST['acao'];
if($acao == "incluir") {
$this->incluir();
}
}
private function incluir() {
$this->cadastro->setNome($_POST['nome']);
$this->cadastro->setIdade($_POST['idade']);
$this->cadastro->setTelefone($_POST['telefone']);
$result = $this->cadastro->incluir();
if($result >=1) {
echo "<script>alert('Registro incluído com sucesso!');document.location='../view/cad_cadastro.php'</script>";
} else {
echo "<script>alert('Erro ao gravar registro!');history.back()</script>";
}
}
}
new CadastroController();
?>
Primeiro incluímos o arquivo Cadastro.php que é nossa classe de modelo;
Declaramos um atributo privado: private $cadastro, que será um objeto de Cadastro;
public function __construct() {
....
}
Nosso método construtor instancia o objeto $this->cadastro da classe Cadastro;Verifica a ação passada no formulário de cadastro através do campo hidden, se a ação for incluir, executa o método incluir que nesta primeira parte será o único apresentado.
private function incluir() {
....
}
Método responsável em "setar" os valores passados pelo formulário para a camada de modelo, através do métodos: setNome(), setIdade() e setTelefone(), sendo referenciado pelo objeto $this->cadastro criado anteriormente;
Na sequência, o método incluir() da classe Cadastro é executado através do objeto $this->cadastro, e o retorno dado na classe Cadastro será armazenado na variável $result;
Então é feita a verificação se o resultado é 1 ou maior que 1, se sim, a query foi executada com sucesso, será apresentada uma mensagem de sucesso para o usuário e em seguida será redirecionado. Em caso de negação será apresentada a mensagem de falha;
E por fim, temos uma instância da própria classe "new CadastroController()", pois precisamos "startar" a classe no momento que ela é invocada pelo action do formulário.Resumindo tudo isso, temos um menu que chama um form que está na camada de visão (view), quando submetemos o form invocamos uma classe chamada CadastroController.php que pertence à camada de controle, que por sua vez "envia" os dados para a classe Cadastro.php que pertence à camada de controle, esta por sua vez executa o método da classe Banco.php nossa "DAO" que faz a inserção no banco de dados, devolvendo uma resposta às camadas anteriores.
Os arquivos foram todos testados em plataforma Windows e utilizando o pacote EasyPHP-5.3.0
Bom, então é isso, espero que gostem do tutorial e que seja útil para o aprendizado de alguém, qualquer coisa estarei à disposição.
Os arquivos poderão ser baixados no endereço: Clique aqui
Carregando comentários...