<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<html>
<head>
<meta name="content-language" content="fr">
<title>Information Version NetBeans 5.0 </title>
<meta name="DESCRIPTION" content="Information concernant la Version EDI NetBeans 5.0 à venir">
<meta name="NAV_LINK" content="5.0">
<meta name="NAV_PRIORITY" content="1">
<meta content="ruth.kusterer@sun.com" name="AUTHOR">
<link rel="stylesheet" type="text/css" HREF="../../../netbeans.css">
<meta http-equiv="content-type" content="text/html; charset=UTF-8" />
</head>

<body>
<h1>EDI NetBeans 5.0</h1>
<div class="articledate" style="margin-left:0px;">Released: January 31st, 2006</div>

<ul>
<li><a href="http://services.netbeans.org/downloads/download.php?type=5.0">T&eacute;l&eacute;chargez L&apos;EDI NetBeans 5.0</a>
<li><a href="install_fr.html">Instructions d&apos;Installation</a>
<li><a href="relnotes_fr.html">Notes de Version</a>
</ul>

<p>L&apos;EDI NetBeans 5.0 introduit un support facile &agrave; appr&eacute;hender pour le d&eacute;veloppement de modules pour l&apos;EDI, mais aussi pour le d&eacute;veloppement d&apos;applications riches bas&eacute;es sur la plateforme NetBeans, le nouveau &eacute;diteur visuel intuitif, Matisse, un support CVS enti&egrave;rement repens&eacute;, le support pour WebLogic9 et JBoss4, et tout un tas d&apos;am&eacute;liorations au niveau de l&apos;&eacute;diteur.
<p>Voici un aper&ccedil;u des quelques fonctionnalit&eacute;s introduites dans cette release:
<ul>
<li><a href="#creating">D&eacute;veloppement de Modules NetBeans</a>
<li><a href="#matisse">&Eacute;diteur Visuel Matisse</a>
<li><a href="#servers">Serveurs</a>
<li><a href="#webframeworks">Web Frameworks</a>
<li><a href="#services">Web Services</a>
<li><a href="#editor">Am&eacute;lioratation de l&apos;&Eacute;diteur</a>
<li><a href="#completion">Completion de Code</a>
<li><a href="#RF">Refactoring</a>
<li><a href="#versioning">Contr&ocirc;le de Version</a>
<li><a href="#debugging">D&eacute;bogage</a>
<li><a href="#ui">D&apos;autres am&eacute;liorations au niveau de l&apos;utilisation </a>
<li><a href="#addon">De nouveaux modules suppl&eacute;mentaires</a>
</ul>
<br />

<h2><a name="creating">D&eacute;veloppement de Modules NetBeans</a> </h2>

<p>L&apos;EDI NetBeans offre un support facile &agrave; appr&eacute;hender pour la conception de modules pour l&apos;EDI, ainsi que d&apos;applications riches bas&eacute;es sur la plateforme NetBeans. De nombreux support pour l&apos;extension de l&apos;EDI mais aussi pour la cr&eacute;ation d&apos;applications bas&eacute;es sur la plateforme NetBeans sont fournis. En utilisant les nouveaux mod&egrave;les de Branding dans les assistants New Project et New File, vous pouvez g&eacute;n&eacute;rer tous les fichiers et code dont vous avez besoin. La boite de dialogue, Project Properties vous permet de configurer les d&eacute;pendances au niveau des API, des entr&eacute;es MANIFEST.MF, et d&apos;autres m&eacute;ta-donn&eacute;es concernant le projet. La completion e code et d&apos;autres supports standards, fournit par l&apos;&Eacute;diteur de Source sont &eacute;galement disponibles pour les modules.
</p>

<h2><a name="matisse">&Eacute;diteur Visuel Matisse</a></h2>

