Padrão PSR-0 de desenvolvimento PHP - Criar um autoloader Artigo

Conheça os cursos gratuitos do WebDevBr! - Inscreva-se!


Este artigo foi publicado a 4 anos, 3 meses, 2 dias atrás.

Este artigo é muito antigo ou seu conteúdo foi descontinuado, com certeza outro artigo foi escrito para substituí-lo, use o campo de pesquisa logo acima e desculpe o incomodo!

Recentemente me questionaram sobre eu saber o que é MVC e como manter esse nível de organização, pois é, isso me levou a questionar meus próprios conhecimentos e acionei o maior recurso de um programador, o Google, depois de alguns segundos acabei descobrindo que eu realmente sabia o que era, e isso me levou a pensar sobre padrões de desenvolvimento, Orientação a Objeto, PSR, passei pelo PHP: The Right Way e fiquei com vontade de postar algo relacionado para vocês.

Bem, para começar vou falar um pouco sobre padrões de desenvolvimento PSR da PHP-FIG. Ele é dividido em 4 partes (por enquanto) que definem diversas práticas, elas não são obrigatórias e você pode ignorar se quiser, porém você vai descobrir que é extremamente proveitoso de se trabalhar seguindo esses padrões, fora que com esse tipo de organização a curto e médio prazo vai agilizar muito o desenvolvimento e  a manutenção das suas aplicações.

Introdução as regras PSR

O PSR divide-se em:

Gostou deste artigo?

Receba atualizações semanais com novos artigos do WebDevBr e outras dicas!

PSR-0: Define como os arquivos serão "carregados" na aplicação, a técnica usada é chamada de autoloader.

PSR-1: Define regras básicas de desenvolvimento como por exemplo, como as tags do php devem ser usadas, a codificação do arquivo, os "efeitos colaterais"

PSR-2: É uma extensão do PSR-1 que vai além, definindo regras mais abrangentes  e até mesmo complexas (nada que um pouco de atenção não resolva).

PSR-3: Define uma interface para Loggers

Para você quer quer estudar, aqui tem o repositório oficial da PHP-FIG e os links de cada especificação no site deles:

Ou para quem não sabe inglês:

Como funciona o autoloader da PSR-0?

De qualquer modo neste artigo vamos ver apenas a PSR-0.

No PHP 5.3 foi introduzida um novo pacote de ferramentas visando um maior e mais abrangente suporte a orientação a objetos e três dessas novas ferramentas são o namespace, o use e a função autoloader, e é dessas ferramentas que se vale a primeira das regras PSR.

As regras são:

  • Um namespace qualificado deve ter a estrutura: ()*
  • Cada namespace deve ter um namespace de nível superior (o Zend por exemplo utiliza ele próprio como primeiro namespace, que é chamado Vendor).
  • Cada namespace pode ter quantos sub-namespaces desejar.
  • Cada separador de namespace é convertido para um separador de diretórios (a barra invertida no Windows e comum no Linux) durante o carregamento do arquivos.
  • Cada _ (underline) também é convertido para um separador de diretórios durante o carregamento de arquivos.
  • Durante o carregamento de arquivos o namespace é completado com a extensão ".php".
  • Nomes de vendors, namespace e  classes pode ter qualquer combinação de letras maiúsculas e minúsculas

Pode parecer complicado ter que decorar isso, mas na verdade se você entender como funciona vai ficar fácil e com apenas uma rápida olhada vai saber o que fazer.

Para colocar isso tudo em prática basta criar um arquivo chamado bootstrap.php e colocar isso dentro

