O Java esquentou gradualmente nos últimos anos. Com o lançamento do Java SE 5 e do Java SE 6, o futuro do Java é ainda mais brilhante. No entanto, o JSP baseado em Java não conseguiu levantar a cabeça antes do lançamento do Java SE 5. A razão mais importante é que, embora o JSP seja muito poderoso, sua maior vantagem é também sua maior desvantagem. Funções poderosas significam complexidade, especialmente Existem. não há muitas ferramentas visuais para projetar interfaces front-end e elas não são poderosas o suficiente. Portanto, projetar páginas JSP torna-se muito complicado e complicado...
O Java esquentou gradualmente nos últimos anos. Com o lançamento do Java SE 5 e do Java SE 6, o futuro do Java é ainda mais brilhante. No entanto, o JSP baseado em Java não conseguiu levantar a cabeça antes do lançamento do Java SE 5. A razão mais importante é que, embora o JSP seja muito poderoso, sua maior vantagem é também sua maior desvantagem. Funções poderosas significam complexidade, especialmente Existem. não há muitas ferramentas visuais para projetar interfaces front-end e elas não são poderosas o suficiente. Portanto, projetar páginas JSP torna-se muito complicado e complicado. No entanto, ao mesmo tempo que o Java SE 5 foi lançado, a Sun lançou uma nova especificação JavaServer Faces (JSF, abreviadamente) para simplificar o desenvolvimento de JSP. Isso coloca JSP no caminho certo.
1. O que é JSF?
JSF e JSP são um novo par. JSP é uma tecnologia usada para processamento lógico em segundo plano, enquanto JSF é exatamente o oposto. É uma tecnologia que permite aos desenvolvedores desenvolver rapidamente aplicativos da Web baseados em Java. Atualmente, o JSF1.2 foi oficialmente adicionado ao Java EE 5 como padrão.
Por ser uma tecnologia altamente componenteizada, os desenvolvedores podem implementar operações de edição de arrastar e soltar com o suporte de algumas ferramentas de desenvolvimento. Os usuários só precisam arrastar os componentes JSF para a página para realizar facilmente o desenvolvimento da Web. Este é o maior benefício dela como uma tecnologia componenteizada. Os componentes que podemos usar não são apenas caixas de entrada relativamente simples, mas também componentes mais complexos, como componentes de tabela como componentes de árvore DataTable, como Tree e assim por diante.
Como tecnologia padrão, o JSF também é suportado por alguns fornecedores de ferramentas. Ao mesmo tempo, também teremos muitas ferramentas de desenvolvimento gratuitas disponíveis. Não muito tempo atrás, o Sun Java Studio Creator 2 e o Oracle JDeveloper 10g foram lançados como ferramentas de desenvolvimento gratuitas que suportam JSF, o que trouxe muita vitalidade ao JSF. Além disso, também temos algumas excelentes ferramentas de desenvolvimento comercial para escolher. Ferramentas de desenvolvimento de plug-ins baseadas em Eclipse, como BEA Workshop (anteriormente M7 NitroX), Exadel e MyEclipse, trouxeram grande conveniência para a maioria dos usuários atuais do Eclipse da IBM. O Rational Application Developer e o JBuilder da Borland também são ferramentas de desenvolvimento comercial muito boas que suportam o desenvolvimento visual JSF.
JSF é fundamentalmente diferente da tecnologia Web tradicional. A tecnologia Web tradicional exige que os usuários capturem solicitações do navegador, salvem o estado do cliente e controlem manualmente o redirecionamento de páginas, etc. O surgimento do JSF sem dúvida nos trouxe grande conveniência. O JSF fornece um modelo de navegação de página orientado a eventos, que permite aos desenvolvedores de aplicativos projetar o fluxo de páginas dos aplicativos. Semelhante à abordagem do Struts, todas as informações de fluxo de página são definidas no arquivo XML de configuração JSF (faces-config.xml) em vez de codificadas no aplicativo. Isso simplifica muito a dificuldade de desenvolvimento para desenvolvedores e simplifica o desenvolvimento de aplicativos.
Ao mesmo tempo, JSF também é uma estrutura que segue o padrão model-view-controller (MVC). Ele consegue a separação completa do código de visualização (View) e da lógica da aplicação (Model), permitindo que aplicativos que utilizam a tecnologia JSF obtenham uma boa separação de páginas e código. Todas as solicitações de páginas JSF serão processadas através de um controlador front-end (FacesServlet). O sistema processa automaticamente a solicitação do usuário e retorna o resultado ao usuário. Isso não é muito diferente da estrutura MVC tradicional.
JSF não usa apenas a tecnologia POJO, mas também usa a tecnologia Spring-like Inversion of Control (IoC) (ou Dependency Injection-DI). No Backing Bean do JSF, podemos colocar os dados e operações exigidos pela visualização Coloque-os em um Backing Bean. . Ao mesmo tempo, graças à tecnologia DI utilizada pelo JSF, podemos inicializar o Managed Bean no arquivo de configuração. Ao mesmo tempo, também podemos usar esta tecnologia para integração fácil com Spring, que utiliza tecnologia semelhante.
2. Como usar JSF em JSP
JSF só pode exercer plenamente seu efeito combinando-o com JSP. JSF é integrado por meio de bibliotecas de tags e JSP. A biblioteca de tags é equivalente ao componente do lado do servidor do ASP.NET. JSF fornece uma biblioteca de tags muito rica, através da qual vários modelos de clientes podem ser gerados, como HTML, WML, XML e JavaScript. Por meio dessas tags, você pode criar facilmente modelos de clientes em grande escala e lidar automaticamente com solicitações de clientes por meio dessas tags.
A seguir, veremos um exemplo de como fazer JSF e JSP funcionarem juntos. Existem duas bibliotecas no JSF. A primeira é chamada de biblioteca do kernel, que contém várias tags importantes, como configuração de componentes, gerenciamento de eventos, validação de informações de entrada, etc. A principal função da segunda biblioteca é corresponder a diversas tags de HTML e JSF. Cada tag JSF corresponde a um componente HTML. Por exemplo, a tag UIInput corresponde à caixa de texto ou caixa de senha em HTML.
A caixa de entrada de texto na tag JSF é chamada inputText e a biblioteca de entrada de senha é chamada inputSecret. A seguir está um programa de interface de usuário simples que combina JSF e JSP.
＜%@ taglib uri=" http://java.sun.com/jsf/html " prefix="h" %＞
＜%@ taglib uri=" http://java.sun.com/jsf/core " prefixo ="f" %＞
＜html＞
＜head＞
＜meta HTTP-EQUIV="Content-Type" CONTENT="text/html;CHARSET=GB2312"＞
＜title＞O primeiro programa JSF ＜/title＞
＜/head ＞
＜body＞
＜f:view＞
＜h:form id="simpleForm"＞
＜h:outputText id="favoriteLabel" value="Por favor, insira um número:"/＞
＜h:inputText id="favoriteValue" value= " #{simple.longValue}"＞
＜f:validateLongrange máximo="30" mínimo="0"/＞
＜/h:inputText＞
＜p/＞
＜h:commandButton id="submit" value="Enviar" action = "#{simple.simpleActionMethod}"/＞
＜/h:form＞
＜/f:view＞
＜/body＞
＜/html＞
No código acima, podemos entender como o JSF é integrado ao JSP. Podemos primeiro ver um rótulo do kernel: view. Depois, há vários componentes JSF. Como formulário, outputText, inputText e commandButton. Esses componentes são colocados no formulário e passam a fazer parte do formulário. Logo no início do programa, duas bibliotecas de tags devem ser importadas usando import. O código é o seguinte.
＜%@ taglib uri=" http://java.sun.com/jsf/html " prefix="h" %＞
＜%@ taglib uri=" http://java.sun.com/jsf/core " prefixo ="f" %>
As duas linhas de código acima declaram qual biblioteca de tags JSF usar em JSP. A biblioteca do kernel é declarada com o prefixo f, enquanto a biblioteca HTML é declarada com o prefixo h. Esses dois prefixos não são obrigatórios, mas são apenas uma sugestão. No programa, a biblioteca do kernel deve ser utilizada, pois a view deve ser utilizada em todas as páginas JSF. A tag HTML converte a tag JSF em um componente HTML em tempo de execução. Este prefixo h não é necessário, mas recomendado pela especificação JSF. Desta forma, tornamos nosso programa JSF mais legível.
Após a declaração há diversas linhas de instruções HTML padrão, que não serão descritas em detalhes neste artigo. Começando em <f:view>, é uma instrução JSF. Este código é o seguinte:
＜f:view＞
＜h:form id="simpleForm"＞
＜h:outputText id="favoriteLabel" value="Por favor insira um número:"/＞
＜h:inputText id="favoriteValue " value="#{simple.longValue}">
＜f:validateLongrange máximo="30" mínimo="0"/＞
＜/h:inputText＞
＜p/＞
＜h:commandButton id="submit" value=" Enviar
A tag"
action="#{simple.simpleActionMethod}"/＞
＜/h:form＞
＜/f:view＞
＜/f:view＞ anuncia o início do JSF, e seu próximo formulário de tag criará um formulário HTML. A tag outputText é equivalente ao componente rótulo em HTML. A tag inputText é equivalente ao componente textField em HTML. A tag commandButton é equivalente ao botão enviar em HTML. Ao executar este programa JSP, você obterá o efeito mostrado na Figura 1.
3. Como o JSP responde às solicitações JSF
No exemplo acima, já sabemos como usar o JSF no JSP. Nesta parte, vamos dar uma olhada em como as solicitações são processadas no JSF.
Primeiro, vejamos um exemplo de conversão de Fahrenheit em Celsius. O programa fará a transição quando o usuário clicar no botão enviar.
＜%@ taglib uri=" http://java.sun.com/jsf/html " prefix="h" %＞
＜%@ taglib uri=" http://java.sun.com/jsf/core " prefixo ="f" %＞
＜html＞
＜head＞
＜meta HTTP-EQUIV="Content-Type" CONTENT="text/html;CHARSET=GB2312"＞
＜title＞Programa de conversão de temperatura＜/title＞
＜/head＞
＜ body＞
＜f:view＞
＜h:form＞
＜div＞
＜h:outputText id="fahrenheitLabel" value="Por favor, insira a temperatura 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="Convert" action="#{tc.convert} " ＞
＜/h:commandButton＞
＜/div＞
＜/h:form＞
＜/f:view＞
＜/body＞
＜/html＞
Nas duas primeiras linhas do programa, a biblioteca principal JSF e a biblioteca HTML são importadas Isso já foi feito antes e não será discutido em detalhes aqui.
Vamos dar uma olhada em como as tags JSF interagem com o backend. Como estamos usando JSF em JSP, não há diferença entre este e o JSP normal. JSP é na verdade um Servlet. Quando o JSP é executado pela primeira vez, o compilador JSP compila o arquivo .JSP em um Servlet e o chama. o Servlet O Servlet então recebe o fluxo de dados do cliente. Mas, diferentemente dos programas JSP comuns, as tags JSF são chamadas pela API JSF (isso permite a separação da camada lógica e da camada de apresentação. Fora isso, elas não são diferentes das tags JSP comuns).
Quando uma tag UIComponent recebe o método doStartTag, o JSF usará essas propriedades para definir o valor da tag. Por exemplo, a tag inputText neste exemplo será definida de acordo com o valor do seu atributo. Abaixo está o trecho de código do JSF.
＜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＞
A tag inputText define os atributos id e value de acordo com os valores correspondentes. No JSF, cada valor de atributo é definido por meio de setAttribute(String name, Object value). Mas o que precisamos observar é que as tags JSF podem especificar valores padrão correspondentes. Isso é um pouco semelhante às propriedades do sistema em Java. Se você fornecer um nome de propriedade, o sistema retornará o valor da propriedade. Se você especificar seu valor padrão e a propriedade não existir, o valor padrão será retornado.
A seguir, vamos dar uma olhada na parte mais importante do programa acima, que é o tratamento de eventos do componente UIInput.
<f:valuechangeListener type="tempconv.page.TCChangedListener"/>
No JSF, o processamento de eventos é concluído pela tag valuechangeListener. O evento representado por este rótulo aciona um evento quando o valor da caixa de texto é alterado. Mas o interessante é que esse evento não é enviado imediatamente. Em vez disso, o evento e os dados correspondentes não são enviados ao backend até que o usuário clique no botão "Enviar". Portanto, esta solicitação de evento também é chamada de pré-confirmação. Finalmente, vamos dar uma olhada na implementação do código do UICommand.
＜div＞
＜h:commandButton value="Conversion" action="#{tc.convert}"＞
＜/h:commandButton＞
＜/div＞
O código acima conecta o método convert() e UICommand, ou seja, após clicar no botão “Enviar”, o método convert() será executado. Depois de encontrar a tag view, o programa JSF resulta e o JSFAPI finalmente chama o método doEnd para encerrar o programa JSF. Depois de analisar este programa, o mecanismo JSF converte as tags JSF correspondentes em componentes HTML.
Finalmente, vamos dar uma olhada em como o JSP responde aos eventos JSF. Abaixo está um trecho de código Java que responde a eventos JSF.
public class TCChangedListener implements ValueChangeListener
{
public TCChangedListener()
{
super()
}
// Tratamento de evento
publicvoid
processValueChange(evento ValueChangeEvent)
lança AbortProcessingException
{
UIComponent comp = event.getComponent()
;
null != valor)
{
float
curVal = ((Número) valor).floatValue();
Valores domapa
=
comp.getAttributes();
;
}
else
{
values.put("styleClass", "black");
Para
responder
a
eventos JSF, você deve implementar a interface ValueChangeListener na biblioteca JSF. O que deve ser observado no programa acima é que a cor correspondente é finalmente definida de acordo com o valor de entrada. Esses valores não dependem de JSP. Claro, você também pode defini-los como nulos e deixar as tags JSP definirem suas cores.