<table border="0"><tr><td>
<a href="../../../images_www/screenshots/5.0/Matisse.png"
   title="Matisse GUI Builder Screenshot -- Using Guidelines to Place GUI Elements">
   <img src="../../../images_www/screenshots/5.0/Matisse_305x158.png" width="305" height="158"
   border="2" alt="Matisse GUI Builder Screenshot -- Using Guidelines to Place GUI Elements"
   style="float:right;" hspace="6"></a>

<p>Matisse &eacute;tend l&apos;Editeur Visuel actuel de l&apos;EDI NetBeans 4.1 pour fournir un simple et intuitif layout, sans avoir &agrave; comprendre la complexit&eacute; des gestionnaires de layouts de Swing. Lorsque vous d&eacute;poser des composants dans un Form, l&apos;EDI sugg&egrave;re automatiquement les contraintes d&apos;allignement, d&apos;espae, et de redimensionnage. Contrairement au GridBagLayout, la position est d&eacute;termin&eacute;e par le look and feel de l&apos;application sur laquelle s&apos;ex&eacute;cute l&apos;application. Redimensionnez-l&agrave;, traduisez-l&agrave;, ex&eacute;cutez-l&agrave; sur une plateforme diff&eacute;rente. Votre GUI aura toujours l&apos;air parfait.</p>
<p>Allez voir la <a href="https://netbeans.org/files/documents/4/475/matisse.html">d&eacute;mo flash Matisse </a>.
</p>
</td></tr></table>

<h2><a name="servers">Serveurs</a></h2>

<table border="0"><tr><td>
   <img src="../../../images_www/screenshots/5.0/servers-in-50.png"
   border="0" alt="Server List Screenshot"
   style="float:right;" hspace="6">
<p>Tout comme dans la version pr&eacute;c&eacute;dente, le serveur d&apos;application Sun Java System Application Server 8.1 est support&eacute;, mais ce n&apos;est pas tout -- vous pouvez maintenant enregistrer JBoss 4 et WebLogic 9 dans l&apos;EDI. Lorsque vous faites cela, vous pouvez d&eacute;ployer vos applications web vers ces serveurs, juste comme si vous le d&eacute;ployiez sur le Sun Java System Application Server. En t&ecirc;te de cela, le support pour le Server Web Tomcat a &eacute;t&eacute; am&eacute;lior&eacute;  -- il est maintenant encore plus facile de travaille avec ce serveur. Par exemple, vous pouvez configurer les options de la JVM de Tomcat directement dans l&apos;EDI.</p>
</td></tr></table>

<h2><a name="webframeworks">Web Frameworks</a></h2>

Bien que vous avez toujours &eacute;t&eacute; capable d&apos;utiliser JavaServer Faces (JSF) et Struts dans l&apos;EDI, cela n&apos;a jamais maintenant &eacute;t&eacute; aussi facile. Dans l&apos;EDI NetBeans 5.0, l&apos;assistant New Project a &eacute;t&eacute; &eacute;tendu pour que lorsque vous cr&eacute;ez une application web, vous pouvez sp&eacute;cifier que vous d&eacute;sirez utiliser JSF, Struts, ou les deux. Lorsque vous avez fait votre choix, l&apos;EDI ajoute toutes les biblioth&egrave;ques Struts et/ou JSP &agrave; votre application, ainsi que leurs fichiers de configuration. Lorsque vous utilisez les fichiers de configuration, vous avez la completion de code pour vous venir en aide, ainsi que la possibilit&eacute; d&apos;avoir des entr&eacute;es menus pour cr&eacute;er tous les tags dont ont besoin les fichiers de configuration. L&apos;assistant New File a &eacute;galement &eacute;t&eacute; am&eacute;lior&eacute; -- vous pouvez choisir des mod&egrave;les de documents pour la cr&eacute;ation de JSF Managed Beans, d&apos;Actions Struts, et des Struts Form Beans. Et qu&apos;en est-il de vos applications web existentes ? Pouvez-vous y rajouter le support Struts et/ou JSF ? Oui, bien s&ucirc;r. Utilisez le nouveau panneau &quot;Frameworks&quot; dans la boite de dialogue Project Properties.</p>

