Como aplicações PHP se tornam cada vez mais e mais
complexas, isso pode ser fácil para acabar com um emaranhado de códigos que faz
a manutenção ser quase impossível. Aplicar o conceito de diferenciação de
aplicativos pode ajudar a aliviar algumas das dificuldades em manter aplicações
complexas.

• Source –
  clique aqui para obter o código.

O que queremos dizer por
Tiered Applications?

Tiered Programming é a prática de manter diferentes
componentes, ideias ou línguas separadas umas das outras. No desenvolvimento
front-end, diferenciar marcação seria usar stylesheets e JavaScript externos.

Ao ligar a um arquivo CSS em vez de encaixar estilos em seu
HTML markup, torna-se mais fácil para alterar a formatação de seus sites porque
agora toda informação estilizada é convenientemente armazenado em um lugar,
separado da marcação do documento. E múltiplas páginas HTML podem puxar
exatamente o mesmo arquivo CSS, todo o seu site pode ser atualizado
simplesmente ao mudar uma linha de CSS.

Em desenvolvimento back-end, as mesmas regras se aplicam,
mas estamos lidando com diferentes componentes. Em termos gerais, estamos
olhando para três níveis: a Database (armazenando e recuperando de dados), Business (processando e manipulando os dados), e Presentation (como os dados são
apresentados).

Por que eu devo ter
cuidado?

Pode não ser imediatamente óbvio, mas separando as suas
aplicações em uma estrutura em camadas terá um enorme impacto sobre a
habilidade do código ao ser mudado no futuro. Por exemplo, se você tem um
sistema de criação de blogs, e torna-se necessário criar um feed RSS para
o blog, as aplicações diferenciadas apropriadas lhe autorizariam a simplesmente
criar um template RSS, e em seguida conectar ao banco de dados e funções empresariais
que você escreveu.

Por outro lado, se o seu cliente de repente decidiu que PostgreSQL
era uma escolha melhor para sua organização do que o MySQL, você teria que
reescrever as funções do seu banco de dados, todos sem tocar o negócio ou
apresentação lógica da aplicação.

Em termos de reutilização, você poderia ter várias
funcionalidades do banco de dados (suportando MySQL, PostgreSQL e Oracle, por
exemplo), que poderiam ser facilmente usadas em novas implantações de sua
aplicação usando apenas algumas linhas de código em um lugar, em vez de editar
várias linhas do seu código através de várias funções.

O caminho errado

Para começar, vamos
ter uma tarefa bastante simples – puxar o título e o corpo do texto de uma
entrada de um banco de dados, criar uma versão abreviada da entrada, e colocar
os dados em HTML markup – e vá completamente no caminho errado. No código
a seguir, vamos escrever uma função para realizar todas as nossas tarefas:

function displayEntry()
{
	$entryDisp = NULL;

	// Get the information from the database
	$sql = "SELECT title, entry FROM entries WHERE page='blog'";
	$r = mysql_query($sql) or die(mysql_error());
	while($entry = mysql_fetch_assoc($r)) {
		$title = $entry['title'];
		$text = $entry['entry'];

		// Create the text preview
		$textArray = explode(' ',$text);
		$preview = NULL;
		for($i=0; $i<24; $i++) {
			$preview .= $textArray[$i] . ' ';
		}
		$preview .= $textArray[24] . '...';

		// Format the entries
		$entryDisp .= <<<ENTRY_DISPLAY

<h2> $title </h2>
<p>
$preview
</p>
ENTRY_DISPLAY;
	}

	return $entryDisp;
}

O código do HTML
markup sai de acordo com estas linhas:

<h2> Entry One </h2>
<p>
This is the shortened description of entry number one. It 
displays the first 25 words of the entry and then trails 
off with an ellipsis...
</p>
<h2> Entry Two </h2>
<p>
This is the shortened description of entry number two. It 
displays the first 25 words of the entry and then trails 
off with an ellipsis...
</p>

Embora isso possa parecer lógico, é realmente muito
indesejável. Vamos passar em revista o que torna este um código menos do que
uma ótima abordagem.

O problema com esta
abordagem

Poor Legibility  – Este código é diluído. O seu objetivo,
embora documentado nos comentários (ou algo do tipo), é difícil de discernir. Se
você escreveu isso, quando voltar para ele em seis meses, não será claro o que estava acontecendo, o que significa alguns
segundos/minutos desperdiçados tentando interpretar o seu próprio código.

