NetBeans Platform 7深度指南：从基础到实战

5星 · 超过95%的资源需积分: 10 4 浏览量更新于2024-07-28 收藏 10.53MB PDF 举报

《NetBeans平台7权威指南》是一本深度探讨NetBeans Platform 7技术的详尽教程，由Apress出版，专为那些希望理解和开发基于此平台的应用程序的专业人士设计。本书结构清晰，分为三个部分：基础与概念、外观与感觉以及即用功能。在基础与概念部分（Part 1），作者首先介绍了NetBeans Platform的基本原理。第1章通过引言概述了平台的核心理念，帮助读者建立对平台的理解。接着，第2章详细阐述了平台的架构，包括其组件和模块组织方式。第3章深入讲解了NetBeans Module System，这是构建模块化应用的关键。第4章介绍了OSGi框架，它是NetBeans Platform的核心运行时环境。第5章至第7章分别讨论了查找（Lookup）概念、Action的设计与使用，以及数据和文件管理，这些都是构建用户界面的基础。第二部分（Part 2：Look & Feel）着重于用户界面的开发。从第9章的菜单栏和工具栏设计，到第10章的窗口系统，读者可以学习如何创建直观且美观的界面。接下来的章节涉及状态栏、进度条、节点和探索器的设计，以及对话框和向导的实现。第14章的Visual Library提供了丰富的可视化工具，以便快速构建界面元素。最后，这一部分还包含了一些实用技巧和最佳实践。进入第三部分（Part 3：Ready & Go），作者指导读者如何利用NetBeans Platform的标准模块来加速开发过程。第16章介绍了帮助系统，这是任何应用程序必不可少的部分。第17章和第18章分别讲解输出窗口和导航器的功能和使用方法，这些是开发过程中不可或缺的工具。总体而言，《The Definitive Guide to NetBeans Platform 7》不仅涵盖了基础知识，还提供了实用的开发技术和案例，旨在帮助读者掌握这个强大的Java开发平台，从而创建高效、可扩展的桌面应用程序。无论你是初学者还是经验丰富的开发者，这本书都是提升NetBeans Platform技能的宝贵资源。

CHAPTER 2  STRUCTURE OF THE NETBEANS PLATFORM

Figure 2-1. Conceptual structure of the NetBeans IDE

To enable your applications to attain this level of modularity, the NetBeans Platform on the one

hand makes mechanisms and concepts available that enable modules to be extendable by other

modules, and on the other hand enables them to communicate with each other without being

dependent on each other. In other words, the NetBeans Platform supports a loose coupling of modules

within an application.

To optimize the encapsulation of code within modules, which is necessary within a modular system,

the NetBeans Platform provides its own classloader system. Each module is loaded by its classloader and,

in the process, makes a separate independent unit of code available. As a result, a module can explicitly

make its packages available, with specific functionality being exposed to other modules. To use

functionality from other modules, a module can declare dependencies on other modules. These

dependencies are declared in the module’s manifest file and resolved by the NetBeans runtime

container, ensuring that the application always starts up in a consistent state. More than anything else,

this loose coupling plays a role in the declarative concept of the NetBeans Platform. By that I mean that

as much as possible is defined in description and configuration files, in order to avoid a hard-wired

connection of these concepts with the Java source code.

A module is described by its manifest file’s data together with the data specified in related XML files

and therefore does not need to be explicitly added to the NetBeans Platform. Using XML files, the

NetBeans Platform knows the modules that are available to it, as well as their locations and the contracts

that need to be satisfied for them to be allowed to be loaded. These dependencies are declared in the

module’s manifest file and resolved by the NetBeans runtime container, ensuring that the application

always starts up in a consistent state. The NetBeans Platform itself is formed from a group of core

modules (see Figure 2-2), which are needed for starting the application and for defining its user

interface. To this end, the NetBeans Platform makes many API modules and service provider interface

(SPI) modules available, simplifying the development process considerably. Included in this group

(shown in Figure 2-2) are, for example, the Actions API, which makes available the often needed action

classes; the powerful Nodes API; and the Options SPI, which helps your own options dialogs to be easily

integrated into the application. In addition to these, there are also complete reusable components in the

NetBeans Platform, such as the Output Window and the Favorites module.

CHAPTER 2  STRUCTURE OF THE NETBEANS PLATFORM

• The module org-openide-windows contains the Window System API, which is the

API that is probably used most. It includes basic classes for developing windows

and the windows manager, among others. From the windows manager you can

access information about all existing windows.

• The update functionality of an application is implemented by the module org-

netbeans-modules-autoupdate-services. This module provides the complete

functionality for finding, downloading, and installing modules. The module org-

netbeans-modules-autoupdate-ui provides the Plugin Manager, which enables the

user to manage and control modules and updates.

• With the org-netbeans-modules-favorites module you can display random data

and directory structures and thereby influence their actions via the Data Systems

API.

• The org-openide-actions module provides a set of frequently used actions, such

as copy, cut, and print. The functionality of these actions can be implemented in a

context-sensitive manner.

• A very powerful module is org-openide-loaders, which contains the Data Systems

API. This can be used to create dataloaders that can be linked with certain types of

files and then create data objects for it. A special behavior can be added to these

data objects in a simple way.

• The Nodes API of the module org-openide-nodes is a very central feature of the

NetBeans Platform. Nodes can, for example, be displayed in an explorer view; by

doing so, nodes can provide actions and property sheets for data objects.

• The org-openide-explorer module provides a framework to develop explorer