<h2><a name="services">Web Services</a></h2>
<table border="0"><tr><td>
<p><a href="../../../images_www/screenshots/5.0/websvc-50.png"
   title="Webservices">
   <img src="../../../images_www/screenshots/5.0/websvc-50_305x91.png" width="305" height="91"
   border="2" alt="Webservices"
   style="float:right;" hspace="6"></a>
La consommation de Web service a &eacute;t&eacute; am&eacute;lior&eacute;e pour que vous puissez maintenant cr&eacute;er des clients web services &eacute;galement dans vos applications J2SE. Toutes les biblioth&egrave;ques n&eacute;c&eacute;ssaires pour cr&eacute;er et d&eacute;ployer un client web service sont livr&eacute;s avec l&apos;EDI, pour que le client web service, cr&eacute;&eacute; dans une application J2SE puisse &ecirc;tre d&eacute;ploy&eacute; sans probl&egrave;me. &Eacute;galement, dans les applications web, vous pouvez maintenant appeler des op&eacute;rations d&apos;un web service directement depuis une page JSP. Vous n&apos;avez m&ecirc;me plus besoin de cr&eacute;er une servlet. Pour terminer, un nouvel assistant, a &eacute;t&eacute; rajout&eacute; -- vous pouvez maintenant cr&eacute;er un fichier WSDL directement dans l&apos;EDI et l&apos;utiliser pour g&eacute;n&eacute;rer vos fichiers de service web.</p>
</td></tr></table>

<h2><a name="completion">Completion de Code</a></h2>

<p>La completion de code de l&apos;&Eacute;diteur est maintenant plus rapide et a &eacute;t&eacute; am&eacute;lior&eacute; pour vous offrir plus de choix pour la completion de code. En plus des classes, m&eacute;thodes, et champs,  vous pouvez g&eacute;n&eacute;rer les extraits de code suivant &agrave; travers la bo&icirc;te de completion de code:
 <ul>
 <li> code depuis les mod&egrave;les de code personalisable  (disponible seulement auparavant comme abbr&eacute;viations &eacute;tendables)
 <li> getters et setters
 <li> classes internes anonymes
 <li> corps de m&eacute;thodes pour les m&eacute;thodes que vous impl&eacute;mentez ou surchargez
 </ul>
De plus, vous pouvez tapez des abbr&eacute;viations de style bosse de chameau (camel case) pour g&eacute;n&eacute;rer du code.  (Par exemple, en tapant <tt>AIOO</tt> et appelant ensuite la bo&icirc;te de completion de code, cela devrait g&eacute;n&eacute;rer <tt>ArrayIndexOutOfBoundsException</tt>). Vous pouvez maintenant &eacute;galement completer le texter et fermer la bo&icirc;te en pressant un point, une virgule ou un point-virgule. Les param&egrave;tres de m&eacute;thode sont maintenant montr&eacute;es sous forme de tooltip.</p>

<h2><a name="RF">Refactoring</a></h2>

<p>NetBeans 5.0 a &eacute;largi le nombre d&apos;action de refactoring disponible. Parmis les nouveaux refactoring inclus :
<ul>
<li> Safe Delete (Effacement s&eacute;curis&eacute;)</li>
<li> Utilisation SuperType lorsque c&apos;est possible</li>
<li> Remonter d&apos;un Niveau Inner vers Outer</li>
<li> Remonter</li>
<li> Descendre</li>
<li> Conversion de Classes Anonymes en Classes Internes</li>
<li> Extraire M&eacute;thode</li>
<li> Extraire Interface</li>
<li> Extraire Super Classe</li>
</ul></p>

<h2><a name="editor">Diverses am&eacute;liorations au sein de l&apos;&eacute;diteur</a></h2>