Too Narrow em Foco – Esta função é falha pela sua especificidade:
a query do banco de dados só funciona para um tipo de entrada; um preview na
criação do código é muito bem codificado para a função, a formatação é
específica para o tipo de entrada que está sendo exibido. A fim de criar uma implementação ligeiramente diferente desta
funcionalidade, seríamos forçados a criar uma segunda função que pareceria quase
exatamente o mesmo, ainda que o necessário fosse apenas mudar o número de
palavras na visualização do texto.

Falta de Escalabilidade – Isso
é muito relacionado com a idéia de ser demasiado em destaque. Se
queremos adicionar mais funcionalidades (como um link ou uma imagem), a nossa
função será maior e mais difícil de gerenciar. E se quisermos acrescentar
condições que afetam o modo como uma entrada é exibida? É fácil ver como
programar assim deixa fácil para o código se tornar rapidamente expansivo e
ingerenciável.

O grande problema: Database, Business e
Display Logic

Esta é a questão que está causando varredura de todos os problemas acima mencionados.

“Ao
combinar os três tipos de nossa lógica, acabamos com um limitado, confuso,
difícil de gerenciar, quase impossível para reutilizar emaranhado de
código.”

Imagine uma aplicação onde cada tipo de visualização (RSS
feed, entrada preview, total entrada no visor, etc.) foi construído com uma
função similar às citadas acima, com acesso a base de dados, lógica empresarial, e
apresentação lógica tudo escrito em conjunto. Agora imagine que há nove páginas
do site, e todas têm a sua própria entrada exibir e visualizar funções.

Mesmo se considerarmos que a aplicação é muito simples e que
existam apenas duas funções por página do site, ainda estamos olhando para quase
vinte funções que terão de ser
atualizadas, se as alterações se tornarem necessárias.

Melhorando o código

Para melhorar o
código acima, nós iremos espalhar nossos diferentes tipos de lógica através de
várias funções. Se feito corretamente, devemos acabar com um conjunto de
funções reutilizáveis, fáceis de entender e que executam uma variedade de tarefas.

Para começar, vamos
planejar as funcionalidades necessárias para ter uma melhor ideia de como ele
deveria ser construído:

1. Obtenha a entrada e uma coluna de títulos para uma
   determinada página da tabela “entries” no banco de dados
2. Encurte o corpo da entrada para visualização de 25
   palavras e anexe uma elipse
3. Insira os dados em tags HTML para exibição no navegador
   do usuário

Como você pode ver, o nosso plano
identifica claramente um banco de dados, negócios, apresentação e grau.
Podemos agora escrever funções para cumprir cada um desses passos com relativa
facilidade.

Passo 1 – A camada do banco de dados

Para obter informação do banco de dados, nós iremos escrever
uma função muito simples. Para incentivar boas práticas de codificação, eu irei
usar a extensão mysqli,
mas não vou me focar em como isso funciona. Se você ainda não está usando, eu te incentivo a explorar o mysqli ou uma extensão similar (i.e. PDO) para garantir suas consultas do MySQL
contra ataques de injeção.

function getDataFromDB($page)
{
	/*
	 * Connect to a MySQL server
	 */
	$mysqli = new mysqli('localhost', 'user', 'password', 'world');
	if (mysqli_connect_errno()) {
		printf("Connect failed: %s\n", mysqli_connect_error());
		exit;
	}

	/*
	 * Create a prepared statement for pulling all entries from a page
	 */
	if ($stmt = $mysqli->prepare('SELECT title, entry FROM entries WHERE page=?')) {
		/*
		 * Create a multi-dimensional array to store
		 * the information from each entry
		 */
		$entries = array();

		/*
		 * Bind the passed parameter to the query, retrieve the data, and place
		 * it into the array $entries for later use
		 */
		$stmt->bind_param("s", $page);
		$stmt->execute();
		$stmt->bind_result($title, $entry);
		while($stmt->fetch()) {
	        $entries[] = array(
				'title' => $title, 
				'entry' => $entry
			);
	    }

	    /*
	     * Destroy the result set and free the memory used for it
	     */
	    $stmt->close();
	}

	/*
	 * Close the connection
	 */
	$mysqli->close();

	/*
	 * Return the array
	 */
	return $entries;
}

Se você quebrar
o que esta função está fazendo, estamos literalmente solicitando apenas duas
colunas (título e entrada) de nossa tabela (entries) e, em seguida, armazenando
cada entrada em uma matriz associativa multi-dimensional, que é o valor de
retorno da função. Nós passamos um parâmetro, $ page, para que possamos
determinar qual página iremos obter as informações. Ao fazê-lo, temos agora
criada uma função que irá trabalhar para todas as páginas do nosso site (desde
que todas elas tenham as fields “title” e “entry”).

