• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

1. 启动线程或者初始线程： 这个线程负责调用main方法，很多顺序编程一开始就用的是这种线程。在Swing中启动线程负责很少的事务，主要干两件事情，第一件就是创建一个可运行的对象(Runnable Object),这个可运行对象的任务比较重要，它负责初始化图形界面，第二件就是将这个可运行对象安排到另外一个非常重要的线程，事件分派线程中执行。第二件事情是通过SwingUtilies的invokeLater和invokeAndWait方法来实现的。几乎所有的创建Swing组件和与Swing组件交互的代码都要在事件分派线程中执行。
2. 事件分派线程：在Swing中负责事件处理的代码需要在一个特定的线程中运行，这个线程就是事件分派线程。大部分调用Swing方法的代码也在这个线程中运行。原因是大部分Swing对象中的方法并不是线程安全的，所以需要这个特定的事件分派线程来保证线程安全。当然也有部分swing对象中的方法指明是线程安全的，这些方法可以在任何线程中调用。你可以将事件分派线程中运行的代码想象成一系列短小的任务，大部分任务都是调用事件处理方法，例如ActionListener.actionPerformed()方法，其他任务可被程序代码通过SwingUtilities的invokeLater/invokeAndWait方法来安排。需要注意的是，在事件分派线程中的任务必须短小精悍，这意味着这些任务能够很快执行完毕，如果你发现有一个耗时的任务，那么你肯定出错了，你会发现你的图形界面经常被卡住，或者死掉了。对于耗时任务你需要另外一个线程，例如工作线程(Worker Thread)来处理。判断你的代码时候运行在事件分派线程上的方法很简单，使用javax.swing.SwingUtilities.isEventDispatchThread()方法即可。
3. 工作线程(Worker Thread)或者后台线程(Background Thread)：你可以在这个线程中处理耗时任务。
   

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

Netbeans平台的顶层组件:org.openide.windows.TopComponent是JComponent的子类. 顶层组件知道如何在Netbeans的窗口系统中工作. 如果你想想主窗口中添加组件, 通常的办法是你自己写一个类,继承顶层组件, 就像你开发普通的Swing程序, 继承一个JPanel一样.

顶层组件需要在模式Mode中生存, Mode是一种docking容器.

顶层组件有各种状态:

• 开/关 open/closed -  当一个顶层组件被打开时,一个Tab面板将会出现在主窗口代表这个顶层组件
  
• 可见的/不可见的 visible/invisible - When a TopComponent is visible, it is the selected tab in its Mode 当一个顶层组件可见时, 它在它的模式Mode中是被选择的Tab面板
• 激活的/失活的 active/inactive - 当一个顶层组件被激活时, 它或者一个子组件将获得键盘焦点, 它也是当前的全局选择的上下文.

每个顶层组件都有一个Lookup和一个或者多个激活的节点. 这些定义了窗口系统的选择上下文, 这将决定哪些动作(菜单条目, 工具栏按钮等)是激活的, 和在何种情况下,当这些动作调用时,系统如何处理.

顶层组件是Netbeans平台的窗口API的一部分. 已经打开了的顶层组件能够被序列化,以便在重新启动的情况下复原. Netbeans5.0提供了这个功能的模版. 实际上它使用了外部化接口进行保存. 至于是否保存取决于getPersistenceType()方法的返回值.

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

一个数据对象代表一个或多个(通常都是只代表一个)文件对象. 一个数据对象知道它代表的文件是何种类型. 它能够代表一个例如java源文件的经过解析的内容.或者在一个InstanceDataObject的情况下, 文件名就可以提供所有的信息.

数据对象由数据装载器产生. 模块为特定的文件类型注册相应的数据装载器. 所有对于每个文件类型,通常都有一个对应的数据装载器. 同时每个术语这个文件类型的文件通常都对应一个数据对象

数据对象很少提及类型. 如果你将一个数据对象转换为一个实现类,那么十有八九你做错了. 通常的使用方法是你询问一个数据对象,要求得到你感兴趣的(程序需要交互的)接口的实例. 这个方法是DataObject.getCookie(Class class).

