<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<html>
    <head>
        <title>Informa&ccedil;&otilde;es sobre a vers&atilde;o do NetBeans IDE 5.5</title>
        <meta name="DESCRIPTION" content="Informa&ccedil;&otilde;es sobre o NetBeans 5.5">
        <link rel="stylesheet" type="text/css" HREF="../../../netbeans.css">
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
   <meta http-equiv="Content-Language" content="pt-br"> 
</head>

    <body>

        <a name="top"></a>
        <h1>Informa&ccedil;&otilde;es sobre o NetBeans IDE 5.5</h1>

        <p>A documenta&ccedil;&atilde;o do NetBeans &eacute; oferecida em guias baseados na Web e no sistema de ajuda da IDE. Voc&ecirc; pode usar os documentos seguintes como introdu&ccedil;&atilde;o:</p>
        <ul>
             <li><a href="relnotes_pt_BR.html">Notas de vers&atilde;o</a></li>
             <li> <a href="install_pt_BR.html">Instru&ccedil;&otilde;es de instala&ccedil;&atilde;o</a></li>
             <li><a href="https://netbeans.org/kb/archive/index.html">Documenta&ccedil;&atilde;o</a></li>
        </ul>
<p>
<a href="http://services.netbeans.org/downloads/index.php"><img
src="../../../images_www/v5/download-nb-button3_pt_BR.gif" border="0" /></a>
</p>
           <!-- NEED AN IMAGE HERE <div style="float:right;padding:5px 5px 5px 5px;text-align:center;"><a href='http://netbeans.info/downloads/download.php?type=5.5' title="Download NetBeans 5.5 Preview"><img src="/images_www/55_front_page.jpg" width="170" height="100" alt="NetBeans 5.5. preview" border="0"></a> </div>-->

             <p>O NetBeans 5.5 &eacute; compat&iacute;vel com a plataforma <b>Java Enterprise Edition 5</b> e com as especifica&ccedil;&otilde;es <b>Java Persistence</b>, <b>EJB 3</b> e <b>JAX-WS 2.0</b>.</p>

            <p>O NetBeans IDE 5.5 amplia o sucesso da vers&atilde;o 5.0 e adiciona suporte para o Java EE 5 e o servidor de aplicativos Sun Java System PE 9. J&aacute; tem o Web 2.0? Claro! O NetBeans 5.5 gera artefatos JAX-WS 2.0 para projetos Java SE 6 e EE 5. Foi inclu&iacute;do o suporte ao Java Persistence e ao Enterprise Java Beans 3. Al&eacute;m disso, h&aacute; um novo m&oacute;dulo de suporte Subversion e um m&oacute;dulo atualizado do construtor de GUI, ambos dispon&iacute;veis na Central de atualiza&ccedil;&otilde;es 5.5.

            <h2><a name="features">Destaques do recurso</a></h2>

            <br> O NetBeans 5.5 traz muitos recursos que maximizam sua produtividade e flexibilidade para construir aplicativos Java s&oacute;lidos e em conformidade com o padr&atilde;o&trade;:
            <ul>
                    <li>Plataforma de suporte geral ao Java Enterprise Edition &trade; 5:
                           <ul>
                            <li>Implementa o servidor de aplicativos Sun Java System PE 9 (GlassFish).</li>
                            <li>Oferece auto-completar de c&oacute;digo e Javadoc para APIs Java EE 5 e descritores de implanta&ccedil;&atilde;o.</li>
                            <li>Tecnologias da camada Web atualizadas para a plataforma Java EE 5: Servlet 2.5, JavaServer&trade; Pages 2.1, JavaServer&trade; Faces 1.2 </li>
                            <li>Projetos de amostra do Java EE 5 para que voc&ecirc; possa se familiarizar rapidamente.</li>
                           </ul>
						  <BR>
                    </li>
                    <li>Suporte ao Java Persistence:
                        <ul>
                          <li>Gera classes de entidade Java a partir de esquemas de banco de dados existentes. </li>
                          <li>Cria classes de entidades no IDE e permite que o servidor gere o banco de dados com base no recurso de banco de dados de Java (DB-from-Java) do GlassFish.</li>
                          <li>O tempo de execu&ccedil;&atilde;o da persist&ecirc;ncia pode ser usado em aplicativos Web e aplicativos Java comuns sem a necessidade de um servidor de aplicativos Java EE totalmente desenvolvido.</li>
                          <li>Assistentes para o desenvolvimento de um aplicativo da Web completo que utiliza o Java Persistence para proporcionar suporte total a opera&ccedil;&otilde;es de <b>C</b>ria&ccedil;&atilde;o/<b>L</b>eitura/<b>A</b>tualiza&ccedil;&atilde;o/<b>E</b>xclus&atilde;o em um banco de dados.
