Trabalhando com camadas

Para começar crie a seguinte estrutura de pastas:

pasta_raiz_do_site/trace

pasta_raiz_do_site/layers

pasta_raiz_do_site/config

A primeira classe é a de conexão:

pasta_raiz_do_site/config/Conexao.php

essa classe trabalha com os bancos MySQL, PostgreSQL e MSSQL e já implementa trasações (vide exemplos posteriores)

<?php
require_once("Config.php");
require_once("Trace.php");
require_once(dirname(dirname(realpath(__FILE__))) . "/layers/ExceptionsLayer.php");

/**
* Classe de conexão com o banco de dados
* @version 1.3
* @author Wagner Brandão Soares
*/
class Conexao
{
/**
* Constante para configurar o banco de dados PostgreSQL
*/

	const POSTGRESQL	= 1001;
	/**
 * Constante para configurar o banco de dados MySQL
 */
	const MYSQL = 1002;
	/**
 * Constante para configurar o banco de dados MS SQL Server
 */
	const MSSQL = 1003;

	/**
 * Variável para configurar o tipo de banco de dados
 */
	private $tipoBanco;
	/**
	* Variável para guardar a conexão
	*/
	private $conexao;
	/**
	* Instância para escrever no trace
	*/
	private $trace;
	/**
	* Variável para guardar o resultado das instruções SQL
	*/
	private $resultado;
	/**
	* Variável para retornar a quantidade de linhas afetadas pela instrução SQL.
	*/
	private $affectedRows;
	/**
	* Variável para retornar o status da transação.
	*/
	private $errorTransaction;