举个最简单的例子, Netbeans API定义了一个接口org.openide.cookies.OpenCookie, 这个接口只有一个方法: open(). 这个方法将在编辑器中打开一个文件. 当open()方法被调用时到底发生了什么完全取决于实现这个数据对象的模块. 系统的其他部分不需也不必知道任何实现的细节: 它仅仅需要知道数据对象是否有一个OpenCookie.如果有,那么在它的上下文菜单中打开动作将被激活, 打开动作将会调用DataObject.getCookie((OpenCookie.class)).open()方法, 同时返回一个OpenCookie.

Cookie这个名字容易让人费解, 很不幸,这是个历史遗留问题. getCookie方法其实时服务发现方法Lookup的老版本变种. 这两个其实是一样的.只不过getCookie方法需要所有返回的对象要实现Node.Cookie这个标记接口,而Lookup能返回任何对象. 估计在未来的版本中getCookie()方法会被一个新的getLookup()方法取代.

就像上面说得一样, 一个数据对象也许代表不止一个文件.所以当你在用户界面展开一个目录时,也许实际的数据对象少于目录中的文件. 这就是为什么使用Netbeans开发可视化图形界面时,每个Swing表单都有一个Java源文件和一个表单文件(.form)相对应,但是在用户界面中你看不到这个表单文件的原因. 在过去, .properties属性文件也使用这种机制从而使用一个节点来代表不同语言的资源文件.

然而, 这种一个数据对象能够代表多个文件的方式是强烈不鼓励的, 新的程序和代码不要使用这种方式, 由于它在弹性方面带来了严重的副作用,这种方式将逐渐被取消.

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

 
<folder name="A">  
      <file name="com-foo-mymodule-MyClass.instance"/>  
   folder>  
  
   <folder name="B">  
      <file name="Shadow1.shadow">  
          <attr name="originalFile" stringvalue="A/com-foo-mymodule-MyClass.instance"/>  
      file>  
   folder>  
  
   <folder name="C">  
      <file name="anotherShadow.shadow">  
          <attr name="originalFile" stringvalue="A/com-foo-mymodule-MyClass.instance"/>  
      file>  
   folder>  

.shadow文件可以指向系统文件的任何文件, 也可以指向磁盘上的真实文件. 例如在Netbeans IDE中Favorite Tab面板上,使用.shadow文件指向磁盘上的真实目录.

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 在模块的JAR文件的META-INF/services目录下增加文件条目
  
• 在系统文件系统下的某目录下增加文件
• 在模块的manifest文件中增加manifest条目
  
• 实现org.openide.modules.ModuleInstall类并且在manifest文件中配置, 这种方式是在系统启动时执行Java代码

A: If so, use META-INF/services

Q: Will all of the objects other modules will register be used at the same time, or are there subsets for specific contexts?

A: This pertains to performance and scalability - wherever possible, you want to avoid actually instantiating the objects other modules install, and delay instantiating them until they really need to be used. Opening module jars and classloading are both expensive operations that slow things down.

If there will potentially be a large number of subclasses of your interface, try to find a way to divide them into context-appropriate categories and use folders in the system filesystem to partition contexts. For example, if you define the interface Eater, and modules will implement eaters of various foods, you probably should create folders for different general kinds of food. That way, you don't have to load a bunch of classes and create the OliveEater, BreadEater, EggEater and SausageEater just to ask them if they can eat the Pizza you came across.

Q: Is there information needed about how each object is to be used which could be provided declaratively, without instantiating the object?

A: If so, use the system filesystem, and either let modules declare file attributes thatprovide additional information, or let modules put their objects in subfolders that have contextual meaning (the same way the folder Loaders/text/x-java uses the folder path to indicate the data type objects pertain to).

Q: How many modules will actually implement my interface? How many objects from other modules will I typically be dealing with? Do I need to instantiate all of them just to display a list in the UI?

A: Displaying things in the UI is a particularly important case: You do not want to have to load a bunch of classes from a module just to show an icon and a display name for something - this pertains to anything you're going to display in the Options dialog, on Menus, or various other views.

You can solve this by using .instance files and asking that modules implementing your API use the file attributes defined for .instance files to declare the icon and display name. Then your code can just get a FileObject for each registered instance, call DataObject.find(theFileObject).getNodeDelegate().getIcon() or getDisplayName() to get the icon or display name of the object without ever having to create the object until it needs to do real work.

