Enhanced descriptions from Syndetics:

The Only Complete Guide and Reference for NetBeans(tm) IDE 5.0

The award-winning NetBeans(tm) IDE eases all aspects of Java application development, incorporating a wide range of powerful features into one well-designed package. NetBeans IDE is consistently first in supporting the latest Java technologies for developing desktop, web, enterprise, and mobile applications.

NetBeans(tm) IDE Field Guide provides an introduction to the IDE and an extensive range of topics to help you with both everyday and advanced programming tasks, including Taking advantage of the Ant-based project system to create easily deployable projects Developing web applications with the built-in Apache Tomcat web server Constructing, assembling, and verifying large-scale Java EE applications Managing the Sun Java System Application Server through NetBeans IDE Developing mobile applications with the NetBeans Mobility Pack In this expanded second edition, you can also learn how to Build powerful and attractive desktop applications with the Matisse GUI Builder Profile your applications for performance issues Develop modules for NetBeans IDE and rich-client applications based on the NetBeans Platform Chat and share code with other developers using the NetBeans Collaboration Modules

Table of contents provided by Syndetics

• Foreword to the First Edition (p. xiii)
• Foreword to the First Edition (p. xv)
• Preface (p. xvii)
• About the Authors (p. xxv)
• Acknowledgments for the Second Edition (p. xxvii)
• Acknowledgments for the First Edition (p. xxix)
• Chapter 1 Download, Installation, and First Project (p. 1)
• Downloading the IDE (p. 2)
• Installing the IDE (p. 3)
• Setting a Proxy (p. 3)
• First NetBeans IDE Project (p. 4)
• Chapter 2 NetBeans IDE Fundamentals (p. 9)
• Creating a Project (p. 10)
• Configuring the Classpath (p. 12)
• Creating a Subproject (p. 13)
• Creating and Editing Files (p. 15)
• Setting Up and Modifying Java Packages (p. 17)
• Compiling and Building (p. 18)
• Viewing Project Metadata and Build Results (p. 18)
• Navigating to the Source of Compilation Errors (p. 19)
• Running (p. 20)
• Creating and Running Tests (p. 20)
• Debugging the Application (p. 21)
• Integrating Version Control Commands (p. 22)
• Managing IDE Windows (p. 23)
• Chapter 3 IDE Project Fundamentals (p. 25)
• Introduction to IDE Projects (p. 26)
• Choosing the Right Project Template (p. 28)
• Creating a Project from Scratch (p. 29)
• Importing a Project Developed in a Different Environment (p. 33)
• Navigating Your Projects (p. 37)
• Working with Files Not in the Project (p. 41)
• Creating Packages and Files in the Project (p. 42)
• Configuring the Project's Classpath (p. 44)
• Changing the Version of the JDK Your Project Is Based On (p. 45)
• Changing the Target JDK for a Standard Project (p. 46)
• Referencing JDK Documentation (Javadoc) from the Project (p. 46)
• Adding Folders and JAR Files to the Classpath (p. 47)
• Making External Sources and Javadoc Available in the IDE (p. 47)
• Structuring Your Projects (p. 48)
• Displaying and Hiding Projects (p. 50)
• Compiling a Project (p. 50)
• Running a Project in the IDE (p. 55)
• Deploying a Java Project Outside of the IDE (p. 57)
• Building a Project from Outside of the IDE (p. 59)
• Customizing the IDE-Generated Build Script (p. 60)
• Running a Specific Ant Target from the IDE (p. 64)
• Completing Ant Expressions (p. 64)
• Making a Menu Item or Shortcut for a Specific Ant Target (p. 65)
• Chapter 4 Versioning Your Projects (p. 69)
• Setting up CVS in NetBeans IDE (p. 70)
• Checking Out Sources from a CVS Repository (p. 71)
• Putting a Project into CVS (p. 74)
• Keeping Track of Changes (p. 76)
• Updating Files (p. 80)
• Committing Changes (p. 80)
• Ignoring Files in CVS Operations (p. 81)
• Adding and Removing Files from a Repository (p. 82)
• Working with Branches (p. 82)
• Working with Patches (p. 85)
• Working with Versioning Histories (p. 87)
• Working with Other Version Control Systems (p. 89)
• Chapter 5 Editing and Refactoring Code (p. 91)
• Opening the Source Editor (p. 92)
• Managing Automatic Insertion of Closing Characters (p. 93)
• Displaying Line Numbers (p. 94)
• Generating Code Snippets without Leaving the Keyboard (p. 94)
• Using Code Completion (p. 96)
• Inserting Snippets from Code Templates (p. 100)
• Using Editor Hints to Generate Missing Code (p. 108)
• Matching Other Words in a File (p. 109)
• Generating Methods to Implement and Override (p. 110)
• Generating JavaBeans Component Code (p. 111)
• Creating and Using Macros (p. 112)
• Creating and Customizing File Templates (p. 113)
• Handling Imports (p. 115)
• Displaying Javadoc Documentation While Editing (p. 116)
• Formatting Code (p. 116)
• Text Selection Shortcuts (p. 120)
• Navigating within the Current Java File (p. 120)
• Navigating from the Source Editor (p. 124)
• Searching and Replacing (p. 126)
• Deleting Code Safely (p. 131)
• Changing a Method's Signature (p. 135)
• Encapsulating a Field (p. 136)
• Moving a Class to a Different Package (p. 138)
• Moving Class Members to Other Classes (p. 139)
• Creating a Method from Existing Statements (p. 141)
• Creating an Interface from Existing Methods (p. 142)
• Extracting a Superclass to Consolidate Common Methods (p. 143)
• Changing References to Use a Supertype (p. 145)
• Unnesting Classes (p. 146)
• Tracking Notes to Yourself in Your Code (p. 148)
• Comparing Differences Between Two Files (p. 150)
• Splitting the Source Editor (p. 151)
• Maximizing Space for the Source Editor (p. 151)
• Changing Source Editor Keyboard Shortcuts (p. 152)
• Chapter 6 Building Java Graphical User Interfaces (p. 153)
• Using Different Layout Managers (p. 156)
• Placing and Aligning a Component in a Form (p. 157)
• Setting Component Size and Resizability (p. 159)
• Setting Component Alignment (p. 160)
• Specifying Component Behavior and Appearance (p. 161)
• Generating Event Listening and Handling Methods (p. 162)
• Customizing Generated Code (p. 165)
• Previewing a Form (p. 166)
• Using Custom Beans in the Form Editor (p. 166)
• Deploying GUI Applications Developed with Matisse (p. 167)
• Chapter 7 Debugging Java Applications (p. 169)
• Starting a Debugging Session (p. 171)
• Attaching the Debugger to a Running Application (p. 175)
• Starting the Debugger Outside of the Project's Main Class (p. 177)
• Stepping through Code (p. 177)
• Setting Breakpoints (p. 181)
• Managing Breakpoints (p. 185)
• Customizing Breakpoint Behavior (p. 186)
• Monitoring Variables and Expressions (p. 189)
• Backing up from a Method to Its Call (p. 192)
• Monitoring and Controlling Execution of Threads (p. 192)
• Fixing Code During a Debugging Session (p. 194)
• Viewing Multiple Debugger Windows Simultaneously (p. 195)
• Chapter 8 Developing Web Applications (p. 197)
• Representation of Web Applications in the IDE (p. 199)
• Adding Files and Libraries to Your Web Application (p. 203)
• Editing and Refactoring Web Application Files (p. 208)
• Deploying a Web Application (p. 214)
• Testing and Debugging Your Web Application (p. 217)
• Creating and Deploying Applets (p. 219)
• Changing the IDE's Default Web Browser (p. 223)
• Monitoring HTTP Transactions (p. 224)
• Chapter 9 Creating Web Applications on the JSF and Struts Frameworks (p. 233)
• JSF Overview (p. 234)
• Struts Overview (p. 240)
• Chapter 10 Introduction to Java EE Development in NetBeans IDE (p. 251)
• Configuring the IDE for Java EE Development (p. 252)
• Java EE Server Support (p. 255)
• Getting the Most from the Java BluePrints Solutions Catalog (p. 257)
• Chapter 11 Extending Web Applications with Business Logic: Introducing Enterprise Beans (p. 267)
• EJB Project Template Wizards (p. 269)
• Adding Enterprise Beans, Files, and Libraries to Your EJB Module (p. 272)
• Adding Business Logic to an Enterprise Bean (p. 275)
• Adding a Simple Business Method (p. 276)
• Enterprise Bean Deployment Descriptors (p. 280)
• Chapter 12 Extending Java EE Applications with Web Services (p. 283)
• Consuming Existing Web Services (p. 284)
• IDE and Server Proxy Settings (p. 291)
• Creating a WSDL File (p. 292)
• Implementing a Web Service in a Web Application (p. 292)
• Implementing Web Services within an EJB Module (p. 300)
• Testing Web Services (p. 301)
• Adding Message Handlers to a Web Service (p. 304)
• Chapter 13 Developing Full-Scale Java EE Applications (p. 311)
• Creating Entity Beans with the Top-Down Approach (p. 313)
• Creating Entity Beans with the Bottom-Up Approach (p. 321)
• Assembling Enterprise Applications (p. 324)
• Importing Existing Enterprise Applications (p. 328)
• Consuming Java Enterprise Resources (p. 333)
• Java EE Platform and Security Management (p. 341)
• Understanding the Java EE Application Server Runtime Environment (p. 347)
• Ensuring Java EE Compliance (p. 355)
• Refactoring Enterprise Beans (p. 357)
• Database Support and Derby Integration (p. 359)
• Chapter 14 Developing Java ME Mobile Applications (p. 363)
• Downloading and Installing the Mobility Pack (p. 364)
• Mobility Primer (p. 364)
• Configuration vs. Configuration (p. 366)
• Setting up Mobility Projects (p. 366)
• Creating a Project from Scratch (p. 366)
• Importing a Project (p. 367)
• Physical Structure of Mobile Projects (p. 369)
• Using Mobility File Templates (p. 370)
• Configuring the Project's Classpath (p. 372)
• Debugging Your Project (p. 376)
• Configuring Your Project for Different Devices (p. 377)
• Setting the Active Configuration for Your Project (p. 379)
• Reusing Project Settings and Configurations (p. 380)
• Structuring Project Dependencies (p. 382)
• Managing the Distribution JAR File Content (p. 383)
• Handling Project Resources for Different Configurations (p. 384)
• Writing Code Specific to a List of Configurations (p. 385)
• Using the Preprocessor (p. 387)
• Using Configuration Abilities (p. 397)
• Creating and Associating an Ability with a Configuration (p. 398)
• Localizing Applications (p. 400)
• Using the MIDP Visual Designer (p. 402)
• Understanding the Flow Designer (p. 405)
• Understanding the Screen Designer (p. 413)
• Deploying Your Application Automatically (p. 414)
• Incrementing the Application's MIDlet-Version Automatically (p. 417)
• Using Ant in Mobility Projects (p. 417)
• Using Headless Builds (p. 421)
• Using the Wireless Connection Tools (p. 422)
• Finding More Information (p. 426)
• Chapter 15 Profiling Java Applications (p. 427)
• Supported Platforms (p. 428)
• Downloading and Installing the NetBeans Profiler (p. 429)
• Starting a Profiling Session (p. 429)
• The Profiler Control Panel (p. 432)
• Monitoring an Application (p. 435)
• Analyzing Performance (p. 437)
• Analyzing Code Fragment Performance (p. 442)
• Analyzing Memory Usage (p. 443)
• Attaching the Profiler to a JVM (p. 447)
• Chapter 16 Integrating Existing Ant Scripts with the IDE (p. 449)
• Creating a Free-Form Project (p. 451)
• Mapping a Target to an IDE Command (p. 453)
• Setting up the Debug Project Command for a General Java Application (p. 455)
• Setting up the Debug Project Command for a Web Application (p. 457)
• Setting up Commands for Selected Files (p. 462)
• Setting up the Compile File Command (p. 463)
• Setting up the Run File Command (p. 466)
• Setting up the Debug File Command (p. 468)
• Setting up the Debugger's Apply Code Changes Command (p. 470)
• Setting up the Profile Project Command for a General Java Application (p. 471)
• Changing the Target JDK for a Free-Form Project (p. 472)
• Making a Custom Menu Item for a Target (p. 473)
• Debugging Ant Scripts (p. 473)
• Chapter 17 Developing NetBeans Plug-in Modules (p. 477)
• Plug-in Modules (p. 478)
• Rich-Client Applications (p. 478)
• Extending NetBeans IDE with Plug-in Modules (p. 480)
• Setting up a Plug-in Module (p. 481)
• Using the NetBeans APIs (p. 486)
• Registering the Plug-in Module (p. 496)
• Adding a License to a Plug-in Module (p. 497)
• Building and Trying Out a Plug-in Module (p. 499)
• Packaging and Distributing a Plug-in Module (p. 500)
• Packaging and Distributing a Rich-Client Application (p. 502)
• Finding Additional Information (p. 504)
• Chapter 18 Using NetBeans Developer Collaboration Tools (p. 507)
• Getting the NetBeans Developer Collaboration Tools (p. 508)
• Configuring NetBeans IDE for Developer Collaboration (p. 509)
• Creating a Collaboration Account (p. 510)
• Managing Collaboration Accounts (p. 514)
• Logging into a Collaboration Server (p. 518)
• Collaborating and Interacting with Developers (p. 519)
• Appendix A Importing an Eclipse Project into NetBeans IDE (p. 527)
• Getting the Eclipse Project Importer (p. 528)
• Choosing Between Importing with and Importing without Project Dependencies (p. 529)
• Importing an Eclipse Project and Preserving Project Dependencies (p. 529)
• Importing an Eclipse Project and Ignoring Project Dependencies (p. 532)
• Handling Eclipse Project Discrepancies (p. 534)
• Handling Eclipse Project Reference Problems (p. 534)
• Appendix B Importing a JBuilder Project into NetBeans IDE (p. 537)
• Getting the JBuilder Project Importer (p. 538)
• Importing a JBuilder 2005 Project (p. 538)
• Project Import Warnings (p. 539)
• Running the Imported Project (p. 540)
• Index (p. 541)

