Mas sem muita conversa, vamos direto ao que interessa: padrões de projeto.

Hoje inicio uma série de alguns posts falando sobre os padrões de projeto mais úteis para programadores PHP e algumas aplicações práticas dos mesmos. Então vamos estudar juntos!

Antes de começar…

Para iniciar os seus estudos, antes de mais nada, você deve estar familiarizado com o PHP 5 (ou superior). Assumo que você já tenha fluência na linguagem. Também é necessário que você já tenha uma boa noção de Orientação a Objetos. Todos os padrões de projeto são feitos de forma orientada a objetos e os termos abordados são diretamente ligados a este paradigma. Caso você não conheça esta metodologia ou nunca tenha trabalhado com ela, sugiro alguns links para dar uma olhada:

• Programação Orientada a Objetos: uma introdução
• Programação Orientada ao Objeto: uma abordagem didática
• Tutorial de Programação Orientada a Objetos no PHP
• PHP Orientado a Objetos: Para quem está começando

O que são e para que servem os Padrões de Projeto?

O conceito de padrões de projeto foi originalmente concebido pelo arquiteto austríaco Christopher Alexander, em meados da década de 1970. O que levou Alexander a realizar este estudo foi o fato de que ele gostaria de descobrir se havia alguma regra que pudesse especificar quando uma construção é de boa ou de má qualidade.

A partir deste estudo, Alexander começou a levantar pontos que estavam presentes em construções boas e não estavam nas ruins e vice versa. Com estes dados em mãos ele começou a elaborar diversas propostas para a solução de problemas comuns dentro da engenharia e da arquitetura.

Tendo isso em mente podemos afirmar que um padrão de projeto nada mais é do que uma forma prevista, estruturada e documentada de solucionar um dado problema que é bastante comum.

No início da década de 1990, a GoF (Gang of Four – Gangue dos Quatro), formada por Eric Gamma, Richard Helm, Ralph Johnson e John Vlissides percebeu que as técnicas publicas por Alexander iam muito além do objetivo de padronizar a criação arquitetônica. Era possível identificar padrões que iriam auxiliar na resolução dos problemas comumente encontrados durante o desenvolvimento de softwares. Lançaram então o Design Patterns: Elements of Reusable Object-Oriented Software, livro este que tornou-se a maior influência sobre a comunidade de desenvolvimento de softwares da época (e que perdura até hoje). Ao todo são citados 23 padrões, divididos em três categorias: criacionais, estruturais e comportamentais. Estas categorias serão explicadas mais adiante.

Por que estudar Padrões de Projeto?

Agora que você já sabe o que são os padrões de projeto, já deve estar procurando (se ainda não encontrou) motivos para estudá-los. Eis alguns bons motivos de porque você deve investir tempo de estudo nestes padrões:

• Reutiliza ao invés de redescobrir: todos os padrões já foram previamente testados e implementados em projetos que deram certo;
• Otimiza a comunicação entre os desenvolvedores: unifica a língua que é falada entre os envolvidos no projeto, pois todos tem ciência dos termos empregados;
• Facilita a análise: Quando você iniciar a análise já terá base e estará bem direcionado ao que implementar no seu projeto;
• Proporciona alterações menos dolorosas: uma vez que existe uma padronização, as alterações tornam-se mais simples devido às estruturações do projeto;
• Desestimula o uso de herança;
• Aumenta a confiabilidade;
• Reduz a complexidade do código;

Como dividem-se os padrões?

Para uma melhor organização dos padrões apresentados, eles foram divididos conforme a aplicação de cada um. As três categorias distintas dos padrões de projeto são:

• Criacionais: Abstraem e escondem o processo de instanciação. O sistema torna-se independente da maneira como o objeto é composto, construido e representado.
• Estruturais: Trabalham com a composição de classes e objetos, definindo a relação entre ambos.
• Comportamentais: Definem como os objetos irão se comportar e padroniza a comunicação que haverá entre os objetos dentro da estrutura do projeto.

E agora?

E agora, meus caros amigos, teremos que esperar pelo próximo post, onde vou começar a falar mais sobre os tipos de padrões, explicar melhor as divisões e dar um resumo de cada um.

Espero que esse post tenha servido para dar uma iluminada no conceito de Design Patterns que muitas vezes é bastante obscuro!

Aceito sugestões para as próximas postagens!

Um abraço a todos e fiquem com Deus!
Rafael Jaques