If you run the risk of having to instantiate all the objects in a folder just do trivial tests such as finding out how many objects of one class are in a given folder (which may contain objects of other classes), consider recommending .settings files instead of .instance files in your folders.

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

在很久很久以前, Netbeans中的大部分对象都是在启动的时候装载的. 当开发程序很小的时候,这个方式没有什么问题, 但是当你开发很大的应用的时候, 这种方式就是一场灾难. 每个系统的新的组件都让启动过长变得更加漫长,垃圾回收变得更加频繁,需要更多的内存支持.这种方式被称为程序式的安装.

不过,现在的Netbeans慢慢改变了这种方式. 大部分系统安装只涉及一个文本条目: 在XML层文件中添加一些东西,而不是运行Java代码. 理想情况下,一个模块在系统启动的时候应该不做任何事情,只有需要这个模块的时候,再做处理.这种方式被称为声明式的安装.

声明式的安装是通过在模块的JAR文件的META-INF/services目录下创建一个文件或者创建一个XML层文件声明这个模块安装时需要处理的信息. 这样,当需要这个模块实际工作时,你的对象才被实例化.

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

窗口系统定义模式, 而我们知道模式其实是Tab容器在主窗口中占用的位置. 顶层组件是能够被放置到Tab容器中的GUI组件.

我们通过使用声明式的XML窗口系统API安装这些组件.这样做的原因如下:

• 弹性: 组件不必被创建和反序列化, 除非它们真的需要被打开
• 单例化: 在IDE中,你肯定不需要5个项目Tab面板.使用XML API,你可以非常方便的使用组件的单例实例
• 持久化: 和窗口系统关联的组件拥有唯一的ID,在会话间能够正确的将组件持久化.

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

They had a brief run of popularity as Yet Another Way To Store Settings a few years ago, around when the new window system was being conceived. They're not bad, but a bit baroque. The main point was to avoid loading classes or creating objects just to satisfy a test like "how many object instances are there of X", "does this folder/lookup/collection contain an instance of X". For NetBeans, where there are lots of classes, this sort of thing really does make a difference in performance. The observation was that huge amounts of classloading could be triggered just to find out that something was not actually of use to whatever code triggered it to be instantiated.

.settings files can be used for the same purposes as .instance files - as a way of indicating that the file represents some class that should be instantiated. The main difference is that by defining all of the superclasses and interfaces of the the object they represent, it is possible for the system to delay actually instantiating the object longer - more questions about the object can be answered by the system without creating it to answer those questions.

.settings files are typically not used for registering actions in the main menu and similar places, since these actions will need to be instantiated almost immediately anyway in order to determine if they should be enabled or not. A future API for declarative actions will possibly change that, but at present, it does neither harm more good, and .instance files are simpler (and for cases where the object will be instatiated immediately anyway, faster).

Some examples:

Declaring a system option as a .settings file from an XML layer

  <folder name="Services">
    <file name="org-openide-text-PrintSettings.settings" url="PrintSettings.settings">
      <attr name="SystemFileSystem.localizingBundle" stringvalue="org.netbeans.core.Bundle"/>
      <attr name="SystemFileSystem.icon" urlvalue="nbresloc:/org/openide/resources/printSettings.gif"/>
    </file>
  </folder>

Note the url attribute - it points to a file PrintSettings.settings which is in the same directory in the module jar as the layer file - it is a relative path. That settings file will look like this:

  <?xml version="1.0"?>
  <!DOCTYPE settings PUBLIC "-//NetBeans//DTD Session settings 1.0//EN" "http://www.netbeans.org/dtds/sessionsettings-1_0.dtd">
  <settings version="1.0">
    <instanceof class="java.beans.beancontext.BeanContextProxy"/>
    <instanceof class="org.openide.util.SharedClassObject"/>
    <instanceof class="org.openide.options.SystemOption"/>
    <instanceof class="org.openide.options.ContextSystemOption"/>
    <instanceof class="org.openide.text.PrintSettings"/>
    <instance class="org.openide.text.PrintSettings"/>
  </settings>

The two things to note are that the .settings file declares many of the relevant parent classes of the object (so it does not need to be instantiated just to see what kind of object it is), and the layer file declares the icon and a resource bundle (for the display name) as file attributes .

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

