Autor: Ma Xiaoning
XML (Extensible Markup Language) pode parecer algum tipo de padrão w3c - não tem impacto prático agora e, mesmo que seja útil no futuro, será muito tempo depois. 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 do sistema b2b agora.
Em sparks.com usamos xml para padronizar a representação de dados entre diferentes sistemas, 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. Neste processo, 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.
Gerar 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 de exibição de dados XML e será mais eficaz se for escrito como vários modelos estáticos.
Gerar HTML
xml mais xsl é igual a html. Isso pode não parecer certo, mas nossa página HTML que os usuários veem é na verdade o resultado de xml e xsl.
1.
A capacidade de padronizar 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ê precisará tomar as seguintes decisões:
•
• Se deve usar dtd (definição de tipo de arquivo)
• Se você deseja usar DOM (Document Object Model) ou SAX (API simplificada para XML) para analisar
e determinar 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 houvesse 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 construir 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 um exemplo de formato de dados xml
Em sparks.com, analisamos todos os dados do produto 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
Em sparks.com usamos xml bem organizado em vez de apenas xml correto, pois o primeiro não requer um 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 o DTD, o mecanismo de análise deverá ser capaz de permitir que seu XML seja verificado 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 estabelece 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 estruturas DOM e enviar eventos por meio de estruturas 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 um método para transplantá-lo dinamicamente do banco de dados.
Gerar documentos XML é relativamente simples porque requer apenas um sistema que possa lidar com strings. Construímos um sistema usando java servlet, servidor corporativo javabean, jdbc e rdbms (sistema de gerenciamento de banco de dados relacional).
• O servlet lida com solicitações de informações do produto descarregando a tarefa de gerar documentos XML para o javabean corporativo (ejb).
• ejb usa jdbc para consultar os detalhes necessários do produto no banco de dados.
• ejb gera o arquivo xml e o passa para o servlet.
O servlet chama o mecanismo de análise para criar saída HTML a partir de arquivos XML e folhas de estilo xsl estáticas.
(Para obter informações adicionais sobre a aplicação de XSL, consulte Usando XSL como linguagem de modelo.)
Exemplo de geração de XML O código real para criar uma string de documento 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 criará 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.
Gerar 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 servlet java é o seguinte:
public static string begindocument(string stylesheet, string page)
{
stringbuffer xml = new stringbuffer();
xml.append("<?xml version="1.0"?>n")
.append("<?xml-stylesheet href="")
.append(folha de estilo).append(""")
.append("type ="texto/xsl"?>n");
xml.append("<").append(page).append(">n");
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 O método de controle chamará o objeto Java para gerar seu xml. Neste exemplo, o objeto produto é chamado. O objeto produto usa 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 toxml()
{
stringbuffer xml = new stringbuffer("<produto>n");
xml.append(internalxml());
xml.append("</product>n");
retornar xml.tostring();
}
string pública internalxml()
{
stringbuffer xml = novo
stringbuffer("t")
.append(producttype).append("n");
xml.append("t").append(idvalue.trim())
.append("n");
xml.append("t").append(idname.trim())
.append("n");
xml.append("t").append(page.trim())
.append("n");
Dor?
xml.append("t").append(quantidade).append("n");
xml.append("t").append(vendor).append("n");
xml.append("tn");
xml.append("t").append(pubdesc).append("n");
xml.append("t").append(vendesc).append("n";
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 saída html, combinamos o arquivo xml gerado com o 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 abaixo. 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 modo 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 as 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 pelo mecanismo de análise XML, deve obedecer a todas as regras do XML bem organizado. Essencialmente, isso significa que todas as tags de abertura devem ter uma tag de fechamento correspondente. Por exemplo, uma tag <p> que normalmente não é fechada deve ser fechada com </p>.
<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="#cccc99" bgproperties="fixed" link="#990000" vlink="#990000">
<br>
?br> </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 when 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="#ffffff"><img height="1" width="1" src="