Posts Tagged Zend Framework

Manual em português do Zend Framework

Bom dia!

Ví hoje que o pessoal do zfdes.com está traduzindo o manual do Zend Framework para 7 linguagens, entre elas o português do Brasil. Atualmente a tradução está 12,9% feita.

Pra galerinha que ainda arranha no inglês, vale a pena dar uma olhada: http://manual.zfdes.com/pt-br/

, ,

3 Comentários

Zend Framework Tutorial Series (por Adler Medrado)

Programar em PHP profissionalmente sem um framework decente é impráticavel. Em 2008 comecei a estudar (na teoria) o Zend Framework e em 2009 participei pela primeira vez em um projeto de grande porte utilizando o ZF. Hoje indico o ZF a todos que estiverem procurando um framework completo e descomplicado.

Estava pensando em escrever um tutorial básico sobre o ZF, mas ao acessar o blog do Adler Medrado hoje ví que ele está preparando uma série de tutoriais semanais sobre o ZF, do básico ao avançado. Não vou escrever um tutorial só pra ter o meu nome nele. Aproveitem e se deliciem com essa série que tenho certeza que vai ser ótima!

Parabéns ao Adler pela iniciativa! Vou atualizando o post à medida que forem saindo os outros capítulos…

Zend Framework Tutorial Series – Capítulo 1

Zend Framework Tutorial Series – Capítulo 2

,

Nenhum comentário.

Autenticação com Zend_Auth

Falar em Zend Framework sem citar o Zend_Auth é impossível. Afinal, qual sistema não possui autenticação de usuários? Nesse post darei um exemplo prático do uso do Zend Auth.

É importante lembrar a diferença entre o Zend_Auth e o Zend_Acl, pois apesar deles se complementarem, tem funções totalmente diferenes. O Zend_Auth é responsável somente pela autenticação, e o Zend_Acl é responsável por mapeamento de permissões do sistema. Falaremos do Zend_Acl em outra oportunidade.

Inicialmente, temos a configuração inicial no bootstrap:

//Bootstrap
  1.  
  2. //Criando um objeto Registry para utilização posterior
  3. $registry = Zend_Registry::getInstance();
  4.  
  5. //Determinando a conexão através de um arquivo INI (ou qualquer outra forma à sua escolha)
  6. $configDb = new Zend_Config_Ini('./application/config/db.ini', 'identificador') ;
  7. $db = Zend_Db::factory ( $configDb->db->adapter, $configDb->db->config->toArray() ) ;
  8.  
  9. //Setando no registro a conexão criada
  10. $registry->set( 'dbSistema', $db ) ;
  11.  
  12. //Definição do Zend_Auth
  13. $authAdapter = new Zend_Auth_Adapter_DbTable($db);
  14. $registry->set( 'authAdapter', $authAdapter ) ;

Não vamos entrar na questão do formulário, vamos direto para a action do controller, onde só chamaremos uma função do model e verificaremos o seu retorno:

//Controller
  1.  
  2. $login = new User();
  3. $result = $login->login($_POST);
  4.  
  5. if($result){
  6. //Usuário autenticado
  7. } else {
  8. //Autenticação inválida
  9. }

Agora a parte mais importante, a função da model:

//Model
  1.  public function login($objPost){
  2.   //Recuperando o objeto que registramos no bootstrap
  3.   $authAdapter = Zend_Registry::get('authAdapter');
  4. //Setando a tabela e as colunas de identificação do usuário no banco
  5.   $authAdapter
  6.   ->setTableName('USUARIO')
  7.   ->setIdentityColumn('LOGIN')
  8.   ->setCredentialColumn('SENHA');
  9.  
  10. //Recebendo os dados do POST
  11.   $authAdapter
  12.   ->setIdentity(strtolower($objPost['input_usuario']))
  13.   ->setCredential(md5($objPost['input_senha']));
  14.  
  15. //Autenticação
  16.   $result = $authAdapter->authenticate();
  17.  
  18. //Verificando a autenticação…
  19.   if($result->isValid()){
  20.  
  21.    return true;
  22.   }
  23.   else{
  24.    return false;
  25.   }
  26.  }

Simples, não? Espero ter ajudado… Um abraço a todos!

Documentação oficial do Zend_Auth: http://framework.zend.com/manual/en/zend.auth.html

, ,

2 Comentários

Implementação de cache automático com Zend_Cache

