Muitas pessoas viram ou aprenderam sobre Velocity. A tradução literal do nome é: velocidade, velocidade, rapidez. É usado no desenvolvimento web, mas poucas pessoas o usam basicamente. e Struts relacionados, o que você acha do Velocity? Vamos tentar entender o conceito de Velocidade. Através da introdução aqui, enfatizamos as questões da seleção de tecnologia, para que todos possam considerar a Velocidade na escolha do desenvolvimento do projeto, e também que todos entendam suas ideias. Uma maneira muito boa de pensar, proporcionando a todos uma mudança de opinião e uma maneira diferente de pensar.
Este artigo é baseado no fato de você ter uma certa base em desenvolvimento Java e conhecer MVC, Struts e outros modelos de desenvolvimento.
Velocity é uma tecnologia de mecanismo de modelo Java. O projeto foi proposto pelo Apache e foi derivado de outra tecnologia de mecanismo, Webmacro. Então, qual é a definição oficial de Velocidade? O Apache o define como: um mecanismo de modelo baseado em Java, mas permite que qualquer pessoa use uma linguagem de modelo simples e poderosa para referenciar objetos definidos no código Java. A versão mais recente é 1.4. Você pode encontrar mais informações em http://jakarta.apache.org/velocity/index.html .
Na verdade, para ser franco, Velocity é uma implementação da arquitetura MVC, mas se concentra mais no relacionamento entre Model e View como uma ponte entre eles. Acredito que todos estejam familiarizados com o Struts, a arquitetura MVC mais popular. Muitos desenvolvedores têm usado extensivamente a arquitetura Struts, incluindo versões da plataforma de gerenciamento da tecnologia Websphere 5 da IBM ou superior, que é uma boa prática do MVC e reduz efetivamente o Java. o código aparece em View (Jsp), mas a conexão entre Model e View ainda depende da tecnologia Taglib do Struts Imagine se o web designer front-end não estiver familiarizado com Struts ou mesmo com Taglib (acredito que seja bastante difícil estar familiarizado). com ele, incluindo O mesmo vale para o pessoal de manutenção posterior), o que tornará muito difícil para web designers e engenheiros de desenvolvimento front-end cooperarem entre si. No desenvolvimento real, ainda existe o fato de que o trabalho entre web designers. e os desenvolvedores front-end podem ser mais complicados. Ainda existe um certo grau de acoplamento. Como resolver esse problema ao máximo? Vamos dar uma olhada no Velocity ou neste conceito.
Vamos começar com o exemplo mais simples de desenvolvimento do Velocity para mostrar como o Velocity funciona:
1. Crie um arquivo, o nome do arquivo é: hellavelocity.vm, que é o modelo de velocidade (na verdade o mesmo que html), o conteúdo é:
Bem-vindo $name ao Javayou.com!
hoje é $data.
2. Crie um arquivo java, HelloVelocity.java, com conteúdo:
pacote com.javayou.velocity;
importar java.io.StringWriter;
importar java.util.*;
importar org.apache.velocity.app.VelocityEngine;
importar org.apache.velocity.Template;
importar org.apache.velocity.VelocityContext;
/**
* @autor Liang.xf 14/12/2004
*/
classe pública HelloVelocity {
public static void main(String[] args) lança exceção {
//Inicializa e obtém o motor Velocity
VelocityEngine ve = new VelocityEngine();
ve.init();
//Obtém o modelo de velocidade
Modelo t = ve.getTemplate("hellovelocity.vm");
//Obtém o contexto da velocidade
Contexto VelocityContext = new VelocityContext();
//Preenche os dados no contexto
context.put("nome", "Liang");
context.put("data", (nova data()).toString());
//Para exibição posterior, insira o valor da lista antecipadamente
Lista temp = new ArrayList();
temp.add("1");
temp.add("2");
context.put("lista", temp);
//fluxo de saída
Escritor StringWriter = new StringWriter();
//converte a saída
t.merge(contexto, escritor);
System.out.println(writer.toString());
}
}
3. Baixe o zip do Velocity 1.4 em http://jakarta.apache.org/site/binindex.cgi , descompacte-o para obter o speed-1.4.jar e use-o para compilar a classe HelloVelocity.java acima.
4. Copie hellavelocity.vm em 1 para o diretório atual da execução. A execução do HelloVelocity também requer outros pacotes, que podem ser obtidos no arquivo speed1.4.zip baixado, \velocity - 1.4\build\lib e colocado. Após a introdução de commons-collections.jar e logkit-1.0.1.jar, execute java -cp .\bin; -Djava.ext.dirs=.\lib2 com.javayou.velocity.HelloVelocity, assumindo que a classe está compilada. para o diretório .\ bin, e os pacotes de classe que precisamos são colocados no diretório .\lib2. A estrutura em execução é a seguinte:
Bem vindo Liang ao Javayou.com!
hoje é terça-feira, 14 de dezembro, 19:26:37 CST de 2004.
O resultado acima é o resultado de execução mais simples. Deixe-me saber aproximadamente. As duas variáveis definidas $name e $date no modelo hellavelocity.vm são respectivamente context.put("name", "Liang") e context.put. ( "date", (new Date()).toString()) é substituído pelo valor definido.
Deste ponto de vista, o processamento de processos de negócios, incluindo resultados de negócios, é basicamente resolvido na camada de modelo, enquanto a camada de visualização é basicamente exibida apenas usando uma VTL (Velocity Template Language) simples. Dessa forma, o Jsp não seria desnecessário? Sim, esse modelo de uso é um pouco parecido com o método CGI anterior :) O Velocity gera código automaticamente, e o Velocity também é muito capaz nesse aspecto, o Velocity é usado no Turbine para gerar muito código.
No Velocity, as definições de variáveis começam com "$" e $ serve como identificador do Velocity. Letras, números, traços e sublinhados podem ser usados como variáveis definidas no Velocity.
Além disso, também precisamos nos atentar às definições de variáveis características do Velocity, como: $student.No, $student.Address, que possuem dois níveis de significado: o primeiro é se o aluno for uma hashtable, a chave Não e vai ser extraído da tabela hash O valor de Endereço, e o segundo tipo é que pode ser um método de chamada, ou seja, as duas variáveis acima serão convertidas em student.getNo() e student.getAddress(). O Velocity possui um objeto para o valor retornado pelo código java no servlet, podendo também chamar os métodos do objeto, como $student.getAddress(), etc.
O exemplo acima é apenas um exemplo simples. É claro que muitas pessoas não estão mais satisfeitas com esses exemplos. Em aplicações reais, muitas vezes precisamos fazer algumas exibições seletivas e enumerar alguns dados iterativos, como listas e, claro, Velocidade (). especificamente, deve ser uma linguagem de modelo VTL) também suporta esta função. Além disso, também suporta algumas outras exibições comumente usadas, como variáveis dentro do modelo (como variáveis em Jsp) e outras mais poderosas, como a criação de macros para obter automação. Continuemos lendo.
Ainda usamos o exemplo acima e alteramos o conteúdo do modelo hellavelocity.vm para:
#set($iAmVariable = "bom!" )
Bem-vindo $name ao Javayou.com!
hoje é $data.
$iAmVariável
Execute novamente o comando de execução acima, o resultado é:
Bem vindo Liang ao Javayou.com!
hoje é terça-feira, 14 de dezembro, 22:44:39 CST de 2004.
bom!
Você pode ver que as variáveis no modelo são definidas como instruções começando com #set, o que não é difícil de entender. Após a execução, as variáveis $iAmVariable no modelo são convertidas nos valores definidos:
bom!
Vejamos novamente uma escolha simples. Altere o conteúdo do modelo hellavelocity.vm para:
#set($admin = "admin")
#set ($usuário = "usuário")
#if ($admin == $usuário)
Bem vindo administrador!
#outro
Bem vindo usuário!
#fim
Execute o comando run, o resultado é:
Bem vindo usuário!
Você pode ver que as declarações de julgamento são simples #if (), #else, #end, não muito complicadas.
Vamos continuar observando os dados da iteração e alterar o conteúdo do modelo hellavelocity.vm para:
#foreach($produto em $lista)
$produto
#fim
Execute o comando run, o resultado é:
#1
#2
Não é conveniente listar os valores pré-salvos na lista VelocityContext do exemplo? Basta usar #foreach ($variable em xx). Se a lista acima for substituída por uma Hashtable, você pode usar a seguinte sintaxe:
#foreach($chave em $hashVariable.keySet() )
Valor de $key: $ hashVariable.get($key)
#fim
Não acho que esses scripts sejam nada complicados.
Muitas pessoas também perguntarão: e se for javabean? Ok, vamos adicionar um feijão:
pacote com.javayou.velocity;
/**
* @autor Liang.xf 14/12/2004
*/
classe pública Aluno {
//Observe que os atributos da classe são públicos
String pública não = "";
public String endereço = "";
aluno público(String _não, String _endereço) {
não = _não;
endereço = _endereço;
}
public String getEndereço() {
endereço de retorno;
}
public void setAddress(String endereço) {
este.endereço = endereço;
}
string pública getNo() {
retornar não;
}
public void setNo(String não) {
isto.não = não;
}
}
Este Student é um javabean completo, ou bean de dados, uma classe comum usada para carregar dados. Em seguida, modificamos HelloVelocity.java para:
temp.add("1");
temp.add("2");
Substitua por:
temp.add(novo Aluno("123", "Guangzhou"));
temp.add(novo Aluno("456", "Zhuhai"));
Em seguida, altere o conteúdo de hellavelocity.vm para:
#foreach ($s em $alunos)
<$velocityCount> Endereço: $s.address
#fim
Recompile e execute o comando run, os resultados são os seguintes:
<1> Endereço: Cantão
<2> Endereço: Zhuhai
Desta forma, os dados do Aluno da lista são impressos e pronto! A variável interna do Velocity $velocityCount é usada aqui, que se refere ao número de sequência de enumeração padrão. Ele começa em 1. Também pode ser alterado para 0, mas precisa ser alterado em Velocity.properties. o pacote speed-1.4.jar No diretório org\apache\velocity \runtime\defaults .
Como lidar com iterações mais complexas? Vejamos o seguinte exemplo de modelo para deixar isso claro:
#foreach ($ elemento em $ lista)
-- foreach interno --
#foreach ($elemento em $lista)
Este é o elemento $.
$ velocidadeCount
#fim
-- foreach interno --
-- foreach externo --
Este é o elemento $.
$ velocidadeCount
-- foreach externo --
#fim
Como você pode ver, o Velocity suporta aninhamento de tags. Esta é uma função muito poderosa que não irei demonstrar em detalhes aqui.
Na verdade, se você pensar um pouco mais a fundo no exemplo que acabamos de dar, você já pode ver, para que serve o Velocity? Esse é o modelo Servlet + Velocity. Além disso, você ainda se lembra do nosso modelo de desenvolvimento Jsp inicial, Jsp + JavaBean? Aqui, mudamos para Servlet+JavaBean+Velocity. Pense nisso, ele substituiu Jsp+JavaBean e removeu mais completamente o código Java de Jsp (vm). Se você usar apenas Struts (Servlet+Jsp), então o custo é. que o código Java sempre aparece mais ou menos em JSP. Mesmo que possa ser feito sem código Java, os desenvolvedores que fizeram sistemas de arquitetura complexa sabem que o custo também é muito caro e, em termos de manutenção, existem certas dificuldades no desenvolvimento integrado. com web designers, então podemos sentir aqui que o modelo Servlet+JavaBean+Velocity concretiza melhor o conceito de OOD. Em termos de eficiência, você não precisa se preocupar. Essa combinação é mais eficiente que o método Servlet+Jsp.
Deveria haver muitas pessoas dispostas a aprender sobre o Velocity, mas talvez poucas possam realmente aplicá-lo aos projetos (alguns projetos ainda o utilizam, como o Jute. Afinal, comparado ao Jsp, o Jsp é mais padronizado e amplamente utilizado). e muitas ferramentas de desenvolvimento foram usadas. Mas a função do Velocity não se limita à competição com o Jsp. Como pode ser visto acima, ele é muito poderoso na saída automática de código. Como mencionado anteriormente, o Turbine usa o Velocity para gerar uma grande quantidade de código. . É uma boa ideia transformá-lo em um gerador de código ou em outra geração de modelo.
Ok, vamos dar uma olhada em alguns problemas comuns que precisam ser observados se você quiser se aprofundar no Velocity para fazer projetos.
O próprio Velocity oferece suporte à conversão de codificação internacional de modelos. Dê uma olhada nos métodos fornecidos pelo Velocity:
Modelo público getTemplate (modelo Stirng, codificação de string),
Especula-se que esta abordagem não pode alcançar a internacionalização completa.
O conceito mais simples de internacionalização no Struts é usar tags de idiomas internacionais em Jsp, e cada idioma usa uma biblioteca de tags de idioma diferente. Por extensão, isso pode ser feito manualmente.
Felizmente, alguém já resolveu o problema mencionado acima e criou as ferramentas do Velocity: MessageTool, que fornece o texto da variável para conter rótulos internacionalizados. Desta forma, basta escrever o código do rótulo, como: $text.get('title). ' ), conteúdo mais específico também pode ser encontrado em http://jakarta.apache.org/velocity/tools/struts/MessageTool.html .
Ok, isso é tudo baseado na introdução do Velocity, vamos falar sobre outras extensões. Algumas pessoas comentaram que o Velocity não é uma estrutura MVC padrão. Sim, dissemos no início que o Velocity é apenas uma boa combinação entre Model e View, e é apenas um bom mecanismo de template. foi formado. Felizmente, o Apache lançou o VelocityStruts baseado na combinação de Struts e Velocity. Podemos apresentar esta parte da declaração em um tópico posterior. Aqui está uma breve introdução ao seu conceito. processamento Finalmente, o processo de negócios é transferido para a camada de exibição com base no Velocity, substituindo assim Jsp como camada de visualização. Vimos também acima que os exemplos citados são basicamente baseados em princípios e demonstrações, e não estão intimamente integrados ao desenvolvimento Web. Combinaremos este aspecto ao descrever o conteúdo do VelocityStruts.
Introdução ao uso do Velocity - código em java
1. Primeiro inicialize o objeto
Contexto VelocityContext = new VelocityContext();
Escritor StringWriter = new StringWriter();
Codificação de string2 = "GBK";
2. PROPERTY_PATH = TEMPLATE_INIT_PATH no arquivo de propriedades do sistema (especifique o caminho do arquivo de propriedades necessário para velocidade.)
3. Conteúdo em Propriedades
file.resource.loader.path = D:/resin/webapps/mip/files/templateupload/ (onde o modelo está localizado)
4. Em seguida, inicialize Velocity.init(PROPERTY_PATH);
5. Corresponda os rótulos em velocidade a java context.put(key, value);
6． Em seguida, carregue o arquivo Velocity.mergeTemplate(templateName, encoding2, context, Writer);
7. Finalmente, chame Generator.writeToFile() para gerar o arquivo.
8. A função writeToFile é a seguinte:
FileOutputStream de = new FileOutputStream(oArquivo);
of.write(writer.toString().getBytes("GBK"));
//String tt = escritor.toString();
de.flush();
de.close();
Este artigo vem do blog CSDN. Indique a fonte ao reimprimir: http://blog.csdn.net/sunrui_work/archive/2009/12/18/5029982.aspx.