NetBeans: The Definitive Guide: Developing, Debugging, and Deploying Java Code

by Tim Boudreau, Jesse Glick, Simeon Greene, Vaughn Spurlin, Jack J. Woehr

Overview

As the Java programming language has increased in both functionality and complexity, developers have demanded more of their program editors. Gone are the days when a simple visual editor is sufficient for even small programming projects. While there are numerous IDEs available today for use by Java developers, one stands above the rest, not only for its functionality, but for its extensibility: NetBeans.In NetBeans: The Definitive Guide, you'll find out how to use this IDE to its fullest, making your Java programming more efficient and productive than ever before. You'll understand the basics of the IDE, and quickly be utilizing the various editor and explorer windows. You'll also master many of NetBeans advanced features, and be working with XML documents, CVS repositories, Javadoc trees, and web applications, all within the NetBeans framework.In addition to teaching you how to use the existing features of NetBeans, this work goes on to cover developing additional modules for NetBeans. Through this instructional portion of the book, you will master the NetBeans APIs, and learn how to enhance NetBeans for your own specific needs. Whether you need to add customized behavior to handle your proprietary file formats, or want to redistribute NetBeans as a proprietary product, NetBeans: The Definitive Guide will allow you to master this open source IDE and all of its advanced features. Whether you are an enterprise developer looking for an IDE that can handle your complex program tasks, an open source developer looking to integrate NetBeans into your own visual projects, or a manager trying to maximize your team's development potential,NetBeans: The Definitive Guide is the book for you.

Product Details

ISBN-13:	9781449332556
Publisher:	O'Reilly Media, Incorporated
Publication date:	10/22/2002
Sold by:	Barnes & Noble
Format:	eBook
Pages:	674
File size:	9 MB

About the Author

is a native of Massachusetts who has worked in the IT industry as a developer, writer, graphic artist on and off since the age of twelve. Following a hiatus as a literary theory major and musician, he returned to the world of computers at the age of 23 in response to the marvelous career opportunities for a student of literature during a recession, and the clamour of the IT world for his return. In the spring of 1999, he moved to the Czech Republic to work for a small company called NetBeans, which was soon to be acquired by Sun Microsystems, where he still lives and works. Tim can be found at most times perched with an underpowered laptop, deep in ascetic concentration in his monastic quarters high in the towers of Sun Microsystems in Prague. He is occasionally led outside, blinking in the twilight, to belt out blues tunes in smoky bars, on the advice of his physicians and Sun Microsystems' "Great Place to Work" program.

has worked on NetBeans since January 1999 in several capacities, including developing NetBeans core software, editing API documentation, and providing assistance for integrators. He joined Sun with the acquisition of NetBeans in the fall of 1999. He has spoken twice at JavaOne on NetBeans module development.

currently lives with his wife Nikki in Philadelphia PA, but is originally from the sunny island republic of Trinidad and Tobago. In the pursuit of money, education and all else that corrupts, he left his island paradise and currently works as a developer for Hewlett-Packard. Although he misses tropical breezes and an idyllic lifestyle, he enjoys being a software developer and the opportunity to work with interesting technical people like those on the NetBeans project. Besides technology, Simeon also enjoys poetry, classical literature, travel and underground hip-hop - of course.

began his programming career in 1967 on the physically largest computer ever built, the SAGE system's house-sized AN/FSQ-7. A freelance consultant since 1975, he worked with a wide range of computer hardware and languages, including several early personal computers before they were known as such. Vaughn currently writes technical articles about Sun ONE Studio and develops training materials for Sun.

Table of Contents

	Preface	xiii
1.	Getting and Installing the IDE	1
	Platforms and Requirements	1
	Getting and Installing a JDK	2
	Which IDE Distribution?	3
	Installing Binary Distributions	5
	Building the IDE from Source (Simple Builds)	6
	Running the IDE	9
	Updating the IDE Automatically	14
	You're Now Running NetBeans	16
