Archive for setembro de 2009

Livro: jQuery – A biblioteca do programador JavaScript

Desde que comecei a trabalhar com tecnologia, sempre preferí adquirir livros a pesquisar material na internet. Ano passado resolví aprender mais JavaScript e cheguei ao jQuery. Por “falta de opção” de outros livros adquirí este livro do Maurício Samy Silva.

Desde então tenho vivido uma relação bem interessante com o jQuery e ele está presente em boa parte dos códigos que implemento. Se você quer aprender ou aprimorar seus conhecimentos em JavaScript/jQuery, te indico esse livro com toda a certeza de que lhe será muito útil. Se quiser uma “prévia” do que vai encontrar, pode fazer o download gratuito dos códigos de exemplo do livro aqui.

“Este livro ensina os fundamentos da biblioteca jQuery e detalha o emprego dos métodos padrão da biblioteca. É indicado para os usuários do nível iniciantes a intermediários. Não contempla as técnicas avançadas e nem o uso com AJAX, JSON, PHP, ASP ou outras linguagens de programação.”

Site do livro: http://www.livrojquery.com.br/

, ,

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

Inauguração

Senhoras e senhores, é com imenso prazer que anuncio a inauguração do meu blog voltado para tecnologia da informação e desenvolvimento de sistemas!

Brincadeira, rs… Quanta formalidade.

A algum tempo tive essa vontade de criar um blog voltado somente para tecnologia (espaço que não criei no meu site) para falar sobre PHP (principalmente), outras tecnologias de desenvolvimento web, “tech dreams”, enfim… TI em geral. Hoje esse projeto está se tornando realidade.

Espero realmente que esse blog seja útil para desenvolvedores (e também os “curiosos” da área), o objetivo e simplesmente disseminar conhecimento e compartilhar opniões. Fiquem à vontade para comentar e criticar, conto com a ajuda da comunidade!

Um grande abraço a todos!

Nenhum comentário.