一个实例文件通过它的类名来表明它是哪个类的实例. 例如 com-foo-mymodule-MyObject.instance 实例文件表明它是MyObject类的实例. 实例文件可以代表任何Java类,只要它提供一个默认的构造器或者一个静态的创建方法.

在Netbeans的基础构建中, 一个实例文件产生InstanceDataObject,实例数据对象, 实例数据对象能够提供一个实例Cookie, InstanceCookie, 然后实例Cookie初始化这个JavaBean. 所以获得系统文件系统中声明的对象的一个实例的代码看起来就像:

public static Object getTheObject (String pathInSystemFilesystem) {
    InstanceCookie ck =  DataObject.find (Repository.getDefault().getDefaultFileSystem().getRoot()
        .getFileObject(pathInSystemFilesystem)).getCookie(InstanceCookie.class);
    return ck.instanceCreate();
}

或者使用FolderLookup, FolderLookup提供一个快捷的方法获得一个目录下对象的所有实例:

FileObject f = Repository.getDefault().getDefaultFileSystem().getRoot().getFileObject("MyFolder");
DataFolder fld = DataFolder.findFolder(f);
FolderLookup lkp = new FolderLookup (fld);
Lookup.Result res = lkp.getLookup().lookup (new Lookup.Template(WhatISaidToPutHere.class));
res.allInstances();

注意XML层文件不需要默认的构造器,你也可以提供一个静态方法来创建对象:

  
<file name="ObjectTypes.instance">
  <attr name="instanceCreate" methodvalue="org.netbeans.core.ui.UINodes.createObjectTypes" />
  <attr name="instanceClass" stringvalue="org.openide.nodes.Node" />
</file>  

第二个条目instanceClass的值意味着系统不必初始化你的对象,仅仅看一下它是否和类节点匹配.

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 你不能生成一个代表尚不存在的文件的文件对象, 就是说如果真正的文件不存在,你不能生成一个对应的Netbeans文件对象
• 你可以监听文件对象的变化.
• 文件对象可以拥有键值对形式的文件属性

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

基本的机制是:特定的,已知的文件类型分别具有自己的图标,菜单选项和行为或者动作.

Netbeans如何知道这些文件的类型呢?

答案是:这些文件其实或者是FileObject包装起来的文件(java.io.File),或者是配置文件(通过包装模块的XML文件). 真正你看到的其实是节点. 节点提供文件相关的动作,名字等其他事情. 而在节点和文件对象之间的是数据对象:

Node <---> DataObject <---> FileObject

                            |-------- DataObject知道文件的类型,不同的文件扩展名对应不同的类型的DataObject(由实现文件类型支持接口的模块提供), 例如图片模块能够识别和打开gif,png格式的图片

所以当一个目录被打开时,Netbeans系统就会询问每个已知的数据装载器: 你认识这个文件类型么? 第一个回答认识的数据装载器负责创建对应的数据对象.实际上这个识别过程会有一些优化过程在里面.但是基本流程是这样的.

为了实际显示每个文件的一些数据,Netbeans系统会调用每个对应数据对象的getNodeDelegate()方法, 这些节点是你在Netbeans用户界面看到的真正的东西.

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• Actions动作 存储系统中所有的全局动作,可以拥有分类的子目录,通过.instance文件安装动作

• Menu菜单 主窗口中菜单条的内容,每个菜单都有一个目录,还有子菜单具有子目录, 下面的.instance文件用来指定哪些动作可以在菜单上显示.
  

• Loaders加载器 - 包含定义MIME类型的子目录,例如 Loaders/text/x-java , MIME类型用来定义不同的属性, 例如弹出菜单(右键)就可以根据节点文件的MIME类型来显示不同的动作. 例如html文件可以激活浏览器, java文件可以激活编译动作.

• 文件的位置: 一个模块可以指定一个目录,直接将对象放入这个目录,或者要求其他客户模块在这个目录中创建子目录,从而使得整个文件路径具有语义(看下面)

• 文件的类型 : 你会经常安装各中代表Java对象的.instance文件, 通常模块指定目录下的那些类或者接口能够被使用

