Exemplos de site estruturado JSP + XML

Autor：Eve Cole Data da Última Atualização：2009-07-02 17:11:58

XML (Extensible Markup Language) pode parecer algum tipo de padrão W3C - tem pouco impacto prático agora e, se for útil mais tarde, demorará muito para chegar. Mas, na verdade, já está sendo usado. Portanto, não espere até que o XML seja adicionado ao seu editor HTML favorito para começar a usá-lo. Ele pode resolver vários problemas internos e problemas de sistema B2B agora.

Na Sparks.com, usamos XML para padronizar a representação de dados em sistemas distintos, desde objetos Java até exibições de dados HTML.

Em particular, descobrimos que os dados podem ser compartilhados e manipulados mais facilmente quando são padronizados em uma estrutura XML muito básica. Ao longo do caminho, descobrimos muitas maneiras eficazes de usar XML. A seguir descrevemos nossa aplicação atual em detalhes.

Padronizar Antes de usar XML, crie um formato de dados XML diferente das informações que você deseja usar.

Gere XML dinâmico
Gerar HTML a partir de um banco de dados não é novidade, mas gerar XML é. Aqui apresentamos as etapas específicas de geração.

Usando XSL como linguagem de modelo
XSL (Extensible Stylesheet Language) é uma boa maneira de definir o formato para exibição de dados XML e seria mais eficiente se fosse escrito como vários modelos estáticos.

Gerar HTML
XML mais XSL é igual a HTML. Isso pode não parecer certo, mas nossas páginas HTML que os usuários veem são, na verdade, o resultado da combinação de XML e XSL.

1. Padronização

O poder do XML vem de sua flexibilidade. Mas, infelizmente, às vezes é tão flexível que você fica com uma página em branco se perguntando como resolver o problema.

Em qualquer projeto XML, o primeiro passo é criar um formato de dados padrão. Para fazer isso, você precisa tomar as seguintes decisões:

&&&
Confirme os dados:
Como não existe um formato XML padrão, os desenvolvedores são livres para desenvolver seus próprios formatos. No entanto, se o seu formato for reconhecido apenas por um aplicativo, você só poderá executar esse aplicativo para usar o formato. Obviamente seria mais útil se existissem outros programas que também pudessem ler o seu formato XML. Se um formato XML for modificado, o sistema que o utiliza também poderá precisar ser modificado, portanto, você deve criar o formato o mais completo possível. Como a maioria dos sistemas ignora tags que não reconhece, a maneira mais segura de alterar o formato de um XML é adicionar tags, em vez de modificá-las.

Clique aqui para ver exemplos de formatos de dados XML

Em Sparks.com, analisamos todos os dados de produtos necessários para diferentes apresentações de produtos. Embora nem todas as páginas utilizem todos os dados, desenvolvemos um formato de dados XML muito completo e adequado para todos os dados. Por exemplo, nossa página de detalhes do produto exibe mais dados do que nossa página de navegação do produto. No entanto, ainda usamos o mesmo formato de dados em ambos os casos porque o modelo XSL de cada página usa apenas os campos necessários.

Se deve usar DTD
No Sparks.com usamos XML bem organizado em vez de apenas XML correto, pois o primeiro não requer DTD. O DTD adiciona uma camada de processamento entre o clique do usuário e a visualização da página. Descobrimos que essa camada exigia muito processamento. Claro, ainda é bom usar DTDs ao se comunicar com outras empresas no formato XML. Porque o DTD pode garantir que a estrutura de dados esteja correta ao enviar e receber.

Escolhendo um mecanismo de análise Agora, existem vários mecanismos de análise que podem ser usados. Qual você escolher depende quase inteiramente das necessidades da sua aplicação. Se você decidir usar um DTD, o mecanismo de análise deverá permitir que seu XML seja validado pelo DTD. Você poderia colocar a validação em um processo separado, mas isso afetaria o desempenho.

SAX e DOM são dois modelos básicos de análise. SAX é baseado em eventos, portanto, quando o XML é analisado, os eventos são enviados ao mecanismo. A seguir, os eventos são sincronizados com o arquivo de saída. O mecanismo de análise DOM cria uma estrutura de árvore hierárquica para dados XML dinâmicos e folhas de estilo XSL. Ao acessar aleatoriamente a árvore DOM, os dados XML podem ser fornecidos como se fossem determinados por uma folha de estilo XSL. O debate sobre o modelo SAX concentra-se principalmente na redução excessiva de memória da estrutura DOM e na aceleração do tempo de análise da folha de estilo XSL.