Para começar, uzaremos uma base de dados (banco de dados ou database, se preferir, dá na mesma) de exemplo como a abaixo (vou chamada de usuarios):

usuario                  senha                     email
fulano                   123456                    fulano@exemplo.com.br
beltrano                 asdfgh                    beltrano@exemplo.com.br
cicrano                  abcdef                    cicrano@exemplo.com.br

Um exemplo simples da forma tradicional de uso seria:

<?php
// Acesso de usuário
$usuario = "fulano";
$senha = "123456";

// Conexão
$banco = mysql_connect("localhost", "usuario", "senha");
// Banco
mysql_select_db("teste", $banco);

// Query
$res = mysql_query("SELECT * FROM usuarios WHERE usuario='$usuario' AND senha='$senha'", $banco);

// Lendo o resultado
if($resultado = mysql_fetch_array($res)) {
// E aqui você continua...
}
?>

Alguma coisas mudam quando se faz este serviço usando MySQLi. O que é de se esperar: tudo começa na instanciação do objeto da classe, que faz logo a conexão com o banco e a disponibiliza. O construtor recebe diversos parâmetros, mas os que mostrarei são os quatro primeiros, que correspondem a servidor, usuario, senha e banco, as primeiras linhas do código anterior ficariam assim:

<?php
// Acesso de usuário
$usuario = "fulano";
$senha = "123456";

// Conexão e banco
$banco = new MySQLi("localhost", "usuario", "senha", "teste");

Se os dados informados estiverem corretos, agora a variável $banco irá apontar para um objeto da classe MySQLi. Em seguida devemos chamar algum método da classe para continuar trabalhando, o equivalente à função mysql_query é o método MySQLi::query, que recebecomo parâmetro a string com o comando SQL e retorna um objeto MySQLi_Result no caso se um comando SELECT, SHOW, DESCRIBE ou EXPLAIN ou um booleano (TRUE ou FALSE) para os demais (como DELETE ou UPDATE). Então teremos:

// Query
$res = $banco->query(“SELECT * FROM usuarios WHERE usuario=’$usuario’AND senha=’$senha’”);

Finalmente executamos a consulta, podemosentão varrer os resultados obtidos, para isso teremos em mãos os métodos (os mais comuns de serem usados) MySQLi_Result::fetch_array, MySQLi_Result::fetch_assoc, MySQLi_Result::fetch_row e MySQLi_Result::fetch_object. Para compatibilidade com o primeiro exemplo, vejamos com MySQLi_Result::fetch_assoc:

// Lendo o resultado
if($ressultado = $res->fetch_assoc()) {
// E aqui você continua...
}
?>

Isso fez o serviço que queriamos de forma orientada a objetos, mas não necessariamente aumenta a segurança do código, algo que poderia fazer isso é o uso de Prepared Statement, que é possível de ser usado com MySQLi, mas este artigo se tornaria grande demais, por hora, vejamos o resultado final completo:

<?php
// Acesso de usuário
$usuario = "fulano";
$senha = "123456";

// Conexão e banco
$banco = new MySQLi("localhost", "usuario", "senha", "teste");

// Query
$res = $banco->query("SELECT * FROM usuarios WHERE usuario='$usuario'AND senha='$senha'");
// Lendo o resultado
if($ressultado = $res->fetch_assoc()) {
// E aqui você continua...
}
?>

Para ter mais informações veja o manual do PHP: http://www.php.net/manual/en/book.mysqli.php

A instrução include() ao gerar um erro gera um Warning. Deixando que o restante do script continue rodando.

A instrução require() ao gerar um erro gera um Fatal Error. Desta forma todo o script depois está instrução será paralisado.

Então cada instrução tem o seu momento de ser adicionada, julgo da seguinte forma, se o arquivo é realmente importante use o require senão use o include.

Outras instruções também usadas são as include_once() e a require_once().

Ambas agem da mesma forma que as duas primeiras porém só permitem a inclusão do mesmo script uma vez.

Espero que tenha sido o mais objetivo possível.

O site is.gd é um encurtador de URLs. O serviço básico deles é pegar uma URL grande e transformá-la em pequena.

Decidi começar com esse site porque é a API mais simples que eu encontrei.

Sobre a API

Documentação: http://is.gd/api_info.php
Necessita registro: Não
Limite de uso: Encurtamento de 1000 URLs/dia por IP
Termos de uso: http://is.gd/terms.php