views as used, for example, in the projects or file view of the NetBeans IDE.

• The org-netbeans-modules-editor-mimelookup module provides an API to find

MIME type–specific settings, services, and other objects, such as an SPI to

implement your own MIME type–specific data provider. The org-netbeans-

modules-editor-mimelookup-impl module is a special implementation of this SPI

which is responsible for finding objects in the directory structure of the System

Filesystem.

• org-netbeans-modules-javahelp contains the JavaHelp runtime library and

provides an implementation to the modules API, which makes it possible for

application modules to integrate their own helpsets by means of the JavaHelp

technology.

• The QuickSearch SPI for implementing and providing your own providers is

located in the module org.netbeans.spi.quicksearch.

• The master filesystem module org-netbeans-modules-masterfs provides an

important wrapper filesystem.

• The module or

g-netbeans-modules-options-api prov

ides an option dialog and an

SPI, making it easy to add your own option panels.

CHAPTER 2  STRUCTURE OF THE NETBEANS PLATFORM

• Long-running tasks can be managed centrally by the module org-netbeans-api-

progress. The module org-netbeans-modules-progress-ui provides a visualization

of this with which it is possible to stop separate tasks.

• org-netbeans-modules-queries provides a general query API with which modules

can query information about files. An SPI is also provided to supply your own

query implementations.

• org-netbeans-modules-sendopts, this module provides a Command Line Parsing

API and an SPI with which your own handlers can become registered for

command lines.

• The org-netbeans-modules-settings module provides an API to save module-

specific settings in a user-defined format. It also provides several useful setting

formats.

• The org-openide-awt module includes the UI Utilities API, by which the different

help classes for creating the user interface are provided.

• In the module org-openide-dialogs an API for displaying standard and

application-specific dialogs is provided. The Wizard Framework is located in this

module.

• org-openide-execution provides an API for executing long-running asynchronous

tasks.

• org-openide-io provides an API and an SPI for the input and output of files. This

module also provides a standard implementation with which you can write on the

Output Window module.

• The Text API in the module org-openide-text provides an extension of the

javax.swing.text API.

• The modules org-netbeans-swing-plaf and org-netbeans-swing-tabcontrol are

responsible for the adaptation of the look and feel and displaying the tabs. The

module org-jdesktop-layout is a wrapper module of the Swing layout extenstion

library.

• The Visual Library API is provided by the module org-netbeans-api-visual.

Furthermore, it is possible to add modules out of the IDE distribution to the listed modules.

NetBeans Runtime Container

The basis of the NetBeans Platform and its modular architecture is called NetBeans Runtime Container.

It consists of the following five modules:

• Bootstrap: This module is executed initially. It executes all registered command-

line handlers, creates a boot classloader which loads the startup module, and then

executes it.

• Startup: This module deploys the application by initializing the module system

and the file system.

CHAPTER 2  STRUCTURE OF THE NETBEANS PLATFORM

• Module System API: This API is responsible for the management of the modules

and for their settings and dependencies.

• File System API: This API provides a virtual file system which provides a platform-

independent access . It is mostly used for loading resources of the modules.

• Lookup & Utilities API : This component provides an important base component

which is used for the intercommunication of the modules. The Lookup API is

located in an independent module, so it can be used independently of the

NetBeans Platform.

The arrows in Figure 2-3 show the dependencies of these five basic modules.

Figure 2-3. NetBeans runtime container

The runtime container is the minimal form of a rich client application and can be executed as such

without further modules. If there are no tasks to do, the runtime container would directly shut down

again after starting up. It is interesting to note that, on the one hand, the Netbeans Platform can create

applications with an extensive user interface, and on the other, can also use this runtime container for a

modular command-line application. Starting the runtime container, it finds all available modules and

creates an internal registry out of them. Usually, one module is just loaded when needed. First, it is

registered as existing. However, a module has the possibility to do tasks right at the start. This is done by

the Module Installer, which will be discussed in Chapter 3. The runtime container also facilitates

dynamic loading, unloading, installing, and uninstalling of modules during runtime. This functionality is

especially necessary for users when updating an application (with the auto update function). It is also

necessary for deactivating unneeded modules within an application.

For a complete understanding of the process of a rich client application, it is also important to

mention that the Bootstrap module (the first module executed) is started by a platform-specific

launcher. This launcher is also responsible for identifying the Java Runtime Environment. The launcher

is part of the NetBeans Platform and is operating system (or OS) specific, so that, for example, on

Windows systems it is an .exe file.

NetBeans Classloader System

The NetBeans classloader system is part of the NetBeans runtime container and a precondition for

encapsulating the module and the structure of a modular architecture. This system consists of three

different types of classloaders. These are the module classloader, the system classloader, and the original

classloader.

• Most classes are loaded by the module classloader.

剩余561页未读，继续阅读

iltgcl

粉丝: 27
资源: 1

NetBeans Platform 7深度指南：从基础到实战

NetBeans Platform for Beginners样章及全书代码

The.Definitive.Guide.to.NetBeans.Platform.7.pdf.rar

The Definitive Guide to NetBeans Platform 7 源代码

the definitive guide to netbeans platform

The Definitive Guide to NetBeans Platform

The Definitive Guide to NetBeans Platform 2009

The Definitive Guide to NetBeans Platform 源代码

[The.Definitive.Guide.to.NetBeans.Platform.7].Heiko.Böck.文字版.pdf

NetBeans Platform 7 学习指南

NetBeans Platform 7完全指南：书签版概览

最新资源