</li>
                          <li>Editor de c&oacute;digo-fonte de Java aprimorado, com auto-completar de c&oacute;digo, verifica&ccedil;&otilde;es constantes de erros e dicas exclusivas sobre o Java Persistence.</li>
                          <li>A&ccedil;&otilde;es de usu&aacute;rio de alto n&iacute;vel que geram padr&otilde;es de c&oacute;digo comuns (por exemplo, usando o Gerenciador de entidades).</li>
                        </ul>
                    </li>
					<BR>
                    <li>Suporte &agrave; API de Java para servi&ccedil;os da Web XML (JAX-WS), tamb&eacute;m conhecido como Web Service 2.0.
                        <ul>
                            <li>Gera artefatos JAX-WS 2.0 para projetos do SE 6 e EE 5</li>
                            <li>A configura&ccedil;&atilde;o &eacute; feita por meio da personaliza&ccedil;&atilde;o de vincula&ccedil;&otilde;es, tais como chamadas ass&iacute;ncronas e informa&ccedil;&otilde;es do pacote.</li>
                            <li>Assistentes para modelos simplificados e atualizados. </li>
                            <li>A&ccedil;&otilde;es de usu&aacute;rio de alto n&iacute;vel que geram padr&otilde;es de c&oacute;digo comuns (por exemplo, chamada a um servi&ccedil;o da Web).</li>
                        </ul>
                    </li>
					<BR>
                    <li>Suporte a Beans de sess&atilde;o do Enterprise Java Beans 3
                        <ul>
                            <li>Desenvolvimento simplificado de Beans de sess&atilde;o e Beans controlados por mensagem.</li>
                            <li>Editor de c&oacute;digo-fonte de Java aprimorado, com auto-completar de c&oacute;digo, verifica&ccedil;&otilde;es constantes de erros e dicas exclusivas sobre o EJB 3.</li>
                        </ul>
                    </li>
					<BR>
                    <li>Outras melhorias:
                        <ul>
                            <li>F&aacute;cil acesso ao Cat&aacute;logo de solu&ccedil;&otilde;es de Java BluePrints do Java EE 5.</li>
                            <li>Auto-completar de c&oacute;digo do Idioma de express&atilde;o do JavaServer&trade; Pages .</li>
                            <li>Suporte a clientes de aplicativos Java EE.</li>
                            <li>Suporte &agrave; configura&ccedil;&atilde;o de seguran&ccedil;a em aplicativos Java EE.</li>
                            <li>Suporte &agrave; execu&ccedil;&atilde;o de scripts SQL diretamente do IDE.</li>
                        </ul>
                    </li>

          </ul>

     <h2><a name="addon">Pacotes suplementares do NetBeans</a></h2>

<ul>
<li>O Enterprise Pack do NetBeans oferece suporte &agrave; cria&ccedil;&atilde;o de aplicativos de Arquitetura Orientada a Servi&ccedil;os (SOA), incluindo ferramentas do esquema XML, editor de WSDL e editor de BPEL para orquestra&ccedil;&atilde;o de servi&ccedil;os da Web.

<li>Utilize o <a href="https://netbeans.org/kb/trails/mobility.html">Mobility Pack</a> para escrever, testar e depurar aplicativos para os dispositivos m&oacute;veis oferecidos pela tecnologia da plataforma Java Micro Edition (plataforma Java ME).</li>

<li>O <a href="https://netbeans.org/features/java/profiler_pt_BR.html">NetBeans Profiler</a> ajuda voc&ecirc; a otimizar a mem&oacute;ria de aplicativos e o uso da CPU

<li> O <a href="http://cnd.netbeans.org">C/C++ Native Development Module</a> &eacute; compat&iacute;vel com projetos de C/C++.</li> 

<li> Use o <a href="../../../features/web/web-app_pt_BR.html">Visual Web Pack</a> para construir r&aacute;pida e visualmente aplicativos da Web com base nos padr&otilde;es, incluindo o suporte aos componentes AJAX e JSF. 
</li>

</ul>


         <h2>Refer&ecirc;ncias</h2>

         <ul>
          <li><a href="https://netbeans.org/kb/archive/index.html">Tutoriais, guias e artigos</a></li>
        </ul>

    </body>
</html>


