Mucha gente ha visto o aprendido sobre Velocity. La traducción literal del nombre es: velocidad, velocidad, rapidez. Se usa en el desarrollo web, pero no mucha gente lo ha usado. La mayoría de ellos básicamente conocen y usan Struts. y relacionado con Struts, ¿qué opinas de Velocity? Probémoslo y comprendamos el concepto de Velocity. A través de la introducción aquí, enfatizamos los problemas en la selección de tecnología, para que todos puedan considerar Velocity al elegir el desarrollo del proyecto y también permitir que todos comprendan sus ideas. Una muy buena forma de pensar, que les da a todos un cambio de opinión y una forma diferente de pensar.
Este artículo se basa en el hecho de que tiene cierta base en el desarrollo de Java y conoce MVC, Struts y otros modelos de desarrollo.
Velocity es una tecnología de motor de plantillas Java. El proyecto fue propuesto por Apache y se deriva de otra tecnología de motor, Webmacro. Entonces, ¿cuál es la definición oficial de Velocidad? Apache lo define como: un motor de plantillas basado en Java, pero permite a cualquiera utilizar un lenguaje de plantillas simple y potente para hacer referencia a objetos definidos en código Java. La última versión es 1.4. Puede encontrar más información en http://jakarta.apache.org/velocity/index.html .
De hecho, para decirlo sin rodeos, Velocity es una implementación de la arquitectura MVC, pero se centra más en la relación entre Modelo y Vista como un puente entre ellos. Creo que todos están familiarizados con Struts, la arquitectura más popular de MVC. Muchos desarrolladores han estado utilizando ampliamente la arquitectura Struts, incluidas las versiones de plataforma de administración de la tecnología Struts de IBM 5 o superior, que es una buena práctica de MVC y reduce efectivamente Java. El código aparece en View (Jsp), pero la conexión entre Model y View todavía depende de la tecnología Taglib de Struts. Imagínese si el diseñador web front-end no está familiarizado con Struts o incluso con Taglib (creo que es bastante difícil estar familiarizado). con él, incluido Lo mismo ocurre con el personal de mantenimiento posterior), lo que hará que sea muy difícil para los diseñadores web y los ingenieros de desarrollo front-end cooperar entre sí. En el desarrollo real, todavía existe el hecho de que el trabajo entre los diseñadores web. Y los desarrolladores front-end pueden ser más complicados. Todavía existe un cierto grado de acoplamiento. ¿Cómo resolver este problema en la mayor medida posible? Echemos un vistazo a Velocity o este concepto.
Comencemos con el ejemplo de desarrollo de Velocity más simple para mostrarle cómo funciona Velocity:
1. Cree un archivo, el nombre del archivo es: hellavelocity.vm, que es la plantilla de velocidad (en realidad es la misma que html), el contenido es:
¡Bienvenido $nombre a Javayou.com!
hoy es fecha $.
2. Cree un archivo java, HelloVelocity.java, con contenido:
paquete 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 2004-12-14
*/
clase pública HolaVelocity {
public static void main (String [] args) lanza una excepción {
//Inicializa y obtiene el motor Velocity
VelocityEngine y = nuevo VelocityEngine();
ve.init();
//Obtener la plantilla de velocidad
Plantilla t = ve.getTemplate("hellovelocity.vm");
//Obtener el contexto de la velocidad
Contexto VelocityContext = nuevo VelocityContext();
//Completar datos en contexto
contexto.put("nombre", "Liang");
context.put("fecha", (nueva fecha()).toString());
//Para visualización posterior, ingrese el valor de la Lista con anticipación
Lista temporal = nueva ArrayList();
temp.add("1");
temp.add("2");
contexto.put("lista", temperatura);
//flujo de salida
Escritor StringWriter = nuevo StringWriter();
//convertir salida
t.merge(contexto, escritor);
System.out.println(writer.toString());
}
}
3. Descargue el zip Velocity 1.4 en http://jakarta.apache.org/site/binindex.cgi , descomprímalo para obtener velocidad-1.4.jar y utilícelo para compilar la clase anterior HelloVelocity.java.
4. Copie hellavelocity.vm en 1 al directorio actual de ejecución. La ejecución de HelloVelocity también requiere otros paquetes, que se pueden obtener desde el speed1.4.zip descargado, \velocity - 1.4\build\lib, y colóquelo. Después de introducir commons-collections.jar y logkit-1.0.1.jar, ejecute java -cp .\bin -Djava.ext.dirs=.\lib2 com.javayou.velocity.HelloVelocity, suponiendo que la clase esté compilada. al directorio .\ bin, y los paquetes de clases que necesitamos se colocan en el directorio .\lib2. La estructura en ejecución es la siguiente:
¡Bienvenido Liang a Javayou.com!
hoy es martes 14 de diciembre a las 19:26:37 CST de 2004.
Lo anterior es el resultado de ejecución más simple. ¿Qué tal? Déjame saber aproximadamente. Las dos variables definidas $name y $date en la plantilla hellavelocity.vm son respectivamente context.put("name", "Liang") y context.put. ( "fecha", (new Date()).toString()) se reemplaza por el valor establecido.
Desde este punto de vista, el procesamiento de procesos de negocio, incluidos los resultados de negocio, se resuelve básicamente en la capa del modelo, mientras que la capa de vista básicamente solo se muestra utilizando un VTL (Velocity Template Language) simple. De esta manera, ¿no sería innecesario Jsp? Sí, este modelo de uso es un poco como el método CGI anterior :) Velocity genera código automáticamente, y Velocity también es muy capaz en este sentido. Velocity se usa en Turbine para generar una gran cantidad de código.
En Velocity, las definiciones de variables comienzan con "$" y $ sirve como identificador de Velocity. Se pueden utilizar letras, números, trazos y subrayados como variables definidas en Velocity.
Además, también debemos prestar atención a las definiciones de variables características de Velocity, como: $student.No, $student.Address, que tienen dos niveles de significado: el primero es si el estudiante es una tabla hash, la clave No y will se extrae de la tabla hash El valor de Dirección, y el segundo tipo es que puede ser un método de llamada, es decir, las dos variables anteriores se convertirán a Student.getNo() y Student.getAddress(). Velocity tiene un objeto para el valor devuelto por el código Java en el servlet, y también puede llamar a los métodos del objeto, como $student.getAddress(), etc. No daré ejemplos ni entraré en detalles aquí.
El ejemplo anterior es solo un ejemplo simple. Por supuesto, muchas personas ya no están satisfechas con tales ejemplos. En aplicaciones reales, a menudo necesitamos hacer algunas visualizaciones selectivas y enumerar algunos datos iterativos, como listas y, por supuesto, Velocidad (. específicamente, debería ser un lenguaje de plantilla VTL) también admite esta función. Además, también admite algunas otras visualizaciones de uso común, como variables dentro de la plantilla (como variables en Jsp) y otras más potentes, como la creación de macros para lograr la automatización. .Continuemos leyendo.
Seguimos usando el ejemplo anterior y cambiamos el contenido de la plantilla hellavelocity.vm a:
#set( $iAmVariable = "¡bien!")
¡Bienvenido $nombre a Javayou.com!
hoy es fecha $.
$ soy variable
Vuelva a ejecutar el comando de ejecución anterior, el resultado es:
¡Bienvenido Liang a Javayou.com!
hoy es martes 14 de diciembre a las 22:44:39 CST de 2004.
¡bien!
Puede ver que las variables en la plantilla se definen como declaraciones que comienzan con #set, lo cual no es difícil de entender. Después de la ejecución, las variables $iAmVariable en la plantilla se convierten a los valores definidos:
¡bien!
Veamos nuevamente una elección simple. Cambie el contenido de la plantilla hellavelocity.vm a:
#set ($admin = "administrador")
#set ($usuario = "usuario")
#if ($admin == $usuario)
¡Bienvenido administrador!
#demás
¡Bienvenido usuario!
#fin
Ejecute el comando ejecutar, el resultado es:
¡Bienvenido usuario!
Puede ver que las declaraciones de juicio son simples #if (), #else, #end, no muy complicadas.
Sigamos mirando los datos de la iteración y cambiemos el contenido de la plantilla hellavelocity.vm a:
#foreach($producto en $lista)
$producto
#fin
Ejecute el comando ejecutar, el resultado es:
#1
#2
¿No es conveniente enumerar los valores guardados previamente en la lista VelocityContext del ejemplo? Simplemente use #foreach ($variable en xx). Si la Lista anterior se reemplaza con una Hashtable, puede usar la siguiente sintaxis:
#foreach($clave en $hashVariable.keySet() )
Valor de $key: $ hashVariable.get($key)
#fin
No creo que estos guiones sean complicados en absoluto.
Mucha gente también preguntará, ¿y si es javabean? Bien, agreguemos un frijol:
paquete com.javayou.velocity;
/**
* @autor Liang.xf 2004-12-14
*/
estudiante de clase pública {
//Ten en cuenta que los atributos de clase son públicos
cadena pública no = "";
dirección de cadena pública = "";
Estudiante público (String _no, String _address) {
no = _no;
dirección = _dirección;
}
cadena pública getAddress() {
dirección del remitente;
}
setAddress público vacío (dirección de cadena) {
esta.dirección = dirección;
}
cadena pública getNo() {
devolver no;
}
conjunto vacío públicoNo (cadena no) {
this.no = no;
}
}
Este Estudiante es un javabean completo, o bean de datos, una clase común utilizada para cargar datos. Luego modificamos HelloVelocity.java para:
temp.add("1");
temp.add("2");
Reemplazar con:
temp.add(nuevo Estudiante("123", "Guangzhou"));
temp.add(nuevo Estudiante("456", "Zhuhai"));
Luego cambie el contenido de hellavelocity.vm a:
#foreach ($s en $estudiantes)
<$velocityCount> Dirección: $s.address
#fin
Vuelva a compilar y ejecutar el comando de ejecución, los resultados son los siguientes:
<1> Dirección: Cantón
<2> Dirección: Zhuhai
De esta manera se imprimen los datos del Estudiante en la lista y ¡listo! Aquí se utiliza la variable incorporada de Velocity $ velocityCount, que se refiere al número de secuencia de enumeración predeterminado. Comienza desde 1. También se puede cambiar a 0, pero debe cambiarse en Velocity.properties. el paquete speed-1.4.jar En el directorio org\apache\velocity \runtime\defaults .
¿Cómo lidiar con iteraciones más complejas? Veamos el siguiente ejemplo de plantilla para que quede claro:
#foreach ($elemento en $lista)
-- antebrazo interior --
#foreach ($elemento en $lista)
Este es el elemento $.
$velocidadCount
#fin
-- antebrazo interior --
-- antebrazo exterior --
Este es el elemento $.
$velocidadCount
-- antebrazo exterior --
#fin
Como puede ver, Velocity admite el anidamiento de etiquetas. Esta es una función muy poderosa. No la demostraré en profundidad aquí. Si está interesado, pruébelo usted mismo.
De hecho, si piensas un poco más en profundidad en el ejemplo que acabamos de dar, ya podrás ver, ¿para qué sirve Velocity? Ese es el modelo Servlet + Velocity. Además, ¿todavía recuerdas nuestro primer modelo de desarrollo Jsp, Jsp + JavaBean? Aquí, cambiamos a Servlet + JavaBean + Velocity. Piénselo, reemplazó a Jsp + JavaBean y eliminó más a fondo el código Java de Jsp (vm). Si solo usa Struts (Servlet + Jsp), entonces El costo es. El código Java siempre aparece más o menos en JSP. Incluso si se puede hacer sin código Java, los desarrolladores que han creado sistemas de arquitectura compleja saben que el costo también es muy elevado y, en términos de mantenibilidad, existen ciertas dificultades en el desarrollo integrado. con diseñadores web, por lo que podemos sentir aquí que el modelo Servlet + JavaBean + Velocity realiza mejor el concepto de OOD. En términos de eficiencia, no tiene que preocuparse. Esta combinación es más eficiente que el método Servlet+Jsp.
Debería haber muchas personas que estén dispuestas a aprender sobre Velocity, pero quizás no muchas puedan aplicarlo a proyectos (algunos proyectos todavía lo usan, como Jute. Después de todo, en comparación con Jsp, Jsp es más estándar y se usa más ampliamente). y se han utilizado muchas herramientas de desarrollo. Pero la función de Velocity no se limita a competir con Jsp. Como se puede ver en lo anterior, es muy poderoso en la salida automática de código. Como se mencionó anteriormente, Turbine usa Velocity para generar una gran cantidad de código. Es una muy buena idea convertirlo en un generador de código u otra generación de plantillas.
Bien, echemos un vistazo a algunos problemas comunes a los que se debe prestar atención si desea profundizar en Velocity para realizar proyectos. El primero es el problema de la internacionalización.
Velocity admite la conversión de codificación internacional de plantillas. Eche un vistazo a los métodos proporcionados por Velocity:
Plantilla pública getTemplate (plantilla Stirng, codificación de cadena),
Se especula que este enfoque no puede lograr una internacionalización completa.
El concepto más simple de internacionalización en Struts es usar etiquetas de idiomas internacionales en Jsp, y cada idioma usa una biblioteca de etiquetas de idiomas diferente. Por extensión, en realidad se puede hacer manualmente. Sí, solo requiere un poco de procesamiento manual.
Afortunadamente, alguien ya resolvió el problema mencionado anteriormente y creó las herramientas de Velocity: MessageTool, que proporciona el texto variable para contener etiquetas internacionalizadas. De esta manera, solo necesita escribir código de etiqueta, como por ejemplo: $text.get('title. ' ), también se puede encontrar contenido más específico en http://jakarta.apache.org/velocity/tools/struts/MessageTool.html .
Bien, todo eso se basa en la introducción de Velocity, hablemos de otras extensiones. Algunas personas comentaron que Velocity no es una estructura MVC estándar. Sí, dijimos al principio que Velocity es solo una buena combinación entre Modelo y Vista, y es solo un buen motor de plantilla. Después de todo, aún no existe una buena combinación de MVC. sido formado. Afortunadamente, Apache lanzó VelocityStruts basado en la combinación de Struts y Velocity. Podemos presentar esta parte de la declaración en un tema posterior. Aquí hay una breve introducción a su concepto. Se basa en la estructura de Struts y la acción de la lógica empresarial. procesamiento Finalmente, el proceso de negocio se traslada a la capa de visualización basada en Velocity, reemplazando así a Jsp como la capa de Vista. También hemos visto anteriormente que los ejemplos citados se basan básicamente en principios y demostraciones y no están estrechamente integrados con el desarrollo web. Combinaremos este aspecto al describir el contenido de VelocityStruts.
Introducción al uso de Velocity - código en java
1. Primero inicializa el objeto.
Contexto VelocityContext = nuevo VelocityContext();
Escritor StringWriter = nuevo StringWriter();
Codificación de cadena2 = "GBK";
2. PROPERTY_PATH = TEMPLATE_INIT_PATH en el archivo de propiedades del sistema (especifique la ruta del archivo de propiedades requerida para la velocidad).
3． Contenidos en Propiedades
file.resource.loader.path = D:/resin/webapps/mip/files/templateupload/ (donde se encuentra la plantilla)
4. Luego inicialice Velocity.init(PROPERTY_PATH);
5. Corresponde las etiquetas en velocidad a java context.put(key, value);
6． Luego cargue el archivo Velocity.mergeTemplate(templateName, encoding2, context,writer);
7. Finalmente, llame a Generator.writeToFile() para generar el archivo.
8. La función writeToFile es la siguiente:
FileOutputStream de = nuevo FileOutputStream(theFile);
of.write(writer.toString().getBytes("GBK"));
// Cadena tt = escritor.toString();
de.flush();
de.cerrar();
Este artículo proviene del blog de CSDN. Indique la fuente al reimprimir: http://blog.csdn.net/sunrui_work/archive/2009/12/18/5029982.aspx.