Table of Contents | NetBeans IDE Field Guide(c) Developing Desktop, Web, Enterprise, and Mobile Applications

NetBeans™ IDE Field Guide: Developing Desktop, Web, Enterprise, and Mobile Applications, Second Edition
By Patrick Keegan, Ludovic Champenois, Gregory Crawley, Charlie Hunt, Christopher Webster, John Jullion-Ceccarelli, Jiri Prazak, Martin Ryzl, Gregg Sporar, Geertjan Wielenga
...............................................
Publisher: Prentice Hall
Pub Date: May 09, 2006
Print ISBN-10: 0-13-239552-5
Print ISBN-13: 978-0-13-239552-6
Pages: 424

Table of Contents | Index

Foreword to the First Edition

Preface

About the Authors

Acknowledgments for the Second Edition

Acknowledgments for the First Edition

Chapter 1. Download, Installation, and First Project

Downloading the IDE

Installing the IDE

Setting a Proxy

First NetBeans IDE Project

Chapter 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

Chapter 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 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

Compiling a Project

Running a Project in the IDE

Deploying a Java Project Outside of the IDE

Building 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

Chapter 4. Versioning Your Projects

Setting up CVS in NetBeans IDE

Checking Out Sources from a CVS Repository

Putting a Project into CVS

Keeping Track of Changes

Updating Files

Committing Changes

Ignoring Files in CVS Operations

Adding and Removing Files from a Repository

Working with Branches

Working with Patches

Working with Versioning Histories

Working with Other Version Control Systems

Chapter 5. Editing and Refactoring Code

Opening the Source Editor

Managing Automatic Insertion of Closing Characters

Displaying Line Numbers

Generating Code Snippets without Leaving the Keyboard

Using Code Completion

Inserting Snippets from Code Templates

Using Editor Hints to Generate Missing Code

Matching Other Words in a File

Generating Methods to Implement and Override

Generating JavaBeans Component Code

Creating and Using Macros

Creating and Customizing File Templates

Handling Imports

Displaying Javadoc Documentation While Editing

Formatting Code

Text Selection Shortcuts

Navigating within the Current Java File

Navigating from the Source Editor

Searching and Replacing

Deleting Code Safely

Changing a Method's Signature

Encapsulating a Field

Moving a Class to a Different Package

Moving Class Members to Other Classes

Creating a Method from Existing Statements

Creating an Interface from Existing Methods

Extracting a Superclass to Consolidate Common Methods

Changing References to Use a Supertype

Unnesting Classes

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

Chapter 6. Building Java Graphical User Interfaces

Using Different Layout Managers

Placing and Aligning a Component in a Form

Setting Component Size and Resizability

Setting Component Alignment

Specifying Component Behavior and Appearance

Generating Event Listening and Handling Methods

Customizing Generated Code

Previewing a Form

Using Custom Beans in the Form Editor

Deploying GUI Applications Developed with Matisse

Chapter 7. 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

Chapter 8. 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

Chapter 9. Creating Web Applications on the JSF and Struts Frameworks

JSF Overview

Struts Overview

Chapter 10. Introduction to Java EE Development in NetBeans IDE

Configuring the IDE for Java EE Development

Java EE Server Support

Getting the Most from the Java BluePrints Solutions Catalog

Chapter 11. Extending Web Applications with Business Logic: Introducing Enterprise Beans

EJB Project Template 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

Chapter 12. Extending Java EE Applications with Web Services

Consuming Existing Web Services

IDE and Server Proxy Settings

Creating a WSDL File

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

Chapter 13. Developing Full-Scale Java EE Applications

Creating Entity Beans with the Top-Down Approach

Creating Entity Beans with the Bottom-Up Approach

Assembling Enterprise Applications

Importing Existing Enterprise Applications

Consuming Java Enterprise Resources

Java EE Platform and Security Management

Understanding the Java EE Application Server Runtime Environment

Ensuring Java EE Compliance

Refactoring Enterprise Beans

Database Support and Derby Integration

Chapter 14. Developing Java ME Mobile Applications

Downloading and Installing the Mobility Pack

Mobility Primer

Configuration vs. Configuration

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 the Preprocessor

Using Configuration Abilities

Creating and Associating an Ability with a Configuration

Localizing Applications

Using the MIDP Visual Designer

Understanding the Flow Designer

Understanding the Screen Designer

Deploying Your Application Automatically

Incrementing the Application's MIDlet-Version Automatically

Using Ant in Mobility Projects

Using Headless Builds

Using the Wireless Connection Tools

Finding More Information

Chapter 15. Profiling Java Applications

Supported Platforms

Downloading and Installing the NetBeans Profiler

Starting a Profiling Session

The Profiler Control Panel

Monitoring an Application

Analyzing Performance

Analyzing Code Fragment Performance

Analyzing Memory Usage

Attaching the Profiler to a JVM

Chapter 16. 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

Setting up the Profile Project Command for a General Java Application

Changing the Target JDK for a Free-Form Project

Making a Custom Menu Item for a Target

Debugging Ant Scripts

Chapter 17. Developing NetBeans Plug-in Modules

Plug-in Modules

Rich-Client Applications

Extending NetBeans IDE with Plug-in Modules

Setting up a Plug-in Module

Using the NetBeans APIs

Registering the Plug-in Module

Adding a License to a Plug-in Module

Building and Trying Out a Plug-in Module

Packaging and Distributing a Plug-in Module

Packaging and Distributing a Rich-Client Application

Finding Additional Information

Chapter 18. Using NetBeans Developer Collaboration Tools

Getting the NetBeans Developer Collaboration Tools

Configuring NetBeans IDE for Developer Collaboration

Creating a Collaboration Account

Managing Collaboration Accounts

Logging into a Collaboration Server

Collaborating and Interacting with Developers

Appendix A. 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

Appendix B. Importing a JBuilder Project into NetBeans IDE

Getting the JBuilder Project Importer

Importing a JBuilder 2005 Project

Project Import Warnings

Running the Imported Project

Index