	/**
	* Construtor da classe Conexao
	*/
	public function __construct()
	{
 //inicia a variável que retorna as linhas afetadas na consulta
 $this->affectedRows = 0;
 // inicia a variável de status da transação
 $this->errorTransaction = false;

 //cria uma nova instância do trace
 $this->trace = new Trace(get_class($this));

 $this->trace->escreveTrace("Inicio do construtor-Conexao");

 //seleciona o tipo de banco de dados que será utilizado
 $this->tipoBanco = Config::TIPO_BANCO;

 //switch para executar a conexão com o tipo de banco de dados selecionado no arquivo de configuração
 switch($this->tipoBanco)
 {
 case self::POSTGRESQL:
 {
 $this->trace->escreveTrace("Conectando-se com servidor - PostgreSQL.");
 $this->conexao = @pg_connect("host=" . (Config::HOST) . " port=" . (Config::PORTA) . " dbname=" . (Config::BASE) . " user=" . (Config::USUARIO) . " password=" . (Config::SENHA));
 if(is_bool($this->conexao) && !$this->conexao)
 {
 //se houver algum erro na conexão o mesmo será escrito no trace
 $this->trace->escreveTrace("Erro ao tentar conectar-se com o servidor ou com a base - PostgreSQL.");

 $this->blnErro = true;
 //essa mensagem será retornada ao usuário
 throw new ExceptionsLayer("Não foi possível conectar-se com a base de dados.",ExceptionsLayer::CONNECTION_ERROR);
 return;
 }
 else
 {
 $this->trace->escreveTrace("Conexão efetuada com sucesso - PostgreSQL.");
 }
 }
 break;
 case self::MYSQL:
 {
 $this->trace->escreveTrace("Conectando-se com servidor - MySQL.");
 $this->conexao = @mysql_connect(Config::HOST.((Config::PORTA != "")?":".Config::PORTA:""),Config::USUARIO,Config::SENHA);

 if((mysql_errno() == 2003) || (mysql_errno() == 2005))
 {
 //se houver algum erro na conexão o mesmo será escrito no trace
 $this->trace->escreveTrace("Erro ao tentar conectar-se com o servidor - MySQL. (" . mysql_error() . ")");

 $this->blnErro = true;
 //essa mensagem será retornada ao usuário
 throw new ExceptionsLayer("Não foi possível conectar-se com o servidor.",ExceptionsLayer::CONNECTION_ERROR);

 return;
 }
 else if((mysql_errno() == 1044) || (mysql_errno() == 1045))
 {
 //se houver algum erro na conexão o mesmo será escrito no trace
 $this->trace->escreveTrace("Erro de autenticação com o servidor - MySQL. (" . mysql_error() . ")");

 $this->blnErro = true;
 //essa mensagem será retornada ao usuário
 throw new ExceptionsLayer("Não foi possível conectar-se com o servidor.",ExceptionsLayer::CONNECTION_ERROR);

 return;
 }
 else
 {
 $this->trace->escreveTrace("Conexão efetuada com sucesso - MySQL.");

 $acessaBase = @mysql_select_db(Config::BASE,$this->conexao);
 if(is_bool($acessaBase) && !$acessaBase)
 {
 //se houver algum erro na conexão com a base de dados o mesmo será escrito no trace
 $this->trace->escreveTrace("Erro ao tentar conectar-se com a base de dados - MySQL. (" . mysql_error($this->conexao) . ")");

 $this->blnErro = true;
 //no mysql a conexão com a base é feita separadamente da conexão,
 //mas se houver algum erro será retornado o mesmo da conexão para o usuário
 throw new ExceptionsLayer("Não foi possível conectar-se com o servidor.",ExceptionsLayer::CONNECTION_ERROR);

 return;
 }
 }
 }
 break;
 case self::MSSQL:
 {
 $this->trace->escreveTrace("Conectando-se com servidor - MSSQL.");
 $this->conexao = @mssql_connect(Config::HOST.((Config::PORTA != "")?",".Config::PORTA:""),Config::USUARIO,Config::SENHA);

 if(is_bool($this->conexao) && !$this->conexao)
 {
 //se houver algum erro na conexão o mesmo será escrito no trace
 $this->trace->escreveTrace("Erro ao tentar conectar-se com o servidor - MSSQL. (" . mssql_get_last_message() . ")");

 $this->blnErro = true;
 //essa mensagem será retornada ao usuário
 throw new ExceptionsLayer("Não foi possível conectar-se com o servidor.",ExceptionsLayer::CONNECTION_ERROR);

 return;
 }
 else
 {
 $this->trace->escreveTrace("Conexão efetuada com sucesso - MSSQL.");

 $acessaBase = @mssql_select_db(Config::BASE,$this->conexao);
 if(is_bool($acessaBase) && !$acessaBase)
 {
 //se houver algum erro na conexão com a base de dados o mesmo será escrito no trace
 $this->trace->escreveTrace("Erro ao tentar conectar-se com a base de dados - MSSQL. (" . mssql_get_last_message() . ")");

 $this->blnErro = true;
 //no mssql a conexão com a base é feita separadamente da conexão,
 //mas se houver algum erro será retornado o mesmo da conexão para o usuário
 throw new ExceptionsLayer("Não foi possível conectar-se com o servidor.",ExceptionsLayer::CONNECTION_ERROR);

 return;
 }
 }
 }
 break;
 default:
 break;
 }

 //inicia resultado
 $this->resultado = null;

 $this->trace->escreveTrace("Fim do construtor-Conexao");
	}

