<!DOCTYPE HTML PUBLIC"-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<META HTTP-EQUIV="content-type" CONTENT="text/html; charset=UTF-8">
 
<title>Guia de instala&ccedil;&atilde;o do NetBeans 5.5.1 Visual Web Pack</title>

<meta name="description" content="Este guia fornece informa&ccedil;&otilde;es para a instala&ccedil;&atilde;o e a configura&ccedil;&atilde;o do NetBeans Visual Web Pack 5.5.">
<meta name="keywords" content="VWP, instalador do VWP, Java Studio Creator"> 

<link rel="stylesheet" type="text/css" href="../../../../netbeans.css" media="screen">
<style type="text/css">
<!--
.style2 {color: #FF0000}
-->
</style>
</head>
<body>
<a name=top></a>
<h1>Instru&ccedil;&otilde;es de instala&ccedil;&atilde;o do NetBeans Visual Web Pack 5.5.1</h1>
<!-- <p>Last Updated: October 2006</p> -->
<p>NetBeans Visual Web Pack 5.5.1 oferece um ambiente para a constru&ccedil;&atilde;o r&aacute;pida de aplicativos da Web com componentes JavaServer Faces ativados por Ajax, suporte &agrave; vincula&ccedil;&atilde;o com arrastar e soltar a fontes de dados, etc. </p>
<p><b>Conte&uacute;do</b></p>
<ul>
  <li><a href="#impnotes"> Observa&ccedil;&otilde;es importantes </a></li>
  <li><a href="#prerequisites" title="Pr&eacute;-requisitos">Pr&eacute;-requisitos</a> </li>
  <li> <a href="#installation" title="Instalando o software">Instalando o software</a></li>
  <li><a href="#upgrade" title="Atualizando o NetBeans Visual Web Pack da vers&atilde;o 5.5 para 5.5.1">Atualizando o NetBeans Visual Web Pack da vers&atilde;o 5.5 para 5.5.1</a></li>
<li> <a href="#configinfo" title="Informa&ccedil;&otilde;es de configura&ccedil;&atilde;o">Informa&ccedil;&otilde;es de configura&ccedil;&atilde;o</a> </li>
  <li> <a href="#uninstallation" title="Desinstalando o software">Desinstalando o software</a> </li>
  <li> <a href="#troubleshoot" title="Solu&ccedil;&atilde;o de problemas">Solu&ccedil;&atilde;o de problemas</a> </li>
</ul>
<p><b>Observa&ccedil;&atilde;o:</b> Para obter informa&ccedil;&otilde;es sobre os requisitos do sistema do software inclu&iacute;do no pacote, consulte as <a href="vwp-release-notes_pt_BR.html">Notas de vers&atilde;o do NetBeans Visual Web Pack 5.5.1</a>.</p>
<br> <!-- IMPORTANT NOTES ----------------------------------------------------- -->
<h2><a name=impnotes></a>Observa&ccedil;&otilde;es importantes</h2>
<blockquote><h3>Servidores de aplicativos/Recipientes do servlet</h3>
<p>O Visual Web Pack funciona com todos os servidores de aplicativos e recipientes de servlet aceitos pelo NetBeans IDE.</p>
  <h3>Restri&ccedil;&otilde;es do Java EE 5/JavaServer Faces 1.2</h3>
<p>A partir desta data, somente o Sun Java System Application Server 9 U1 (compila&ccedil;&atilde;o 14), ou superior, aceita aplicativos do Visual Web que usam a plataforma Java EE 5. Se voc&ecirc; usa um servidor diferente, escolha a plataforma J2EE 1.4 ao criar o seu projeto.</p>
<h3>Banco de dados Viagem fornecido</h3>
<p> Muitos tutoriais e aplicativos de amostra usam o banco de dados Viagem. Se disponibilizar o servidor de aplicativos Sun Java System para o IDE antes de instalar o Visual Web Pack,


 a instala&ccedil;&atilde;o do Visual Web Pack adicionar&aacute; um banco de dados Viagem ao servidor Java DB (Derby) que &eacute; fornecido com o servidor de aplicativos Sun Java System.

Se disponibilizar o servidor de aplicativos Sun Java System para o IDE depois de instalar o Visual Web Pack, reinicie o IDE para ativar o banco de dados Viagem. Para obter instru&ccedil;&otilde;es sobre a instala&ccedil;&atilde;o do banco de dados Viagem em sua pr&oacute;pria instala&ccedil;&atilde;o do servidor de banco de dados Java DB ou Apache Derby, consulte <a href="#samples">Banco de dados de amostra do Visual Web Pack</a> na se&ccedil;&atilde;o Informa&ccedil;&otilde;es de configura&ccedil;&atilde;o.</p>
<h3>Visualiza&ccedil;&atilde;o da tecnologia</h3>
<p>Caso voc&ecirc; tenha instalado a vers&atilde;o Visualiza&ccedil;&atilde;o da tecnologia do NetBeans Visual Web Pack 5.5, desinstale-a, conforme descrito em <a href="#uninstallation" title="Desinstalando o software">Desinstalando o software</a>, antes de instalar a vers&atilde;o de produ&ccedil;&atilde;o do Visual Web Pack. </p>
<p>Caso voc&ecirc; tenha instalado os componentes Blueprints Ajax na Visualiza&ccedil;&atilde;o da tecnologia do NetBeans Visual Web Pack 5.5, desinstale esses componentes manualmente antes de instalar a vers&atilde;o de produ&ccedil;&atilde;o do Visual Web Pack. Para excluir uma biblioteca de componentes do IDE:
<!--
<ol>
  <li>Escolha Ferramentas &gt; Gerenciador de bibliotecas de componentes.</li>
  <li>
    <p>No Gerenciador de bibliotecas de componentes, selecione a biblioteca que deseja excluir e clique no bot&atilde;o Remover na parte inferior da janela.</p> 
    Talvez voc&ecirc; veja uma mensagem dizendo que h&aacute; projetos abertos que usam a biblioteca. Se for o caso, clique em OK na mensagem, feche o Gerenciador de bibliotecas de componentes e, em seguida, feche esses projetos. Voc&ecirc; poder&aacute;, ent&atilde;o, reabrir o Gerenciador de bibliotecas de componentes e come&ccedil;ar novamente.</li>
  <li>
    <p>Confirme que deseja excluir a biblioteca.</p>
  A biblioteca &eacute; removida do seu diret&oacute;rio de usu&aacute;rio. Quaisquer projetos que usam a biblioteca podem continuar a faz&ecirc;-lo porque possuem a sua pr&oacute;pria c&oacute;pia da biblioteca no diret&oacute;rio do projeto.
  </li>
</ol></p>-->
</blockquote>
<p align=center><a href="#top">superior</a></p>
<!-- PREREQUISITES ----------------------------------------------------- -->
<h2><a name=prerequisites></a>Pr&eacute;-requisitos</h2>

<p>Este t&oacute;pico especifica os pr&eacute;-requisitos que devem ser atendidos antes de voc&ecirc; come&ccedil;ar a instalar o <a href="https://netbeans.org/kb/archive/index.html">NetBeans Visual Web Pack 5.5.1</a>. </p>
<p>Baixe o NetBeans Visual Web Pack 5.5.1 da <a href="http://services.netbeans.org/downloads/index.php?rs=21">p&aacute;gina de downloads netbeans.org</a>.</p>
<blockquote>
  <h3>Software necess&aacute;rio</h3>
  <!--
  Release Notes does this better - refer to *an* app server and then *to best take advantage, use SJAS*
   -->

   <p>Antes da instala&ccedil;&atilde;o do NetBeans Visual Web Pack 5.5.1, o software abaixo deve ser instalado:</p>

   <ul>
        <li><a href="../../../../downloads/index.html?pagelang=pt_BR">NetBeans IDE 5.5.1</a>.</li>
     <li><a href="http://java.sun.com/javase/downloads/index.jsp">Java SE Development Kit (JDK) 5.0 atualiza&ccedil;&atilde;o 6 (vers&atilde;o 1.5.0_06)</a> ou superior.<br> <br> Se n&atilde;o tiver o JDK 5.0 atualiza&ccedil;&atilde;o 6 ou superior instalado, n&atilde;o &eacute; poss&iacute;vel prosseguir com a instala&ccedil;&atilde;o. Voc&ecirc; pode fazer o download deste JDK na p&aacute;gina de <a href="http://java.sun.com/javase/downloads/index.jsp">downloads do Java SE</a>. <br> <br> <span class="bold">Observa&ccedil;&atilde;o: </span>O Windows Vista requer o JDK 5.0 atualiza&ccedil;&atilde;o 11 ou JDK 6. Voc&ecirc; pode fazer o download de ambos os JDKs na p&aacute;gina de <a href="http://java.sun.com/javase/downloads/index.jsp">downloads do Java SE</a>. Se voc&ecirc; precisar de JDKs anteriores, coloque-os depois no caminho de classe para que o 1.5.0_11 ou JDK 6 seja encontrado primeiro.<br> <br> <span class="bold">Observa&ccedil;&atilde;o: </span>As instala&ccedil;&otilde;es do Mac OS X requerem o Java 2 Standard Edition (J2SE) 5.0  vers&atilde;o 4. Voc&ecirc; pode fazer o download desse JDK na <a href="http://www.apple.com/support/downloads/" target="_blank">p&aacute;gina de downloads da Apple</a>. Procure &quot;J2SE&quot; para localizar essa vers&atilde;o. </li>
        <li>Um dos servidores de aplicativos ou recipientes de servlet que s&atilde;o aceitos pelo Netbeans IDE.<br> <br> <b>Observa&ccedil;&atilde;o:</b> Para desenvolver aplicativos do Visual Web usando a plataforma Java EE 5, voc&ecirc; deve usar o servidor de aplicativos Sun Java System 9. Para obter mais informa&ccedil;&otilde;es, consulte o site na Web de <a href="http://www.sun.com/software/products/appsrvr/index.xml">downloads do Java EE</a>. </li>

  </ul>
   <h3>Ordem de instala&ccedil;&atilde;o</h3>
   <p> Se estiver instalando o NetBeans Visual Web Pack com o NetBeans IDE e a instala&ccedil;&atilde;o separada do servidor de aplicativos Sun Java System, &eacute; melhor <a href="#config_sjas">configurar o servidor de aplicativos</a> antes de instalar o Visual Web Pack, para que o banco de dados Viagem fornecido esteja imediatamente dispon&iacute;vel. Se configurar o servidor de aplicativos depois de instalar o Visual Web Pack, reinicie o IDE antes que o banco de dados Viagem esteja dispon&iacute;vel na janela Tempo de execu&ccedil;&atilde;o.

  </p>
  <h3>Aplicativos firewall</h3>
  <p>Os aplicativos firewall ativados podem impedir que alguns componentes sejam configurados corretamente durante o processo de instala&ccedil;&atilde;o. Dependendo do firewall, talvez voc&ecirc; tenha que desativ&aacute;-lo antes da instala&ccedil;&atilde;o. Consulte a documenta&ccedil;&atilde;o do seu firewall. </p>

</blockquote>

<p align=center><a href="#top">superior</a></p>
<!-- INSTALLATION ------------------------------------------------------ -->
<h2><a name=installation></a>Instala&ccedil;&atilde;o do software</h2>
<p>Este t&oacute;pico cont&eacute;m instru&ccedil;&otilde;es para a instala&ccedil;&atilde;o do NetBeans Visual Web Pack 5.5.1 em todas as plataformas aceitas:
<ul>
<li> <a href="#install_windows">Microsoft Windows</a> </li>
<li> <a href="#install_sollinux">Solaris OS e Linux</a> </li>
<li> <a href="#install_macos">Mac OS X</a> </li>
</ul>
<p><b>Observa&ccedil;&atilde;o: </b>Caso voc&ecirc; tenha instalado o servidor de aplicativos Sun Java System, configure o servidor de aplicativos no NetBeans IDE, conforme descrito em <a href="#config_sjas">Configura&ccedil;&atilde;o do servidor de aplicativos</a> antes de instalar o Visual Web Pack, para que o instalador possa instalar o esquema Viagem de amostra no banco de dados Java DB fornecido do servidor. Observe que o Visual Web Pack n&atilde;o requer um servidor de aplicativos, mas voc&ecirc; implanta os projetos do Visual Web Pack em um servidor de aplicativos.</p>
<!--<p><b>Importante: </b>Caso voc&ecirc; tenha instalado a vers&atilde;o Visualiza&ccedil;&atilde;o da tecnologia do NetBeans Visual Web Pack 5.5, desinstale-a, conforme descrito em <a href="#uninstallation" title="Desinstalando o software">Desinstalando o software</a>, antes de instalar a vers&atilde;o de produ&ccedil;&atilde;o do Visual Web Pack. </p>-->
<blockquote>  <h3><a name=install_windows></a>Microsoft Windows</h3>

  <p>A seguir h&aacute; instru&ccedil;&otilde;es para a instala&ccedil;&atilde;o do NetBeans Visual Web Pack 5.5.1 na plataforma Microsoft Windows.</p>
  <p><b>Antes de come&ccedil;ar</b></p>

  <p>A instala&ccedil;&atilde;o na plataforma Microsoft Windows apresenta as seguintes restri&ccedil;&otilde;es:</p>
  O instalador extrai os arquivos necess&aacute;rios para o diret&oacute;rio tempor&aacute;rio padr&atilde;o definido pela vari&aacute;vel de ambiente <tt>TEMP</tt>. Se a quantidade de espa&ccedil;o em disco no diret&oacute;rio tempor&aacute;rio for menor que o necess&aacute;rio, a instala&ccedil;&atilde;o poder&aacute; falhar ou prosseguir de forma incorreta. <br> <br>

      Se tiver este problema, voc&ecirc; pode aumentar o espa&ccedil;o alocado da vari&aacute;vel de ambiente <tt>TEMP</tt> ou especificar outro diret&oacute;rio tempor&aacute;rio com espa&ccedil;o suficiente. Para especificar um diret&oacute;rio tempor&aacute;rio para a instala&ccedil;&atilde;o, digite os seguintes comandos: <br>

      <br>
    <blockquote><tt>&gt;&nbsp;cd&nbsp;<i>local_do_instalador</i></tt> <br> <tt>&gt;&nbsp; <strong></strong>netbeans-visualweb-5_5_1-windows.exe&nbsp;-is:tempdir&nbsp;<i>diret&oacute;rio_tempor&aacute;rio</i></tt></blockquote>

     <p><b>Para instalar</b></p>
    <ol>
    <li> Depois de fazer o download do arquivo de instala&ccedil;&atilde;o <tt>netbeans-visualweb-5_5_1-windows.exe</tt>, clique duas vezes no &iacute;cone do instalador para inici&aacute;-lo.
    </li>
    <li> Na p&aacute;gina de boas-vindas do assistente para instala&ccedil;&atilde;o, clique em Pr&oacute;ximo.
    </li>
    <li> Aceite o contrato de licen&ccedil;a e clique em Pr&oacute;ximo.    </li>

    <li> Na p&aacute;gina do diret&oacute;rio de instala&ccedil;&atilde;o do assistente para instala&ccedil;&atilde;o, especifique o local de instala&ccedil;&atilde;o do NetBeans IDE 5.5.1 e clique em Pr&oacute;ximo. </li>

    <li> O assistente para instala&ccedil;&atilde;o procura as instala&ccedil;&otilde;es compat&iacute;veis do JDK. Se o JDK n&atilde;o estiver no local padr&atilde;o, voc&ecirc; precisar&aacute; especificar o local do Java JDK 1.5.0_06 ou superior. Voc&ecirc; tamb&eacute;m pode digitar o caminho de outro JDK instalado ou usar o bot&atilde;o Explorar para ir at&eacute; outra instala&ccedil;&atilde;o e selecion&aacute;-la.
    </li>
    <li>Quando a instala&ccedil;&atilde;o estiver conclu&iacute;da, clique em Finalizar para sair do assistente.</li>
  </ol>
    <p>O diret&oacute;rio de projeto padr&atilde;o &eacute; <tt>C:\Documentos e configura&ccedil;&otilde;es\<i>nome de usu&aacute;rio</i></tt>. Se voc&ecirc; desinstalar o NetBeans Visual Web Pack, este diret&oacute;rio n&atilde;o ser&aacute; exclu&iacute;do, e ser&aacute; identificado da pr&oacute;xima vez que voc&ecirc; instalar o Visual Web Pack.</p>

    <div class=greybox><b>Observa&ccedil;&atilde;o: </b>Se voc&ecirc; encontrar problemas durante a instala&ccedil;&atilde;o do software, consulte <a href="#troubleshoot">Solu&ccedil;&atilde;o de problemas</a> para obter descri&ccedil;&otilde;es completas e solu&ccedil;&otilde;es sugeridas para problemas n&atilde;o resolvidos que poderiam afetar a instala&ccedil;&atilde;o. </div>
</blockquote>
 <p align=center><a href="#top">superior</a></p>

<blockquote>
  <h3><a name=install_sollinux></a>Solaris OS e Linux</h3>
    <p>A seguir encontram-se as instru&ccedil;&otilde;es para a instala&ccedil;&atilde;o do NetBeans Visual Web Pack 5.5.1 nas plataformas Solaris e Linux.</p>
    <p>Nas instru&ccedil;&otilde;es abaixo, substitua <tt><i>seu_execut&aacute;vel_bin&aacute;rio</i></tt> por um dos seguintes:</p>
    <ul>

    <li> <b>Solaris OS, SPARC</b>: <tt>netbeans-visualweb-5_5_1-solaris-sparc.bin</tt> </li>

      <li> <b>Solaris OS, x86/x64 Platform Edition</b>: <tt>netbeans-visualweb-5_5_1-solaris-x86.bin</tt> </li>
	  <li> <b>Linux</b>: <tt>netbeans-visualweb-5_5_1-linux.bin</tt> </li>
    </ul>

    <p><b>Para instalar</b>

    <ol>
      <li> Depois de fazer o download do arquivo de instala&ccedil;&atilde;o, <tt><i>seu_execut&aacute;vel_bin&aacute;rio</i></tt>, navegue at&eacute; a pasta que cont&eacute;m este arquivo.
      </li>
      <li>
        <p>Se necess&aacute;rio, altere as permiss&otilde;es no arquivo de instala&ccedil;&atilde;o para tornar o bin&aacute;rio execut&aacute;vel, digitando o seguinte comando em um prompt de comando:</p>

        <tt>$&nbsp;chmod&nbsp;+x&nbsp;<i>seu_execut&aacute;vel_bin&aacute;rio</i></tt>

      </li>
      <li> Inicie o instalador, digitando o seguinte comando em um prompt de comando:<br> <br> <tt>$&nbsp;./<i>seu_execut&aacute;vel_bin&aacute;rio</i></tt>    </li>

      <li> Na p&aacute;gina de boas-vindas do assistente para instala&ccedil;&atilde;o, clique em Pr&oacute;ximo.
      </li>

      <li> Aceite o contrato de licen&ccedil;a e clique em Pr&oacute;ximo.
      </li>
      <li> Na p&aacute;gina do diret&oacute;rio de instala&ccedil;&atilde;o do assistente para instala&ccedil;&atilde;o, aceite o diret&oacute;rio do NetBeans IDE encontrado pelo assistente ou selecione uma instala&ccedil;&atilde;o diferente do IDE.
      </li>
      <li>
        <p> Verifique se o local de instala&ccedil;&atilde;o est&aacute; correto e se h&aacute; espa&ccedil;o dispon&iacute;vel no sistema para a instala&ccedil;&atilde;o. Para determinar a quantidade de espa&ccedil;o em disco livre, execute o seguinte comando:
        </p>
        <tt>$ df -k</tt>
      </li>
      <li> Clique em Pr&oacute;ximo para iniciar a instala&ccedil;&atilde;o.
      </li>
      <li> Quando a instala&ccedil;&atilde;o estiver conclu&iacute;da, clique em Finalizar para sair do assistente. </li>
    </ol></p>
    <p>O diret&oacute;rio de projetos padr&atilde;o &eacute; <tt>$HOME/</tt>. Se voc&ecirc; desinstalar o NetBeans Visual Web Pack, este diret&oacute;rio n&atilde;o ser&aacute; exclu&iacute;do, e ser&aacute; identificado da pr&oacute;xima vez que voc&ecirc; instalar o Visual Web Pack.</p>
    <div class=greybox><b>Observa&ccedil;&atilde;o: </b>Se voc&ecirc; encontrar problemas durante a instala&ccedil;&atilde;o do software, consulte <a href="#troubleshoot">Solu&ccedil;&atilde;o de problemas</a> para obter descri&ccedil;&otilde;es completas e solu&ccedil;&otilde;es sugeridas para problemas n&atilde;o resolvidos que poderiam afetar a instala&ccedil;&atilde;o. </div>
</blockquote>
<br>
  <p align=center><a href="#top">superior</a></p>
  <!-- INSTALLATION: MAC OS ---------------------------------------------- -->
   <blockquote>  <h3><a name=install_macos></a>Mac OS X</h3>

    <p>A seguir encontram-se as instru&ccedil;&otilde;es para a instala&ccedil;&atilde;o do NetBeans Visual Web Pack 5.5.1 na plataforma Macintosh OS X.</p>
    <p>Observe que para o Macintosh OS, o JDK necess&aacute;rio &eacute; o Java 2 Standard Edition (J2SE) 5.0 vers&atilde;o 4. Voc&ecirc; pode fazer o download deste JDK na <a href="http://www.apple.com/support/downloads/">p&aacute;gina de downloads da Apple</a>. Procure &quot;J2SE&quot; para localizar essa vers&atilde;o. </p>

    <p><b>Antes de come&ccedil;ar</b></p>
    <p>A instala&ccedil;&atilde;o na plataforma Mac OS X apresenta as seguintes restri&ccedil;&otilde;es:</p>

    <ul>
      <li>
        <p>Para garantir a correta opera&ccedil;&atilde;o do instalador e do desinstalador, voc&ecirc; deve configurar o Java para que use o JDK 5.0:</p>
        <ol type=a>
          <li> Na janela Localizador, v&aacute; para Aplicativos &gt; Utilit&aacute;rios &gt; Java &gt; J2SE5.0 e abra o utilit&aacute;rio Prefer&ecirc;ncias de Java. </li>

          <li> Na se&ccedil;&atilde;o Configura&ccedil;&otilde;es em tempo de execu&ccedil;&atilde;o do aplicativo Java, mova o J2SE5.0 para a parte superior da lista.</li>

        </ol>
      </li>
      <li> Para permitir que o sistema operacional reconhe&ccedil;a corretamente os componentes do pacote do NetBeans 5.5.1 IDE, o diret&oacute;rio de instala&ccedil;&atilde;o deve terminar com a seq&uuml;&ecirc;ncia <tt>.app</tt>. </li>
    </ul>
    <p><b>Para instalar</b></p>
  <ol>
    <li>Clique duas vezes no &iacute;cone do instalador na janela de download para iniciar o instalador. </li>

      <li> Na p&aacute;gina de boas-vindas do assistente para instala&ccedil;&atilde;o, clique em Pr&oacute;ximo.
      </li>
      <li>Aceite o contrato de licen&ccedil;a e clique em Pr&oacute;ximo.
      </li>
      <li> Na p&aacute;gina do diret&oacute;rio de instala&ccedil;&atilde;o do assistente para instala&ccedil;&atilde;o, aceite o diret&oacute;rio do NetBeans IDE encontrado pelo assistente ou selecione uma instala&ccedil;&atilde;o diferente do IDE.
      </li>
      <li>
        <p> Verifique se o local de instala&ccedil;&atilde;o est&aacute; correto e se h&aacute; espa&ccedil;o dispon&iacute;vel no sistema para a instala&ccedil;&atilde;o. Para determinar a quantidade de espa&ccedil;o em disco livre, execute o seguinte comando:
        </p>
        <tt>$ df -b</tt>

      </li>
      <li> Clique em Pr&oacute;ximo para iniciar a instala&ccedil;&atilde;o.
      </li>
      <li> Quando a instala&ccedil;&atilde;o estiver conclu&iacute;da, clique em Finalizar para sair do assistente. </li>
     </ol>
     <p>O diret&oacute;rio de projetos padr&atilde;o &eacute; <tt>$<i>nome_de_usu&aacute;rio</i>/</tt>. Se voc&ecirc; desinstalar o NetBeans Visual Web Pack, este diret&oacute;rio n&atilde;o ser&aacute; exclu&iacute;do, e ser&aacute; identificado da pr&oacute;xima vez que voc&ecirc; instalar o Visual Web Pack.</p>

    <div class=greybox><b>Observa&ccedil;&atilde;o: </b>Se voc&ecirc; encontrar problemas durante a instala&ccedil;&atilde;o do software, consulte <a href="#troubleshoot">Solu&ccedil;&atilde;o de problemas</a> para obter descri&ccedil;&otilde;es completas e solu&ccedil;&otilde;es sugeridas para problemas n&atilde;o resolvidos que poderiam afetar a instala&ccedil;&atilde;o.<br>
</div>
</blockquote>
  <p align=center><a href="#top">superior</a></p>
<br>
<h2><a name="upgrade"></a>Atualizando o NetBeans Visual Web Pack da vers&atilde;o 5.5 para 5.5.1.</h2>
<!-- <p>To upgrade your Visual Web Pack installation, you must uninstall any BluePrints AJAX Components you have installed as well as the Visual Web Pack itself before installing the Production Release.</p>
<p>To uninstall BluePrints AJAX components:
<ol><li>From the Main menu, select Tools > Module Manager.</li>
  <li>In the Module Manager, expand the Visual Web module and select <tt>BluePrints AJAX Components Technology Preview v. 0.1.1</tt>. </li>
  <li>Click Uninstall, and then click Close.</li>
</ol>
</p> -->
<p>O NetBeans Visual Web Pack 5.5.1 funciona somente com o NetBeans IDE 5.5.1. Para atualizar:<ol><li>Desinstale o Visual Web Pack 5.5, seguindo as instru&ccedil;&otilde;es de <a href="#uninstallation">Desinstalando o software</a> abaixo.</li>
<li>Desinstale o NetBeans IDE 5.5 e instale o NetBeans IDE 5.5.1 de acordo com as instru&ccedil;&otilde;es de <a href="install_pt_BR.html">Instru&ccedil;&otilde;es de instala&ccedil;&atilde;o do NetBeans 5.5</a>.</li>
<li>Instale o NetBeans Visual Web Pack 5.5.1, conforme descrito em <a href="#installation">Instalando o software</a> acima. </li>
</ol>
</p>

<!-- CONFIG INFO ------------------------------------------------------- -->
<h2><a name=configinfo></a>Informa&ccedil;&otilde;es de configura&ccedil;&atilde;o</h2>

<p> Este t&oacute;pico fornece informa&ccedil;&otilde;es sobre como disponibilizar o servidor de aplicativos Sun para o IDE, como acessar o banco de dados Viagem de amostra, que &eacute; usado por alguns aplicativos e tutoriais de amostra, e como configurar um projeto do Visual Web. </p>

<blockquote><ul>
  <li><a href="#config_sjas">Configura&ccedil;&atilde;o do servidor de aplicativos Sun Java System </a></li>
  <!--  <li><a href="#dbaseconfig">Database Configuration</a></li> -->
    <li><a href="#samples"> Banco de dados de amostra do Visual Web Pack</a></li>
    <li><a href="#projconfig">Configura&ccedil;&atilde;o de projeto do Visual Web</a></li>

</ul>


<!-- Configuration: SJAS --------------------------------------------- -->

  <h3 style="color: rgb(14, 27, 85);"><a name=config_sjas></a>Configura&ccedil;&atilde;o do servidor de aplicativos Sun Java System</h3>

  <p>Se tiver instalado o NetBeans IDE fornecido com o servidor de aplicativos Sun Java System, o servidor de aplicativos j&aacute; estar&aacute; registrado no IDE e voc&ecirc; n&atilde;o precisar&aacute; configur&aacute;-lo. Se fez o download e instalou o servidor de aplicativos Sun Java System separadamente, configure o IDE para disponibilizar o servidor no IDE. &Eacute; melhor configurar o servidor antes de instalar o Visual Web Pack.</p>
  <p>Para configurar uma instala&ccedil;&atilde;o separada do servidor:</p>
  <ol>

    <li>Depois de instalar o NetBeans IDE e o servidor de aplicativos Sun Java System, inicie o IDE.</li>
    <li>Na janela Tempo de execu&ccedil;&atilde;o, clique com o bot&atilde;o direito do mouse no n&oacute; Servidores e escolha Adicionar servidor no menu pop-up.  </li>
    <li>No assistente para Adicionar inst&acirc;ncia de servidor, selecione Servidor de aplicativos Sun Java System na lista suspensa, e clique em Pr&oacute;ximo.
  </li>
    <li>Insira o local da instala&ccedil;&atilde;o do servidor de aplicativos e clique em Pr&oacute;ximo. </li>
    <li><div>Os valores de nome de usu&aacute;rio e senha padr&atilde;o do dom&iacute;nio do servidor de aplicativos padr&atilde;o, <tt>domain1</tt>, s&atilde;o:</div><ul>

      <li>nome de usu&aacute;rio: <tt>admin</tt></li>

    <li>senha: <tt>adminadmin</tt></li></ul>Observe que se voc&ecirc; especificar uma senha aqui, ela ser&aacute; armazenada em seu diret&oacute;rio de usu&aacute;rio, um poss&iacute;vel risco de seguran&ccedil;a. Se n&atilde;o especificar a senha aqui, voc&ecirc; ser&aacute; solicitado a fornecer os valores quando necess&aacute;rio.</li>
    <li>Clique em Finalizar.</li>

  </ol>
  <!-- <p>If you need to access the administration console for the Access Manager server, use the following values:
  <ul>
      <li>username: <tt>amadmin</tt></li>

  <li>password: <tt>admin123</tt> </li>   </ul>
  </p>-->

<!--
<h3><a name="dbaseconfig"></a>Database Configuration</h3>
<p>This section contains information for configuring Visual Web Pack for various database systems.</p>
<p>To create a new database connection: </p>
<ol><li>Launch the NetBeans IDE.
</li>
<li>In the Runtime window, right-click Databases and select New Connection.</li>
<li>
  <p>On the Basic setting tab of the New JDBC Driver dialog:
    </p>
  <ol type="a">
      <li>Select New Driver from the Name dropdown list. </li>
      <li>In the New JDBC Driver window, click Add and navigate to the location of your database's JDBC driver. The Driver Class and Name fields should populate automatically. Click OK. </li>
      <li>Modify the Database URL to reflect the host, port, and database you are using.
    </li>
      <li>Enter the User name and password of a user registered on the database. If you want to specify a database schema to use, do so on the Advanced tab.
    Otherwise click OK.</li>

  </ol>
</li>
</ol>
<p>To configure your database for NetBeans Visual Web Pack 5.5:</p>
<ol>
  <li>Launch the NetBeans IDE.
</li>
  <li>In the Runtime window, right-click Databases &gt; Drivers and select New Driver. </li>
  <li>In the New JDBC Driver window, click Add, navigate to the location of your database's JDBC driver, and select the driver. The Driver Class and Name fields should populate automatically. Click OK. </li>
</ol>
-->

<!-- Configuration: Java DB --------------------------------------------- -->

<h3><a name="samples"></a>Banco de dados de amostra do Visual Web Pack</h3>
<p>Quando voc&ecirc; instala o Visual Web Pack, o processo de instala&ccedil;&atilde;o disponibiliza um banco de dados Viagem de amostra para o banco de dados Java DB que &eacute; fornecido com o servidor de aplicativos Sun Java System, conforme mostrado na tabela abaixo. Alguns aplicativos e tutoriais de amostra requerem o banco de dados Viagem. Se o IDE estiver configurado para usar o servidor de aplicativos Sun Java System antes que o Visual Web Pack seja instalado, o banco de dados Viagem estar&aacute; dispon&iacute;vel na janela Tempo de execu&ccedil;&atilde;o. Se disponibilizar o servidor de aplicativos Sun Java System para o IDE depois de instalar o Visual Web Pack, reinicie o IDE antes que o banco de dados Viagem apare&ccedil;a na janela Tempo de execu&ccedil;&atilde;o.
</p>
<table border=1 cellpadding=4 cellspacing=3>
<col width="20*">
<col width="40*">
<col width="40*">
<tr valign="top"><th width="20%">Banco de dados de amostra</th>
<th width="40%">Detalhes da conex&atilde;o</th>

<th width="40%">Necess&aacute;rio para</th></tr>
<tr width="20%"><td>Viagem</td>
<td width="40%">URL do DB: <tt>jdbc:derby://localhost:1527/travel</tt><br> Driver: <tt>org.apache.derby.jdbc.ClientDriver</tt><br> Nome de usu&aacute;rio: viagem<br> Senha: viagem<br>
</td>
<td width="40%">Alguns tutoriais e aplicativos de amostra</td>
</tr>
</table>

<p><b>Observa&ccedil;&atilde;o:</b> Para usar o banco de dados Viagem em um servidor diferente do servidor de aplicativos Sun Java System, voc&ecirc; deve disponibilizar o arquivo <tt>derbyclient.jar</tt> para o servidor, conforme descrito na se&ccedil;&atilde;o seguinte.
</p>
<p>Se n&atilde;o quiser instalar o servidor de aplicativos Sun Java System, complete as etapas seguintes para disponibilizar o banco de dados Viagem para o IDE.</p>
<ol>
<li>Fa&ccedil;a o download e instale o banco de dados <a href="http://developers.sun.com/prodtech/javadb/downloads/">Java DB</a> ou o banco de dados <a href="http://db.apache.org/derby/derby_downloads.html">Apache Derby</a>.
</li>
<li>
  <p>Complete as etapas seguintes para disponibilizar o banco de dados para o IDE:</p>
<ol type="a">
<li>Escolha Op&ccedil;&otilde;es no menu Ferramentas.</li>

<li>Clique em Op&ccedil;&otilde;es avan&ccedil;adas.</li>
<li>Expanda Configura&ccedil;&otilde;es de servidores e ferramentas externas, e selecione Banco de dados Java DB.</li>
<li>Defina o <tt>Local do Java DB</tt> para a pasta na qual voc&ecirc; instalou o servidor de banco de dados.</li>
<li>Defina o <tt>Local do banco de dados</tt> para a pasta em que voc&ecirc; armazena os bancos de dados.</li>
<li>Clique em Fechar.</li>
</ol>
</li>
<li>Se ainda n&atilde;o iniciou o servidor de banco de dados, escolha Ferramentas &gt; Banco de dados Java DB &gt; Iniciar servidor Java DB.</li>
<li>Na janela Tempo de execu&ccedil;&atilde;o, clique com o bot&atilde;o direito do mouse em Bancos de dados e escolha Nova conex&atilde;o no menu pop-up para abrir a caixa de di&aacute;logo Nova conex&atilde;o de banco de dados.</li>
<li>Escolha Java DB (Rede) na lista suspensa Nome.</li>
<li>Na caixa de texto de URL do banco de dados, digite <tt>jdbc:derby://localhost:1527/travel;create=true;</tt>.
<li>Defina o Nome de usu&aacute;rio como <tt>viagem</tt>, defina a Senha como <tt>viagem</tt>, e clique em OK.</li>
<li>Um novo n&oacute; da conex&atilde;o &eacute; exibido. Clique com o bot&atilde;o direito do mouse no n&oacute; e escolha Desconectar no menu pop-up.</li>
<li>Voc&ecirc; j&aacute; n&atilde;o precisa da conex&atilde;o para criar o banco de dados. Clique com o bot&atilde;o direito do mouse no n&oacute; e escolha Excluir no menu pop-up.
</li>
<li>Clique com o bot&atilde;o direito do mouse em Bancos de dados e escolha Nova conex&atilde;o no menu pop-up para abrir a caixa de di&aacute;logo Nova conex&atilde;o de banco de dados.</li>
<li>Escolha Java DB (Rede) na lista suspensa Nome.</li>
<li>Na caixa de texto do URL do banco de dados, digite <tt>jdbc:derby://localhost:1527/travel</tt>.
<li>Defina o Nome de usu&aacute;rio e a Senha como <tt>travel</tt> e clique em OK.</li>

<li><p>Quando a conex&atilde;o tiver sido estabelecida, clique em OK para fechar a caixa de di&aacute;logo.</p>
Voc&ecirc; usar&aacute; este n&oacute; a partir de agora para conectar-se ao banco de dados Viagem.</li>
<li>Clique com o bot&atilde;o direito do mouse no n&oacute; da conex&atilde;o e escolha Executar comando para abrir o editor de consultas Comando SQL.</li>
<li>No menu principal, escolha Arquivo &gt; Abrir arquivo.</li>
<li>Navegue at&eacute; <tt>$NetBeansInstallDir/rave2.0/startup/samples/create-Travel-derby.sql</tt> e selecione-o, em seguida, clique em Abrir.</li>
<!-- <li>Copy the contents of the <tt>create-Travel-derby.sql</tt> file and
paste it into the SQL Command query editor.</li> -->

<li>Clique em Executar SQL na barra de ferramentas de edi&ccedil;&atilde;o para criar e preencher as tabelas no banco de dados Viagem.</li>
<li>Feche o editor de consultas Comando SQL e crie o arquivo Travel-derby.sql.</li>
<li>Expanda o n&oacute; da conex&atilde;o de banco de dados Viagem e exiba as tabelas.</li>
</ol>
<p>Para obter mais informa&ccedil;&otilde;es:</p>
<ul>

 <li> <a href="vwp-release-notes_pt_BR.html#configinfo">Informa&ccedil;&otilde;es de configura&ccedil;&atilde;o do NetBeans Visual Web Pack 5.5.1</a> possui instru&ccedil;&otilde;es mais detalhadas para configurar os bancos de dados e os servidores de aplicativos.</li>

<li>  <a href="http://developers.sun.com/prodtech/javadb/" target="_blank">Uma r&aacute;pida descri&ccedil;&atilde;o do Java DB </a> oferece uma vis&atilde;o geral do produto Java DB, assim como um tour e uma documenta&ccedil;&atilde;o. <i>(O site externo &eacute; aberto em uma nova janela).</i> </li>
<li><a href="https://netbeans.org/kb/archive/index.html">Conectando a banco de dados</a> explica como conectar o IDE a outros servidores de banco de dados.</li>
</ul>

<h3><a name="projconfig"></a>Configura&ccedil;&atilde;o de projeto do Visual Web</h3>
<p>Quando voc&ecirc; cria um projeto do Visual Web, o assistente para Novo aplicativo do Visual Web permite definir o servidor e a vers&atilde;o do Java EE desse projeto, como mostrado na figura seguinte:</p>

  <!-- BEGIN FIGURE COMPONENT -->
<table border="0" cellpadding="2" cellspacing="0" width="668">
<tr>
<td align="center" class="grey3">

  <img src="../../../../images_www/articles/newProject_pt_BR.png" width="658" height="436" border="0" alt="Figura 1: Assistente para Novo projeto">
  <div class="pad3"> <span class="dkcaption1"> <b>Figura 1</b>: Assistente para Novo projeto</span></div></td>
</tr>
</table>
<!-- END FIGURE COMPONENT -->

<p>Se quiser usar os componentes do JavaServer Faces 1.2, defina a vers&atilde;o do Java EE como Java EE 5. O servidor de aplicativos Sun Java System 9 &eacute; no momento o &uacute;nico servidor testado que oferece suporte aos projetos Java EE 5. O t&oacute;pico da ajuda on-line do Visual Web Pack, Assistente para Novo aplicativo do Visual Web, possui informa&ccedil;&otilde;es detalhadas sobre as configura&ccedil;&otilde;es que podem ser usadas para criar um novo projeto. </p>

<p>A tabela seguinte &eacute; apresentada no in&iacute;cio de cada tutorial do Visual Web Pack e mostra os recursos que funcionam com esse tutorial:</p>

<table border="1" cellpadding="1">
  <tbody>
  <tr>
    <td valign="top">Componentes JavaServer Faces/<br> Plataforma Java EE</td>
    <td valign="top"><img src="../../../../images_www/articles/check.png" alt="funciona com" height="15" hspace="3" width="14"> 1.2 com Java EE 5*<br> <img src="../../../../images_www/articles/check.png" alt="funciona com" height="15" hspace="3" width="14"> 1.1 com J2EE 1.4
  </td></tr>
  <tr>
    <td valign="top">Banco de dados Viagem</td>
    <td colspan="4" valign="top"><img src="../../../../images_www/articles/spacer.png" alt="n&atilde;o &eacute; necess&aacute;rio" height="15" hspace="3" width="14">N&atilde;o &eacute; necess&aacute;rio</td>
  </tr>
  <tr>
    <td valign="top">Biblioteca de componentes BluePrints AJAX</td>
    <td colspan="4" valign="top"><img src="../../../../images_www/articles/spacer.png" alt="n&atilde;o &eacute; necess&aacute;rio" height="15" hspace="3" width="14">N&atilde;o &eacute; necess&aacute;rio</td>
  </tr>
</tbody></table><br>
<ul>
  
  <li><b>Componentes JavaServer Faces/Plataforma Java EE:


  </b>Ao escolher Java EE 5 como a plataforma, a Paleta de componentes cont&eacute;m os componentes JavaServer Faces 1.2. Ao escolher J2EE 1.4 como a plataforma, a Paleta de componentes cont&eacute;m os componentes do JavaServer Faces 1.1</li>

  <li><p><b>Banco de dados Viagem: </b>Se listado como <em>Necess&aacute;rio</em>, o banco de dados Viagem &eacute; necess&aacute;rio para a conclus&atilde;o do tutorial. Para obter mais informa&ccedil;&otilde;es sobre o banco de dados Viagem, consulte a se&ccedil;&atilde;o anterior intitulada <a href="#samples">Amostra do Visual Web Pack</a>.</p>

Para usar o banco de dados Viagem em um servidor diferente do servidor de aplicativos Sun Java System, voc&ecirc; deve adicionar o arquivo <tt>derbyclient.jar</tt> ao seu projeto ou copi&aacute;-lo para o diret&oacute;rio da biblioteca do servidor. Por exemplo, se voc&ecirc; quiser usar o banco de dados Viagem com Tomcat, copie o arquivo <tt>derbyclient.jar</tt> em <tt>$visualwebpack_install\enterprise3\apache-tomcat-5.5.17\common\lib.</tt>. Voc&ecirc; pode encontrar uma c&oacute;pia do arquivo <tt>derbyclient.jar</tt> em <tt>$glassfish_install\javadb\lib\derbyclient.jar</tt>.</li>
  <li><b>Biblioteca de componentes BluePrints AJAX: </b>Se listado como <em>Necess&aacute;rio</em>, o tutorial demonstra como usar os componentes que s&atilde;o fornecidos com a Biblioteca de componentes BluePrints AJAX. Consulte <a href="https://netbeans.org/kb/archive/index.html">Fazendo download e importando componentes Ajax e outros componentes</a> para obter detalhes. </li>
</ul>


</blockquote>
<!--
<a href="http://db.apache.org/derby/quick_start.html">Apache Derby: Quick Start</a>-->

<p align=center><a href="#top">superior</a></p>
<!-- UNINSTALLATION ------------------------------------------------------>
<h2><a name=uninstallation>Desinstala&ccedil;&atilde;o do software</a></h2>
<p>Esta se&ccedil;&atilde;o cont&eacute;m informa&ccedil;&otilde;es para a desinstala&ccedil;&atilde;o do NetBeans Visual Web Pack 5.5 ou 5.5.1<!--, Sun Java System Application Server Platform Edition 9, Project Open ESB Starter Kit, and Sun Java System Access Manager--> do seu sistema.
<ul>
<li><a href="#uninstall_windows">Microsoft Windows</a> </li>
<li> <a href="#uninstall_sollinux">Solaris OS e Linux</a> </li>
<li> <a href="#uninstall_macos">Mac OS X</a> </li>

</p>
<blockquote>
<!-- UNINSTALLATION: WINDOWS --------------------------------------------->
<h3><a name=uninstall_windows>Microsoft Windows</a></h3>
<p></p>
  <ol>
    <li> Feche o IDE.</li>
    <li> No Painel de controle, inicie Adicionar ou remover programas, selecione NetBeans Visual Web Pack e clique em Alterar/Remover.
    </li>

    <li> Siga as instru&ccedil;&otilde;es do desinstalador. </li>

    <li>Remova o diret&oacute;rio <tt>$&lt;NetBeans install directory&gt;\rave2.0</tt> manualmente se ele ainda existir. </li>
  </ol>
  <!-- UNINSTALLATION: SOLARIS and LINUX ----------------------------------->
  <h3><a name=uninstall_sollinux>Solaris OS e Linux</a></h3>

  <ol>
    <li> Feche o IDE.</li>

    <li> 
      <p>Navegue para o subdiret&oacute;rio <tt>uninst</tt> da sua instala&ccedil;&atilde;o do NetBeans Visual Web Pack 5.5 ou 5.5.1, </p>
    <tt>$NetBeansInstallDir/rave2.0/uninst</tt></li>
    <li> Execute o script <tt>uninstaller</tt>. </li>
<li>Remova o diret&oacute;rio <tt>$NetBeansInstallDir/rave2.0</tt> manualmente se ele ainda existir. </li>
  </ol>

  
  <!-- UNINSTALLING MAC OS ------------------------------------------------- -->
<h3><a name=uninstall_macos>Mac OS X</a></h3>

  <ol>
    <li> Feche o IDE.</li>

    <li> 
      <p>V&aacute; at&eacute; o subdiret&oacute;rio <tt>uninst</tt> do Visual Web Pack de sua instala&ccedil;&atilde;o do NetBeans Visual Web Pack 5.5 ou 5.5.1,</p>
      <tt>$NetBeansInstallDir/NetBeans.app/Contents/Resources/NetBeans/rave2.0/uninst</tt></li>

    

    <li>
      <p>Execute o comando:</p> 
    <tt>$ java -jar uninstall.jar</tt>.</li>
	<li>Remova o diret&oacute;rio <tt>$NetBeansInstallDir/NetBeans.app/Contents/Resources/NetBeans/rave2.0</tt> manualmente se ele ainda existir. </li>
  </ol>
</blockquote>
<br>
<p align=center><a href="#top">superior</a></p>
<br>
<h2><a name=troubleshoot>Solu&ccedil;&atilde;o de problemas</a></h2>
<p>Se tiver problemas ao instalar ou executar o software, consulte a lista de problemas abaixo para ver as solu&ccedil;&otilde;es. Para obter uma lista completa dos problemas conhecidos, dos requisitos do sistema e de informa&ccedil;&otilde;es de configura&ccedil;&atilde;o, consulte as <a href="vwp-release-notes_pt_BR.html">Notas da vers&atilde;o</a>. </p>

<p> Se encontrar um problema que n&atilde;o esteja listado nas notas da vers&atilde;o ou quiser solicitar uma melhoria, registre o problema no sistema de controle de erros do NetBeans, IssueZilla, em <a href="https://netbeans.org/issues">https://netbeans.org/issues</a>. Para problemas do Visual Web Pack, selecione o componente &quot;visualweb&quot; e, em seguida, selecione um subcomponente apropriado. Se n&atilde;o tiver certeza do nome correto do subcomponente, escolha &quot;outro&quot;.</p>
<p>Se j&aacute; estiver conectado a netbeans.org, v&aacute; diretamente para a tela de entrada de problemas do visualweb: <a href="https://netbeans.org/bugzilla/enter_bug.cgi?component=visualweb&version=5.5">https://netbeans.org/bugzilla/enter_bug.cgi?component=visualweb&amp;version=5.5</a>.</p>

<p>Encontram-se abaixo os problemas n&atilde;o solucionados desta vers&atilde;o que podem afetar ou interromper o processo de instala&ccedil;&atilde;o: </p>
<ul>
  <!-- Bug Id: 6346340 http://bt2ws.central.sun.com/CrPrint?id=6346340 -->
  <li> <b><span style="color: rgb(4, 84, 145);">A instala&ccedil;&atilde;o do Solaris &eacute; anulada com o erro &quot;JRE n&atilde;o encontrado&quot; embora o JRE tenha sido instalado e especificado.</span></b>

    <blockquote>
      <p><strong><span class="titlectable style2"></span>Descri&ccedil;&atilde;o: </strong> Este aplicativo requer uma implementa&ccedil;&atilde;o do Java Run Time Environment (JRE) para ser executado, mas o instalador n&atilde;o consegue encontr&aacute;-la em seu computador. Use a op&ccedil;&atilde;o da linha de comando <tt>-is:javahome</tt> para especificar um JRE v&aacute;lido.  Para obter mais ajuda, use a op&ccedil;&atilde;o <tt>-is:help</tt>.</p>
      <p><strong>Solu&ccedil;&atilde;o: </strong> Inicie o instalador com o par&acirc;metro de linha de comando <tt>-is:tempdir <i>dir-temp-personalizado</i></tt>. Observe que <tt><i>dir-temp-personalizado</i></tt> deve ser um caminho absoluto, e deve conter pelo menos 1 GB de espa&ccedil;o em disco.</p>
    </blockquote>
  </li>
  <li><b><span style="color: rgb(4, 84, 145);">A instala&ccedil;&atilde;o do Sun Java System Application Server 9 falha devido ao conflito com a porta 4848</span></b></li>
  <blockquote>
  <p><strong><span class="titlectable style 2"></span>Descri&ccedil;&atilde;o: </strong>Por padr&atilde;o, o servidor de aplicativos Sun Java System usa a porta 4848, uma porta que pode ser usada por outro aplicativo. Voc&ecirc; pode modificar o arquivo <tt>setup.xml</tt> do servidor de aplicativos para apontar para uma porta diferente. Observe que esse problema s&oacute; afeta instala&ccedil;&otilde;es independentes do servidor de aplicativos Sun Java, n&atilde;o instala&ccedil;&otilde;es em que o servidor de aplicativos &eacute; empacotado com o NetBeans IDE. </p>
  <p><strong>Solu&ccedil;&atilde;o: </strong>Para atribuir um n&uacute;mero de porta diferente ao servidor de aplicativos Sun Java System:<ol>
  <li>Navegue para o diret&oacute;rio que cont&eacute;m o arquivo .JAR do instalador do servidor de aplicativos por.</li>
  <li><p>Extraia os arquivos no instalador executando o comando: </p>
    <tt>java -Xmx256m -jar <i>nome_do_arquivo.jar</i></tt></li>
   <li>Abra <tt>setup.xml</tt> em um editor de texto.</li>
<li>Procure pela seq&uuml;&ecirc;ncia 4848 e altere esse n&uacute;mero para o de uma  porta que n&atilde;o est&aacute; sendo utilizada. Salve e feche o arquivo. </li>
<li>Continue com a <a href="http://glassfish.dev.java.net/public/downloadsindex.html#Instructions_to_unbundle_and_configure">instala&ccedil;&atilde;o do servidor de aplicativos</a>.</li>
  </ol> </p>
  </blockquote>
</ul>

<p align=center><a href="#top">superior</a></p>

<!-- End Content Area -->
</body>
</html>