2.	Concepts and Paradigms	18
	NetBeans and the Java Abstract Model of Computing	18
	Explorer	19
	Creating Packages and Classes	38
	Services	41
	Workspaces	45
	Project Management	47
	Object Browser	50
	Summary	52
3.	Working with the Source Editor	53
	Why Learn a New Editor?	53
	Opening the Source Editor	53
	Context Menus	54
	Closing the Source Editor	54
	Code Completion	55
	Editor Colorings	57
	Shortcuts	59
	Word Matching	60
	Indentation Engines and Code Formatting	60
	Automatic Edits	61
	Other Editor Functionality	62
	A Simple Example	62
4.	Debugging	66
	Debugger Types	66
	Breakpoint Types	67
	Adding and Removing Breakpoints	68
	Setting Watches	71
	Starting the Debugger	72
	The Debugger Window	74
	The Variables View	76
	Remote Debugging in NetBeans	76
5.	Compilation and Execution Services	80
	Using Custom Compilation and Execution Services	80
	Associating Services with Java Files	87
	Building with Ant	88
6.	Customizing the Environment	93
	The Setup Wizard	93
	The Tools[right arrow]Options Dialog	97
	Configuring Toolbars	98
	Configuring Menus	100
	Configuring Editors	100
	Command Line Options	109
	Modules	111
7.	Using Source Control (CVS)	115
	What Is CVS?	115
	The How, When, and Why of CVS in NetBeans	117
	Mounting CVS Sources	120
	Exploring Versioned Sources	121
	Common CVS Operations	122
	Unexpected Results	125
	Uncommon CVS Operations	127
	Mounting a Generic Versioning System	128
	One Final Tip	130
8.	GUI Building	132
	Creating a GUI Frame or Panel	132
	Adding Components to a GUI Container	135
	Configuring Components	137
	Building Menus	138
	Changing a Container's Layout	139
	Working with Borders	139
	Accessibility	140
	Copying a Source Object	141
	The Connection Wizard	141
	The GridBagLayout Customizer	143
	Adding Event Handlers	146
	Using the Code Generation Properties	148
	Working Around Code Generation	150
	Containers Within Containers	151
	Building Complex GUIs	152
9.	JavaBeans	154
	Why Should I Make Beans?	154
	Creating JavaBeans	154
	Component Palette	165
10.	Using Javadoc	168
	Javadoc Support in NetBeans	168
	Mounting Javadocs	168
	The Javadoc Search Tool	169
	Creating Javadoc	172
11.	Working with XML	180
	Installing XML Support	180
	Overview	180
	XML Editors	182
	Beyond Editing XML	184
	Generating Java Classes	189
12.	Developing Web Applications	198
	Why the IDE Supports Web Application Development	198
	How the IDE Provides Web Application Support	198
	Creating a Web Application	199
	Working with JSP and HTML Files	202
	Advanced Web Applications Features	204
	Packaging and Deploying Web Applications	206
13.	Extending NetBeans	208
	What's Different About NetBeans?	209
	The Core and the Open APIs	210
	NetBeans for Bean Counters	215
	Getting and Installing the Open APIs Support Module	216
	Life Is Change	217
	Source Code for the Examples	217
14.	Understanding the NetBeans APIs	218
	Design Philosophy of NetBeans	218
	User-Level Customization	231
	Modules--Overview	236
	Interacting with the IDE	240
15.	The Open APIs	243
	APIs versus Core versus Modules	244
	Service Provider Interfaces and Client APIs	245
	Overview of the APIs and Their Purposes	246
	Modules, JARs, and Class Loaders	276
	Threading, Deadlocks, and How to Avoid Them	280
16.	Developing Modules--the New Module Wizard	283
	The HelloWorld Module	283