	/**
	* executeQuery()
	* Método para executar uma consulta na base de dados
	*/
	public function executeQuery($_stringSQL)
	{
 $this->trace->escreveTrace("Inicio da função executeQuery-Conexao");

 //switch para executar uma instrução SELECT com o tipo de
 //banco de dados selecionado no arquivo de configuração
 switch($this->tipoBanco)
 {
 case self::POSTGRESQL:
 {
 if(is_array($_stringSQL))
 {
 @pg_query($this->conexao, "START TRANSACTION");
 for($i = 0; $i < count($_stringSQL); $i++)
 {
 //executa a consulta
 $this->resultado = @pg_query($this->conexao, $_stringSQL[$i]);

 $this->affectedRows += @pg_affected_rows($this->resultado);

 //se houver algum erro cai aqui
 if(is_bool($this->resultado) && !$this->resultado)
 {
 //a mensagem de erro é escrita no trace
 $this->trace->escreveTrace("Erro ao tentar executar a instrução SQL:" . $_stringSQL[$i] . " - (" . pg_last_error($this->conexao) . ")");

 $this->errorTransaction = true;

 break;
 }
 }

 if($this->errorTransaction)
 {
 @pg_query($this->conexao, "ROLLBACK");

 $this->affectedRows = 0;

 $this->errorTransaction = false;

 throw new ExceptionsLayer("Erro ao tentar executar a instrução SQL.",ExceptionsLayer::SQL_ERROR);

 return;
 }
 else
 {
 @pg_query($this->conexao, "COMMIT");

 return array();
 }
 }
 else
 {
 //executa a consulta
 $this->resultado = @pg_query($this->conexao, $_stringSQL);

 $this->affectedRows = @pg_affected_rows($this->resultado);

 //se houver algum erro cai aqui
 if(is_bool($this->resultado) && !$this->resultado)
 {
 //a mensagem de erro é escrita no trace
 $this->trace->escreveTrace("Erro ao tentar executar a instrução SQL:\n" . $_stringSQL . " - Postgre error:".pg_last_error($this->conexao));

 throw new ExceptionsLayer("Erro ao tentar executar a instrução SQL.",ExceptionsLayer::SQL_ERROR);
 return;
 }
 else
 {
 $this->trace->escreveTrace("Fim da função executeQuery-Conexao");

 $this->resultado = @pg_fetch_all($this->resultado);
 //retorna o resultado da pesquisa
 return (is_bool($this->resultado) && !$this->resultado)?array():$this->resultado;
 }
 }
 }
 break;
 case self::MYSQL:
 {
 if(is_array($_stringSQL))
 {
 @mysql_query("START TRANSACTION");
 for($i = 0; $i < count($_stringSQL); $i++)
 {
 //executa a consulta
 $this->resultado = @mysql_query($_stringSQL[$i]);

 $this->affectedRows += @mysql_affected_rows();

 //se houver algum erro cai aqui
 if(is_bool($this->resultado) && !$this->resultado)
 {
 //a mensagem de erro é escrita no trace
 $this->trace->escreveTrace("Erro ao tentar executar a instrução SQL:" . $_stringSQL[$i] . " - (" . mysql_error($this->conexao) . ")");

 $this->errorTransaction = true;

 break;
 }
 }

 if($this->errorTransaction)
 {
 @mysql_query("ROLLBACK");

 $this->affectedRows = 0;

 $this->errorTransaction = false;

 throw new ExceptionsLayer("Erro ao tentar executar a instrução SQL.",ExceptionsLayer::SQL_ERROR);

 return;
 }
 else
 {
 @mysql_query("COMMIT");

 return array();
 }
 }
 else
 {
 //executa a consulta
 $this->resultado = @mysql_query($_stringSQL);

 $this->affectedRows = @mysql_affected_rows();

 //se houver algum erro cai aqui
 if(is_bool($this->resultado) && !$this->resultado)
 {
 //a mensagem de erro é escrita no trace
 $this->trace->escreveTrace("Erro ao tentar executar a instrução SQL:" . $_stringSQL . " - (" . mysql_error($this->conexao) . ")");

 throw new ExceptionsLayer("Erro ao tentar executar a instrução SQL.",ExceptionsLayer::SQL_ERROR);

 return;
 }
 else
 {
 $this->trace->escreveTrace("Fim da função executeQuery-Conexao");

 //retorna o resultado da pesquisa
 if((strpos($_stringSQL,"UPDATE") === false) && (strpos($_stringSQL,"INSERT") === false) && (strpos($_stringSQL,"DELETE") === false))
 {
 $this->resultado = $this->mysql_fetch_all($this->resultado);
 return (is_bool($this->resultado) && !$this->resultado)?array():$this->resultado;
 }
 else
 return (is_bool($this->resultado) && !$this->resultado)?array():$this->resultado;
 }
 }
 }
 break;
 case self::MSSQL:
 {
 if(is_array($_stringSQL))
 {
 @mssql_query("START TRANSACTION");
 for($i = 0; $i < count($_stringSQL); $i++)
 {
 //executa a consulta
 $this->resultado = @mssql_query($_stringSQL[$i]);

 $this->affectedRows += @mssql_rows_affected($this->conexao);;

 //se houver algum erro cai aqui
 if(is_bool($this->resultado) && !$this->resultado)
 {
 //a mensagem de erro é escrita no trace
 $this->trace->escreveTrace("Erro ao tentar executar a instrução SQL:" . $_stringSQL[$i] . " - (" . mssql_get_last_message() . ")");

 $this->errorTransaction = true;

 break;
 }
 }

 if($this->errorTransaction)
 {
 @mssql_query("ROLLBACK");

 $this->affectedRows = 0;

 $this->errorTransaction = false;

 throw new ExceptionsLayer("Erro ao tentar executar a instrução SQL.",ExceptionsLayer::SQL_ERROR);

 return;
 }
 else
 {
 @mssql_query("COMMIT");

 return array();
 }
 }
 else
 {
 //executa a consulta
 $this->resultado = @mssql_query($_stringSQL);

 $this->affectedRows = @mssql_rows_affected($this->conexao);

 //se houver algum erro cai aqui
 if(is_bool($this->resultado) && !$this->resultado)
 {
 //a mensagem de erro é escrita no trace
 $this->trace->escreveTrace("Erro ao tentar executar a instrução SQL:" . $_stringSQL . " - (" . mssql_get_last_message() . ")");

 throw new ExceptionsLayer("Erro ao tentar executar a instrução SQL.",ExceptionsLayer::SQL_ERROR);

 return;
 }
 else
 {
 $this->trace->escreveTrace("Fim da função executeQuery-Conexao");

 //retorna o resultado da pesquisa
 if((strpos($_stringSQL,"UPDATE") === false) && (strpos($_stringSQL,"INSERT") === false) && (strpos($_stringSQL,"DELETE") === false))
 {
 $this->resultado = $this->mssql_fetch_all($this->resultado);
 return (is_bool($this->resultado) && !$this->resultado)?array():$this->resultado;
 }
 else
 return (is_bool($this->resultado) && !$this->resultado)?array():$this->resultado;
 }
 }
 }
 break;
 default:
 {
 }
 break;
 }
 $this->trace->escreveTrace("Fim da função executeQuery-Conexao");
	}