Utilizando a API

O uso do is.gd é muito simples: você envia uma URL e recebe outra. A única limitação é quanto a URLs com mais de 2000 caracteres, o que não deve ser um problema já que é muito raro de se ver isso.

Para a nossa experiência, decidi fazer uma classe para trabalhar com o encurtamento de URLs. Para fins didáticos, não irei trabalhar com métodos e propriedades privados (só um ) e muito menos com padrões de projeto.

A classe vai funcionar da seguinte maneira: instanciamos o objeto, solicitamos o encurtamento da URL e depois trabalhamos com os dados recebidos.

As propriedades que o nosso objeto deve ter serão as seguintes:
url_original: URL original que foi passada para ser encurtada.
url_curta: URL curta retornada pelo servidor.
erro: true ou false, indicando se houve erro durante a tentativa de encurtar a URL.
erro_msg: no caso de ‘erro’ ser true, aqui fica a mensagem de erro, caso contrário fica como NULL.

E os métodos que utilizaremos:
encurtar: obviamente serve para encurtar a URL.
desencurtar: método “brinde” para desencurtar a URL, por que na real a própria API não desencurta as URLs.

Mão na massa

O primeiro passo é montar o corpo da nossa classe. Optei por utilizar um método de encurtar a URL para que o mesmo objeto possa ser utilizado para encurtar várias URLs e também te dá a possibilidade de instanciar o objeto apenas para desencurtar URLs.

Vou dar uma breve explicação do que há no código pois todo ele está comentado.

Para fazer o encurtamento precisamos enviar a URL para a API através do método GET.
Por exemplo: http://is.gd/api.php?longurl=phpit.com.br

Desta requisição podem retornar duas coisas: o status 200 (OK) com a URL encurtada ou o status 500 (Internal Server Error) com a mensagem de erro.

O método encurtar preenche as propriedades da classe com os dados pertinentes e retorna true para o caso de ter ocorrido tudo bem e false para o caso de ter dado problema.
Já o método desencurtar apenas retorna a URL desencurtada, sem mexer nas propriedades da classe. Pode também retornar false para o caso de a URL ser inválida.

A seguir você tem a classe na versão comentada e na versão não comentários.

Versão comentada:

<?php
class isgd {

// Declara as propriedades que serão utilizadas
public $url_original, $url_curta, $erro, $erro_msg = NULL;

// Este será nosso objeto cURL, o que utilizaremos para acessar a API
private $curl;

// Nosso método construtor, que será executado quando a classe for instanciada
public function __construct() {
// Cria nosso objeto cURL
$this->curl = curl_init();

// Configura o objeto para retornar os dados ao invés de imprimir na tela
curl_setopt($this->curl, CURLOPT_RETURNTRANSFER, 1);
/* Configura o objeto para responder a redirecionamentos
É utilizado no método de desencurtar URLs, pois precisamos seguir até a URL final */
curl_setopt($this->curl, CURLOPT_FOLLOWLOCATION, 1);
}

// Método para encurtar a URL
public function encurtar($url) {
// Utilizamos esta função para codificar os caracteres especiais da URL
$urlCodificada = rawurlencode($url);

// Esta é a URL que utilizaremos para acessar a API
$urlApi = ’http://is.gd/api.php?longurl=’.$urlCodificada;

// Configuramos a URL no cURL
curl_setopt($this->curl, CURLOPT_URL, $urlApi);

// Executamos a requisição
$retorno = curl_exec($this->curl);

// Recebemos os dados da execução
$dados = curl_getinfo($this->curl);

// O http_code pode ser 200 (OK) e 500 (Internal Server Error)
/* Junto com a verificação, é bom olhar também se a URL
possui menos de 20 caracteres, já que o is.gd trabalha
com no máximo 18. Isto ajuda a evitar error arbitrários. */
if ($dados['http_code'] == 200 && strlen($retorno) < 20) {
// Caso tenha ocorrido tudo bem, resetamos estas propriedades
$this->erro = false;
$this->erro_msg = NULL;
$this->url_curta = $retorno;
} else {
// Caso tenha dado algum problema, colocamos os dados aqui
$this->erro = true;
$this->erro_msg = $retorno;
$this->url_curta = NULL;
}

// Colocamos a URL original no seu lugar
$this->url_original = $url;

/* Por fim, para tornar mais fácil ainda, o retorno da função será
true ou false dependendo do resultado que obtivemos no processo */
return $this->erro;
}

// Método para desencurtar a URL
public function desencurtar($url) {
// Primeiro verificamos se a URL é realmente is.gd
if (substr($url, 0, 13) == ’http://is.gd/’ || substr($url, 0, 6) == ’is.gd/’) {
// Configuramos a URL no cURL
curl_setopt($this->curl, CURLOPT_URL, $url);

// Executamos a requisição
curl_exec($this->curl);

// Recebemos os dados da execução
$dados = curl_getinfo($this->curl);

// Testamos se o status é 200 e se a URL retornada é diferente da desencurtada
if ($dados['http_code'] == 200 && $url != $dados['url']) {
// Retornamos a URL desencurtada
return $dados['url'];
}
}
// Caso tenha dado algum problema no meio do caminho, retornamos false
return false;
}

}
?>

