NetBeans™ IDE Field Guide

Patrick Keegan is one of the technical writers for NetBeans IDE. He has been writing about the IDE since May 1999, when NetBeans was a small Czech company yet to be acquired by Sun Microsystems. Ludovic Champenois is a senior architect at Sun Microsystems. He has been with Sun for more than a decade, and is currently the tech lead and architect for NetBeans J2EE support. Gregory Crawley conceptualized and implemented the Mobility device fragmentation solution for NetBeans IDE 4.0. He 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. He has been working with Java since 1997 and has held many other positions at Sun, including Java Architect and NetBeans Technology Evangelist. Christopher Webster, a member of the NetBeans Enterprise Pack development team, focuses on service-oriented architecture (SOA) development tools. Before joining Sun, Chris was a computer scientist at the Lawrence Livermore National Laboratory.

Foreword by James Gosling.

Foreword by Bill Shannon.

Preface.

About the Authors.

Acknowledgments.

1. Download, Installation, and First Project.

    Downloading the IDE

    Installing the IDE

    Setting a Proxy

    First NetBeans IDE Project

2. NetBeans IDE Fundamentals.

    Creating a Project

    Configuring the Classpath

    Creating a Subproject

    Creating and Editing Files

    Setting Up and Modifying Java Packages

    Compiling and Building

    Viewing Project Metadata and Build Results

    Navigating to the Source of Compilation Errors

    Running

    Creating and Running Tests

    Debugging the Application

    Integrating Version Control Commands

    Managing IDE Windows

3. IDE Project Fundamentals.

    Introduction to IDE Projects

    Choosing the Right Project Template

    Creating a Project from Scratch

    Importing a Project Developed in a Different Environment

    Navigating Your Projects

    Working with Files Not in the Project

    Creating Packages and Files in the Project

    Configuring the Project's Classpath

    Changing the Version of the JDK That Your Project Is Based On

    Changing the Target JDK for a Standard Project

    Referencing JDK Documentation (Javadoc) from the Project

    Adding Folders and JAR Files to the Classpath

    Making External Sources and Javadoc Available in the IDE

    Structuring Your Projects

    Displaying and Hiding Projects

    Setting Up a Project to Work with Version Control

    Compiling a Project

    Running a Project

    Writing Your Own Manifest for Your JAR File

    Filtering Contents Packaged into Outputs

    Running a Project from Outside of the IDE

    Customizing the IDE-Generated Build Script

    Running a Specific Ant Target from the IDE

    Completing Ant Expressions

    Making a Menu Item or Shortcut for a Specific Ant Target

4. Editing and Refactoring Code.

    Opening the Source Editor

    Managing Automatic Insertion of Closing Characters

    Displaying Line Numbers

    Generating Code Snippets

    Handling Imports

    Displaying Javadoc Documentation While Editing

    Formatting Code

    Navigating within the Current Java File

    Navigating from the Source Editor

    Searching and Replacing

    Moving a Class to a Different Package

    Changing a Method's Signature

    Tracking Notes to Yourself in Your Code

    Comparing Differences Between Two Files

    Splitting the Source Editor

    Maximizing Space for the Source Editor

    Changing Source Editor Keyboard Shortcuts

    Building Rich Clients

5. Debugging Java Applications.

    Starting a Debugging Session

    Attaching the Debugger to a Running Application

    Starting the Debugger Outside of the Project's Main Class

    Stepping Through Code

    Setting Breakpoints

    Managing Breakpoints

    Customizing Breakpoint Behavior

    Monitoring Variables and Expressions

    Backing Up from a Method to Its Call

    Monitoring and Controlling Execution of Threads

    Fixing Code During a Debugging Session

    Viewing Multiple Debugger Windows Simultaneously

6. Developing Web Applications.

    Representation of Web Applications in the IDE

    Adding Files and Libraries to Your Web Application

    Editing and Refactoring Web Application Files

    Deploying a Web Application

    Testing and Debugging Your Web Application

    Creating and Deploying Applets

    Changing the IDE's Default Web Browser

    Monitoring HTTP Transactions

7. Introduction to J2EE Development in NetBeans IDE.

    Configuring the IDE for J2EE Development

    Getting the Most from the Java BluePrints Solutions Catalog

8. Extending Web Applications with Business Logic: Introducing Enterprise Beans.

    EJB Project Type Wizards

    Adding Enterprise Beans, Files, and Libraries to Your EJB Module

    Adding Business Logic to an Enterprise Bean

    Adding a Simple Business Method

    Enterprise Bean Deployment Descriptors

9. Extending J2EE Applications with Web Services.

    Consuming Existing Web Services

    Implementing a Web Service in a Web Application

    Implementing Web Services within an EJB Module

    Testing Web Services

    Adding Message Handlers to a Web Service

10. Developing Full-Scale J2EE Applications.

    Creating Entity Beans with the Top-Down Approach

    Creating Entity Beans with the Bottom-Up Approach

    Assembling J2EE Applications

    Importing Existing J2EE Applications

    Consuming J2EE Resources

    J2EE and Security Management

    Understanding the J2EE Application Server Runtime Environment

    Ensuring J2EE Compliance

    Refactoring Enterprise Beans

11. Developing J2ME Mobility Applications.

    Downloading and Installing the Mobility Pack

    Setting Up Mobility Projects

    Creating a Project from Scratch

    Importing a Project

    Physical Structure of Mobile Projects

    Using Mobility File Templates

    Configuring the Project's Classpath

    Debugging Your Project

    Configuring Your Project for Different Devices

    Setting the Active Configuration for Your Project

    Reusing Project Settings and Configurations

    Structuring Project Dependencies

    Managing the Distribution JAR File Content

    Handling Project Resources for Different Configurations

    Writing Code Specific to a List of Configurations

    Using Configuration Abilities

    Creating and Associating an Ability with a Configuration

    Localizing Applications

    Using the MIDP Visual Designer

    Deploying Your Application Automatically

    Incrementing the Application's MIDlet-Version Automatically

    Installing Nonstandard Emulator Platforms

    Using Ant in Mobility Projects

    Using Headless Builds

    Finding More Information

12. Integrating Existing Ant Scripts with the IDE.

    Creating a Free-Form Project

    Mapping a Target to an IDE Command

    Setting Up the Debug Project Command for a General Java Application

    Setting Up the Debug Project Command for a Web Application

    Setting Up Commands for Selected Files

    Setting Up the Compile File Command

    Setting Up the Run File Command

    Setting Up the Debug File Command

    Setting Up the Debugger's Apply Code Changes Command

    Changing the Target JDK for a Free-Form Project

    Making a Custom Menu Item for a Target

    Debugging Ant Scripts

Appendix: Importing an Eclipse Project into NetBeans IDE.

    Getting the Eclipse Project Importer

    Choosing Between Importing with and Importing without Project Dependencies

    Importing an Eclipse Project and Preserving Project Dependencies

    Importing an Eclipse Project and Ignoring Project Dependencies

    Handling Eclipse Project Discrepancies

    Handling Eclipse Project Reference Problems

Index.