	/**
	* fechaConexao()
	* Método para executar o fechamento da conexão
	*/
	public function fechaConexao()
	{
 $this->trace->escreveTrace("Inicio da função fechaConexao-Conexao");

 //switch para executar o fechamento da conexão
 switch($this->tipoBanco)
 {
 case self::POSTGRESQL:
 {
 //fecha a conexão
 $this->resultado = @pg_close($this->conexao);

 //se houver algum erro durante o fechamento cai aqui
 if(is_bool($this->resultado) && !$this->resultado)
 {
 $this->trace->escreveTrace("Erro ao tentar fechar a conexão");

 throw new ExceptionsLayer("Erro ao tentar fechar a conexão com o banco de dados.",ExceptionsLayer::CONNECTION_ERROR);

 return;
 }
 else
 {
 $this->trace->escreveTrace("Fim da função fechaConexao-Conexao");

 //retorna verdadeiro se o fechamento foi efetuado
 return true;
 }
 }
 break;

 case self::MYSQL:
 {
 //fecha a conexão
 $this->resultado = @mysql_close($this->conexao);

 //se houver algum erro cai aqui
 if(is_bool($this->resultado) && !$this->resultado)
 {
 $this->trace->escreveTrace("Erro ao tentar fechar a conexão");

 throw new ExceptionsLayer("Erro ao tentar fechar a conexão com o banco de dados.",ExceptionsLayer::CONNECTION_ERROR);

 return;
 }
 else
 {
 $this->trace->escreveTrace("Fim da função fechaConexao-Conexao");

 //retorna verdadeiro se o fechamento foi efetuado
 return true;
 }
 }
 break;

 case self::MSSQL:
 {
 //fecha a conexão
 $this->resultado = @mssql_close($this->conexao);

 //se houver algum erro cai aqui
 if(is_bool($this->resultado) && !$this->resultado)
 {
 $this->trace->escreveTrace("Erro ao tentar fechar a conexão");

 throw new ExceptionsLayer("Erro ao tentar fechar a conexão com o banco de dados.",ExceptionsLayer::CONNECTION_ERROR);

 return;
 }
 else
 {
 $this->trace->escreveTrace("Fim da função fechaConexao-Conexao");

 //retorna verdadeiro se o fechamento foi efetuado
 return true;
 }
 }
 break;

 default:
 {
 }
 break;
 }
 $this->trace->escreveTrace("Fim da função fechaConexao-Conexao");
	}

