Java se ha ido calentando gradualmente en los últimos años. Con el lanzamiento de Java SE 5 y Java SE 6, el futuro de Java es aún más brillante. Sin embargo, JSP basado en Java no pudo levantar la cabeza antes del lanzamiento de Java SE 5. La razón más importante es que, aunque JSP es muy poderoso, su mayor ventaja es también su mayor desventaja. Las funciones poderosas significan complejidad, especialmente Hay. No hay muchas herramientas visuales para diseñar interfaces front-end y no son lo suficientemente potentes. Por lo tanto, diseñar páginas JSP se vuelve muy complicado y engorroso...
Java se ha ido calentando gradualmente en los últimos años. Con el lanzamiento de Java SE 5 y Java SE 6, el futuro de Java es aún más brillante. Sin embargo, JSP basado en Java no pudo levantar la cabeza antes del lanzamiento de Java SE 5. La razón más importante es que, aunque JSP es muy poderoso, su mayor ventaja es también su mayor desventaja. Las funciones poderosas significan complejidad, especialmente Hay. No hay muchas herramientas visuales para diseñar interfaces front-end y no son lo suficientemente potentes. Por tanto, diseñar páginas JSP se vuelve muy complicado y engorroso. Sin embargo, al mismo tiempo que se lanzó Java SE 5, Sun lanzó una nueva especificación JavaServer Faces (JSF para abreviar) para simplificar el desarrollo de JSP. Esto coloca a JSP en el camino brillante.
1. ¿Qué es JSF?
JSF y JSP son un par nuevo. JSP es una tecnología utilizada para el procesamiento lógico en segundo plano, mientras que JSF es todo lo contrario. Es una tecnología que permite a los desarrolladores desarrollar rápidamente aplicaciones web basadas en Java. Es una tecnología de capa de presentación. Actualmente, JSF1.2 se ha agregado oficialmente a Java EE 5 como estándar.
Como tecnología altamente compuesta, los desarrolladores pueden implementar operaciones de edición de arrastrar y soltar con el soporte de algunas herramientas de desarrollo. Los usuarios solo necesitan arrastrar componentes JSF a la página para realizar fácilmente el desarrollo web. Este es el mayor beneficio de esta tecnología en componentes. Los componentes que podemos usar no son solo cuadros de entrada relativamente simples, sino también componentes más complejos, como componentes de tabla como componentes de árbol como DataTable, etc.
Como tecnología estándar, JSF también cuenta con el respaldo de bastantes proveedores de herramientas. Al mismo tiempo, también tendremos muchas buenas herramientas de desarrollo gratuitas disponibles. No hace mucho, se lanzaron Sun Java Studio Creator 2 y Oracle JDeveloper 10g como herramientas de desarrollo gratuitas que admiten JSF, lo que aportó mucha vitalidad a JSF. Además, también tenemos excelentes herramientas de desarrollo comercial para elegir. Las herramientas de desarrollo de complementos basadas en Eclipse, como BEA Workshop (anteriormente M7 NitroX), Exadel y MyEclipse, han brindado una gran comodidad a la mayoría de los usuarios actuales de IBM. Rational Application Developer y JBuilder de Borland también son muy buenas herramientas de desarrollo comercial que respaldan el desarrollo visual JSF.
JSF es fundamentalmente diferente de la tecnología web tradicional. La tecnología web tradicional requiere que los usuarios capturen las solicitudes del navegador, guarden el estado del cliente y controlen manualmente la redirección de páginas. Sin duda, la aparición de JSF nos ha brindado una gran comodidad. JSF proporciona un modelo de navegación de páginas basado en eventos, que permite a los desarrolladores de aplicaciones diseñar el flujo de páginas de las aplicaciones. De manera similar al enfoque de Struts, toda la información del flujo de página se define en el archivo XML de configuración JSF (faces-config.xml) en lugar de estar codificada en la aplicación. Esto simplifica enormemente la dificultad de desarrollo para los desarrolladores y simplifica el desarrollo de aplicaciones.
Al mismo tiempo, JSF también es un marco que sigue el patrón modelo-vista-controlador (MVC). Logra la separación completa del código de vista (Ver) y la lógica de la aplicación (Modelo), permitiendo que las aplicaciones que utilizan tecnología JSF logren una buena separación de páginas y código. Todas las solicitudes de páginas JSF se procesarán a través de un controlador de front-end (FacesServlet). El sistema procesa automáticamente la solicitud del usuario y le devuelve el resultado. Esto no es muy diferente del marco MVC tradicional.
JSF no solo usa la tecnología POJO, sino que también usa la tecnología de inversión de control (IoC) similar a Spring (o inyección de dependencia-DI). En el Backing Bean de JSF, podemos colocar los datos y las operaciones requeridas por la vista. . Al mismo tiempo, gracias a la tecnología DI utilizada por JSF, podemos inicializar Managed Bean en el archivo de configuración. Al mismo tiempo, también podemos utilizar esta tecnología para integrarnos fácilmente con Spring, que utiliza una tecnología similar.
2. Cómo utilizar JSF en JSP
JSF puede ejercer plenamente su efecto sólo combinándolo con JSP. JSF se integra a través de bibliotecas de etiquetas y JSP. La biblioteca de etiquetas es equivalente al componente del lado del servidor de ASP.NET. JSF proporciona una biblioteca de etiquetas muy rica a través de la cual se pueden generar varios modelos de cliente, como HTML, WML, XML y JavaScript. A través de estas etiquetas, puede crear fácilmente modelos de clientes a gran escala y manejar automáticamente las solicitudes de los clientes a través de estas etiquetas.
A continuación, veamos un ejemplo de cómo hacer que JSF y JSP funcionen juntos. Hay dos bibliotecas en JSF. La primera se llama biblioteca del núcleo y contiene varias etiquetas importantes, como configurar componentes, gestionar eventos, validar información de entrada, etc. La función principal de la segunda biblioteca es corresponder a varias etiquetas de HTML y JSF. Cada etiqueta JSF corresponde a un componente HTML. Por ejemplo, la etiqueta UIInput corresponde al cuadro de texto o al cuadro de contraseña en HTML.
El cuadro de entrada de texto en la etiqueta JSF se llama inputText y la biblioteca de entrada de contraseña se llama inputSecret. El siguiente es un programa de interfaz de usuario simple que combina JSF y JSP.
＜%@ taglib uri=" http://java.sun.com/jsf/html " prefijo="h" %＞
＜%@ taglib uri=" http://java.sun.com/jsf/core " prefijo ="f" %＞
＜html＞
＜head＞
＜meta HTTP-EQUIV="Content-Type" CONTENT="text/html;CHARSET=GB2312"＞
＜title＞El primer programa JSF ＜/title＞
＜/head ＞
＜body＞
＜f:view＞
＜h:form id="simpleForm"＞
＜h:outputText id="favoriteLabel" value="Ingrese un número:"/＞ ＞
＜h:inputText id="favoriteValue" value= " #{simple.longValue}"＞
＜f:validateLongrange máximo="30" mínimo="0"/＞
＜/h:inputText＞
＜p/＞ ＞
＜h:commandButton id="enviar" valor="Enviar" acción = "#{simple.simpleActionMethod}"/＞
＜/h:form＞
＜/f:view＞
＜/body＞
＜/html＞
En el código anterior, podemos comprender cómo se integra JSF con JSP. Primero podemos ver una etiqueta del kernel: ver. Luego hay varios componentes JSF. Como formulario, texto de salida, texto de entrada y botón de comando. Estos componentes se colocan en el formulario y se convierten en parte del formulario. Al comienzo del programa, se deben importar dos bibliotecas de etiquetas mediante importación. El código es el siguiente.
＜%@ taglib uri=" http://java.sun.com/jsf/html " prefijo="h" %＞
＜%@ taglib uri=" http://java.sun.com/jsf/core " prefijo ="f" %>
Las dos líneas de código anteriores declaran qué biblioteca de etiquetas JSF usar en JSP. La biblioteca del kernel se declara con el prefijo f, mientras que la biblioteca HTML se declara con el prefijo h. Estos dos prefijos no son obligatorios, son sólo una sugerencia. En el programa, se debe usar la biblioteca del kernel, porque la vista debe usarse en todas las páginas JSF. La etiqueta HTML convierte la etiqueta JSF en un componente HTML en tiempo de ejecución. Este prefijo h no es necesario, pero lo recomienda la especificación JSF. De esta manera, hacemos que nuestro programa JSF sea más legible.
Después de la declaración hay varias líneas de declaraciones HTML estándar, que no se describirán en detalle en este artículo. A partir de
＜f:view＞
＜h:form id="simpleForm"＞
＜h:outputText id="favoriteLabel" value="Ingrese un número:"/＞
＜h:inputText id="favoriteValue " value="#{simple.longValue}">
＜f:validateLongrange máximo="30" mínimo="0"/＞
＜/h:inputText＞
＜p/＞ ＞
＜h:commandButton id="enviar" valor=" Enviar
La etiqueta"
action="#{simple.simpleActionMethod}"/＞
＜/h:form＞
＜/f:view＞
＜/f:view＞ presagia el comienzo de JSF, y su siguiente formulario de etiqueta creará un formulario HTML. La etiqueta OutputText es equivalente al componente de etiqueta en HTML. La etiqueta inputText es equivalente al componente textField en HTML. La etiqueta CommandButton es equivalente al botón de envío en HTML. Cuando ejecute este programa JSP, obtendrá el efecto que se muestra en la Figura 1.
3. ¿Cómo responde JSP a las solicitudes JSF?
Del ejemplo anterior, ya sabemos cómo usar JSF en JSP. En esta parte, echemos un vistazo a cómo se procesan las solicitudes en JSF.
Primero veamos un ejemplo de conversión de Fahrenheit a Celsius. El programa realizará la transición cuando el usuario haga clic en el botón Enviar.
＜%@ taglib uri=" http://java.sun.com/jsf/html " prefijo="h" %＞
＜%@ taglib uri=" http://java.sun.com/jsf/core " prefijo ="f" %＞
＜html＞
＜head＞
＜meta HTTP-EQUIV="Content-Type" CONTENT="text/html;CHARSET=GB2312"＞
＜title＞Programa de conversión de temperatura＜/title＞
＜/head＞
＜ body＞
＜f:view＞
＜h:form＞
＜div＞
＜h:outputText id="fahrenheitLabel" value="Ingrese la temperatura en grados Fahrenheit:"/＞
＜span＞
＜h:inputText id="temperature" value= " #{tc.fahrenheitTemp}"＞
＜f:validateDoublerange mínimo="-100.0" máximo="100.0"/＞
＜f:valuechangeListener type="tempconv.page.TCChangedListener"/＞
＜/h:inputText＞
＜/span ＞
＜/div＞
＜div＞
＜h:outputText id="celsiusLabel" value="Temperatura Celsius:"/＞
＜span＞
＜h:outputText id="celsiusValue" value="#{tc.celsiusTemp}"＞
＜ f :convertNumber maxFractionDigits="3" type="number"/＞
＜/h:outputText＞
＜/span＞
＜/div＞
＜div＞
＜h:commandButton value="Convertir" action="#{tc.convert} " ＞
＜/h:commandButton＞
＜/div＞
＜/h:form＞
＜/f:view＞
＜/body＞
＜/html＞
En las dos primeras líneas del programa, se importan la biblioteca principal JSF y la biblioteca HTML Esto se ha hecho antes y no se discutirá en detalle aquí.
Echemos un vistazo a cómo interactúan las etiquetas JSF con el backend. Dado que estamos usando JSF en JSP, no hay diferencia entre este y el JSP normal; JSP es en realidad un Servlet. Cuando se ejecuta el JSP por primera vez, el compilador JSP compila el archivo .JSP en un Servlet y luego lo llama. el Servlet. El Servlet luego recibe el flujo de datos del cliente. Pero a diferencia de los programas JSP ordinarios, las etiquetas JSF son llamadas por la API JSF (esto permite la separación de la capa lógica y la capa de presentación. Aparte de eso, no son diferentes de las etiquetas JSP ordinarias).
Cuando una etiqueta UIComponent recibe el método doStartTag, JSF usará estas propiedades para establecer el valor de la etiqueta. Por ejemplo, la etiqueta inputText en este ejemplo se establecerá según el valor de su atributo. A continuación se muestra el fragmento de código de JSF.
＜h:inputText id="temperatura" valor="#{tc.fahrenheitTemp}"＞
＜f:validateDoublerange mínimo="-100.0" máximo="100.0"/＞
＜f:valuechangeListener type="tempconv.page.TCChangedListener" /＞
＜/h:inputText＞
La etiqueta inputText establece los atributos id y value de acuerdo con los valores correspondientes. En JSF, cada valor de atributo se establece mediante setAttribute (nombre de cadena, valor de objeto). Pero lo que debemos tener en cuenta es que las etiquetas JSF pueden especificar los valores predeterminados correspondientes. Esto es algo similar a las propiedades del sistema en Java. Si proporciona un nombre de propiedad, el sistema devolverá el valor de la propiedad. Si especifica su valor predeterminado y la propiedad no existe, se devolverá el valor predeterminado.
A continuación, echemos un vistazo a la parte más importante del programa anterior, que es el manejo de eventos del componente UIInput.
En JSF, el procesamiento de eventos se completa mediante la etiqueta valuechangeListener. El evento representado por esta etiqueta desencadena un evento cuando cambia el valor del cuadro de texto. Pero lo interesante es que este evento no se envía inmediatamente. En cambio, el evento y los datos correspondientes no se envían al servidor hasta que el usuario hace clic en el botón "Enviar". Por lo tanto, esta solicitud de evento también se denomina confirmación previa. Finalmente, veamos la implementación del código de UICommand.
＜div＞
＜h:commandButton value="Conversion" action="#{tc.convert}"＞
＜/h:commandButton＞
＜/div＞
El código anterior conecta el método convert() y UICommand, es decir, después de hacer clic en el botón "Enviar", se ejecutará el método convert(). Después de encontrar la etiqueta de vista, el programa JSF resulta y JSFAPI finalmente llama al método doEnd para finalizar el programa JSF. Después de analizar este programa, el motor JSF convierte las etiquetas JSF correspondientes en componentes HTML.
Finalmente, echemos un vistazo a cómo responde JSP a los eventos JSF. A continuación se muestra un fragmento de código Java que responde a eventos JSF.
clase pública TCChangedListener implementa ValueChangeListener
{
public TCChangedListener()
{
super
();
}
// Manejo de eventos
public void ProcessValueChange (evento ValueChangeEvent)
lanza AbortProcessingException
{
UIComponent comp = event.getComponent()
Valor del objeto = event.getNewValue();
nulo! = valor)
{
float curVal = ((Número) valor).floatValue();
Valores de mapa = comp.getAttributes()
if (curVal < 0)
{
valores.put("styleClass", "red"); ;
}
else
{
values.put("styleClass", "black");
}
}
}
Para responder a eventos JSF, debe implementar la interfaz ValueChangeListener en la biblioteca JSF. Lo que se debe tener en cuenta en el programa anterior es que el color correspondiente finalmente se establece de acuerdo con el valor de entrada. Estos valores no dependen de JSP. Por supuesto, también puede establecerlos como nulos y dejar que las etiquetas JSP establezcan sus colores.