17.	Internals of the Running IDE	288
	The Activated Node(s)	288
	Cookies	289
	A Peek under the Hood	290
	Touring NetBeans with the Bean Browser	291
	Data Objects, Nodes, and Cookies	293
	Filesystems and the Repository	294
	Services	295
	Lookup	296
	Options	297
	UI Components	298
	Localization	306
	Wizards	306
	Jumping-off Places	307
	Special Folders in the System Filesystem	308
18.	Creating the QuickPanel Module	311
	Abstractions Covered in This Chapter	312
	Creating the Project Files Drop-Down	313
	FilterNode--Filtering Which Children of a Node Are Displayed	317
	Creating the Methods Drop-Down	319
	Improving the Methods Drop-Down	321
	Creating the Module	325
	A Little Homework	328
19.	A Mail-Based Filesystem	329
	Building a Mail Reader in the NetBeans Paradigm	329
	Implementing MailFileSystem Using AbstractFileSystem and JavaMail	330
	Creating Folder Objects for Attachments	340
	Using FileSystem.Status Annotations to Mark Unread Messages	341
	BeanInfo--Displaying Filesystem Properties	343
	Using the Wizard Framework to Set Up Mail Accounts	345
20.	Creating the User Interface for the Mail Client	356
	Creating a DataLoader for Messages	356
	Creating a Threaded Mail View Using Filter Nodes	363
	Creating a Mail Workspace	377
21.	Score File Support	383
	Overview--Functionality to be Implemented	383
	Creating the Minicomposer Module	383
	Creating a UniFileLoader and MultiDataObject for *.score Files	386
	Creating an Editor Support for Scores	389
	Creating a Fixed ExecCookie to Play Scores	392
	Creating a Simple Template	395
22.	Creating a Structural View of the Score	398
	Creating a ScoreCookie to Represent a Sequence of Notes	398
	Creating a ScoreSupport	401
	Lifecycle of the Score	406
	An OpenSupport	407
	Indicating Parse Errors on the Node	415
23.	Compiling Scores	420
	Creating the Compilers	420
	Creating and Using the Compiler Cookie	426
	Displaying an Out-of-Date Badge on Score Icons	430
24.	Executing Scores	433
	Creating the .au Player Executor	434
	Creating Player Configuration Support	444
	Creating a SystemOption for the Default Executor	446
25.	Better Score Support in the Explorer	454
	The Clip Length Property	454
	Representing Notes as Subnodes Using Children.Keys	458
	Permitting Subnodes to Be Renamed or Deleted	465
	Permitting Subnodes to Be Added	468
	Making Read/Write Properties on Subnodes	471
	Reordering Subnodes	474
	Data Transfer--Cut, Copy, and Paste of Notes and Sequences	478
26.	Tuning Modules for Performance & Memory Footprint	491
	Startup Performance vs. Runtime Performance	492
	Operating Principles	492
	Techniques	494
27.	Producing Modules (Packaging & Distribution)	504
	Versioning	504
	Upgrading User Settings	512
	Bundling Extension Libraries	519
	Internationalization and Accessibility	524
	JavaHelp--Writing and Distributing	528
	Supporting User-Level Java APIs	534
	Creating the Module JAR File Within the IDE	539
	Creating a Build Script Using Ant	539
	Producing the .nbm File	541
	Publishing Using the Update Center	543
	Using ErrorManager to Log Problems	546
	Testing	548
28.	Building Your Distribution of NetBeans	550
	Do You Need Your Own Distribution?	550
	Licensing	551
	Selecting a Baseline	552
	Getting the Sources	553
	Customizing the Build Process	554
	Adding Modules to a "Stock" Distribution	556
	Creating Preconfigured Settings	558
	Branding	558
A.	A Tour of Existing Modules	572
B.	Useful Utility Classes	586
C.	Resources	590
D.	Future Plans	595
E.	Working with Open Source and NetBeans	602
F.	Additional Modules and Where to Find Them	615
	Index	627