	private function mysql_fetch_all($query)
	{
 $result = array();
 while($row = mysql_fetch_assoc($query))
 {
 array_push($result, $row);
 }
 return $result;
	}

	private function mssql_fetch_all($query)
	{
 $result = array();
 while($row = mssql_fetch_assoc($query))
 {
 array_push($result, $row);
 }
 return $result;
	}

	/**
	* getAffectedRows()
	* Método para retornar o número de linhas afetadas pela instrução sql
	*/
	public function getAffectedRows()
	{
 $linhas = $this->affectedRows;
 $this->affectedRows = 0;
 return $linhas;
	}
}
?>

a próxima classe é a de configuração do banco pasta_raiz_do_site/config/Config.php

<?php
/**
* Classe de configuração da base
* @version 1.0
* @author Wagner Brandão Soares
*/
class Config
{

	const HOST = "servidor";
	const PORTA = "3306";
	const BASE = "dtm";
	const USUARIO = "root";
	const SENHA = "plan";
	const TIPO_BANCO	= 1002;

	public function __construct()
	{

	}
}
?>

a próxima classe é a de trace pasta_raiz_do_site/config/Trace.php

<?php
/**
* Classe para a geração do trace
* @version 1.0
* @author Wagner Brandão Soares
*/
class Trace
{

	private $stream;
	private $nomeArquivo;
	private $debug;

	public function __construct($_nome_modulo)
	{
 $this->nomeArquivo = "./trace/" . $_nome_modulo. date("d-m-y") . ".txt";
 $this->debug = true;
	}

	public function escreveTrace($_stringMensagem)
	{
 if($this->debug)
 {
 $this->stream = fopen($this->nomeArquivo, "ab");
 fwrite($this->stream,date("d-m-y H:i:s") . " : " . $_stringMensagem . "\r\n");
 fclose($this->stream);
 }
	}
}
?>

a próxima classe é a de declaração dos SQLs pasta_raiz_do_site/layers/SqlLayer.php

<?php
/**
* Classe para a declaração dos SQLs.
* @version 1.0
* @author Wagner Brandão Soares
*/
class SqlLayer
{

	private $prefixo;

	public function __construct()
	{
 $this->prefixo = "dtm_";
	}

	/**
 * Retorna o SQL para o cadastro dos logs do sistema.
 */
	public function insereLog($arrayInfoLog)
	{
 return "INSERT INTO ".$this->prefixo."logs
 ( usuario
 , data
 , hora
 , log
 , idioma)
 VALUES
 ( '".$arrayInfoLog['usuario']."'
 , '".$arrayInfoLog['data']."'
 , '".$arrayInfoLog['hora']."'
 , '".$arrayInfoLog['log']."'
 , '".$arrayInfoLog['lingua']."');";
	}
}
?>

a próxima classe é a base da camada de acesso pasta_raiz_do_site/layers/AccessBase.php

<?php

/**
* Classe base para a classe de acesso a base de dados.
* @version 1.0
* @author Wagner Brandão Soares
*/
class AccessBase
{
/**
* Variável booleana de erro do sistema
*/

	protected $blnErro;
	/**
 * Variável com a mensagem de erro do sistema
 */
	protected $strMensagemErro;
	/**
 * Instância para uma nova conexão
 */
	protected $conexao;
	/**
 * Variável para guardar os resultados das instruções SQL
 */
	protected $resultado;
	/**
 * Instância do trace
 */
	protected $trace;
	/**
 * Variável para guardar a quantidade de linhas afetadas pela instrução SQL
 */
	protected $affectedRows;

	public function __construct()
	{
 $this->conexao = null;

 $this->resultado = array();

 $this->affectedRows = 0;

 $this->blnErro = false;
	}

