Persistência – s.f. Ato de persistir. / Qualidade do que dura.
Bom hoje vou falar de um assunto que particularmente entendo bem, pois fiz para meu trabalho de conclusão de curso, um framework de persistência web para PHP ( mais pra frente posso disponibilza-lo aqui). Vou escrever 3 artigos sobre esse assunto, que juntos nos trará um mini-framework para persistência de dados em PHP.
Introdução
Bom todo o sistema ou até mesmo web sites, necessitam armazer as informações inseridas neles, ou seja as informações deverão ser persistentes. Para isso sempre é utilizado um mecanismo de persistencia, que pode ser, um arquivo xml, texto, banco de dados orientado a objetos, banco de dados relacional, entre outros tipos possiveis de armazenar uma informação. O mais utilizado é o banco de dados relacional, que são bancos com varios padrões estabelecidos e anos de experiencia armazenando informações relacionalmente, além de terem sistemas que fazem a gerência das informações relacionais (SGBD – Sistema Gerenciador de Banco de Dados) de fabricantes, preços e objetivos diferentes. Um banco de dados relacional, como o nome já diz, armazena as informações relacionalmente dentro de tabelas. No caso um conjunto de registros ou informações de uma tabela podem estar relacionados com outros registros de outra tabela e assim por diante. Mas temos um problema ai, pois o banco de dados é relacional e a aplicação é orientada a objetos. Dois paradigmas diferentes, como tratar as informações entre esses dois caras? Ai que entra o framework de persistência.
Modelo Relacional x Modelo Orientado a Objetos
Se existe esse problema, então porque não utilizar um banco de dados orientado a objetos? Bom primeiro que o custo seria aumentado, pois eu nunca vi um desses ao vivo, mas sei que existe, então provavelmente arranjar pessoal para mexer com esse treco não deve ser tão facil. Segundo os bancos relacionais estão mais maduros que os OO. A orientação a objetos trabalha as informações como classes, atributos, métodos, etc… Enquanto os bancos de dados relacionais tratam as informações com tabelas, registros, indices, relacionamentos, etc… Então para que o programador trabalhe somente Orientado a objetos e o DBA (Administrador do banco de dados) cuide do banco relacional, é proposto um framework que ficará “no meio” desses dois cara (aplicação e banco), ele irá traduzir as informações OO para Relacional e Relacional para OO.
Classe de Conexão
Bom vamos para o que interessa, primeiramente vamo criar uma classe de conexão com o banco.
Descrição:
Como de praxe, vou utilizar o pattern Singleton para fazer a classe de conexão, onde somente existirá uma única instância da classe. Essa classe terá conexão com o banco MySQL (prometo postar uma classe com o PDO para vários bancos), e terá métodos para facilitar a manipulação das informações no banco (insert, delete, update).
conecta.php
class Conecta {
// atributo static para o singletom
static private $_instancia = null;
// variavel de conexão
private $_conexao = null;
// Construtor só é chamado quando não existir a instância
private function __construct(){
$_host = “localhost”;
$_database = “base”;
$_user = “usuario”;
$_password = “senha”;
$this->_conexao = mysql_connect($_host, $_user, $_password) or die(‘Não foi possível abrir uma conexão’ );
mysql_select_db($_database, $this->_conexao) or die(‘Base de dados nao encontrada.’);
}
// Método chamado para instânciar a classe
public static function getConexao() {
if (!self::$_instancia instanceof self) {
self::$_instancia = new self();
}
$con = self::$_instancia;
return $con;
}
// Fecha a conexão
public function close(){
if($this->_conexao)
mysql_close($this->_conexao);
}
/* Executa uma select
public function select($sql){
$resultado = mysql_query($sql,$this->_conexao);
// Erro na sql
if(!$resultado){
die(“Não foi possível executar a consulta ($sql ) no banco de dados: “ . mysql_error());
}
// Não existe erros
else{
// Recebe os resultados da consulta
while($row=mysql_fetch_assoc($resultado)) {
$retorno->result[] = $row;
}
// Recebe a quantidade de registros encontrados
$retorno->count= mysql_num_rows($resultado);
}
return $retorno;
}
// Executa a inserção no banco
public function insert($sql){
$resultado = mysql_query($sql,$this->_conexao);
//Erro na sql
if(!$resultado){
die(“Não foi possível executar a consulta ($sql) no banco de dados: ” . mysql_error());
}else{
// Retorna o id cadastrado se foi executado com sucesso
// Retorna false se não foi possivel fazer a execução
return (mysql_insert_id()) ? mysql_insert_id() : false;
}
}
// Executa a alteração no banco
public function update($sql,$unicos=null){
$resultado = mysql_query($sql,$this->_conexao);
//Erro na sql
if(!$resultado){
die(“Não foi possível executar a consulta ($sql) no banco de dados: ” . mysql_error());
}
//Retorna 1 (true) se foi executado com sucesso
return $resultado;
}
}
// Executa a exclusão no banco
public function delete($sql,$unicos=null){
$resultado = mysql_query($sql,$this->_conexao);
//Erro na sql
if(!$resultado){
die(“Não foi possível executar a consulta ($sql) no banco de dados: ” . mysql_error());
}
//Retorna 1 (true) se foi executado com sucesso
return $resultado;
}
}
Para fazer executar esse camarada ai.
$conn = Conecta::getConexao();
$rs = $conn->select(“SELECT nome,telefone FROM dados WHERE cidade=’cascavel'”);
if($rs->count > 0){
foreach($rs->result as $v){
echo $v[‘nome’] . “-“. $v[‘telefone’]. “<br>”;
}
}else{
echo “Não foi encontrado nenhum registro”;
}
A primeira parte é isso ai, próximo passo vou mostrar como criar as classes que serão manipuladas pela persistência. Qualquer coisa só entrar em contato =).
PS: SE ALGUEM TIVER UM TEMPLATE QUE FORMATE CÓDIGOS FONTES, POR FAVOR ME AVISEEEE.