A melhor maneira de aprender XML é começar com um desenvolvimento simples, praticar com ousadia e prosseguir passo a passo. A beleza do XML só pode ser profundamente compreendida durante o processo de desenvolvimento. É impossível aprender XML sem desenvolvimento. Portanto, ao aprender XML, você deve primeiro estabelecer um ambiente de desenvolvimento XML. Deixe-me apresentar como estabelecer um ambiente de desenvolvimento XML baseado em Java. Como não tenho acesso ao Linux no momento, todos os exemplos são feitos no Windows. No entanto, todo o software apresentado aqui pode ser usado em Linux e Windows, e o uso é semelhante. Além disso, exceto o JRE da Sun, todos eles são softwares de código aberto e qualquer pessoa pode usá-los para qualquer finalidade, ou até mesmo redistribuí-los para fins comerciais. O download e o uso do JRE também são gratuitos, mas não há código-fonte. Se você tem experiência no uso desses softwares no Linux, espero que possa contribuir com todos.
A configuração de um ambiente de desenvolvimento XML requer as seguintes etapas:
1. Instale o ambiente de execução Java
2. Instale um compilador Java.
3. Instale um contêiner JSP.
4. Instale um taglib que suporte XSLT.
5. Instale um analisador XML.
6. Instale um navegador que suporte XSLT.
7. Instale um editor de arquivo XML (opcional).
Etapa 1. Instale o ambiente de execução Java
Recomenda-se usar o JRE 1.3 da Sun, que pode ser baixado aqui:
http://java.sun.com/j2se/1.3/jre/download-windows.html
NOTA: Não é JDK 1.3, tudo que precisamos é JRE 1.3
Após fazer download do JRE 1.3, execute o programa de instalação, assumindo que ele esteja instalado em C:JRE1.3. Então você precisa definir três variáveis de ambiente.
JAVA_HOME=C:JRE1.3
CLASSPATH=.;C:JRE1.3librt.jar
CAMINHO=%PATH%;C:JRE1.3bin
Se for Windows 95/98/me, coloque as configurações das variáveis de ambiente em Autoexec.bat e reinicie a máquina. Para Windows NT/2000, basta configurá-las em "Meu Computador/Propriedades".
Etapa 2: Instale um compilador Java.
Recomenda-se usar o jikes da IBM, um eficiente compilador Java de código aberto. A página inicial do Jikes está em
http://oss.software.ibm.com/developerworks/opensource/jikes/
A versão mais recente é 1.1.3, que pode ser baixada aqui:
/u/info_img/2009-07/07/jikes-1_13-mingw-win32.zip
Após o download, descompacte-o para obter um jikes.exe e coloque-o em qualquer diretório na variável de ambiente PATH, como C:JRE1.3bin
Edite um programa simples de hello world e experimente:
// olá.java
aula pública olá {
public static void main(String [] args) {
System.out.print("olá, mundo!n");
}
}
então compile
jikes olá.java
Se hello.class for gerado, ele poderá ser usado.
Etapa 3. Instale um contêiner JSP.
Recomenda-se usar o Tomcat 3.2.1 de Jacarta. O Tomcat 3.2.1 pode ser baixado aqui:
http://jakarta.apache.org/builds/jakarta-tomcat/release/v3.2.1/bin/
Você precisa fazer download do arquivo jakarta-tomcat-3.2.1.zip Se estiver instalando no Windows NT/2000, também há jk_nt_service.zip no diretório win32/i386.
Após o download, descompacte-o, assumindo que ele esteja colocado em C:Tomcat e então você precisa definir uma variável de ambiente.
TOMCAT=C:tomcat
Para fazer o Tomcat usar jikes, você precisa fazer um pequeno hack, como segue:
Adicione parser.jar, jaxp.jar e webserver.jar no diretório lib do Tomcat à variável de ambiente CLASSPATH para torná-la efetiva e, em seguida, execute as seguintes etapas:
cdtomcatsrcorgapachetomcatcontext
Edite o arquivo WebXmlReader.java e altere
// sw.addInitParam("jspCompilerPlugin", "org.apache.jasper.compiler.JikesJavaCompiler");
Remova o comentário antes
então compile
jikesWebXmlReader.java
Crie um diretório temporário e use a ferramenta jar (disponível no JDK) para descompactar webserver.jar no diretório lib do Tomcat.
mkdir t
CDT
jar xvf ..webserver.jar
Substitua WebXmlReader*.class em orgapachetomcatcontext pelo WebXmlReader*.class recém compilado e gerado
Em seguida, reembale:
jar cf servidor web.jar .
Substitua o webserver.jar do Tomcat pelo novo webserver.jar
Edite web.xml no diretório conf do Tomcat e altere
<!-- descomente o seguinte para usar Jikes para compilação JSP
<parâmetro de inicialização>
<param-name>jspCompilerPlugin</param-name>
<param-value>org.apache.jasper.compiler.JikesJavaCompiler</param-value>
</init-param>
-->
Remova comentários externos.
Edite tomcat.bat no diretório bin do Tomcat e substitua todas as ferramentas.jar por rt.jar
Inicie o Tomcat e execute startup.bat no diretório bin.
Use um navegador para fazer um teste e visite
http://localhost:8080
Se os exemplos JSP e Servlet forem compilados e executados, o Tomcat funcionará.
Pare o Tomcat usando shutdown.bat
No Windows NT/2000, o Tomcat pode ser instalado como um serviço da seguinte forma:
Copie wrapper.properties do diretório conf do Tomcat e edite-o. Altere duas das variáveis
wrapper.tomcat_home
wrapper.java_home
Defina os caminhos de instalação do TOMCAT e JRE respectivamente e substitua todos os tools.jar por rt.jar.
então corra
jk_nt_service -I Tomcat wrapper.properties
Onde Tomcat é o nome do serviço que instalamos.
Entre no painel de controle e inicie o serviço Tomcat. Após a instalação do serviço Tomcat, ele será configurado para iniciar manualmente. É possível modificar as propriedades do serviço Tomcat para que ele seja iniciado automaticamente.
Exclua o serviço Tomcat com:
jk_nt_service -RTomcat
Etapa 4. Instale um taglib que suporte XSLT.
Recomenda-se usar XSL Taglib em Jakarta Taglibs para XSLT
Sua página está em http://jakarta.apache.org/taglibs/doc/xsl-doc/intro.html
Baixe o instantâneo XSL Taglib desta página. Você também pode baixar todos os Jakarta Taglibs. Os Jakarta Taglibs têm uma ampla variedade, mas aqui usaremos apenas o XSL Taglib.
Após o download, descompacte-o, copie os dois arquivos xsl-examples.war e xsl-doc.war para o diretório webapps do Tomcat e reinicie o Tomcat. Acesse usando um navegador
http://localhost:8080/xsl-examples/
Execute Apply.jsp na página Se não houver erros e uma página com muitas tabelas for exibida, XSL Taglib poderá ser usado.
O documento XSL Taglib também está instalado, em
http://localhost:8080/xsl-doc/
Você pode começar com este exemplo e começar a escrever seu próprio manipulador XML passo a passo. Por exemplo, você pode adicionar um novo contexto no server.xml do Tomcat
<Caminho do contexto="/jspxml"
docBase = "caminho para seu diretório de trabalho"
crossContext="falso"
depuração = "0"
recarregável="verdadeiro" >
</Contexto>
O caminho para o diretório de trabalho é o seu diretório de desenvolvimento. Copie o conteúdo do diretório webapps/xsl-examples do Tomcat intacto para seu diretório de desenvolvimento e use este programa como referência para começar a escrever seu próprio programa de processamento XML.
Para obter informações sobre como usar JSP para desenvolvimento XML, consulte o whitepaper da Sun em: http://java.sun.com/products/jsp/pdf/JSPXML.pdf
Este é basicamente o método que falei acima.
Etapa 5. Instale um analisador XML.
Após concluir as etapas 3 e 4, você já terá dois analisadores XML disponíveis, ou seja, o JAXP da Sun usado pelo próprio Tomcat e o Xerces do xml.apache.org usado pelo XSL Taglib. JAXP inclui dois arquivos, parser.jar e jaxp.jar, e o Xerces possui apenas um arquivo, xerces.jar. Esses arquivos podem ser encontrados no diretório Tomcat.
Recomenda-se usar o Xerecs XML Parser porque atualmente ele suporta XML Schema e é um software de código aberto. Mas isso é puramente uma questão de preferência pessoal, e o XML Parser da Sun também é excelente. Depois de decidir qual analisador XML usar, adicione seu arquivo ao CLASSPATH. Mas não use os dois analisadores XML ao mesmo tempo. Depois que CLASSPATH entrar em vigor, você poderá usar APIs JDOM e SAX para processar arquivos XML em seu programa Java.
Exemplos de situações aplicáveis e uso de JDOM e SAX podem ser encontrados aqui: http://developerlife.com
Etapa 6. Instale um navegador que suporte XSLT.
Esta etapa não é necessária, pois agora podemos usar XSL Taglib no lado do servidor para converter o arquivo XML para o formato HTML e enviá-lo para o navegador, então na verdade você pode usar qualquer navegador que desejar. Mas instalar um navegador que suporte XSLT pode facilitar nosso aprendizado. Embora precisemos fazer XSLT no lado do servidor agora, quando os navegadores que suportam XSLT se tornarem populares no futuro, podemos até pular esta etapa e apenas enviar os arquivos XML e XSL diretamente para o navegador. Isso pode reduzir bastante a carga do lado do servidor, porque fazer XSLT não é uma tarefa fácil.
Mozilla 0.8 é recomendado. Neste ponto, você pode perguntar novamente: por que não usar o IE 4/5? O IE 4/5 também não pode fazer XSLT? Além da preferência pessoal, posso citar 3 motivos para usar o Mozilla:
Em primeiro lugar, a versão XSLT suportada pelo Mozilla é mais recente que o IE 4/5. O XSLT suportado pelo IE 4/5 não é uma versão oficial, mas um rascunho. Isto é: http://www.w3.org/TR/WD-xsl, e o XSLT suportado pela Mozilla é a versão oficial do XSLT. Nomeadamente: http://www.w3.org/1999/XSL/Transform.
Em segundo lugar, os aplicativos XML no Mozilla incluem não apenas XSLT, mas também RDF, XUL, SVG, MathML, etc., portanto, o suporte do Mozilla para XML excede o IE 4/5 em amplitude e profundidade.
O autor do terceiro FAQ sobre XML elogia muito a Mozilla e acredita que o suporte da Mozilla para XML é muito melhor que o IE 4/5 em termos de robustez.
OK, tendo dito tudo isso, vamos voltar ao assunto, como fazer com que o Mozilla 0.8 suporte XSLT?
Primeiro, baixe o Mozilla 0.8 aqui: http://www.mozilla.org/releases/
A versão mais recente é a 0.8.1, mas esta versão não pode ser executada após a instalação de um módulo que suporte XSLT, portanto, atualmente só podemos usar a versão 0.8, mais antiga, porém mais lenta.
Se você não quiser mais outros recursos como SVG/MathML, a maneira mais conveniente é instalá-lo usando o arquivo .exe preparado.
Após a instalação, inicie o Mozilla e visite esta página: http://www.mozilla.org/projects/xslt/
Há um botão Instalar na página. Clique neste botão para instalar o módulo TransformMiiX que implementa a função XSLT.
Reinicie o Mozilla e visite a página mencionada acima. Clique no link para o exemplo simples acima. Se você vir os mesmos resultados de quando clicou no link semelhante, então seu Mozilla já suporta XSLT.
Sobre como configurar o Mozilla 0.8 para suportar Java Plug-in, consulte outro post que postei na versão XML: Solução cliente XML baseada em Mozilla. Não entrarei em detalhes aqui.
Etapa 7. Instale um editor de arquivo XML.
Esta etapa é ainda menos necessária. Você já ouviu falar que as pessoas ainda usam o vi para criar páginas HTML? Eu vi uma pessoa assim, e essa pessoa é o professor Yu Mingjian. Há uma frase marcante na página pessoal do professor Yu: Basta usar o vim it, você pode usar qualquer editor que desejar para editar arquivos XML, mas para a conveniência dos amigos que estão acostumados a usar editores WYSIWYG, ainda recomendo algumas comparações! Bom editor XML:
1. XML Spy: Um editor XML totalmente funcional, uma versão de teste está disponível para download.
http://www.xmlspy.com/
2. EditML Pro: Outro editor XML com funções mais completas.
http://www.editml.com
3. PSGML para Emacs: Emacs, não preciso falar nada, certo?
http://www.lysator.liu.se/projects/about_psgml.html
Aqui é apenas para apresentar alguns outros conhecimentos como a cereja do bolo. Usando esse conhecimento, podemos construir um ambiente de desenvolvimento mais poderoso.
Etapa 8. Instale um framework JSP melhor
Recomenda-se usar Struts. Struts é um subprojeto do projeto Jakarta, que visa desenvolver um Framework JSP baseado no padrão de design MVC. O desenvolvimento dentro da estrutura Struts pode separar efetivamente a camada de apresentação e a camada de implementação de aplicativos Web e melhorar a reutilização do código. O desenvolvimento baseado no padrão de design MVC é o chamado padrão de desenvolvimento Modelo 2. O projeto está em fase de conclusão e a versão mais recente é 1.0-beta-1.
Para obter informações sobre o que é o padrão de design MVC, você pode consultar o livro "Design Patterns" da Machinery Industry Press. Com relação ao uso do Struts, você pode consultar minha tradução do "Struts User Guide" na coleção de artigos: http://www.linuxforum.net/doc/strutsususerguide.html
Baixe Jakarta Struts aqui:
http://jakarta.apache.org/builds/jakarta-struts/release/v1.0-b1/
Você precisa baixar o arquivo jakarta-struts-1.0-b1.zip.
Descompacte-o, copie os dois arquivos struts-example.war e struts-documentation.war para o diretório webapps do Tomcat e reinicie o Tomcat. Acesse usando um navegador
http://localhost:8080/struts-example/
Execute o programa MailReader na página. Se puder ser registrado corretamente, ele poderá ser usado.
A documentação do Struts também está instalada.
http://localhost:8080/struts-documentation/
Para obter informações sobre como usar o Struts em seu próprio diretório de desenvolvimento, consulte a documentação fornecida com o Struts. Existem algumas discussões sobre Struts na versão Java, que podem ser encontradas usando a função de busca do fórum.
Etapa 9. Já se fala há muito tempo sobre o estabelecimento de uma conexão com o Apache. Deixe-me apresentar o método mais simples, usando mod_jk para estabelecer uma conexão com o Apache.
Supondo que você tenha o Apache instalado, baixe o mod_jk aqui:
http://jakarta.apache.org/builds/jakarta-tomcat/release/v3.2.1/bin/win32/i386/
Você precisa baixar o arquivo mod_jk.zip.
Descompacte-o para obter um mod_jk.dll e copie-o para o diretório de módulos no diretório de instalação do Apache.
Modifique o arquivo de configuração do Apache httpd.conf e adicione as duas linhas a seguir:
Incluir C:/tomcat/conf/mod_jk.conf-auto
JkMount /*.do ajp12
Entre eles, “C:/Tomcat” é o diretório de instalação do Tomcat.
Adicione index.jsp ao DirectoryIndex, ou seja:
DirectoryIndex index.html index.jsp
Se houver um comentário antes de ServerName, abra o comentário antes de ServerName e defina-o como localhost, ou seja:
Nome do servidor localhost
Reinicie o Apache e visite esta página:
http://localhost/exemplos/
Se os diretórios jsp e servlet puderem ser listados, a conexão entre o Tomcat e o Apache será estabelecida.
OK, depois de dizer tanto, na verdade é apenas resolver as tarefas domésticas. Agora que a limpeza está organizada, podemos iniciar o desenvolvimento do XML. :-)