	/**
 * Método para retornar a variável booleana de erro do sistema
 */
	public function getBlnErro()
	{
 $erro = $this->blnErro;
 $this->blnErro = false;
 return $erro;
	}

	/**
 * Método para retornar a variável com a mensagem de erro do sistema
 */
	public function getStrMensagemErro()
	{
 $mensagem = $this->strMensagemErro;
 $this->strMensagemErro = null;
 return $mensagem;
	}

	/**
	* Método para retornar o número de linhas afetadas pela instrução sql
	*/
	public function getAffectedRows()
	{
 $linhas = $this->affectedRows;
 $this->affectedRows = 0;
 return $linhas;
	}
}
?>

a próxima classe é a camada de acesso pasta_raiz_do_site/layers/AccessLayer.php

<?php
require_once("SqlLayer.php");
require_once(dirname(dirname(realpath(__FILE__))) . "/config/Trace.php");
require_once(dirname(dirname(realpath(__FILE__))) . "/config/Conexao.php");
require_once("ExceptionsLayer.php");
require_once("AccessBase.php");

/**
* Classe de acesso a base de dados.
* @version 1.0
* @author Wagner Brandão Soares
*/
class AccessLayer extends AccessBase
{
/**
* Instância de SqlLayer
*/

	private $sqlLayer;

	public function __construct()
	{
 parent::__construct();

 //cria uma instância do trace
 $this->trace = new Trace(get_class($this));

 $this->trace->escreveTrace("Inicio do construtor-AccessLayer");

 //cria uma instância da camada de SQL
 $this->sqlLayer = new SqlLayer();

 $this->trace->escreveTrace("Fim do construtor-AccessLayer");
	}

	/**
 * Insere o cadastro de acesso no sistema.
 */
	public function insereLog($arrayInfoLog)
	{
 $this->trace->escreveTrace("Inicio do insereAcesso-AccessLayer");

 try
 {
 //cria uma nova conexão
 $this->conexao = new Conexao();

 $sql = $this->sqlLayer->insereLog($arrayInfoLog);

 //escreve o sql no trace para posterior consulta de erro
 if(is_array($sql)) for($i = 0; $i < count($sql); $i++) $this->trace->escreveTrace($sql[$i]);
 else $this->trace->escreveTrace($sql);

 //recebe o resultado da execução da query
 $this->resultado = $this->conexao->executeQuery($sql);

 $this->affectedRows = $this->conexao->getAffectedRows();
 }
 catch(Exception $ex)
 {
 if($ex->getCode() == ExceptionsLayer::CONNECTION_ERROR)
 {
 $this->strMensagemErro = $ex->getMessage();
 }
 else if ($ex->getCode() == ExceptionsLayer::SQL_ERROR)
 {
 $this->strMensagemErro = "Não foi possível inserir o log de acesso.";
 }

 $this->blnErro = true;
 return array();
 }

 if($this->affectedRows == 0)
 {
 $this->strMensagemErro = "Ocorreu um erro ao tentar inserir o log de acesso.";
 $this->blnErro = true;
 }

 //fecha a conexão
 $this->conexao->fechaConexao();

 $this->trace->escreveTrace("Fim do insereAcesso-AccessLayer");

 //retorna o resultado da instrução sql
 return $this->resultado;
	}

	/**
 * Verifica o login do usuário no sistema.
 */
	public function verificaLogin($infoLogin)
	{
 $this->trace->escreveTrace("Inicio do verificaLogin-AccessLayer");

 try
 {
 //cria uma nova conexão
 $this->conexao = new Conexao();

 $sql = $this->sqlLayer->verificaLogin($infoLogin);

 //escreve o sql no trace para posterior consulta de erro
 if(is_array($sql)) for($i = 0; $i < count($sql); $i++) $this->trace->escreveTrace($sql[$i]);
 else $this->trace->escreveTrace($sql);

 //recebe o resultado da execução da query
 $this->resultado = $this->conexao->executeQuery($sql);

 $this->affectedRows = $this->conexao->getAffectedRows();
 }
 catch(Exception $ex)
 {
 if($ex->getCode() == ExceptionsLayer::CONNECTION_ERROR)
 {
 $this->strMensagemErro = $ex->getMessage();
 }
 else if ($ex->getCode() == ExceptionsLayer::SQL_ERROR)
 {
 $this->strMensagemErro = "Não foi possível verifica o login do usuário.";
 }

 $this->blnErro = true;
 return array();
 }

 if(count($this->resultado) == 0)
 {
 $this->strMensagemErro = "Login ou senha incorreto(a).";
 $this->blnErro = true;
 }

 //fecha a conexão
 $this->conexao->fechaConexao();

 $this->trace->escreveTrace("Fim do verificaLogin-AccessLayer");

 //retorna o resultado da instrução sql
 return $this->resultado;
	}
}
?>