<table border="0"><tr><td>
<a href="../../../images_www/screenshots/5.0/errorstripe.png"
   title="Error Stripe Screenshot">
   <img src="../../../images_www/screenshots/5.0/errorstripe_305x223.png"
     width="305" height="223"
     border="2" alt="Error Stripe Screenshot"
     style="float:right;" hspace="6"></a>

<p>Ce qui sont sont quelques am&eacute;liorations g&eacute;n&eacute;rales au niveau de l&apos;&eacute;dition. Voir les sections ci-dessus pour des informations quant aux am&eacute;liorations pour la completion de code et les nouvelles op&eacute;rations de refactoring.
<ul>
<li> Conseils Java (indiqu&eacute;e par une ampoule lumineuse) qui vous aide &agrave; g&eacute;n&eacute;rer du code</li>
<li> Palette de composants pour d&eacute;poser des bouts de code HTML, JSP et base de donn&eacute;es sur une page JSP ou une page HTML</li>
<li> Un indicateur d&apos;erreur qui vous dit si votre fichier est compilable ou non, et fournit un aper&ccedil;u de toutes les erreurs, attention, TODO, et signets pr&eacute;sents dans votre code source.</li>
<li> Entoure une construction de style try-catch autour de la commande s&eacute;lectionn&eacute;e</li>
<li> Un nouvel &eacute;diteur SQL am&eacute;lior&eacute;, avec coloration syntaxique</li>
<li> Copier et coller de texte s&eacute;lectionn&eacute; dans l&apos;&eacute;diteur via les mouvements de drag&amp;drop dans l&apos;&eacute;diteur</li><li> Ajout simplifi&eacute; de XML DTDs et XML Schemas pour utiliser dans la completion de code et la validation XML</li>
<li> Navigation XML et indentation automatique am&eacute;lior&eacute;e dans l&apos;&eacute;diteur XML</li>
 <li> Capacit&eacute; de choisir parmis des ensembles de raccourcis pr&eacute;-configur&eacute;s et des palettes de couleurs  (cr&eacute;&eacute;es en accordance avec des environnements bien connus comme Emacs).
</p>
</td></tr></table>

<h2><a name="versioning">Contr&ocirc;le de Version</a></h2>

<table border="0"><tr><td>

   <img src="../../../images_www/screenshots/5.0/versioning_305_128.png"
     width="305" height="128"
     border="1" alt="CVS Versioning Window Screenshot" style="float:right;" hspace="6">
<p>Le support CVS a &eacute;t&eacute; totalement retravaill&eacute; pour s&apos;int&eacute;grer dans votre work-flow. L&apos;EDI reconnait automatiquement les r&eacute;pertoires de travailles CVS et reprend une liste de tous les fichiers modifi&eacute;s dans la fen&ecirc;tre Versioning. Le support de versionning est &eacute;galement int&eacute;gr&eacute; avec le syst&egrave;me de projets et les actions de refactoring.

<p>
La mise &agrave; jour et le Commit de fichiers sont les activit&eacute;s les plus courantes que vous effectuez avec CVS. Vous povez lancez ces actions depuis les fen&ecirc;tres principales de navigation de l&apos;EDI (Projects, Files, et Favorites) ou depuis la fen&ecirc;tre Versioning. Un syst&egrave;me de Badges et de code de couleurs indique le statut actuel des fichiers, dossiers, packages, et projets. Avec la commande Diff, vous pouvez rapidement voir les diff&eacute;rences d&apos;un seul fichier, ou un d&apos;un package, dossier, ou projet complet. Le nouveau support CVS simplifie &eacute;galement le partage des m&eacute;ta-donn&eacute;es de votre projet, ce qui vous permet de non seulement partager vos sources, mais aussi les param&egrave;tres de votre EDI. Voir une d&eacute;mo flash du nouveau support CVS.
</p>
</td></tr></table>

<h2><a name="debugging">D&eacute;bogage</a></h2>
<table border="0"><tr><td>
   <img src="../../../images_www/screenshots/5.0/debugging_305x204.png"
     width="305" height="204"
     border="0" alt="Debugging window"
     style="float:right;" hspace="6"></a>
