Turbinando o Desenvolvimento de Aplicações Web com CodeIgniter e Doctrine 2

Prévia do material em texto

ANA CARLINA SERTORI SOARES – RA: 1087138
GABRIEL VITORINO AREIA RISSI – RA: 1090351
Plataforma de Desenvolvimento Web
TURBINANDO O DESENVOLVIMENTO DE APLICAÇÕES
WEB COM CODEIGNITER E DOCTRINE 2
Orientador: Prof. Eduardo de Oliveira Azevedo
Centro Universitário Claretiano
BATATAIS
2015
RESUMO
Desenvolver aplicações para web é uma tarefa vista como algo um tanto quanto
complexo e que demanda de horas e mais horas de estudos acerca de padrões de
desenvolvimento e linguagens de programação. Algumas das preocupações que são
bastante frequentes entre a grande maioria daqueles que iniciam o desenvolvimento
de uma aplicação está em sua escalabilidade, ou seja, no quanto a mesma poderá
crescer nos próximos anos, bem como em sua segurança e robustez. Outro grande
problema encontrado em um desenvolvimento consiste em mapear tudo aquilo que
se encontra na forma relacional no banco de dados, para a aplicação em si, através
do paradigma orientado a objetos. A fim de suprir a todas essas necessidades foram
desenvolvidos os frameworks, ferramentas que já trazem em si todos esses recursos
implementados e que permitem ao desenvolvedor preocupa-se apenas com a lógica
da aplicação. Este trabalho tem como objetivo realizar a integração entre dois
excelentes frameworks PHP, o CodeIgniter e o Doctrine 2, e demonstrar através de
um exemplo básico, quão intuitivo, simples e ágil podem tornar o desenvolvimento.
Palavras-chave: PHP. Banco de Dados. MVC. CodeIgniter. Composer. Doctrine 2.
Persistência de Dados.
INTRODUÇÃO
Desenvolver uma aplicação seja ela em PHP, ou em qualquer outra linguagem,
é algo que quase sempre demanda de uma grande parcela de tempo e
conhecimentos bastante específicos acerca de diversos conceitos relacionados à
programação, isso muitas vezes acaba afastando o desenvolvedor do que realmente
interessa, a lógica de negócios da mesma. Existem hoje dezenas de frameworks
que visam justamente isso, reduzir o tempo de desenvolvimento, melhorar a
qualidade do código e manter o desenvolvedor focado principalmente no modelo de
negócios a ser reproduzido na aplicação, contudo em não raras as vezes, essas
ferramentas demandam de muitas horas de leitura de documentações muitas vezes
confusa e sem o menor nexo para reles estudantes ou entusiastas da programação.
Neste artigo serão abordados os procedimentos necessários para a integração do
Codeigniter, um framework extremamente simples e com uma curva de
aprendizagem relativamente pequena, ao Doctrine 2, considerado por muitos um
dos melhores mapeadores de objetos relacionais para PHP na atualidade, assim
como um pequeno exemplo prático da utilização de ambas as ferramentas. 
1. MATERIAL E MÉTODOS
1.1 O MODELO MVC
A estrutura Model-View-Controller (MVC) consiste em um design pattern ou
padrão de design de software que visa separar o projeto em 3 camadas distintas,
separando os “papéis” dentro da aplicação, isolando assim a visualização da lógica
de negócios.
Segundo Hemrajani (2007, apud. GABARDO, 2012, p. 18), “o MVC foi
originalmente concebido na Xerox PARC entre 1978 e 1979 e mais tarde
implementado na biblioteca de classe Samalltalk-80”. A necessidade em se
desenvolver soluções reutilizáveis foi um dos fatores que levou o MVC a
ser amplamente utilizado no desenvolvimento, principalmente de soluções
para web.
Figura 1: Um diagrama simples exemplificando as relações entre as camadas do modelo MVC.
Fonte: Disponível em: <http://pt.wikipedia.org/wiki/MVC>. Acesso em: 11 maio 2014.
1.1.1 A MODEL
A camada Model ou modelo consiste na representação dos dados da
aplicação. É através dessa camada que será definido como as coisas devem
funcionar dentro da aplicação, as regras de negócios da mesma. Além disso,
geralmente cabe a ela a responsabilidade em persistir e recuperar os dados
presentes na base de dados.
1.1.2 A VIEW
A camada View ou visão, é a responsável por receber os dados da Model e
exibi-los ao usuário através do browser. É nela que fica toda a parte visual da
aplicação, que será vista pelo usuário final.
1.1.3 O CONTROLLER
A camada Controller ou controle, é a responsável por fazer a comunicação
entre a camada View e a camada Model, interpretando as requisições feitas pelo
usuário, através do browser, decidindo quais transações deverão ser executadas
ou quais Views deverão ser apresentadas.
1.2 O CODEIGNITER
O CodeIgniter foi criado por Rick Ellis, motociclista e roqueiro, fundador e
CEO da companhia norte-americana Ellislab, In., que desenvolve projetos
para a web incluindo um gerenciador de conteúdo chamado Expression
Engine, de onde se originaram algumas funcionalidades do CodeIgniter.
(GABARDO, 2010, p. 27)
A criação do CodeIgniter por Ellis teria se dado graças à sua própria
insatisfação com as opções de frameworks disponíveis, após estudar a fundo cada
um deles, não satisfeito, decidiu iniciar o desenvolvimento de seu próprio framework.
Atualmente o CodeIgniter é um dos frameworks mais utilizados no desenvolvimento
de pequenas e médias aplicações, muito desse sucesso se deve à sua simplicidade
e a sua documentação que é inegavelmente uma das melhores dentre os
frameworks PHP. (GABARDO, 2010, p. 27)
Segundo o CodeIgniter Documentation (2015):
O CodeIgniter é um framework para desenvolvimento de aplicações –
conjunto de ferramentas – para pessoas que querem construir web sites
usando PHP. Seu objetivo é permitir que você desenvolva projetos muito
mais rapidamente do que você poderia se estivesse escrevendo o código do
zero, lhe proporcionando um rico conjunto de bibliotecas para as tarefas
mais comuns, assim como uma interface simples e uma estrutura lógica
para acessar essas bibliotecas. CodeIgniter permite que você mantenha o
foco em seu projeto minimizando a quantidade de código para uma dada
tarefa.
1.3 O DOCTRINE 2
Doctrine 2 é um mapeador de objeto relacional (ORM) para PHP 5.4+ que
fornece persistência transparente para objetos PHP. Ele usa o padrão Data
Mapper em seu núcleo, apontando para uma completa separação da sua
lógica de domínio/negócios da persistência em um sistema de
gerenciamento de banco de dados relacional. (Doctrine Project, 2015)
Uma Object-relational mapping (ORM) consiste em uma solução que realiza o
gerenciamento dos dados persistentes na base de dados. Ela se relaciona com o
banco de dados e efetua a conversão do paradigma relacional para o paradigma
orientado a objetos e vice-versa, esse tipo de relacionamento é denominado
mapeamento objeto/relacional, o principal benefício de sua utilização está em
permitir que o desenvolvedor se concentre principalmente na lógica de negócios da
aplicação, tendo a persistência como algo secundário. Outro grande problema
sanado pela utilização de uma ORM estaria numa possível mudança da base de
dados, uma vez que a ORM isola a persistência da lógica de negócios, portanto
essa migração poderia ser bem menos dolorosa, sendo necessárias apenas
algumas poucas alterações. (GONÇALVES, 2007, p. 512)
1.4 COMPOSER
“Composer é uma ferramenta para gerenciamento de dependências em PHP.
Ele permite que você declare as bibliotecas dependentes que seu projeto necessita
e ele então irá instalá-las em seu projeto para você”. (Composer Documentation,
2015) Desenvolvido em meados de 2011, por Nils Adermann e Jordi Boggiano,
sendo oficialmente lançado em 1 de Março de 2012. O Composer é fortemente
inspirado por outros gerenciadores de pacotes como o Node.js com o “npm” e o
Ruby com o “bundler”. (WIKIPEDIA, 2015)
1.5 INTEGRANDO O DOCTRINE2 AO CODEIGNITER
O Doctrine 2 por si só, já é um framework completo, contudo é necessário
integrá-lo ao CodeIgniter para que ambos funcionem em perfeita sintonia. Para essa
integração, é necessário realizar alguns procedimentos, tais como:
• Efetuar o download do CodeIgniter através do site oficial do projeto
(http://www.codeigniter.com), fazer o upload no servidor web, depois
configurar o arquivo application/config/database.php com a respectiva
conexão à base de dados.
• Instalar o Composer (https://getcomposer.org/download) na máquina.
• Criar na raiz do CodeIgniter um arquivo chamado composer.json e inserir
o seguinte código:
{
"minimun-stability": "stable",
"require": {
"symfony/yaml": "2.*"
"doctrine/orm": "2.4.*"
},
"autoload": {
"psr-0": {"": "src/"}
}
}
• Inserir no arquivo index,php, presente na raiz do CodeIgniter, a seguinte
linha:
Figura 2: Configuração do arquivo index.php
Fonte: Acervo pessoal
• Criar um arquivo chamado Doctrine.php dentro do diretório
application/libraries do CodeIgniter e inserir o seguinte código:
<?php
use Doctrine\Common\ClassLoader,
 Doctrine\ORM\Tools\Setup,
 Doctrine\ORM\EntityManager;
class Doctrine
{
 public $em;
 public function __construct()
 {
 require APPPATH . 'config/database.php';
 $connection_options = array(
 'driver' => 'pdo_mysql',
 'user' => $db['default']['username'],
 'password' => $db['default']['password'],
 'host' => $db['default']['hostname'],
 'dbname' => $db['default']['database'],
 'charset' => $db['default']['char_set'],
 'driverOptions' => array(
 'charset' => $db['default']['char_set'],
 ),
 );
 $models_namespace = 'Entities';
 $models_path = APPPATH . 'models';
 $proxies_dir = APPPATH . 'models/Proxies';
 $metadata_paths = array(APPPATH . 'models/Entities');
 $dev_mode = false;
 $config = Setup::createAnnotationMetadataConfiguration 
($metadata_paths, $dev_mode, $proxies_dir);
 $this->em = EntityManager::create($connection_options, $config);
 $loader = new ClassLoader($models_namespace, $models_path);
 $loader->register();
 }
}
• Criar um arquivo chamado doctrine.php dentro da pasta /application do
CodeIgniter e colar o código:
<?php
define('APPPATH', dirname(__FILE__).DIRECTORY_SEPARATOR );
define('BASEPATH', APPPATH);
define('ENVIRONMENT', 'development');
require_once( APPPATH . '../vendor/autoload.php');
require __DIR__ . '/libraries/Doctrine.php';
foreach ($GLOBALS as $helperSetCandidate) {
 if ($helperSetCandidate instanceof 
\Symfony\Component\Console\Helper\HelperSet) {
 $helperSet = $helperSetCandidate;
 break;
 }
}
$doctrine = new Doctrine;
$em = $doctrine->em;
$helperSet = new 
\Symfony\Component\Console\Helper\HelperSet(array(
 'db' => new 
\Doctrine\DBAL\Tools\Console\Helper\ConnectionHelper($em-
>getConnection()),
 'em' => new 
\Doctrine\ORM\Tools\Console\Helper\EntityManagerHelper($em)
));
\Doctrine\ORM\Tools\Console\ConsoleRunner::run($helperSet);
1.6 EXEMPLO PRÁTICO
A fim de demonstrar o perfeito funcionamento Doctrine integrado ao
CodeIgniter, foi elaborado um exemplo bem simples e prático do uso de ambas as
ferramentas, neste exemplo foi utilizado como IDE, o Netbeans 8.0.2 por ele possui
suporte à sintaxe do Doctrine 2, ter suporte ao português brasileiro e por ser
extremamente simples, mesmo para iniciantes na programação.
Figura 3: Estrutura do CodeIgniter
Fonte: Acervo Pessoal
Após realizar a integração do CodeIgniter com o Doctrine o resultado foi
semelhante à Figura 3. Em seguida, foi criado dentro da pasta models/Entities, um
modelo denominado Usuario.php, responsável por servir como molde aos objetos do
tipo Usuário a serem criados e posteriormente persistidos. É a partir das classes
presentes na pasta models/Entities que o Doctrine gerará as tabelas do banco, para
isso, ele utiliza algumas anotações, semelhantes ao Hibernate do Java, na forma de
comentários. São elas:
@Entity: indica que a entidade deve ser persistida;
@Table: indica qual deverá ser o nome da tabela ao ser persistida;
@Id: indica qual atributo será mapeado como chave primária da tabela;
@GeneratedValue: indica que o valor do atributo será gerado;
@Column: possui as informações acerca das colunas da tabela, tais como:
nome da coluna, tipo de dado, tamanho e etc.
<?php
namespace Entities;
/**
 * @Entity
 * @Table(name="usuarios")
 */
class Usuario {
 /**
 * @Id
 * @Column(name="cod_usuario", type="integer", unique=true, 
nullable=false)
 * @GeneratedValue(strategy="AUTO")
 */
 private $codigo;
 
 /** @Column(name="nom_usuario", type="string", length=90, 
nullable=false) */
 private $nome;
 
 /** @Column(name="lgn_usuario", type="string", length=90, 
nullable=false) */
 private $login;
 
 /** @Column(name="sen_usuario", type="string", length=90, 
nullable=false) */
 private $senha;
 
 function __construct($codigo = '', $nome = '', $login = '', $senha
= '') {
 $this->codigo = $codigo;
 $this->nome = $nome;
 $this->login = $login;
 $this->senha = $senha;
 }
 
 function getCodigo() { return $this->codigo; }
 function getNome() { return $this->nome; }
 function getLogin() { return $this->login; }
 function getSenha() { return $this->senha; }
 function setCodigo($codigo) { $this->codigo = $codigo; }
 function setNome($nome) { $this->nome = $nome; }
 function setLogin($login) { $this->login = $login; }
 function setSenha($senha) { $this->senha = $senha; } 
}
Para gerar as tabelas da base de dados, foi utilizado através do console PHP, o
comando: php doctrine.php orm:generate-entities. Em seguida foi criada a classe
denominada Usuario_model.php, responsável por manipular os métodos do Doctrine
2 para persistência dos dados.
 
<?php
class Usuario_model extends CI_Model {
 protected $em;
 public function __construct() {
 parent::__construct();
 $this->load->library('doctrine');
 $this->em = $this->doctrine->em;
 }
 public function getUsuarios() {
 try {
 $query = $this->em->createQuery("SELECT u FROM "
. "Entities\Usuario u ORDER BY u.codigo");
 $result['usuarios'] = $query->getResult();
 } catch (Exception $err) {
 log_message("error", $err->getMessage(), false);
 return NULL;
 }
 return $result;
 }
 public function saveUsuario($usuario) {
 try {
 $this->em->persist($usuario);
 $this->em->flush();
 } catch (Exception $err) {
 log_message("error", $err->getMessage(), false);
 }
 }
}
Após criados os métodos de persistência do Doctrine, foi necessário criar um
controlador denominado aqui como Usuarios.php, cuja função é a de mediador entre
as camadas Model e View, ou seja, ele envia os dados da View para serem
persistidos pela Model, além de retornar o resultado das respectivas consultas ao
banco para que sejam tratados e exibidos pela View, para realizar essa consulta à
base de dados, o Doctrine utiliza uma linguagem própria bastante semelhante ao
Structured Query Language (SQL), denominadaDoctrine Query Language (DQL).
Para realizar a persistência da entidade é necessário apenas que seja passado
o objeto a ser persistido, o gerenciador de entidades se encarrega de persisti-lo sem
que haja necessidade de mais intervenções.
class usuarios extends CI_Controller { 
 public function __construct() {
 parent::__construct();
 $this->load->model('usuario_model', 'usuario');
 }
 public function index() {
 $usuario = new Entities\Usuario();
 $usuario->setCodigo(1);
 $usuario->setNome('Gabriel Rissi');
 $usuario->setLogin('gabriel2012rissi@gmail.com');
 $usuario->setSenha('123456');
 $this->usuario->saveUsuario($usuario);
 
 $usuarios = $this->usuario->getUsuarios();
 $this->load->view('usuarios_view', $usuarios);
 }
}
Figura 4: Tela de Visualização de usuários.
Fonte: Acervo pessoal
Para finalizar, é passível de observação que a utilização do Doctrine junto ao
CodeIgniter agrega em muito ao código da aplicação, tornando-o muito mais
simples, intuitivo e limpo do que seria a utilização do PHP em sua forma pura,
permitindo a redução do tempo de desenvolvimento de forma bastante considerável.
Afinal, nos tempos de hoje, como já dizia Benjamim Franklin: “Tempo é dinheiro”.
2. RESULTADOS
O principal resultado buscado e atingido por esse artigo foi demonstrar como a
utilização do framework CodeIgniter agregado à ORM Doctrine é capaz de tornar o
desenvolvimento de aplicações em PHP muito mais simples, intuitivo e rápido. Para
demonstrar isso foi necessária toda uma fundamentação teórica buscando introduzir
o leitor do artigo aos conceitos apresentados, em seguida foi desenvolvido um
exemplo prático com a finalidade de demonstrar a facilidade de uso de ambas as
ferramentas e como até mesmo um desenvolvedor inexperiente é capaz de utilizá-
las. Para chegar a esses resultados, foi necessário expandir os conhecimentos já
adquiridos acerca dos conceitos relacionados ao MVC e Orientação a Objetos, além
estudos à fontes em inglês acerca de como realizar uma integração funcional entre o
CodeIgniter e o Doctrine.
CONCLUSÃO
Para se chegar ao objetivo final, foi necessário expandir os conhecimentos já
adquiridos no decorrer deste curso. O maior obstáculo para a escrita deste artigo foi
a escassez de materiais de qualidade e definitivos sobre como realizar a integração
entre o CodeIgniter e o Doctrine 2.
A utilização do padrão MVC é algo imprescindível no CodeIgniter, bem como no
exemplo prático desenvolvido, e permite uma a divisão e organização do código em
camadas distintas, tornando assim o seu mantenimento uma tarefa muito mais
simples. Além disso, foi possível observar um grande e significativo aumento da
produtividade com a utilização do Doctrine 2 como ORM, uma vez que ele próprio é
capaz gerar e manipular as tabelas do banco, tornando desnecessário que a escrita
de códigos SQL.
REFERÊNCIAS
British Columbia Institute of Technology. CodeIgniter User Guide Version 3.0.0.
2015. Disponível em: <http://goo.gl/tle0L4> Acesso em: 22 abr. 2015.
Doctrine Project. Reference Documentarion. 2015. Disponível em
<http://goo.gl/FuTdFz> Acesso em: 26 abr. 2015.
GABARDO, Ademir Cristiano. CodeIgniter Framework PHP. São Paulo: Novatec,
2012.
GONÇALVES, Edson. Desenvolvendo Aplicações Web com JSP Servlets,
JavaServer Faces, Hibernate, EJB 3 Persistence e Ajax. Rio de Janeiro: Ciência
Moderna, 2007.
WIKIPÉDIA. MVC. Disponível em: <http://pt.wikipedia.org/wiki/MVC>. Acesso em: 3 
mai. 2015.
WIKIPEDIA. Composer (software). Disponível em: 
<http://en.wikipedia.org/wiki/Composer_%28software%29>. Acesso em: 3 mai. 2015.