• 文件的属性: 需要额外信息来描述如何对待文件时需要指定文件属性键值对.

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

1. init 用来初始化组件
2. close 用来关闭组件
3. setContext(VfsComponentContext ctx) 设置组件上下文，注意它维护了一个组件上下文：VfsComponentContext
4. setLogger 设置日志

1. AbstractFilesCache
2. AbstractFileSystem
3. AbstractVfsContainer
4. DefaultFileReplicator

1. DefaultFileReplicator 一个简单的文件复制器和临时文件仓库，同时实现了FileReplicator接口，TemporaryFileStore接口和VfsComponent接口
   
2. PriviledgedFileReplicator 一个文件复制器的包装类，接受一个文件复制器作为参数。这个包装类能够执行某些需要权限的动作

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

1. getManager 这个方法最重要，将返回一个默认的FileSystemManager接口
   
2. setUriStyle
3. isUriStyle 判断是否是URI形式

1. 绝对的URI: 必须以协议Schema开始，例如file:,ftp:然后跟着文件名：file:/c:/temp.txt, ftp://myftp.org/somefile.txt等
2. 绝对的本地文件名：例如/home/my.txt或C:\dir\file.txt, 注意分隔符可以用“\",也可以用”/".
3. 相对路径： 例如../dir/file.txt或者 home/myfile.txt等

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

1. ChangedEvent
2. CreatedEvent
3. DeletedEvent

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

1. getBaseFolder 返回遍历的根目录
   
2. getDepth 返回文件相对根目录(Base Folder)的深度
   
3. getFile 返回考虑的文件对象

1. includeFile(FileSelectInfo info) 判断是否这个文件或者目录应该被选择，这个方法使用深度优先，首先检查子文件(that is, it is called for the children of a folder before it is called for the folder itself)
2. traverseDescendents(FileSelectInfo info) 判断这个目录是否应该被遍历I，如果这个方法返回真的话，对每个这个目录的子文件都会调用includeFile(FileSelectInfo info)方法，并且每个子目录都递归遍历。对于一个目录，这个方法在includeFile方法调用之前调用。

1. AllFileSelector 顾名思义，将选择所有文件
   
2. FileDepthSelector (int minDepth, int maxDepth) 选择特定深度的所有文件,以最小深度，最大深度为参数
   
3. FileFilterSelector 选择所有给定文件对象的子文件。和FileFilter非常象。（那还要这个干什么？？），可以接受一个FileFilter作为参数
   
4. FileTypeSelector (FileType type) 选择特定类型的文件。不要被这个迷惑! Apache VFS的文件类型FileType对象只有FILE,FILE_OR_FOLDER, FOLDER, FILE_IMAGINARY 四种类型。就是文件，目录，文件或目录， 尚不存在的文件。

FileFilter ff = new FileFilter()
{
    public boolean accept(FileSelectInfo fileInfo)
    {
        FileObject fo = fileInfo.getFile();
        return fo.getName().getBaseName().startsWith("ABC-");
    }
                
};
VFS.getManager().resolveFile("/base/folder").findFiles(new FileFilterSelector(ff));

方法二：使用FileSelector:

FileSelector ff = new FileSelector()
{
    public boolean includeFile(FileSelectInfo fileInfo) throws Exception
    {
        FileObject fo = fileInfo.getFile();
        return fo.getName().getBaseName().startsWith("ABC-");
    }

    public boolean traverseDescendents(FileSelectInfo fileInfo) throws Exception
    {
        return true;
    }                   
};
VFS.getManager().resolveFile("/base/folder").findFiles(ff);

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• fileChanged(FileChangeEvent eve): 文件变化，只有使用了FileMonitor才触发
• fileCreated(FileChangeEvent eve): 文件创建
• fileDeleted(FileChangeEvent eve): 文件删除

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

1. LocalFile:(很奇怪为什么不是LocalFileObject)
2. FtpFileObject
3. HttpFileObject
4. SftpFileObject
5. ZipFileObject
6. TarFileObject
7. RamFileObject
8. UrlFileObject
9. DelegateFileObject
10. CompressedFileObject

1. getBaseName
2. getDepth
3. getExtension
4. getFriendlyURI
5. getParent
6. getPath
7. getRoot
8. 等等