<p>Le d&eacute;bogage a &eacute;t&eacute; am&eacute;lior&eacute; pour mieux s&apos;int&eacute;grer dans l&apos;&Eacute;diteur de Source. Vous pouvez maintenant activer et d&eacute;sactiver des points d&apos;arr&ecirc;ts dans l&apos;&Eacute;diteur de Soruce m&ecirc;me, et acc&eacute;der aux propri&eacute;t&eacute;s des points d&apos;arr&ecirc;t depuis les annotations de l&apos;&Eacute;diteur. La fen&ecirc;tre Variable a &eacute;galement &eacute;t&eacute; am&eacute;lior&eacute;e pour afficher plus facilement de grands tableaux. La bo&icirc;te de dialogue Evaluate Expression vous permet d&apos;&eacute;valuer toute expression &agrave; la vol&eacute;e. Et vous pouvez maintenant ex&eacute;cuter n&apos;importe quelle m&eacute;thode dans l&apos;&Eacute;diteur de Source. Il y a &eacute;galement un d&eacute;bogueur Ant que vous pouvez utiliser pour avancer pas &agrave; pas &agrave; travers les appels de target, et examiner les status des propri&eacute;t&eacute;s durant l&apos;ex&eacute;cution du script. La fen&ecirc;tre de tests JUnit affiche maintenant les r&eacute;sultats sous forme d&apos;arborescence. Vous pouvez maintenant utliser la completion de code dans les bo&icirc;tes de dialogue New Watch et Breakpoint Customizer.</p>
</td></tr></table>

<h2><a name="ui">D&apos;autres am&eacute;liorations au niveau de l&apos;utilisation </a></h2>

La configuration de l&apos;EDI a &eacute;t&eacute; repens&eacute;e et rendue beaucoup plus user-friendly. Le scanning des classpath des projets se d&eacute;roule maintenant en arri&egrave;re plan. Vous ne devez donc pas attendre que le scanning soit termin&eacute; pour utiliser l&apos;EDI. Le look and feel sur MacOS X a &eacute;t&eacute; &eacute;galement grandement am&eacute;lior&eacute;.

<h2><a name="addon">De nouveaux modules suppl&eacute;mentaires</a></h2>

Le NetBeans <a href="https://netbeans.org/projects/obsolete/">Developer Collaboration</a> vous permet de discuter et d&apos;&eacute;diter du code avec d&apos;autres d&eacute;veloppeurs se trouvant sur le r&eacute;seau. Utilisez le <a href="https://netbeans.org/kb/archive/index.html">Pack de Mobilit&eacute;</a> pour &eacute;crire, tester et d&eacute;boguer des applications pour les appareils mobiles pr&ecirc;ts pour la technologie de la plateform Java Micro Edition (Java ME platform). Le <a href="http://profiler.netbeans.org/">Profileur NetBeans</a> vous aide &agrave; optimiser la m&eacute;moire de vos applications et son utilisation CPU</p>

<h2>R&eacute;f&eacute;rences</h2>

<p>
<h2>Guides to Developing J2EE Applications in NetBeans IDE</h2>

NetBeans IDE 5.0 Quick Start Guides:

<ul>
<li><a href="../../../kb/archive/index.html">For Web Applications</a>
<li><a href="../../../kb/archive/index.html">For Web Services</a>
<li><a href="../../../kb/archive/index.html">For J2EE Applications</a>
<li><a href="../../../kb/archive/index.html">For J2ME MIDP Development</a>

</ul>

NetBeans IDE 5.0 Import Guides:
<ul>
<li><a href="../../../kb/archive/index.html">For Web Applications</a>
<li><a href="../../../kb/archive/index.html">For J2EE Applications</a>
</ul>

<ul>
<li><a href="../../../kb/archive/index.html">Tutoriels, Guides, et Articles</a></li></ul>



</body>
</html>

