velocity

Velocity – incluindo diversos arquivos através de um loop

Publicado 10 de fevereiro de 2010 por gserrano

O Chris já publicou aqui um tutorial de Velocity, uma linguagem de templates que estou usando diariamente no trabalho.

Como eu não conhecia a linguagem até começar a trabalhar aqui, existem várias coisas que são são novidades para mim – e os blogs e docmentações estão ajudando a aumentar a produtividade.

Para compartilhar o que aprendi (e servir para minhas consultas futuras), fiz algumas contribuições com posts aqui no O Desenvolvedor, e entre as relacionadas ao Velocity (e Java) destaco duas:

Velocity – Loop de includes usando variáveis

Estava estudando métodos para dar include (parse) em arquivos com o Velocity, e em um caso específico queria incluir diversos arquivos através de um loop: código enxuto, ao invés de adicionar uma linha para cada parse.

Se você não sabe como funciona o parse no Velocity, veja este exemplo de código.

Para ilustrar este post, criei um "problema" e abaixo explico a solução.

Problema
Necessário fazer diversos includes a partir de uma lista de arquivos (string).

Solução
Pegar a lista, transformar em array e usar o parse para cada elemento do array

Supondo que você tem a string: "include1,include2,include5" e estes são os nomes de arquivos que você precisa incluir, o primeiro passo é dar um split pelas vírgulas e transformar isso em um array.

Primeiro setamos uma variável ($inc) com a lista de includes que serão feitos

#set($inc = "include3,include4,include9")

Abaixo utilizo o método split (ler documentação) na variável $inc gerada anteriormente, separado os elementos pela vírgula e criando um array com os nomes dos arquivos (o array poderia ser criado diretamente, porém usei o string para enriquecer mais o exemplo).

#set($arr = $stringUtils.split($inc,","))

Pronto, agora temos um array com o nome dos arquivos e é aqui que a "mágica" começa. Criamos um loop (foreach) para o array, e dentro dele definimos uma variável com o caminho do arquivo que será incluído e chamamos o parse para a variável do caminho ($dir).

#foreach($o in $arr) #set($dir = "includes/vm/"+$o+".vm") #parse($dir) #end

Tentei concatenar o nome do arquivo (elemento do array) com o caminho direto na linha do parse e não funcionou. O workarround de definir a variável antes resolve o problema!

Espero que seja útil, esse script pode ser bastante útil para o controle de includes!

Fazer um loop (foreach) no Velocity, com array ou limite numérico

Publicado 16 de outubro de 2009 por gserrano

O Chris certa vez publicou aqui um guia inicial de Velocity que ensina os conceitos básicos dessa linguagem para desenvolvimento de templates com objetos Java.

Quando li o post não entendi patavinas, hoje trabalhando com o Chris aqui na MMCafé estou um pouco mais familiarizado com o Velocity, por isso resolvi publicar aqui algumas soluções que estão facilitando minha vida! 😀

Como fazer um loop no velocity com array

Primeiro o básico, listar os itens de um array:

#set ($arr= ["flush", "straight", "full house"])
#foreach($item in $arr)
Mão no poker: $item
#end

Como fazer um loop no velocity com limite numérico

Agora o que achei que seria mais simples, mas demorei um pouco mais para encontrar em posts e documentações pela interwebs, como fazer um loop de N até 3N por exemplo:

#foreach($i in [3..9])
<li>$i</li>
#end

Pronto, simples assim! Espero ter ajudado quem está começando com o Velocity!

Em tempo, vejam essa programação mágica (POG de primeira) que o Chris publicou lá no blog dele.

Velocity – linguagem de templates

Publicado 8 de janeiro de 2009 por gserrano

Quando comecei a trabalhar na empresa em que estou até hoje, 4 anos atrás, fui "jogado" no mundo de aplicações java para web. Antes, só tinha mexido de verdade com PHP. E de cara comecei a mexer com o que, hoje em dia, é muito comum: templates.