isgd Object
(
[url_original] => phpit.com.br
[url_curta] => http://is.gd/9Q9kP
[erro] =>
[erro_msg] =>
[curl:private] => Resource id #2
)

isgd Object
(
[url_original] => [...] uma url muito longa aqui [...]
[url_curta] =>
[erro] => 1
[erro_msg] => Error: The URL entered was too long.
[curl:private] => Resource id #2
)

Aqui estão todos os arquivos usados na série

Hoje nós vamos criar a página que cadastra a pergunta

<?php
//cadastra_pergunta.php
include('conexao.php');
if($_POST)
{
$pergunta = $_POST['pergunta'];
$sql = "INSERT INTO enq_perguntas(id,pergunta) VALUES(null,'{$pergunta}')";
$query = mysql_query($sql) or die("Erro: ".mysql_error());
$id_pergunta = mysql_insert_id();
if($query)
{
echo "
if( confirm(\"Voce gostaria de cadastrar outra pergunta? Clica sim para cadastrar outra pergunta e cancelar para uma opção\"))
{
window.location = 'cadastra_pergunta.php';
}
else
{
window.location = 'cadastra_opcao.php?pergunta={$id_pergunta}';
}
";
}
}

este e o link do primeiro artigo da serie
http://www.mxstudio.com.br/dreamweaver/criando-uma-enquete-dinamica-parte-1/
e este o do segundo artigo
http://www.mxstudio.com.br/dreamweaver/criando-uma-enquete-dinamica-parte-2/

mysql_connect($host, $user, $pass) or die('Erro :'.mysql_error());
mysql_select_db($db) or die('Erro:'.mysql_error());

este e o primeiro artigo da serie…

http://www.mxstudio.com.br/dreamweaver/criando-uma-enquete-dinamica-parte-1/

Nós vamos aprender a criar uma enquete dinâmica, com banco de dados.
A primeira parte é bem simples, vamos apenas criar o banco de dados. Usaremos somente 2 tabelas….

A primeira é a de perguntas. Vá ao seu phpmyadmin, crie um banco de dados, ou use um ja existente, vá na aba ‘SQL’, insira este o seguinte script sql, e cliquei em executar

CREATE TABLE `enq_perguntas` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`pergunta` varchar(250) CHARACTER SET latin1 COLLATE latin1_general_ci NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=17 DEFAULT CHARSET=utf8

a próxima tabela é a de opções

CREATE TABLE `enq_opcao` (
`id` int(11) NOT NULL AUTO_INCREMENT COMMENT ' ',
`pergunta_fk` int(11) NOT NULL,
`opcao` varchar(250) CHARACTER SET utf8 NOT NULL,
`votos` int(6) DEFAULT NULL,
PRIMARY KEY (`id`),
KEY `pergunta_fk` (`pergunta_fk`),
CONSTRAINT `enq_opcao_ibfk_1` FOREIGN KEY (`pergunta_fk`) REFERENCES `enq_perguntas` (`id`) ON DELETE CASCADE ON UPDATE CASCADE
) ENGINE=InnoDB AUTO_INCREMENT=8 DEFAULT CHARSET=utf8 COLLATE=utf8_latvian_ci

NOTA:
Observe que ambas as tabelas sao do tipo innodb, ou seja, o proprio banco eh que fara as referencias dos indices. Quando uma pergunta for excluida, todas as suas opcoes tambem serao…se as tabelas forem do tipo myisam, isso tera que ser feito manualmente….