Há muito tempo que programo com JSP e ASP. Entre essas duas soluções de programação do lado do servidor, sinto cada vez mais que o JSP é muito mais poderoso que o ASP. Por que devo escolher JSP como minha ferramenta preferida de desenvolvimento de aplicativos da web no servidor? É claro que o JSP tem muitos recursos e funções fascinantes, mas a biblioteca de tags do JSP foi um dos motivos mais importantes para tomar essa decisão.
Por que você diz isso? As razões são duplas: manutenção e velocidade de desenvolvimento. As linguagens de script do lado do servidor são, na verdade, o caldeirão do desenvolvimento da Internet. Em uma página do servidor, você pode combinar facilmente vários métodos e objetos de script. Esse tipo de página é simplesmente o concreto para a construção da Web. É essa mistura de “coisas” que dá aos scripts do lado do servidor capacidades poderosas de processamento de informações. Ele permite que programadores do lado do servidor desenvolvam páginas da Web dinâmicas e flexíveis. Mas, por outro lado, a livre mistura de scripts também tem as suas desvantagens, que é o facto de ser muito difícil de manter, especialmente à medida que o tamanho do projecto continua a crescer. Para piorar a situação, à medida que a complexidade do código aumenta, a velocidade de desenvolvimento diminuirá, o que não favorece o desenvolvimento de aplicações web de médio e grande porte. Muitas aplicações web do lado do servidor de médio ou grande porte. são lançados muito tarde e o custo é incontrolável. Além disso, uma vez desenvolvido, o site ainda precisa encontrar programadores qualificados para manter esses códigos bastante complexos. Como resultado, esses programadores se tornam web designers gerais, e o aplicativo do lado do servidor desempenha um papel fundamental tanto no design gráfico final quanto na implementação. . Está enfraquecido.
Para superar esse problema, o ASP introduziu a tecnologia de objetos COM, enquanto o JSP forneceu o J2EE como contramedida. Essas soluções são construídas em mecanismos de bases de código centralizadas e reutilizáveis. No entanto, eles são muito difíceis de usar e levam muito tempo para aprender. Além disso, estas soluções não reduzem a tentação de criar códigos confusos e, como resultado, temos que organizar equipas de desenvolvimento grandes e bem estruturadas para utilizar estas tecnologias. Para projetos de médio porte, esses métodos geralmente são menos utilizados, mas, na verdade, projetos de aplicações web de médio porte são os mais comuns. Como resultado, muitos projetos são forçados a utilizar um ambiente de desenvolvimento e manutenção que não atende às suas necessidades.
Felizmente, JSP oferece uma maneira melhor de resolver esse problema. As bibliotecas de tags fornecem uma maneira fácil de criar blocos de código reutilizáveis. Depois que uma biblioteca de tags é projetada, ela pode ser usada novamente em muitos projetos. O que é ainda mais conveniente é que, diferentemente do COM e do J2EE, desde que você saiba escrever JSP, não precisará aprender nenhuma outra habilidade para criar uma biblioteca de tags! Finalmente, as bibliotecas de tags também melhoram a capacidade de manutenção das aplicações web. Essa melhoria na capacidade de manutenção se reflete na fácil implementação de interfaces personalizáveis baseadas em XML em páginas JSP. Como resultado, web designers podem construir aplicações web JSP sem saber o que é JSP. Desta forma, o desenvolvimento Web torna-se uma tarefa de desenvolvimento de equipe muito eficiente. Os programadores JSP podem criar tags personalizadas e módulos de código de back-end, enquanto os web designers podem usar tags personalizadas e se concentrar inteiramente no próprio design da Web. A biblioteca de tags resolve o problema de confusão de código e faz isso de forma limpa e bonita (na verdade, XML é a essência da solução desses problemas, mas a biblioteca de tags ainda desempenha um papel fundamental).
O que é uma biblioteca de tags?
A biblioteca de tags JSP (também chamada de biblioteca de tags personalizadas) pode ser vista como um método de geração de scripts baseados em XML por meio de JavaBeans. Conceitualmente, as tags são estruturas de código simples e reutilizáveis. Por exemplo, em nossa versão mais recente do JSPKit (dentro do JSP Insider), os documentos XML são facilmente acessados usando tags XML. Consulte a Lista A abaixo.
Listagem A: Exemplos de tags que executam transformações XML/XSL e as páginas HTML que elas contêm
<%@ taglib uri=" http://www.jspinsider.com/jspkit/JAXP " prefix="JAXP"%>
O exemplo acima usa tags simples para acessar o código mais poderoso nos bastidores. A parte da tag da instrução primeiro carrega um arquivo XML e depois aplica um arquivo XSL para transformar o conteúdo do arquivo XML em um determinado arquivo. formato de representação e enviado ao cliente, tudo isso usando apenas uma tag bem simples. Tags personalizadas facilitam a criação de módulos de código aberto reutilizáveis em projetos JSP, e tudo que você precisa é de uma biblioteca de tags e sua documentação.
Recursos importantes da biblioteca de tags
1. Fácil de instalar em vários projetos As tags podem ser facilmente migradas de um projeto JSP para outros projetos. Depois de criar uma biblioteca de tags, basta empacotar tudo em um arquivo JAR que você pode reutilizar em qualquer projeto JSP. As bibliotecas de tags estão se tornando cada vez mais populares porque as tags podem ser reutilizadas e facilmente usadas em seus próprios projetos. Atualmente, o melhor recurso de tag pode ser encontrado em JSPTags.com.
2. A biblioteca de tags JSP estendida pode ter quaisquer recursos e funções na especificação JSP (JSP 1.2). Você pode estender e aumentar as funções do JSP sem limite, sem esperar que a próxima versão do JSP apareça. Por exemplo, você não está satisfeito com a chamada de inclusão JSP. Você pode criar suas próprias tags de inclusão que aplicam suas próprias especificações.
3. Fácil de manter
A biblioteca de tags torna os aplicativos da web JSP muito fáceis de manter pelos seguintes motivos:
(1) A aplicação da etiqueta é simples e fácil de usar e entender por qualquer pessoa.
(2) Todos os códigos lógicos do programa estão concentrados no processador de tags e no JavaBeans. Isso significa que ao atualizar o código, você não precisa modificar todas as páginas que usam o código. Você só precisa modificar os arquivos de código centralizados.
(3) Se precisar adicionar novas funções, você não precisa modificar nenhuma página existente. Você pode adicionar atributos adicionais às tags para introduzir novos comportamentos, enquanto outros atributos antigos permanecem inalterados, para que todas as páginas antigas ainda possam ser usadas. . Funciona normalmente. Por exemplo, você tem um rótulo que deixa todo o texto azul:
Porém, mais tarde no projeto, você deseja que o azul fique mais escuro. Você pode manter o rótulo original e apenas adicionar um novo atributo a ele: shade, conforme mostrado abaixo:
Todas as tags antigas ainda podem produzir texto azul, mas agora você pode usar a mesma tag para produzir texto azul escurecido.
(4) Os rótulos melhoram a reutilização do código. O código que foi testado e usado muitas vezes certamente terá menos bugs. Portanto, as páginas JSP que usam tags personalizadas também apresentam menos defeitos e são naturalmente muito mais convenientes de manter.
4. A biblioteca de tags de tempo de desenvolvimento rápido fornece uma maneira fácil de reutilizar código. Uma das maneiras padrão de reutilizar código em linguagens do lado do servidor é usar modelos. Em comparação com o uso de bibliotecas de modelos, as bibliotecas de tags são uma solução melhor. Com uma biblioteca de templates, você tem que modificar os templates ou construir uma interface estrita para cada projeto, enquanto a biblioteca de tags não possui essas restrições e tem todos os benefícios da orientação a objetos, pode ser flexível e mais extensível, e, ao reutilizar code , você poderá gastar menos tempo desenvolvendo e mais tempo projetando seu aplicativo da web. A interface da biblioteca de tags também é muito simples, facilitando a inserção, uso e depuração.
Estrutura de tags
Embora a biblioteca de tags seja muito fácil de usar, o mecanismo interno de implementação para estabelecer uma biblioteca de tags ainda é bastante complicado, pelo menos mais complicado do que estabelecer um simples JavaBean. A complexidade vem do fato da biblioteca de tags ser composta por diversas partes. Porém, você só precisa dominar o conhecimento de Java e JSP.
Uma tag simples consiste nos seguintes elementos:
1. JavaBean: Para obter os benefícios do Java e sua natureza inerente orientada a objetos, o código reutilizável deve ser colocado em um contêiner de código separado, que é um JavaBean. Esses JavaBeans não são uma parte essencial da biblioteca de tags, mas são os módulos de código básicos usados pela biblioteca de tags para executar as tarefas atribuídas.
2. Processador de tags: O processador de tags é o verdadeiro coração da biblioteca de tags. Um manipulador de tags faz referência a quaisquer recursos externos necessários (JavaBeans) e é responsável por acessar as informações da página JSP (objetos PageContext). A página JSP passa os atributos da tag definidos na página e o conteúdo do corpo da tag para o processador de tags. Quando o processador de tags concluir seu processamento, ele enviará os resultados de saída processados de volta à página JSP para processamento adicional.
3. Descritor de biblioteca de tags (arquivo TLD): Este é um arquivo XML simples que registra os atributos, informações e localização do processador de tags. O contêiner JSP usa esse arquivo para saber onde e como chamar uma biblioteca de tags.
4. O arquivo web.xml do site: Este é o arquivo de inicialização do site. Neste arquivo, as tags customizadas utilizadas no site precisam ser definidas, bem como o arquivo tld utilizado para descrever cada tag customizada.
5. Arquivos de lançamento (arquivos WAR ou JAR): Se quiser reutilizar tags personalizadas, você precisa encontrar uma maneira de movê-las de um projeto para outro. Empacotar a biblioteca de tags em um arquivo JAR é uma maneira simples e eficaz.
6． Declaração da biblioteca de tags na página JSP: Se desejar usar uma tag personalizada na página JSP, você precisará usar o identificador da biblioteca de tags para declará-la na página.
Parece que há muito trabalho a ser feito e é claro que será um pouco complicado quando você começar a usá-lo, mas não é muito difícil. A questão não é codificar, mas organizar as peças corretamente. Essa estrutura hierárquica é importante porque torna o uso de tags flexível e fácil de transferir. Mais importante ainda, esses níveis permitem que todo o processo de criação de uma biblioteca de tags seja automatizado através do JSP IDE (ambiente de desenvolvimento integrado JSP). O IDE JSP pode concluir automaticamente a maior parte do trabalho de criação de tags personalizadas, e você só precisa ser responsável pela configuração do código e dos processadores de tags.
(Nota: Um processador de tags define apenas uma tag personalizada; uma biblioteca de tags é uma coleção de vários processadores de tags que lidam com a mesma tarefa)
Crie sua primeira tag
A seguir, você aprenderá passo a passo como criar uma tag personalizada, um exemplo específico está estendendo o JSP para que ele tenha sua própria função de codificação HTML. Este recurso substitui todos os caracteres < e > por código HTML. Ele pode ser facilmente estendido para realizar outro processamento de codificação. Para simplificar, este exemplo explica apenas os elementos básicos da criação de uma tag personalizada.
Qualquer parte reutilizável do código
que cria um JavaBean
deve ser colocada em um JavaBean.Isto é muito importante. Dessa forma você pode reutilizar o código em outros projetos. Como qualquer código colocado dentro de um manipulador de tags não é reutilizável fora da tag, é importante isolar as partes reutilizáveis do código. Neste exemplo, a lógica codificada para HTML é comum e portanto colocada em um JavaBean, veja Listagem B
Listagem B: JavaBeans codificados em HTML
/* HTML_Format.java */
classe pública HTML_Format estende Object implements java.io.Serializable {
/** Cria um novo HTML_Format */
public HTML_Format() {}
/** Substitua todos os caracteres < e > em uma string pela codificação HTML de resposta */
String pública HTML_Encode (String as_data)
{
int li_len = as_data.length();
/*O comprimento do buffer de string é maior que a string original*/
StringBuffer lsb_encode = new StringBuffer(li_len + (li_len/10));
/* Loop para substituir todos os caracteres < e >*/
for(int li_count = 0; li_count < li_len; li_count++)
{String ls_next = String.valueOf(as_data.charAt(li_count));
if (ls_next.equals("<")) ls_next = "<";
if (ls_next.equals(">")) ls_next = ">";
lsb_encode.append(ls_next);
}
return(lsb_encode.toString());
}
}
O código para criar um processador de tags é mostrado na Listagem C:
Listagem C: Processador de tags de codificação HTML
importar java.io.IOException;
importar javax.servlet.jsp.*;
importar javax.servlet.jsp.tagext.*;
classe pública HTML_FormatTag estende BodyTagSupport
{
/* 1) Esta função será chamada no final da tag*/
public int doEndTag() lança JspTagException
{
tentar
{ /* 2) Obtenha o texto no rótulo */
BodyContent l_tagbody = getBodyContent();
String ls_output = "";
/* 3) Se o corpo da tag tiver texto, processe-o */
if(l_tagbody! = nulo)
{ HTML_Format l_format = new HTML_Format();
/* 3a) Converte o conteúdo do corpo da tag em uma string */
String ls_html_text = l_tagbody.getString();
ls_output = l_format.HTML_Encode(ls_html_text);
}
/* 4) Grava os resultados de volta no fluxo de dados */
pageContext.getOut().write(ls_output.trim());
}
pegar (IOException e)
{ throw new JspTagException("Erro de tag:" + e.toString());
}
/* Deixe o JSP continuar processando o conteúdo das páginas seguintes*/
retornar EVAL_PAGE;
}
}
Este processamento é muito simples, inclui:
1. Leia o texto entre as tags de abertura e fechamento
2. Chamar função de codificação HTML
3. Retorne os resultados para a página JSP.
Crie um descritor de tag
Precisamos descrever a tag personalizada para que o sistema saiba o que fazer com ela. O sufixo deste arquivo de descrição é .tld. O arquivo TLD geralmente recebe o nome do processador de tags e é armazenado no diretório "/WEB-INF/". Veja Listagem D.
Listagem D: descritor de tag de codificação HTML ＜?xml version="1.0" encoding="UTF-8" ?＞
＜!DOCTYPE taglib
PÚBLICO "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.1//EN"
" http://java.sun.com/j2ee/dtds/web-jsptaglibrary_1_1.dtd "＞
＜TAGLIB＞
＜TLIBVERSION＞1.0＜/TLIBVERSION＞
＜JSPVERSION＞1.1＜/JSPVERSION＞
＜SHORTNAME＞HTML_FormatTag＜/SHORTNAME＞
＜URI＞＜/URI＞
＜INFO＞Tag de codificação HTML ＜/INFO＞
＜TAG＞
＜NOME＞HTMLEncode＜/NOME＞
＜TAGCLASS＞HTML_FormatTag＜/TAGCLASS＞
＜INFO＞Codificar HTML＜/INFO＞
＜/TAG＞
＜/TAGLIB＞
Atualize o arquivo Web XML
para informar ao contêiner JSP como usar a biblioteca de tags. Para fazer isso, você precisa modificar o arquivo web.xml Especificamente, você precisa adicionar um projeto taglib para registrar a biblioteca de tags e atribuir um URI à tag. O URI é o único índice no site que se aplica a esta tag específica. Como a tag poderá ser usada em diferentes sites no futuro, é melhor usar a URL completa e/ou o nome do pacote para garantir a exclusividade. Este exemplo é simplificado; consulte a Listagem E para ver o código de amostra.
Listagem E: Modifique o arquivo web.xml
PÚBLICO "-//Sun Microsystems, Inc.//DTD Web Application 2.2//EN"
" http://java.sun.com/j2ee/dtds/web-app_2.2.dtd "＞
＜WEB-APP＞
＜TAGLIB＞
＜TAGLIB-URI＞
Código HTML
＜/TAGLIB-URI＞
＜TAGLIB-LOCAÇÃO＞
/WEB-INF/HTML_FormatTag.tld
＜/TAGLIB-LOCATION＞
＜/TAGLIB＞
＜/WEB-APP＞
Use novas tags
Depois que as tags personalizadas forem definidas, você poderá usá-las em suas páginas JSP. Para fazer isso, basta usar o comando da diretiva taglib para declarar as tags que deseja usar na página. As tags são indexadas por seu URI exclusivo, ao qual é então atribuído um prefixo de namespace. Este prefixo não tem nenhum significado especial, desde que não entre em conflito com outros namespaces, pode ser arbitrário. Consulte as listagens F e G abaixo.
Listagem F: Usando a tag de codificação HTML<%@ taglib uri="HTMLEncode" prefix="Examples" %>
em uma página JSP
＜PRÉ＞
＜?XML:NAMESPACE PREFIX = Exemplos /＞＜Exemplos:HTMLEncode＞
＜Olá, amostra simples＞
＜/Exemplos:HTMLEncode＞
＜/PRE＞
Listagem G: Saída do código de amostra＜Olá, amostra simples＞
que é exibido como:
＜Olá, amostra simples＞
Com esta tag codifiquei todo o código da página. Todas as tags personalizadas são processadas no servidor. Isso significa que você não verá tags personalizadas na página de saída.
Como você pode ver, criar tags não é difícil. A parte mais problemática é aprender todos os detalhes dos processadores de tags. Este é um recurso poderoso e apenas arranhamos a superfície. Devido às muitas etapas envolvidas neste processo, novos programadores JSP podem achar confuso ao criar tags.
Conclusão
A biblioteca de tags é um dos recursos mais importantes do JSP e ainda está em constante desenvolvimento. Na verdade, é uma coisa nova, por isso ainda não foi amplamente adotada, mas a biblioteca de tags personalizadas desfez seu mistério e mais e mais desenvolvedores estão começando a prestar atenção e a usá-la. No final de 2001, pode-se esperar que as bibliotecas de tags serão um recurso muito comum em muitos projetos JSP.
Os benefícios das bibliotecas de tags são discutidos brevemente neste artigo. Na verdade, as bibliotecas de tags possuem muitos outros recursos poderosos. As bibliotecas de tags levam o desenvolvimento JSP a um mundo novo sem precedentes. Esta é realmente uma nova tecnologia interessante para desenvolvedores JSP porque eles obtêm uma ferramenta que pode converter JSPs em vários aplicativos e construir qualquer tipo de aplicativo web. A biblioteca de tags transforma o JSP no mais rico e dinâmico recurso de desenvolvimento e no poderoso ambiente de programação da Web. Suas capacidades são limitadas apenas pela nossa imaginação e criatividade.