1. close 关闭文件内容使用的所有资源，包括所有打开的文件流。当心！！
   
2. get/set Attribute/Attributes: 不能用目前，除非自己重写，其实调用AbstractFileObject的doGet/SetAttribute方法
   
3. getContentInfo 返回一个ContentInfo对象, ContentInfo对象记录了内容的类型和编码信息
   
4. getInputStream 读文件内容
5. getOutputStream 写文件内容
6. isOpen 检查看看该文件有没有打开的文件流
7. getFile 返回FileObject对象
8. get/setLastModifiedTime

1. copyFrom(FileObject src,FileSelector selector) 从其他地方的源文件拷贝到这个文件中，包括源文件的子文件，有一个文件选择器参数和源文件参数
2. delete() 删除此文件
3. delete(FileSelector selector) 删除符合文件选择器的所有该文件的子文件
4. createFile() 如果这个文件不存在，创建它
5. createFolder() 如果这个目录不存在，创建它

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

1. org.openide.loaders 负责处理文件，将他们关联到组，然后设置数据类型
   
2. org.openide.cookies 提供了一种设计模式，能够对数据对象和节点提供附加的行为
   
3. org.openide.util.datatransfer 实现了一些剪切版的扩展

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

1. 什么是节点？可以说节点是任何Netbeans中的数据对象的包装器，这些对象通过节点来显示和执行任务（通过节点的动作），一般来说这些数据对象由数据系统接口（Datasystem API）提供。当然数据对象也可以根据特定需要单独创建。你看到的查看器中的图标，对话框，组件窗口都是基于节点的，他们通过查看器API显示。节点本身不存储数据，这个任务是由数据对象完成，节点仅仅是数据对象的表现层。实际上，节点是JavaBean概念的延伸。从开发完整的企业级应用来讲（例如Netbeans本身）JavaBean忽略了很多东西：完整的层次支持，Cookie和动作，节点特定的动作（例如序列化节点，剪切粘贴等），关键的一点是JavaBean需要自省机制，不管属性列表是否需要，都要自省，这带来严重的性能问题。而节点能够支持动态修饰属性列表。
2. 节点的显示。节点的显示是靠查看器API(Explorer API)的，通过查看器API，节点可以使用BeanTreeView, TreeView, MenuView, TreeTableView等形式来显示节点的整个树或者子树。在查看器中可以触发节点支持的动作（通常右键显示这些动作），基于Cookie的动作开关（例如节点的选择会影响工具栏某些工具是否可用，比如编译按钮），剪切复制等动作，以及对子节点的排序，创建，删除，以及节点图标名字的状态改变等等。
3. 节点是活的！最重要的是，节点是活的组件。在系统中发生的任何事件都可能让查看器中的视图更新，比如可视化Swing开发中，如果将一个组件拖到可视化开发面板中，那么相应的查看器中的组件树就会刷新，新的组件被加入到组件树中。同时任何查看器中发生的动作都可能影响系统，比如Netbeans全局配置查看器中如果改变了工具栏的配置，那么工具栏会立刻更新。而这一切都是通过节点接口的富事件通知机制（Rich Event Notification）实现的。
4. 常见的节点类型：

• 基于数据对象的数据节点：
• 数据目录节点：
• 磁盘上用户自己开发的JavaBean:
• JavaBean衍生的节点：
• 高级选项的设置节点
• 组件窗口
• 调试器中的断点
• 项目桌面节点

1. 节点Node是抽象类,不是接口，具有两个子类：AbstractNode, FilterNode.
   