Existem inúmeras opções de frameworks que usam templates, para as mais variadas linguagens (inclusive foi lançado um, em PHP, que parece ser bem bacana, o Spaghetti).
Em java, muito se usa JSP. Mas nem de longe são os mais bacanas: se você quer implementar uma aplicação MVC mesmo, deve usar o JSTL ou Velocity.

E Velocity é com o que eu trabalho atualmente. Ela é ótima para uma aplicação de grande porte, que usa MVC: você escreve seu XHTML normalmente e, depois, utiliza os objetos que a camada de negócios te dá. Ou seja, você coloca apenas lógica de interface na interface. E a lógica de negócios fica na camada de negócios. E não tem como misturar uma coisa com a outra (ok, até tem, mas vai dar tanto trabalho e é tão mais difícil de fazer isso quando comparado com JSP, que desestimula qualquer POG…).

Vamos falar um pouco, então, dele:

Conceito

É um engine baseado em java para a construção de templates. Um template velocity é um documento que permite a escrita de html com a inserção de lógica usando objetos do Java na sua inteligência, aplicando o conceito de MVC para separar a camada de negócios da camada de apresentação.

Tipos

Sendo baseado em Java, o código Velocity tem os mesmos tipos de objetos do Java, e podem ser usados todos os métodos dos objetos Java. Objetos são sempre chamados através do identificador $
Por exemplo: $nome ou $quantidade
Para definir um valor a um objeto, é usada a diretiva #set(objeto = valor)
Não é necessário definir o tipo do objeto. O engine do Velocity se encarrega de definir a qual tipo ele pertence.
Por exemplo: #set($nome = "Eduardo") ou #set($quantidade = 5)

Arrays

Para criar um array – um objeto que contêm uma lista de outros objetos, há duas formas:
#set($meu_array = ["a", "b", "c", "d", "e"]) ##instancia-se o objeto e já passa o valor a ele
ou
#set($meu_array = []) ##instancia um objeto e cria uma lista vazia
##adiciona item a item os objetos da lista, usando o método add() da classe Array
#set($foo = $meu_array.add("a"))
#set($foo = $meu_array.add("b"))
#set($foo = $meu_array.add("c"))
#set($foo = $meu_array.add("d"))
#set($foo = $meu_array.add("e"))
##como o método add() tem um valor de retorno, jogamos o valor do método em uma variável qualquer, $foo, para que esse valor não seja printado na tela

Tomada de decisão

Há um tipo de estrutura de decisão no Velocity, que é definida pela seguinte sintaxe:
#if(condição)
…
#elseif(condição)
…
#else
…
#end

Nesse caso, apenas a diretiva #if(condição) e #end são obrigatórios; as demais ficam por conta da necessidade da implementação. A lógica é a mesma de qualquer estrutura de outras linguagens. Segue um exemplo completo:
#if($c<5)
##só entra quando $c for menor do que cinco
#elseif($c==5)
##só entra quando $c for igual a c
#else
##entre nos demais casos
#end

Laço de repetição

Há um tipo de estrutura para laço de peteição no Velocity – ou seja, como percorrer um Array (lista), que é definida pela seguinte sintaxe:
#foreach($iter in $lista)
…
#end
Usando aquele Array criado no item Arrays, segue um exemplo completo da utilização:
#set($meu_array = ["a", "b", "c", "d", "e"])
#foreach($letra in $meu_array)
$letra ##printa na tela a letra
#end
É possível também criar uma repetição de n vezes. Por exemplo, no código abaixo serão feitas 3 iterações (de 1 até 3):
#foreach($c in [1..3])
$c
#end

Macro
Uma macro pode ter seu conceito simplificado para função carregada em memória. Deve ser utilizada quando um trecho de código é repetido várias vezes em diversos locais do seu código. Por ser carregada em memória e não interpretada em tempo de execução, a performance é maior.
A sintaxe para criação e posterior acesso a ela segue o seguinte padrão:
#macro(meu_nome $param1 $param2 .. $paramn)
##lógica da macro
#end
##chama a macro
#meu_nome($p1 $p2 .. $pn)
Vale ressaltar que n é a quantidade de parâmetros que a macro recebe. Se ela não receber nenhum, é chamada a macro com os parênteses em branco.

Referência: User Guide