Trabalhando em uma estrutura Zend Framework a alguns meses atrás, tivemos a necessidade de um sistema de cache automático para a grande maioria das consultas de um sistema. Depois de pesquisar bastante chegamos à conclusão de que não havia essa possibilidade no ZF, então desenvolví uma solução que atendeu muito bem à nossa necessidade e creio que também vai atender à outras pessoas, fazendo com que o cache seja uma propriedade do objeto model. Vamos lá.

Classe abstrata que extende da Zend_Db_Table_Abstract

  1. abstract class Base_Db_Table extends Zend_Db_Table_Abstract{
  2. /**
  3. * Definições das configurações de cache
  4. *
  5. * @var $cacheFrontendOptions
  6. * @var $cacheBackendOptions
  7. * @var $cacheName
  8. * @var $cacheObject
  9. */
  10.  
  11. protected $cacheFrontendOptions = array();
  12. protected $cacheBackendOptions = array();
  13. protected $cacheName;
  14. protected $cacheObject;
  15.  
  16. public function init(){
  17.   //Iniciando cache automaticamente
  18.   $this->startCaching();
  19. }
  20.  
  21.  /* Seta o prefixo do nome do arquivo cache
  22.   * @param  string $cacheName
  23.   */
  24.  public function setNameCaching($cacheName) {
  25.   $this->cacheName = $cacheName;
  26.  }
  27.  
  28.  /* Seta as configurações de cache
  29.   * @param array $cacheFrontendOptions – Array de configurações de frontend
  30.   * @param string $cacheName – Nome do prefixo do arquivo cache
  31.   */
  32.  public function setCaching($cacheFrontendOptions = null, $cacheName = null) {
  33.  
  34.   if($cacheFrontendOptions == null) {
  35.  
  36.    $frontendOptions = array(
  37.           'lifetime' => 7200,
  38.           'automatic_serialization' => true);
  39.  
  40.   } else {
  41.    $frontendOptions = $cacheFrontendOptions;
  42.   }
  43.  
  44.   if($cacheName == null) {
  45.    $cacheName = $this->_name.'_'.date('dmy');
  46.   }
  47.  
  48.   $cacheBackendOptions = array('cache_dir' => './application/cache_dir/');
  49.  
  50.   $this->cacheFrontendOptions = $frontendOptions;
  51.   $this->cacheBackendOptions = $cacheBackendOptions;
  52.   $this->cacheName = $cacheName;
  53.  
  54.   $this->startCaching();
  55.  }
  56.  
  57. /* Verifica se a cache está ativa no objeto Model
  58.  * @return  bool
  59.  */
  60. public function isCaching() {
  61.  if($this->cacheObject) {
  62.   return true;
  63.  } else {
  64.   return false;
  65.  }
  66. }
  67.  
  68. /* Retorna um array com as configurações de cache
  69.  * @return array $arrayCacheConfigs
  70.  */
  71. public function getCaching() {
  72.  if($this->cacheFrontendOptions) {
  73.   $arrayCacheConfigs = array(
  74. 'cacheFrontendOptions' => $this->cacheFrontendOptions, 'cacheBackendOptions'=>$this->cacheBackendOptions, 'cacheName' => $this->cacheName);
  75.    return $arrayCacheConfigs;
  76.   } else {
  77.    return false;
  78.   }
  79.  }
  80.  
  81. /* Inicia o cache
  82.  */
  83. public function startCaching() {
  84.  if($this->isCaching()) {
  85.   echo "
  86. <pre>";
  87.   print_r('Cache já iniciada anteriormente: startCaching()');
  88.   print_r("
  89. ");
  90.   die(__FILE__.' – Linha '.__LINE__);
  91.  }
  92.  else {
  93.   if(!$this->getCaching()) {
  94.    $this->setCaching();
  95.   }
  96.   $cache = Zend_Cache::factory('Core',
  97.                              'File',
  98.   $this->cacheFrontendOptions,
  99.   $this->cacheBackendOptions);
  100.   $this->cacheObject = $cache;
  101.  }
  102. }
  103.  
  104. public function removeCaching() {
  105.  $this->cacheObject->remove($this->cacheName);
  106.  $this->cacheObject = null;
  107. }
  108.  
  109. public function disableCaching() {
  110.  $this->cacheName = null;
  111.  $this->cacheFrontendOptions = null;
  112.  $this->cacheBackendOptions = null;
  113.  $this->cacheObject = null;
  114. }
  115.  
  116. public function saveCaching($param) {
  117.  if($this->isCaching()) {
  118.   $this->cacheObject->save($param, $this->cacheName);
  119.  } else {
  120.   echo "
  121. <pre>";
  122.   print_r('Cache não iniciada: saveCaching()');
  123.   print_r("
  124. ");
  125.   die(__FILE__.' – Linha '.__LINE__);
  126.  }
  127. }
  128.  
  129. public function fetchAll($where = null, $order = null, $count = null, $offset = null)
  130. {
  131.  if (!($where instanceof Zend_Db_Table_Select)) {
  132.   $select = $this->select();
  133.  
  134.   if ($where !== null) {
  135.    $this->_where($select, $where);
  136.   }
  137.  
  138.   if ($order !== null) {
  139.    $this->_order($select, $order);
  140.   }
  141.  
  142.   if ($count !== null || $offset !== null) {
  143.    $select->limit($count, $offset);
  144.   }
  145.  
  146.   } else {
  147.    $select = $where;
  148.   }
  149.  
  150.  if($this->isCaching()) {
  151.   if(!$result = $this->cacheObject->load($this->cacheName)) {
  152.    $rows = $this->_fetch($select);
  153.    $data  = array(
  154.              'table'    => $this,
  155.              'data'     => $rows,
  156.              'readOnly' => $select->isReadOnly(),
  157.              'rowClass' => $this->_rowClass,
  158.              'stored'   => true
  159.   );
  160.  
  161.   if (!class_exists($this->_rowsetClass)) {
  162.    require_once 'Zend/Loader.php';
  163.    Zend_Loader::loadClass($this->_rowsetClass);
  164.   }
  165.  
  166.    $result = new $this->_rowsetClass($data);
  167.    $this->saveCaching($result);
  168.   }
  169.  
  170.   } else {
  171.  
  172.    $rows = $this->_fetch($select);
  173.    $data  = array(
  174.           'table'    => $this,
  175.               'data'     => $rows,
  176.               'readOnly' => $select->isReadOnly(),
  177.               'rowClass' => $this->_rowClass,
  178.               'stored'   => true
  179.    );
  180.  
  181.    if (!class_exists($this->_rowsetClass)) {
  182.     require_once 'Zend/Loader.php';
  183.     Zend_Loader::loadClass($this->_rowsetClass);
  184.    }
  185.  
  186.    $result = new $this->_rowsetClass($data);
  187.   }
  188.  
  189.   return $result;
  190.  }

Com esta implementação, todas as consultas realizadas com o método fetchAll() serão salvas em cache no arquivo que foi definido no $cacheBackendOptions (linha 52). Se o nome do arquivo cache não for definido pelo desenvolvedor, será definido automaticamente na linha 44. Antes de realizar a consulta no banco, é verificado se já existe o arquivo no cache, caso não exista a consulta é realizada e o arquivo é criado no cache, caso existe, s resultado é retornado do cache.

Criando as configurações manualmente

Caso haja a necessidade de alterar qualquer configuração de front-end manualmente, não é necessário alterar a classe abstrata. Todas as configurações podem ser enviadas como argumento através do método setCaching() (linha 32).

Exemplo:

  1. $objModel = new ObjModel();
  2.  
  3. $frontendOptions = array(
  4.           'lifetime' => 120,
  5.           'automatic_serialization' => false);
  6.  
  7. $cacheName = "Nome_do_arquivo";
  8.  
  9. $objModel->setCaching($frontEndOptions, $cacheName);

Se por algum motivo você precisar desabilitar o cache para um determinado model, utilize o método disableCaching().

Exemplo:

  1. $objModel = new ObjModel();
  2. $objModel->disableCaching();

Para verificar se o cache está habilitado para determinada model, utilize o método isCaching().

Exemplo:

  1. $objModel = new ObjModel();
  2. if($objModel->isCaching()) {
  3. echo "Cache habilitada!";
  4. } else {
  5. echo "Cache desabilitada!";
  6. }

Para a minha necessidade não precisei criar a definição manual do diretório em que os arquivos serão salvos, mas se você precisar, apenas dinamize a definição das configurações de back-end.

Enfim, é isso. Espero que seja útil. Caso tenha alguma crítica ou sugestão para a melhoria, terei prazer em recebê-la!

Documentação oficial do Zend_Cache: http://framework.zend.com/manual/en/zend.cache.html

, ,

6 Comentários