Repare que a nossa função não faz nada para lidar com os
dados, ele simplesmente age como um correio, pegar as informações que
solicitamos e passando-o para o que vem a seguir. Isto é importante, porque se
fez nada de mais, gostaríamos de estar na esfera da lógica empresarial.

Por que isso é
importante para separar a lógica empresarial da lógica do banco de dados?

A resposta curta é que isso autoriza a abstração do banco
de dados, o que significa essencialmente que o dado poderia ser migrado do
MySQL dentro de um outro formato de base de dados, tal como PostgreSQL ou
Oracle, todos, sem alterar as funções dos dados de movimentação (business
tier), desde que a produção continue a ser simplesmente uma
ordem multi-dimensional associativa contendo entradas com uma coluna de título
e de entrada, não importa que tipo de banco de dados que estamos utilizando.

Passo 2 – A camada
Business

Com os dados carregados em nossa matriz, podemos iniciar processando a informação para servir para nossos propósitos. Neste exemplo,
estamos tentando criar uma entrada de visualização. No primeiro exemplo, a
duração da visualização foi dificilmente codificada dentro da função, o que decidimos que é de má prática. Nesta função, vamos passar dois parâmetros
para o nosso código: o texto a processar, e o número de palavras que deseja
exibir como nossa pré visualização.

Dê uma olhada na
função:

function createTextPreview($text, $length=25)
{
	/*
	 * Break the text apart at the spaces and create the preview variable
	 */
	$words = explode(' ', $text);
	$preview = NULL;

	/*
	 * Run a loop to add words to the preview variable
	 */
	if($length < count($words)) {
		for($i=0; $i<$length; $i++) {
			$preview .= $words[$i] . ' '; // Add the space back in between words
		}
		$preview .= $words[$length] . '...'; // Ellipsis to indicate preview
	} else {
		/*
		 * If the entry isn't as long as the specified preview length, simply
		 * return the whole entry.
		 */
		$preview = $text;
	}

	/*
	 * Return the preview
	 */

	return $preview;

}

Na função acima, simplesmente checamos que o número de
palavras na entrada fornecida é superior ao número de palavras que
queremos exibir em nossa visualização. Em seguida, adicione palavras à
recém-criada variável $preview uma de cada vez até atingir o comprimento
máximo, ao ponto que colocar uma elipse e retornar $preview.

Assim como na camada de nossa base de dados, estamos
mantendo o código dentro dos limites da camada Business. Tudo que nós estamos
fazendo é criando um texto visualização; não há interação com o banco de dados,
nem elementos presenciais, como HTML markup.

Passo 3 – A camada de
apresentação

Finalmente, temos de mostrar os dados que obtivemos e processamos. Para nosso propósito, o que vamos exibir é
extremamente simples com HTML markup:

<?php
	$entries = getDataFromDB(); // Load entries into an array
	foreach($entries as $entry) {
		/*
		 * Place the title and shortened entry text into two appropriately
		 * named variables to further simplify formatting. Also note that
		 * we're using the optional $length parameter to create a 30-word 
		 * text preview with createTextPreview()
		 */
		$title = $entry['title'];
		$preview = createTextPreview($entry['entry'], 30);
?>

	<h2> <?php echo $title; ?> </h2>
	<p> <?php echo $preview; ?> </p>

<?php
	} // End foreach loop
?>

A ideia por trás do código é bem simples: primeiro, carrega
as entradas usando a função da base de dados, então faz um loops nos dados
através das entradas, encurtando a entrada do texto utilizando a nossa função
preview e, em seguida, colocando o título e a entrada preview na marcação da
apresentação.

Agora, para mudar o layout das pré visualizações da entry, somente
duas linhas de HTML são necessárias para serem ajustadas. Este é um grito muito
menos confuso do que a função original que tratava dos três níveis.

Olhando através de
diferentes tipos de programação

Gostaria de salientar que o exemplo acima é muito básico,
e serve somente para demonstrar o conceito de Tiered Programmin. A
ideia é que, mantendo os diferentes tipos de lógica de programação separados,
você pode aumentar enormemente a legibilidade de manutenção do seu código.

Nota: Há um grande artigo sobre TheDailyWTF.com discutindo o uso e abuso de softwares diferenciados de design, e maravilhoso comentário sobre o artigo que apresenta diferentes opiniões.
Aplicações Multi-tiered são extremamente úteis, mas também fácil de se compreender
mal e o excesso de complicar, por isso lembre-se
de planejar cuidadosamente o seu software antes de construir para evitar que
causem mais problemas do que você está resolvendo.

*

Publicado originalmente em: http://net.tutsplus.com/tutorials/php/add-power-to-your-php-with-multi-tiered-applications/