a próxima classe é a exceções (básica) pasta_raiz_do_site/layers/ExceptionsLayer.php

<?php
/**
* Classe de exceções do sistema.
* @version 1.0
* @author Wagner Brandão Soares
*/
class ExceptionsLayer extends Exception
{

	const NOT_NULL = 1001;
	const INCORRECT_FORMAT	= 1002;
	const CONNECTION_ERROR	= 1003;
	const SQL_ERROR = 1004;

	public function __construct($_mensagem, $_codigo)
	{
 parent::__construct($_mensagem, $_codigo);
	}
}
?>

Bom primeiramente cria-se uma camada que acessará a camada de acesso ao banco (AccessLayer):

pasta_raiz_do_site/produtos_class.php

<?php
require_once("layers/AccessLayer.php");

class produtos_class
{

/**
* Instância de AccessLayer
*/

	private $accessLayer;

	/**
 * Construtor da classe
 */
	public function __construct()
	{
 if(!isset($_SESSION['AccessLayer']))
 {
 $_SESSION['AccessLayer'] = new AccessLayer();
 }
 $this->accessLayer = $_SESSION['AccessLayer'];
	}

	/**
 * Retorna um valor booleano se houve erro
 */
	public function getBlnErro()
	{
 return $this->accessLayer->getBlnErro();
	}

	/**
 * Retorna a mensagem de erro do sistema
 */
	public function getStrMensagemErro()
	{
 return $this->accessLayer->getStrMensagemErro();
	}

	/**
 * Retorna o número de linhas afetadas por uma instrução SQL.
 */
	public function getAffectedRows()
	{
 return $this->accessLayer->getAffectedRows();
	}

	/**
 * Insere um contador de acesso do sistema.
 */
	public function insereLog($arrayInfoLog)
	{
 return $this->accessLayer->insereLog($arrayInfoLog);
	}

	/**
 * Consulta os produtos do sistema.
 */
	public function consultaProdutos($infoPaginacao)
	{
 return $this->accessLayer->consultaProdutos($infoPaginacao);
	}

	/**
 * Exclui um produto do sistema.
 */
	public function excluirProduto($id)
	{
 return $this->accessLayer->excluirProduto($id);
	}

	/**
 * Consulta os tipos de produtos do sistema.
 */
	public function consultaTipoProdutos($infoPaginacao)
	{
 return $this->accessLayer->consultaProdutos($infoPaginacao);
	}
}
?>

agora um exemplo de como utilizar:

pasta_raiz_do_site/produtos.php

<?php

require_once("produtos_class.php");

$infoPaginacao = array();
$infoPaginacao['id']	= 0;
$infoPaginacao['ini']	= 0;
$infoPaginacao['fim']	= 0;

$produtos = array();

$produtos = $produtos_class->consultaProdutos($infoPaginacao);
$erro = $produtos_class->getBlnErro();
$mensagem = $produtos_class->getStrMensagemErro();

// exemplo de como trabalhar com os dados retornados do banco

if(!$erro)
{
for($i = 0; $i < count($produtos); $i++)
{

 echo "Id do produto: ".$produtos[$i]['id']."<br />";
 echo "Nome do produto: ".$produtos[$i]['nome']."<br /><br />";
	}
}
else echo $mensagem;

?>

No próximo post, mostrarei como trabalhar com transações. Qualquer dúvida é só perguntar.