<?php
function __autoload($className)
{
    $className = ltrim($className, '\');
    $fileName  = '';
    $namespace = '';
    if ($lastNsPos = strrpos($className, '\')) {
        $namespace = substr($className, 0, $lastNsPos);
        $className = substr($className, $lastNsPos + 1);
        $fileName  = str_replace('\', DIRECTORY_SEPARATOR, $namespace) . DIRECTORY_SEPARATOR;
    }
    $fileName .= str_replace('_', DIRECTORY_SEPARATOR, $className) . '.php';

    require $fileName;
}

E pronto, a mágica está pronta, agora podemos usar o use para incluir os arquivos que queremos, para manter o padrão de desenvolvimento e você entender bem o que estamos fazendo, vou fazer uma pequena alteração na minha função autoloader, na linha require $filename, troque por:

require 'lib'.DIRECTORY_SEPARATOR.$fileName;

Pronto, agora vamos criar nossa estrutura,

Na mesma pasta crie um arquivo index.php e uma pasta chamada lib, com outra pasta dentro formando a estrutura:

lib/Erik/core/

E dentro da pasta core dois arquivos, core.php e request.php.

Dentro de core.php vou colocar funções diversas e em request.php funções de retorno de variável.

Abra o core.php e cole:

<?php

namespace Erikcore;

class Core
{
  function debug($var)
  {
    echo '<pre>';
    print_r($var);
    echo '</pre>';
  }
}

E em request.php:

<?php 

namespace Erikcore;

class request
{

  public function data()
  {
    $retorno['post'] = $this->post();
    $retorno['get'] = $this->get();

    return $retorno;
  }

  public function post()
  {
    $retorno=array();
    foreach($_POST as $key=>$value){
      $retorno[$key]=$this->securityVar($value);
    }
    return $retorno;
  }

  public function get()
  {
    $retorno['parametros']=array();
    foreach($_GET as $value){
      $retorno['parametros'][]=$this->securityVar($value);
    }
    return $retorno;
  }

  public function securityVar($var)
  {
    $var = addslashes($var);
    return $var;
  }

}

Note que é um exemplo, não é pra serem funções perfeitas e que funcionem incrivelmente bem, apenas exemplo.

Agora em index.php cole:

<?php

//chama nosso autoloader
include 'bootstrap.php';

//inclui os arquivos e cria um nome curto para o namespace
use Erikcore\core as core; 
use Erikcore\request as request; 

//instancia as classes
$core = new core;
$request = new request; 

//executa os códigos
$core->debug($request->data());

O que fizemos foi cria uma classe que supostamente deveria trazer variáveis seguras para a nossa aplicação e uma outra classe com um recurso debug, que imprime nossas variáveis na tela, um recurso parecido com o debug do CakePHP, chame sua aplicação no navegador com por exemplo:

http://localhost/caminho/ate/o/exemplo/index.php?teste=Erik

E veja o que acontece.

Melhor ainda, cole isso no fim do seu index.php e clique em enviar.

<form action="index.php?nome=Erik&sobrenome=Figueiredo" method="post">
<input type="text" name="idade" value="28 anos">
<input type="text" name="sexo" value="Masculino">
<input type="text" name="profissao" value="Vendedor de agua de coco">
<input name="envia" type="submit" value="Enviar">
</form>

São inúmeras as vantagens de se trabalhar desta forma, além da organização ainda ganhamos as vantagens da agilidade e mobilidade, claro que ainda precisamos implementar uma estrutura MVC, já que esse código de exemplo é apenas para fins educacionais, mas quem sabe eu não estenda este artigo e mostre como fazer uma estrutura de desenvolvimento show de bola pra vocês se basearem.

Indo além

Note que este recurso também esta se tornando obsoleto e logo esta convenção de desenvolvimento estará defasada (o recurso _autoload()), consequentemente a página da PSR-0 terá que ser revista, o CakePHP, por exemplo, já não usa este tipo de desenvolvimento, ele usa o spl_autoloadregister(), leia mais na documentação do PHP sobre a descontinuação do __autoload().

Atualizando: Para quem não acreditou que vinha uma revisão por ai veja o que foi aprovado pela PHP-FIG: https://github.com/php-fig/fig-standards/blob/master/proposed/psr-4-autoloader/psr-4-autoloader.md, claro que vamos ter um artigo novo sobre isso, mas acabei de falar sobre a PSR-1 e PSR-2 e ainda nem falei sobre a PSR-3, portanto ainda vai um tempinho até esse artigo sair.


Cursos relacionados


* Parcelamento apenas cartão de crédito! Pode haver uma pequena variação no parcelamento em relação a simulações apresentadas!