No entanto, descobrimos que muitos sistemas que usam SAX não o utilizam em todas as suas capacidades. Esses sistemas o utilizam para construir a estrutura DOM e enviar eventos por meio da estrutura DOM. Com esta abordagem, o DOM deve ser construído a partir da folha de estilo antes de qualquer processamento XML, portanto o desempenho será prejudicado.

2. Gere XML dinâmico

Uma vez estabelecido o formato XML, precisamos de uma maneira de portá-lo dinamicamente do banco de dados.

A geração de documentos XML é relativamente simples porque requer apenas um sistema que possa lidar com strings. Construímos um sistema utilizando Java Servlets, servidor Enterprise JavaBean, JDBC e RDBMS (sistema de gerenciamento de banco de dados relacional).

&&&&
(Para obter informações adicionais sobre a aplicação de XSL, consulte XSL como linguagem de modelo.)

Exemplo de geração de XML O código real para criação de uma docstring XML em Java pode ser dividido em vários métodos e classes.

O código que inicia o processo de geração do XML é colocado no método EJB. Esta instância cria imediatamente um StringBuffer para armazenar a string XML gerada.

StringBuffer xml = new StringBuffer();
xml.append(XmlUtils.beginDocument("/browse_find/browse.xsl", "navegar", solicitação));
xml.append(produto.toXml());
xml.append(XmlUtils.endDocument("navegar");
out.print(xml.toString());

As três variáveis xml.append() a seguir são chamadas para outros métodos.
Gerando o cabeçalho do arquivo O primeiro método adicional chama a classe XmlUtils para gerar o cabeçalho do arquivo XML. O código em nosso Java Servlet é o seguinte:

string estática pública startDocument (folha de estilo de string, página de string)
{
StringBuffer xml = new StringBuffer();
xml.append("<?xml version="1.0"?> ")
.append("<?xml-stylesheet href="")
.append(folha de estilo).append(""")
.append("type="text/xsl"?> ");
xml.append("<").append(página).append("> ");
retornar xml.toString();
}

Este código gera o cabeçalho do arquivo XML. A tag <?xml> define este arquivo como um arquivo XML que suporta a versão 1.0. A segunda linha de código aponta para o local da folha de estilo correta para exibir os dados. A última coisa incluída é a tag de nível de item (<browse> neste exemplo). No final do arquivo, apenas a tag <browse> precisa ser fechada.

<?xml version="1.0"?> <?xml-stylesheet href="/browse_find/browse.xsl" type="text/xsl"?> <browse>

Após preencher as informações do produto e preencher o cabeçalho do arquivo, o método de controle chamará o objeto Java para gerar seu XML. Neste exemplo, o objeto produto é chamado. O objeto produto utiliza dois métodos para gerar sua representação XML. O primeiro método toXML() cria o nó do produto gerando tags <product> e </product>. Em seguida, ele chama internalXML(), que fornece o conteúdo necessário para o XML do produto. internalXML() é uma série de chamadas StringBuffer.append(). O StringBuffer também é convertido em uma string e retornado ao método de controle.
String pública paraXml()
{
StringBuffer xml = new StringBuffer("<produto> ");
xml.append(internalXml());
xml.append("</produto> ");
retornar xml.toString();
}

String pública internalXml()
{
StringBuffer xml = novo
StringBuffer(" ")
.append(productType).append(" ");
xml.append(" ").append(idValue.trim())
.append(" ");
xml.append(" ").append(idNome.trim())
.append(" ");
xml.append(" ").append(page.trim())
.append(" ");
Dor?
xml.append(" ").append(quantidade).append(" ");
xml.append(" ").append(vendor).append(" ");
xml.append(" ");
xml.append(" ").append(pubDesc).append(" ");
xml.append(" ").append(venDesc).append(" ";
Dor?
retornar xml.toString();
}

Finalmente, o método XMLUtils.endDocument() é chamado após fechar o arquivo. Esta chamada fecha a tag XML (neste caso) e finalmente completa o arquivo XML estruturado. Todo o StringBuffer do método de controle também é convertido em uma string e retornado ao servlet que tratou a solicitação HTTP original.

3. Use XSL como linguagem de modelo

Para obter a saída HTML, combinamos o arquivo XML gerado com um modelo XSL que controla como os dados XML são representados. Nossos modelos XSL consistem em tags XSL e HTML cuidadosamente organizadas.

Comece a construir o modelo O início do nosso modelo XSL é semelhante ao código a seguir. A primeira linha de código é necessária e define este arquivo como uma folha de estilo XSL. O atributo xmlns:xsl= refere-se ao namespace XML usado por este arquivo e o atributo version= define o número da versão do namespace. No final do arquivo fechamos a tag.

A segunda linha de código começando com <xsl:template> determina o padrão do modelo XSL. O atributo Match é obrigatório e aqui aponta para a tag XML <basketPage>. Em nosso sistema, a tag <basketPage> contém a tag <product>, que permite que o modelo XSL acesse informações do produto incorporadas na tag <product>. Mais uma vez temos que fechar a tag <xsl:template> no final do arquivo.

A seguir, vamos dar uma olhada no HTML bem organizado. Como será processado por um mecanismo de análise de XML, deverá obedecer a todas as regras de um XML bem organizado. Essencialmente, isso significa que todas as tags de abertura devem ter uma tag de fechamento correspondente. Por exemplo, uma tag que normalmente não é fechada deve ser fechada com .

<xsl:folha de estilo xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
versão="1.0">
<xsl:template match="basketPage">
<html>
<cabeça>
<title>Sacola de compras / Ajustar quantidade</title>
</head>
<body bgcolor="

</xsl:template>
</xsl:folha de estilo>

Dentro do corpo do modelo, há muitas tags XSL usadas para fornecer lógica para apresentação de dados. Duas tags comumente usadas são explicadas abaixo.
Escolher
A tag <xsl:choose> é semelhante ao início de uma estrutura if-then-else nas linguagens de programação tradicionais. Em XSL, a tag Choose indica que na parte onde o código entra, a atribuição irá desencadear a ação. A tag <xsl:when> com atributos atribuídos segue a tag Choose. Se a atribuição estiver correta, será utilizado o conteúdo entre as tags de abertura e fechamento de <xsl:when>. Se a atribuição estiver errada, o conteúdo entre as tags de abertura e fechamento de <xsl:otherwise> será usado. A seção inteira termina com </xsl:choose>.

Neste exemplo, a tag quando verifica o XML para a tag de quantidade. Se a etiqueta de quantidade contiver um atributo de erro com valor verdadeiro, a etiqueta de quantidade exibirá as células da tabela listadas abaixo. Se o valor do atributo não for verdadeiro, o XSL exibirá o conteúdo entre as tags. No exemplo abaixo, se o atributo error não for verdadeiro, nada será exibido.

<xsl:escolha>
<xsl:when test="quantidade[@error='true']">
<td bgcolor="src=""/></td>
<td valign="top" bgcolor="*Não há estoque suficiente em estoque.
</td>
</xsl:quando>
<xsl:caso contrário>
</xsl:caso contrário>
</xsl:escolha>

Para cada um
A tag <xsl:for-each> pode ser usada para aplicar a mesma folha de estilo a diversas situações de dados XML semelhantes. Para nós, uma série de informações do produto podem ser retiradas do banco de dados e formatadas uniformemente na página web. Aqui está um exemplo:
<xsl:for-each select="pacote">
<xsl:apply-templates select="produto"/>
</xsl:for-each>

O loop for-each começa quando o programa encontra um rótulo. Este loop terminará quando o programa encontrar um rótulo. Depois que esse loop for executado, esse modelo será aplicado sempre que o rótulo aparecer.

4. Gere HTML

Em algum momento no futuro, os navegadores integrarão mecanismos de análise XML. Nesse ponto, você pode enviar arquivos XML e XSL diretamente para o navegador, e o navegador exibe os dados XML de acordo com as regras listadas na folha de estilos. No entanto, até então, os desenvolvedores terão que criar recursos de análise em seus sistemas do lado do servidor.

No Sparks.com, integramos um analisador XML ao servlet Java. Este analisador usa um mecanismo chamado XSLT (XSL Transformation) para adicionar dados XML ao modelo XSL conforme especificado pela tag XSL.

Quando nosso servlet Java trata uma solicitação HTTP, o servlet recupera o XML gerado dinamicamente, que é então passado para o mecanismo de análise. Com base nas instruções do arquivo XML, o mecanismo de análise procura a folha de estilo XSL apropriada. O analisador cria um arquivo HTML a partir da estrutura DOM e então esse arquivo é enviado ao usuário que faz a solicitação HTTP.

Se você optar por usar o modelo SAX, o analisador lerá a origem XML e criará um evento para cada tag XML. Os eventos correspondem aos dados XML e os dados são finalmente inseridos na folha de estilos de acordo com as tags XSL.