2. AbstractNode不是抽象类！通常自定义的节点要继承AbstractNode或他的子类.
3. 自定义的节点要提供一个子节点列表给节点构造器，如果这个节点是叶节点，传参数Children.LEAF给构造器
4. 从AbstractNode继承而来的自定义节点不需要覆盖或实现特定方法（AbstractNode不是抽象类），不过有几个方法通常需要覆盖：一些编辑方法例如AbstractNode.canCopy()等，他们默认的是true, 每个节点有两个名字，一个是显示名字，一个是内部系统名字，内部名字用来序列化和反序列化等使用。Node.setName(), Node.setDisplayName(). 还有节点的图片，例如展开时的节点图片等。
5. 节点的属性，集和表单

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• Actions APIs - 最重要的也是开发者必须使用的API,负责处理象表单和工具栏等上面的动作， 想一下Swing的Action.
• Ant -Ant的整合API.
• Ant-Based Project Support -如上
• Auto Update Services - 自动更新支持，非常方便模块的更新和添加等。
• Classfile Reader - 访问类文件信息的API
• Command Line Parsing API - 支持命令行的API
• Common Palette - 项目间共享的组件属性窗口
• Convertor - XML和对象间的转换器
• Database Explorer - 支持数据库查看器的API
• Datasystems API - 负责扫描目录中的文件，根据需要按照逻辑组成平台相关的结构
• Debugger Core API - 支持调试的API
• Debugger Core - UI - 调试界面API
• Dialogs API - 负责对话框的API,例如事件通知等
• Diff - 支持查看文件间的不同之处的API
• Editor Code Completion - 编辑器的代码补全API
• Editor Code Folding - 编辑器的行折叠API
• Editor Guarded Sections - 编辑器的代码保护API,例如可视化Swing的自动生成的代码不可编辑
• Editor Library - 编辑器中和平台无关的库文件API
• Editor Library 2 -同上
• Editor Module - 提供整套方案（包括表单编辑，浏览，编译，调试）的编辑器模块T
• Editor Settings Storage - The module is an implementation of the org.netbeans.modules.editor.settings providing a settings storage on the default filesystem.
• Editor Utilities - Editor Utilities module contains useful utility classes and methods used by other editor related modules.
• Error Stripe API - The Error Stripe shows an overview of important information of an edited source code.
• Execution API - The IDE uses a small interface to describe the execution of Java-based classes together with arguments.
• Explorer & Property Sheet API - The ExplorerAPI is build around Explorer - solely a user-interface device: it has no particular knowledge of the structure of the IDE.
• External Libraries - Permits libraries to be defined, customized, and stored by the user for reuse in multiple projects.
• File System API - The Filesystems API provides a common API to access files in a uniform manner.
• General Queries API - General kinds of queries between modules.
• I/O APIs - The Input/Output API is a small API module which contains InputOutput and related interfaces used in driving the Output Window.
• Java EE Metadata - The project provides a generic framework for accessing Java EE metadata models.
• JavaHelp Integration - The JavaHelp integration API wraps the standard JavaHelp extension library.
• Java Platform - Many Java-based project types need to be able to configure the version and location of Java to be used when building and running the project.
• Java Project Support - Provides support infrastructure for projects working with the Java language.
• Java SE Projects - Provides a project type for plain Java projects.
• Java Source - XXX no answer for arch-what .
• Java Support APIs - Models basic aspects of the metadata surrounding Java source files, such as the classpath.
• JPDA Debugger API - The debuggerjpda/api (Debugger JPDA API) defines API for NetBeans Java Debugger.
• JUnit Tests - The module makes creating, running and navigation between tests easier.
• Lexer - Lexer module provides token lists for various text inputs.
• Look & Feel Customization Library - The plaf library consists primarily of code that used to be in core.
• Looks - Looks provides an SPI for converting arbitrary objects into displayable form.
• Master Filesystem - MasterFileSystems is just implementation of FileSystem provided in standalone module including implementation of URLMapper that resolves file protocol and is responsible for conversion from URL into FileObject and vice versa.
• MIME Lookup API - Each editor provides an EditorKit which controls the policy of specific MIME content type.
• Module System API - The Modules API lies at the core of NetBeans and describes how plug-in modules are added and managed.
• MultiView Windows - Multi views are general mechanism for displaying several perspectives, or views of data, which will be used consistently across whole IDE window system.
• Navigator API - Navigator module is a base API module which provides: A place for modules to show structure/outline of their documents Ability for modules to show their view only when special document(node) is active in the system UI for switching between multiple views available for currently active document(node) Coalescing of fast coming selected node changes to show content for .
• NB JUnit - Module contains NetBeans extension to JUnit.
• Nodes API - 节点提供平台中对象的可视化工作，注意这里的节点远远超出Swing中节点的含义。
• Options Dialog and SPI - This module contains implementation of Options Panel and simple SPI.
• Progress API - 跟踪显示任务进度的API
• Project API -