Excerpt provided by Syndetics

Welcome to the second edition of the NetBeans™ IDE Field Guide ! This book is designed both as an introduction to NetBeans IDE and as a task reference, something that you can pick up from time to time to get an answer to a question or to find new ways to take advantage of the IDE's possibilities. Whether NetBeans is your first IDE or your fifth, this book can help you make the most of the IDE. This edition is updated and expanded to cover the following features, some of which are brand new in NetBeans IDE 5.0: Matisse GUI builder The IDE's new and improved CVS support New editing and refactoring features Support for developing on the JSF and Struts web frameworks Support for creating plug-in modules for NetBeans IDE and standalone applications based on the NetBeans platform Support for profiling applications for performance problems What Is NetBeans IDE? NetBeans IDE is a free-of-charge integrated development environment (IDE) primarily focused on making it easier to develop Java applications. It provides support for all types of Java applications, from rich desktop clients to multi-tier enterprise applications to applications for Java-enabled handheld devices. NetBeans IDE has a modular architecture that allows for plug-ins. However, the range of features in the basic installation is so rich that you can probably can start using the IDE for your work without worrying about plug-ins at all.The IDE itself is written in Java, so you can run it on any operating system for which there is a Java 2 Standard Edition JDK (version 1.4.2, version 5.0, or later) available. Click-through installers are available for Microsoft Windows, Solaris, Linux, Mac OS, and other systems. You can also download the IDE as a ZIP or TAR file if you want to install it on an operating system other than the ones listed here. The IDE's basic job is to make the edit-compile-debug cycle much smoother by integrating the tools for these activities. For example, the IDE: Identifies coding errors almost immediately and marks them in the Source Editor. Helps you code faster with code completion, code template, word matching, and fix import features. Provides visual navigation aids, such as the Navigator window and "code folding," as well as numerous keyboard navigation shortcuts designed especially for Java programmers. Can display documentation for a class as you are typing in the Source Editor. Hot-links compilation errors in the Output window, so you can jump straight to the source by double-clicking the line or pressing F12. Manages package names and references to other classes. When you rename or move classes around, the IDE identifies places in the code that are affected by these changes and enables you to have the IDE generate the appropriate changes to those files. Has many debugging features that provide a comprehensive view of the way your code is working as it runs. You can set breakpoints (which persist from session to session) and keep your code free of clutter (such as println statements). Helps you integrate other parts of your workflow, such as checking sources in to and out from a version control system. You can also download the NetBeans Profiler to augment the traditional edit-compile-debug cycle with performance profiling. What Makes NetBeans IDE Special When you use NetBeans IDE, you get the benefits of a top-shelf IDE without the negatives that you might associate with moving your development to a single environment. Like other integrated development environments, NetBeans IDE provides a graphical user interface for command-line tools that handle the compiling, debugging, and packaging of applications. Unlike other IDEs, NetBeans IDE does not force a build structure on you with project metadata that you need to reverse engineer if you are to build the project outside of the IDE. NetBeans IDE builds on existing open standards to help you automate your development process without locking you in. NetBeans IDE (beginning with version 4.0) bases its whole project system on Ant, which is the de facto standard build tool for Java applications. The project metadata that NetBeans IDE produces is in the form of XML and properties files that can be used by Ant outside of the IDE. Thus, developing a project in NetBeans IDE does not lock you or co-developers into NetBeans IDE. You can use NetBeans IDE to create large projects with sophisticated build parameters. Where you already have such projects in place, you can adapt NetBeans IDE to work with them without necessarily changing the project's structure. If you are generally more comfortable with command-line tools because of their transparency and the level of control they allow you over your projects, NetBeans IDE could become the first IDE that you love. NetBeans IDE is also consistently ahead of the curve in providing support for new and evolving standards, such as the new language features that were introduced in the Java SE 5 JDK and new specifications in all areas of Java technology. NetBeans IDE provides an astonishing array of features right out of the box. NetBeans has a fully featured Java EE platform development environment built in. All the editor, debugger, and project support that is available for Java application development is also available for Java EE development. In addition, NetBeans IDE provides access to the Java BluePrints Solutions Catalog and the ability to install them as NetBeans projects. The Mobility Pack, available as a free add-on installer, enables Java ME developers to design, develop, and debug MIDlets from within NetBeans IDE. Providing one of the most powerful sets of mobile development tools, the Mobility Pack includes a flow designer to visually lay out the application logic, a screen designer to create the user interface, an integrated device fragmentation solution, and tools for building client server applications. The NetBeans Profiler, also available as a free add-on installer, makes application performance profiling accessible to developers. What Comes with NetBeans IDE Besides providing support for coding, NetBeans IDE comes bundled with other tools and libraries that you might already use in your production environment. The IDE integrates these tools into the IDE workflow, but you can also use them at the command line. Out of the box with NetBeans IDE 5.0, you get: Apache Ant 1.6.5 Tomcat 5.5.9 JUnit 3.8.1 Java BluePrints Solutions Catalog If you download the Mobility Modules pack, you also get the Wireless Toolkit. You can also get NetBeans IDE in a bundle with the Java SE JDK or the Sun Java System Application Server Platform Edition. If you download the NetBeans Profiler, you also get a full-featured, nonintrusive Java profiler that is based on profiling technology developed at Sun Labs. What This Book Will Do for You This book was written with both new and existing NetBeans IDE users in mind. If you are new to NetBeans IDE (or IDEs in general), this book will quickly guide you through the basics and advantages of using NetBeans IDE. Learn how to take advantage of the IDE's layout and feature integration to tighten up the basic edit-compile-debug cycle. Learn how to take advantage of the IDE's support for increasingly popular advanced technologies such as web services and Java EE technology to add new capabilities to your applications. If you are already familiar with NetBeans IDE, this book will provide a new perspective on what you already know and possibly point you to useful features that you have not yet discovered. Learn how you can customize the IDE to work with complex build structures. If you are looking to move from client-server web applications to multi-tier transactional enterprise applications, this book will help you make that jump. This book does not teach the Java programming language. Much of the material in this book is meaningful only if you have some experience with programming Java applications. However, this book could be a useful companion if you are expanding your Java technology palette into Java EE technology and other advanced areas. How to Use This Book NetBeans IDE is overflowing with features, so quite a bit can be written about it. NetBeans™ IDE Field Guide sorts out the essentials so that you can get productive quickly and then adds a generous selection of tips and advanced information. This book is primarily designed as a task-reference with short topics on accomplishing specific tasks. If you wish, you can read the book from cover to cover, but most likely you will want to keep it near your computer to get answers to pressing questions or simply to read up on ways to get more out of your work with the IDE. The topics are written in a way that allows you to skip all over the book to get answers to the specific questions you have without having to follow long end-to-end examples. Chapter 1 provides the information you need to install NetBeans IDE and to set up your first project. Chapter 2 provides an overview of the IDE environment and the basic tasks for developing general Java projects. If you have never used NetBeans IDE, you will probably want to read this chapter from beginning to end. Chapter 3 provides in-depth information on setting up and configuring projects. Although this chapter is mostly geared toward general Java applications, a working knowledge of the information in this chapter will be useful for developing Java EE and Java ME applications as well. Chapter 4 covers the IDE's unique and powerful client for the CVS version control system. Chapter 5 provides useful tips and tricks for making your day-to-day coding more productive, such as using editor hints, code completion, code templates, and refactoring features. Chapter 6 shows you how to use the IDE's powerful Project Matisse GUI builder to easily create visual desktop applications. Chapter 7 provides an overview of the IDE's rich set of debugging features and displays practical techniques for finding problem areas in your code. Chapter 8 covers development of web applications, with a focus on developing with the Tomcat web server. Chapter 9 provides an overview of the IDE's support for the JavaServer Faces (JSF) and Struts web application frameworks.There are several chapters devoted to Java EE topics. You should begin with Chapter 10, Introduction to Java EE Development in NetBeans IDE, to get information on setting up your environment and learning how to leverage the Java BluePrints Solutions catalog in Java EE development. If you are familiar with web application development and would like to learn how to extend it into using Java EE Enterprise JavaBeans components, you should read Chapter 11, Extending Web Applications with Business Logic: Introducing EJB Components. If you are interested in learning how to extend your Java EE applications to include web services, you should read Chapter 12, Extending Java EE Applications with Web Services. Chapter 13, Developing Full-Scale Java EE Applications, contains in-depth information on developing entity beans, assembling applications, verifying Java EE compliance, and other topics. Chapter 14 covers special IDE features for using the NetBeans Mobility Pack to develop Java ME applications for handheld devices. Chapter 15 walks you through use of the NetBeans Profiler to detect memory leaks and find code that is slowing down your application. Chapter 16 provides information for taking advantage of NetBeans IDE's unique Ant integration to use the IDE with existing intricate build environments. Chapter 17 shows you the process of creating a plug-in module for NetBeans IDE and also provides information on using the NetBeans Platform as a framework for creating rich client applications. Chapter 18 shows you how to use the IDE's unique Developer Collaboration modules to chat and share code with other developers in real time. The appendices show you how to get and use project importers to simplify migration of projects from the Eclipse and JBuilder environments into NetBeans IDE. NetBeans as Platform and Open-Source Project Besides being an IDE, NetBeans is also a 100% pure Java open-source platform. You can develop plug-in modules for NetBeans IDE or create an entirely different application built on top of a small core of the modules that make up the IDE. Because NetBeans is 100% pure Java, any platform that supports a Java Virtual Machine will run NetBeans IDE. Hence, any plug-in module or application that extends NetBeans and that is 100% pure Java will also execute on any platform for which there is a Java Virtual Machine. Chapter 17 of this book addresses developing modules for the IDE and using the NetBeans platform as an application framework. Excerpted from NetBeans IDE Field Guide: Developing Desktop, Web, Enterprise, and Mobile Applications by Patrick Keegan, Ludovic Champenois, Gregory Crawley, Charlie Hunt, Christopher Webster All rights reserved by the original copyright owners. Excerpts are provided for display purposes only and may not be reproduced, reprinted or distributed without the written permission of the publisher.

Author notes provided by Syndetics

Patrick Keegan is one of the technical writers for NetBeans IDE
Ludovic Champenois is a senior architect at Sun Microsystems
Gregory Crawley continues to be an avid NetBeans IDE user and developer of J2ME games in association with Cotopia Wireless
Charlie hunt is a Java performance engineer at Sun Microsystems
Christopher Webster, a member of the NetBeans Enterprise Pack development team, focuses on service-oriented architecture (SOA) development tools