Visão geral: A eXtensible Markup Language (XML) está sendo rapidamente usada na indústria. Tornou-se um padrão amplamente utilizado para descrever e trocar dados em um formato independente de plataforma, linguagem e protocolo. XML e suas especificações auxiliares podem ser usadas para descrever a representação de dados do documento, descrever as limitações dos tipos de documentos XML, descrever os links entre documentos e recursos XML e descrever a conversão e formatação automática de documentos XML.
Como desenvolver uma biblioteca de tags customizadas?
Tenho usado programação JSP e ASP há muito tempo. Entre os dois métodos de programação do lado do servidor, sinto cada vez mais que JSP é muito mais poderoso. Sem mencionar mais nada, a biblioteca de tags JSP é a razão pela qual escolhi JSP como a ferramenta preferida de desenvolvimento de aplicativos da web do lado do servidor. Por que? Porque: velocidade de manutenção e desenvolvimento. Em uma única página do servidor, você pode misturar e combinar vários métodos e objetos de script. Como "concreto", esse mix torna o script do lado do servidor poderoso e permite que os programadores do lado do servidor projetem páginas da Web muito flexíveis e dinâmicas. No entanto, esse mix gratuito também tem suas desvantagens, que são muito difíceis de manter. principalmente à medida que o projeto fica maior, já que o produto final é mantido por um web designer tradicional e, pior ainda, a velocidade de desenvolvimento aumenta à medida que a complexidade do código aumenta. aplicações web em larga escala Uma vez desenvolvidas, o site ainda precisará encontrar programadores qualificados para manter esses códigos bastante complexos.
Felizmente, JSP oferece uma boa solução. As bibliotecas de tags fornecem uma maneira fácil de criar um bloco de código reutilizável. 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, você não precisa aprender nenhuma outra habilidade para criar uma biblioteca de tags! Contanto que você saiba escrever JSP, poderá criar uma biblioteca de tags. As bibliotecas de tags também podem melhorar a manutenção de aplicações web. Esta é uma interface XML simples graças às tags personalizadas da página JSP. Dessa forma, os web designers podem até mesmo construir aplicativos da Web JSP sem nenhum conhecimento de JSP. Este desenvolvimento web aberto é muito eficaz para operações em equipe. Os programadores JSP podem criar tags personalizadas e módulos de código de fundo, enquanto os designers da Web podem usar tags personalizadas para construir aplicativos da Web e focar no design da Web.
1. Definição da biblioteca de tags A biblioteca de tags JSP (também chamada de biblioteca customizada) pode ser considerada como um conjunto de métodos para gerar scripts baseados em XML, que é suportado pelo JavaBeans. Conceitualmente, as bibliotecas de tags são construções de código muito simples e reutilizáveis.
Exemplos de tags e páginas HTML que realizam conversão XML/XSL
<%@ taglib uri=" http://www.jspinsider.com/jspkit/JAXP " prefix="JAXP"%>
c:/xml/exemplo.xml
c:/xml/example.xsl
Neste exemplo, usando tags simples para acessar o código mais poderoso nos bastidores, um XML é carregado e um resultado é gerado através de um arquivo XSL e enviado ao cliente, tudo via Isso é feito usando uma chamada de tag simples.
Tags personalizadas abrem a porta para a criação de código facilmente reutilizável em projetos JSP. Tudo que você precisa é de uma biblioteca de tags e sua documentação.
2. Componentes de tags Embora a biblioteca de tags seja muito fácil de usar, é bastante complicado criar um design interno para suportar a biblioteca de tags, pelo menos mais complicado do que criar um simples JavaBean. A complexidade vem do fato da biblioteca de tags ser composta por diversas partes. Porém, você só precisa conhecer Java e JSP.
Uma tag simples consiste nos seguintes elementos:
⑴ JavaBeans: Para obter os benefícios inerentes à orientação a objetos do Java, o código reutilizável deve ser colocado em um contêiner de código independente. Esses JavaBeans não fazem parte da biblioteca de tags. Mas é o bloco básico de código que sua base de código usa para executar tarefas relacionadas.
⑵ Processamento de tags: Este é o verdadeiro núcleo da biblioteca de tags. Um manipulador de tags fará referência a quaisquer recursos necessários (seus JavaBeans) e acessará todas as informações sobre sua página JSP (o objeto pageContext). A página JSP também transmitirá todos os atributos da tag que foram definidos e o conteúdo do corpo da tag na página JSP para o processador de tags. Depois que o processador de tags terminar o processamento, ele enviará a saída de volta à sua página JSP para processamento.
⑶ Descrição da 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.
⑷ Arquivo web.xml do site: Este é o arquivo de inicialização do seu site. Neste arquivo, você define as tags personalizadas usadas no site e qual arquivo tld é usado para descrever cada tag personalizada.
⑸ Arquivo de distribuição (um arquivo WAR ou JAR): Se quiser reutilizar tags personalizadas, você precisa de uma forma de transferi-las de um projeto para outro. Empacotar a biblioteca de tags em um arquivo JAR é uma maneira simples e eficaz.
⑹ Faça uma declaração da biblioteca de tags em seu arquivo JSP: Se você quiser usar esta tag, basta declará-la na página.
Parece muito trabalho a fazer, mas na verdade não é tão difícil. A questão não é codificar, mas organizar as peças corretamente. No entanto, esta estratificação é importante porque torna o uso da etiqueta flexível e mais fácil de transferir. Mais importante ainda, essas camadas existem para automatizar o processo de criação de tags por meio de um JSP IDE (JSP Integrated Development Environment). Espera-se que futuros IDEs JSP possam concluir automaticamente a maior parte do trabalho de criação de uma tag personalizada, de modo que você só precise escrever o código e o processamento da tag.
Nota: Um manipulador de tags define apenas uma tag personalizada; uma biblioteca de tags é uma coleção de vários processadores de tags que tratam da mesma tarefa.
3. Crie suas próprias tags. A seguir, você aprenderá passo a passo como criar tags personalizadas. O exemplo específico é estender 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.
⑴ Crie um JavaBean
Qualquer parte reutilizável do seu código deve ser colocada em um JavaBean. Isso é importante porque você usará frequentemente esse código em outras partes do projeto. Qualquer código colocado dentro de um manipulador de tags não é reutilizável fora da tag, por isso é importante isolar as partes reutilizáveis do código. Neste exemplo, a lógica codificada para HTML é comum e portanto colocada em um JavaBean.
⑵ Codificação HTML JavaBean
/* HTML_Format.Java */
classe pública HTML_Format estende objeto implementa Java.io.Serializable {
/** Cria novo HTML_Format */
HTML_Format público() {}
/** 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());
}
}
⑶ Crie um processador de tags O processador de tags usa o seguinte código:
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}Escrever 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:
o Leia o texto entre o início e o fim da tag o Chame a função de codificação html o Retorne o resultado para a página JSP.
⑷ A criação de um descritor de tag precisa descrever a tag personalizada para que o sistema saiba como processá-la. O sufixo deste arquivo de descrição é .tld, geralmente seu nome é o mesmo do processador da tag e é armazenado no diretório "/WEB-INF/".
Descritor de tag de codificação HTML
PÚBLICO "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.1//EN"
" http://Java.sun.com/j2ee/dtds/web-jsptaglibrary_1_1.dtd ">
⑸ Atualize o arquivo XML da Web para informar ao contêiner JSP para 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. Mais importante ainda, atribua um URI à tag. Um URI é uma referência exclusiva que se aplica apenas a esta tag específica no site. É uma boa prática usar o URL completo ou o nome do pacote para garantir a exclusividade, pois a tag pode ser usada em diferentes sites. Este exemplo é simplificado.
Modificar 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 ">
Código HTML
/WEB-INF/HTML_FormatTag.tld
⑹ A tag personalizada usando novas tags foi configurada e pode ser usada em uma página JSP. Para fazer isso, basta declarar a tag na página usando a diretiva taglib. A tag é referenciada por seu URI exclusivo e recebe um prefixo de namespace. O prefixo pode ser arbitrário, desde que não entre em conflito com outros namespaces.
Use tags de codificação HTML em uma página JSP:
<%@ taglib uri="HTMLEncode" prefix="Examples" %>
Exemplo de saída de código
que é exibido como:
Com esta tag codifiquei todo o código da página. O interessante é que todas as tags personalizadas são tratadas no servidor. Isso significa que você não verá tags personalizadas na página de saída.
Não é difícil criar um rótulo. A parte mais difícil é aprender todos os detalhes do processamento de etiquetas. Este é um recurso muito poderoso e tocamos apenas no básico. Como esse processo requer várias etapas, os novos programadores JSP ficarão confusos ao criar tags.
Como usar JSP para desenvolver aplicativos DOM?
DOM é a abreviatura de Document Object Model, que é o modelo de objeto de documento. XML organiza os dados em uma árvore, então DOM é uma descrição de objeto dessa árvore. Em termos leigos, trata-se de construir logicamente um modelo de árvore para o documento XML analisando o documento XML, e os nós da árvore são objetos. Podemos acessar o conteúdo de documentos XML acessando esses objetos.
Vejamos um exemplo simples abaixo para ver como operamos um documento XML no DOM. Este é um documento XML e o objeto no qual queremos operar:
A seguir, precisamos analisar o conteúdo deste documento em objetos Java para uso pelo programa. Usando JAXP, podemos fazer isso com apenas algumas linhas de código. Primeiro, precisamos criar uma fábrica de analisadores para usar esta fábrica para obter um objeto analisador específico:
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
O objetivo de usar DocumentBuilderFacotry aqui é criar um programa que seja independente do analisador específico. Quando o método estático newInstance() da classe DocumentBuilderFactory é chamado, ele determina qual analisador usar com base em uma variável do sistema. E como todos os analisadores obedecem à interface definida pelo JAXP, o código é o mesmo, independentemente do analisador utilizado. Portanto, ao alternar entre diferentes analisadores, você só precisa alterar os valores das variáveis do sistema sem alterar nenhum código. Este é o benefício da fábrica.
DocumentBuilder db = dbf.newDocumentBuilder();
Depois de obter um objeto de fábrica, use seu método estático newDocumentBuilder() para obter um objeto DocumentBuilder, que representa um analisador DOM específico. Mas qual analisador é, da Microsoft ou da IBM, não é importante para o programa.
Então, podemos usar este analisador para analisar o documento XML:
Documento doc = db.parse("c:/xml/message.xml");
O método parse() de DocumentBuilder aceita um nome de documento XML como parâmetro de entrada e retorna um objeto Document. Este objeto Document representa um modelo de árvore de um documento XML. Todas as operações futuras em documentos XML não têm nada a ver com o analisador e podem ser operadas diretamente neste objeto Document. O método específico de operação do Documento é definido pelo DOM.
A partir do objeto Document obtido, podemos iniciar nossa jornada no DOM. Usando o método getElementsByTagName() do objeto Document, podemos obter um objeto NodeList. Um objeto Node representa um elemento de tag em um documento XML, e o objeto NodeList, como você pode ver pelo seu nome, representa um objeto Node List:
NodeList nl = doc.getElementsByTagName("mensagem");
O que obtemos com tal declaração é uma lista de objetos Node correspondentes a todas as tags
Nó meu_nó = nl.item(0);
Quando um objeto Node é criado, os dados armazenados no documento XML são extraídos e encapsulados no arquivo Node. Neste exemplo, para extrair o conteúdo da tag Message, normalmente usamos o método getNodeValue() do objeto Node:
String mensagem = my_node.getFirstChild().getNodeValue();
Observe que um método getFirstChild() também é usado aqui para obter o primeiro objeto Node filho da mensagem. Embora não haja outras subtags ou atributos na tag de mensagem, exceto texto, insistimos em usar o método getFirseChild() aqui, que está relacionado principalmente à definição de DOM do W3C. O W3C também define a parte do texto dentro da tag como um Nó, portanto, devemos primeiro obter o Nó que representa o texto antes de podermos usar getNodeValue() para obter o conteúdo do texto. Agora, como conseguimos extrair os dados do arquivo XML, podemos utilizar esses dados no local apropriado para construir a aplicação.
Exemplo de DOM
Vamos primeiro falar sobre o que este exemplo fará. Salvamos alguns endereços URL em um arquivo chamado link. O endereço URL adicionado está escrito neste arquivo XML. É muito simples, mas muito prático, e é suficiente para ilustrar a maior parte do uso do DOM.
O primeiro programa é chamado xmldisplay.Java. Sua função principal é ler o conteúdo de cada nó neste arquivo XML e, em seguida, formatar a saída em System.out. Vamos dar uma olhada neste programa:
import Javax.xml.parsers. *;
import org.w3c.dom.*;
Isto é para introduzir as classes necessárias, porque o analisador XML fornecido pela Sun é usado aqui, então o pacote Java.xml.parsers precisa ser introduzido, que contém o analisador DOM e a análise SAX. A implementação específica do dispositivo. O pacote org.w3c.dom define a interface DOM desenvolvida pelo w3c.
Fábrica de DocumentBuilderFactory = DocumentBuilderFactory.newInstance();
Construtor DocumentBuilder=factory.newDocumentBuilder();
Documento doc=builder.parse("links.xml");
doc.normalize();
Além do acima, há também um pequeno truque. Chamar normalize() no objeto Document pode remover objetos desnecessários do Text Node mapeados na árvore DOM como espaços em branco no documento XML como conteúdo formatado. Caso contrário, a árvore DOM obtida pode não ser o que você imaginou. Especialmente durante a saída, normalize() é mais útil.
NodeList links =doc.getElementsByTagName("link");
Conforme mencionado agora, caracteres de espaço em branco em documentos XML também serão mapeados como objetos na árvore DOM. Portanto, chamar diretamente o método getChildNodes do método Node às vezes apresenta alguns problemas e às vezes não pode retornar o objeto NodeList esperado. A solução é usar getElementByTagName(String) do Element, e o NodeLise retornado é o objeto esperado. Então, você pode usar o método item() para extrair o elemento desejado.
for (int i=0;i
System.out.print("Conteúdo: ");
System.out.println(link.getElementsByTagName("texto").item(0).getFirstChild();
.getNodeValue());
...
O trecho de código acima completa a saída formatada do conteúdo do documento XML. Contanto que você preste atenção a alguns detalhes, como o uso do método getFirstChile() e do método getElementsByTagName(), eles são relativamente fáceis.
O conteúdo a seguir é sobre como reescrever a árvore DOM no documento XML após modificá-la. Este programa é denominado xmlwrite.Java. Na versão JAXP 1.0, não existem classes e métodos diretos que possam lidar com a escrita de documentos XML, sendo necessário utilizar algumas classes auxiliares em outros pacotes. Na versão JAXP 1.1, foi introduzido suporte para XSLT. O chamado XSLT é obter uma nova estrutura de documento após a transformação do documento XML (Tradução). Usando esta função recém-adicionada, podemos facilmente escrever a árvore DOM recém-gerada ou modificada de volta no arquivo XML. Vamos dar uma olhada na implementação do código. A principal função deste código é vincular Adicionar um novo nó de link ao. Arquivo .xml:
importar Javax.xml.parsers.*;
importar Javax.xml.transform.*;
importar Javax.xml.transform.dom.DOMSource;
importar Javax.xml.transform.stream.StreamResult;
import org.w3c.dom.*;
Várias classes no pacote Java.xml.transform recém-introduzido são usadas para manipular transformações XSLT.
Esperamos adicionar um novo nó de link ao arquivo XML acima, portanto, devemos primeiro ler o arquivo links.xml, construir uma árvore DOM, depois modificar a árvore DOM (adicionar nós) e, finalmente, adicionar o DOM modificado Write de volta ao arquivo links.xml:
DocumentBuilderFactory fábrica = DocumentBuilderFactory.newInstance();
Construtor DocumentBuilder=factory.newDocumentBuilder();
Documento doc=builder.parse("links.xml");
doc.normalize();
//---Obter variáveis----
String text="Página inicial de Hanzhong";
String url=" www.hzliu.com ";
String autor = "Hzliu Liu";
String description="Um site de Hanzhong Liu, dê muitas surpresas!!!";
Para ver os pontos-chave claramente e simplificar o procedimento, codificamos o conteúdo a ser adicionado ao objeto String de memória. operação, geralmente usamos uma interface para extrair a entrada do usuário ou extrair o conteúdo desejado do banco de dados via JDBC.
Texto de texto, por exemplo;
Element link=doc.createElement("link");
Em primeiro lugar, deve ficar claro que não importa o tipo de Node, seja do tipo Text, Attr ou Element, todos eles são criados através do objeto Document CreateXXX( ) em (XXX representa o tipo específico a ser criado), portanto, precisamos adicionar um item de link ao documento XML, primeiro crie um objeto de link:
Element linktext=doc.createElement("text") ;
textseg=doc.createTextNode(texto);
linktext.appendChild(textseg);
link.appendChild(linktext);
...
O processo de criação de nós pode ser um pouco uniforme, mas o que precisa ser observado é que o texto contido em Element (no DOM, esses textos também representam um Node, portanto, nós correspondentes também devem ser criados para eles). Use diretamente o método setNodeValue() do objeto Element para definir o conteúdo desses textos, e você precisa usar o método setNodeValue() do objeto Text criado para definir o texto, para que o Elemento criado e seu conteúdo de texto possam ser adicionado à árvore DOM. Dê uma olhada no código anterior e você entenderá melhor:
doc.getDocumentElement().appendChild(link);
Finalmente, não esqueça de adicionar o nó criado à árvore DOM. O método getDocumentElement() da classe Document retorna o objeto Element que representa o nó raiz do documento. Em um documento XML, o nó raiz deve ser exclusivo.
TransformerFactory tFactory =TransformerFactory.newInstance();
Transformador transformador = tFactory.newTransformer();
Fonte DOMSource = new DOMSource(doc);
Resultado StreamResult = new StreamResult(new Java.io.File("links.xml"));
transformer.transform(source, result);
Em seguida, use XSLT para gerar a árvore DOM. O TransformerFactory aqui também aplica o padrão de fábrica, tornando o código específico independente do transformador específico. O método de implementação é o mesmo do DocumentBuilderFactory, então não entrarei em detalhes aqui. O método transfrom da classe Transformer aceita dois parâmetros, uma fonte de dados Fonte e um resultado de destino de saída. DOMSource e StreamResult são usados aqui respectivamente, para que o conteúdo do DOM possa ser enviado para um fluxo de saída. Quando o fluxo de saída é um arquivo, o conteúdo do DOM é gravado no arquivo.
Como usar JSP para desenvolver aplicações SAX?
SAX é a abreviatura de Simple API for XML. Não é um padrão oficial proposto pelo W3C. Pode ser considerado um padrão "popular" de fato. Na verdade, é o produto de uma discussão comunitária. Mesmo assim, SAX não é menos usado em XML que DOM, e quase todos os analisadores XML o suportam.
Comparado ao DOM, o SAX é um método leve. Sabemos que ao processar o DOM, precisamos ler todo o documento XML, depois criar uma árvore DOM na memória e gerar cada objeto Node na árvore DOM. Quando o documento é pequeno, isso não causa problemas, mas à medida que o documento fica maior, o processamento do DOM torna-se bastante demorado e trabalhoso. Em particular, os seus requisitos de memória também aumentarão exponencialmente, de modo que o uso do DOM em algumas aplicações não é rentável (como em miniaplicativos). Neste momento, uma solução alternativa melhor é o SAX.
SAX é conceitualmente completamente diferente do DOM. Em primeiro lugar, ao contrário do driver de documento DOM, ele é orientado a eventos, ou seja, não precisa ler o documento inteiro, e o processo de leitura do documento também é o processo de análise SAX. O chamado método orientado a eventos refere-se a um método de execução de programa baseado no mecanismo de retorno de chamada. (Se você tiver clareza sobre o novo modelo de evento proxy do Java, entenderá facilmente esse mecanismo.) O XMLReader aceita o documento XML e o analisa durante o processo de leitura do documento XML, ou seja, o processo de leitura do documento. O processo de análise é realizado ao mesmo tempo, o que é muito diferente do DOM. Antes de iniciar a análise, você precisa registrar um ContentHandler com XMLReader, que é equivalente a um ouvinte de evento. Muitos métodos são definidos em ContentHandler, como startDocument(), que customiza o que deve ser tratado quando o documento começa a ser encontrado durante a análise. processo. Quando o XMLReader lê o conteúdo apropriado, ele lança o evento correspondente, delega o poder de processamento desse evento ao ContentHandler e chama seu método correspondente para responder.
Pode ser um pouco difícil de entender de uma forma geral, mas não se preocupe, os exemplos a seguir irão ajudá-lo a entender o processo de análise SAX. Dê uma olhada neste arquivo XML simples:
Quando o XMLReader lê a tag
Retorno de chamada do método de projeto encontrado
{início do documento} startDocument()
"n" caracteres("
Caracteres "Ogden Nash"("
endElement(null,"AUTHOR",null)
"n" caracteres("
Caracteres "pulgas"("
endElement(null,"TÍTULO",null)
"n" caracteres("
Caracteres "Adão"("
"n" caracteres("
{Fim do documento} endDocument()
ContentHandler é na verdade uma interface. Ao processar um arquivo XML específico, você precisa criar uma classe que implemente ContentHandler para lidar com eventos específicos. o documento. Vamos dar uma olhada em alguns dos métodos definidos nele:
caracteres void (char[] ch, int start, int length): Este método é usado para processar a string lida no arquivo XML. Seu parâmetro é uma matriz de caracteres e o ponto inicial da string lida nesta matriz. length, podemos facilmente usar um construtor da classe String para obter a classe String desta string: String charEncontered=new String(ch,start,length).
void startDocument(): Ao encontrar o início do documento, chame este método para fazer algum trabalho de pré-processamento.
void endDocument(): Correspondente ao método acima, quando o documento termina, este método é chamado para fazer algum trabalho posterior.
void startElement(String namespaceURI, String localName, String qName, Attributes atts): Este método será acionado quando uma tag inicial for lida. Namespaces não são suportados na versão SAX1.0, mas o suporte para namespaces é fornecido na nova versão 2.0 O namespaceURI no parâmetro aqui é o namespace, localName é o nome do rótulo e qName é o prefixo modificado do rótulo If. não há Ao usar namespaces, nenhum dos parâmetros é nulo. E atts é a lista de atributos contidos nesta tag. Através do atts, você pode obter todos os nomes de atributos e valores correspondentes. Deve-se notar que uma característica importante do SAX é o seu processamento de streaming. Ao encontrar uma tag, ele não registrará as tags encontradas anteriormente. Em outras palavras, no método startElement(), todas as informações que você conhece são o nome e os atributos. da tag. Quanto à estrutura aninhada da tag, o nome da tag superior, se existem atributos de subelementos e outras informações relacionadas à estrutura, elas são desconhecidas e precisam de sua ajuda para serem concluídas. Isso torna o SAX menos conveniente para programação do que o DOM.
void endElement (String namespaceURI, String localName, String qName): Este método corresponde ao método acima. Este método é chamado quando uma tag final é encontrada.
Ainda usamos o exemplo de documento que usamos quando falamos sobre DOM, mas primeiro, vamos dar uma olhada em uma aplicação mais simples. Esperamos contar o número de vezes que cada tag aparece em um arquivo XML. Este exemplo é muito simples, mas é suficiente para ilustrar as ideias básicas da programação SAX. É claro que a instrução import ainda é usada no início:
import org.xml.sax.helpers.DefaultHandler;
importar Javax.xml.parsers.*;
importar org.xml.sax.*;
importar org.xml.sax.helpers.*;
importar Java.util.*;
import Java.io.*
Em seguida, criamos uma classe que herda de DefaultHandler A lógica específica do programa pode ser deixada de lado por enquanto. O que devemos prestar atenção é a estrutura do programa:
public class SAXCounter extends DefaultHandler {.
private Hashtable tags; //Esta Hashtable é usada para registrar o número de vezes que a tag aparece
//Trabalho antes de processar o documento
public void startDocument() lança SAXException {
tags = new Hashtable();//Inicializa Hashtable
}
//Processa cada atributo do elemento inicial
public void startElement(String namespaceURI, String localName,
String rawName, Atributos atts)
lança SAXException
{
String chave = localNome;
...
Vamos ver o que este programa faz. No método main(), a principal coisa a fazer é criar um analisador e então analisar o documento. Na verdade, ao criar o objeto SAXParser aqui, para tornar o código do programa independente do analisador específico, é usada a mesma técnica de design do DOM: crie um objeto SAXParser específico por meio de uma classe SAXParserFactory, para que quando diferente Ao analisar , tudo o que precisa ser alterado é o valor de uma variável de ambiente, enquanto o código do programa pode permanecer inalterado. Essa é a ideia do padrão FactoryMethod. Não entrarei em detalhes aqui. Se você ainda não entendeu, pode consultar a explicação no DOM acima.
Mas há uma coisa a ser observada aqui: o relacionamento entre a classe SAXParser e a classe XMLReader. Você pode estar um pouco confuso. Na verdade, SAXParser é uma classe wrapper para XMLReader em JAXP e XMLReader é uma interface definida em SAX2.0 para análise de documentos. Você também pode chamar o método parser() em SAXParser ou XMLReader para analisar o documento, e o efeito é exatamente o mesmo. No entanto, o método parser() em SAXParser aceita mais parâmetros e pode analisar diferentes fontes de dados de documentos XML, por isso é mais conveniente de usar do que XMLReader.
Este exemplo apenas toca a superfície do SAX, mas o seguinte é mais avançado. A função que queremos implementar abaixo já foi implementada no exemplo do DOM, que é ler o conteúdo do documento XML e formatar a saída. Embora a lógica do programa ainda pareça muito simples, o SAX não é melhor que o DOM.
Conforme mencionado anteriormente, ao encontrar uma tag inicial, no método startElement(), não podemos obter a posição da tag no documento XML. Este é um grande problema ao processar documentos XML, porque a semântica das tags em XML é parcialmente determinada pela sua localização. E em alguns programas que precisam verificar a estrutura do documento, isso é ainda mais problemático. Claro, não há problema que não possa ser resolvido. Podemos usar uma pilha para registrar a estrutura do documento.
A característica da pilha é primeiro a entrar, primeiro a sair. Nossa ideia atual é usar push para adicionar o nome do rótulo à pilha no método startElemnt() e retirá-lo no método endElement(). Sabemos que para um XML bem estruturado, sua estrutura de aninhamento é completa. Cada tag inicial sempre corresponde a uma tag final, e não haverá desalinhamento entre os aninhamentos de tags. Portanto, cada chamada ao método startElement() corresponderá inevitavelmente a uma chamada ao método endElement(), portanto push e pop também aparecem em pares. Só precisamos analisar a estrutura da pilha para saber facilmente onde está o rótulo atual. Posição na estrutura do documento.
classe pública Saxreader estende Defaulthandler {
Java.util.stack tags = new java.util.stack ();
...
Embora a análise da pilha não seja usada aqui, a análise da pilha é realmente uma tarefa muito fácil está organizado de baixo para cima. atributos de cada elemento. De fato, se organizarmos os elementos da pilha, um por um de baixo para o topo, obteremos um caminho exclusivo do nó da raiz XML para o nó atual. .
Até agora, dominamos as duas principais ferramentas para programação XML: DOM e Sax e também sabemos como usá -las em um programa Java. A programação DOM é relativamente simples, mas lenta e ocupa muita memória, enquanto a programação do S AX é mais complexa, mas rápida e ocupa menos memória. Portanto, devemos optar por usar métodos diferentes de acordo com diferentes ambientes. A maioria dos aplicativos XML pode basicamente ser resolvida usando -os. Deve-se notar que o DOM e o Sax são realmente independentes da linguagem e não são exclusivos do Java.