下面表格列出Swing中组件及其模型的映射关系：

Swing模型分类

       Swing提供的模型分为两大类：GUI状态模型和应用数据模型。

       GUI状态模型是描述GUI控件可视化状态的接口，如按钮是否按下，或列表中那一项被选中。GUI状态模型通常仅在图形用户界面(GUI)环境中用到。通常来说，虽然编写使用GUI状态模型分离程序，尤其是当多个GUI控件共享状态，或当操作一个控件自动更新另一个的值时比较有用，但GUI状态模型在Swing中并不是必需的，完全可以通过组件顶层方法操作GUI控件的状态，而不必和模型直接交互。

       应用数据模型是描述具有应用程序含义数据的接口，比如表格中的数据，或列表显示的选项。这些数据模型为Swing提供了一个清晰分割应用程序界面和数据逻辑的强大编程模式。对于以数据为核心的Swing组件，比如JTree和JTable，强烈推荐使用数据模型进行交互。

       当然一些组件的模型根据应用场景的不同其分类介于GUI状态模型和应用数据模型之间，比如JSlider和JProgressBar 的BoundedRangeModel。

       Swing的可分离模型接口并没有明确界定GUI状态模型和应用数据模型。这儿所以做此说明，目的是让你更好的理解何时以及为何要需要使用分离的模型。

共享模型定义

       值得注意的是，上文中表格中，许多组件的数据抽象相似，只需一个接口而不用过分泛化时，组件可以共享同一模型定义。共享模型定义允许在不同组件之间自动连接。比如，JSlider和JScrollBar都使用BoundedRangeModel接口，因此可以在一个JScrollBar和一个JSlider之间共享同一个BoundedRangeModel实例，这样它们之间的状态就总是同步的。

分离模型编程接口

       使用模型的Swing组件必须提供访问修改模型的set/get方法，即模型必须是该组件的限定性属性。比如，JSlider使用BoundedRangeModel接口作为它的模型定义，因此它必须提供下面方法：

      所有Swing组件有一个共同点：如果你不设置它的模型，组件会在内部创建/安装一个缺省模型。这些缺省模型类的命名习惯是在接口名称之前加上“Default”，比如JSlider的构造函数中初始化一个DefaultBoundedModel对象。

       如果程序接着调用setModel()，缺省的模型就被替换了，比如下面例子：

       对于更复杂的模型（如JTable和JList），Swing还提供一个抽象模型实现，让开发者不需要从头开始创建自己的模型。

       如JList的模型接口是ListModel，Swing同时提供了DefaultListModel和AbstractListModel两个类来协助开发者创建自定义的列表模型。

模型改变通知

       当数据或者发生变动时，模型必须通知所有相关方（比如视图）。Swing模型使用前面文章所讲述的事件模型来实现这种触发。Swing中有两种方法发送这种通知：

       发送轻量级通知，表明状态已经改变，需要Listener通过查询模型，发现什么改变了并做出响应。此方法的优点是单独事件实例能用作该模型的所有通知，同时对于需要频繁通知的事件非常有用（比如JScrollBar被拖动时)。

       发送状态化通知，详细描述模型如何改变。这种方法需要为每个通知创建一个新的事件实例。当通知通过查询模型不能有效地给Listener提供足够的信息时，此方法非常有用。比如当JTable的一列表格数据发生改变时。

         今天从Swing的四大基本对象Component说起。

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

         Component在Swing的MVC模型中担任Controller的角色，同时它也是Swing API中代表具体组件的对象。Component在Swing中对外负责提供API接口，对内负责协调控制Model和UI Delegate（有时可能还包括Renderer）的操作，可以说是整个Swing结构的中心角色。为了方便你回忆Swing的MVC模型，特地将上一篇文章中的Swing模型示意图引了过来：

         Component代表Swing对应用程序提供了如下几类编程接口：

1. 用户界面的组件树的创建和修改的方法。这包括组件的添加和删除等操作。
2. 组件属性访问的方法，比如组件位置、组件前后背景色、组件字体等等。
3. 组件状态及生命周期的管理的方法，比如隐藏和显示、创建和销毁等等。
4. 组件位置、大小的管理，包括通过布局管理器的方法。
5. 组件事件处理接口的管理，包括添加、删除等操作。

         从开发者的角度来看，Component是组件树上的节点、是控制外观和行为的入口、是组件事件的发源地。从Swing组件实现者的角度来看， Component是协调Model和UI Delegate的操作的地方，是低层次事件处理的地方，是高层事件发生的地方，是同父组件和子组件交互的地方。掌握的这些角度，Swing程序员完全可以实现自己的自定义简单组件，当然如需要实现类似于JTable和JTree等复杂的矢量组件，还需要进一步了解Swing的Model和UI Delegate以及Renderer模型。

         对于复合型(Composite)组件很简单，这儿要讲述的是如何实现自定义的组件，比如表盘，比如温度计这些没有标准组件可以使用的组件，那么如何自己实现这种自定义组件呢？

         不考虑Model分隔和UI Delegate皮肤分离问题，能够简化自定义Component的模型。总的来说自定义组件需要完成两样基本任务：第一侦听并处理低层事件，根据具体情况改变组件状态，如需要还要发出高级事件；第二，根据当前组件的状态画出当前组件的外观。

         侦听底层的事件是指侦听类似于mouse、keyboard、focus等事件，然后处理此事件，如果发现此事件带有特定语义，表达某种组件行为，则改变当前的组件状态以记录，并触发某种事件通知应用程序进行处理。举例说明，想象你准备实现一个简单的按钮，你可以通过继承JComponent来完成。你可以在按钮初始化时，注册此按钮的鼠标事件侦听器，以侦听发生自己组件上的鼠标事件。当按钮捕获到鼠标按下时，检查鼠标按下的点是否在按钮有效区域内。如果是，则认为当前是一个按钮按下动作，那么改变按钮的状态为按下去，调用repaint方法通知按钮重画成按下去的状态，然后发出 ActionPerformed的事件，通知注册在此按钮上的应用程序的ActionListener处理这个动作。下面是一个简单示意代码：

         上面要注意的是你要自己管理自定义组件的事件监听器，包括addListener和removeListener方法，以及如何触发。这个过程很简单，基本上就是上面的模板来实现添加删除和触发。

         除了要负责事件的处理和新事件的触发，自定义组件第二个要完成的任务就是要根据组件当前的状态改变重画组件的外观。重画组件的外观只需要覆盖public void paint(Graphics g)方法即可以，在这个方法里，你只需要根据当前的组件状态分别画出当前的组件即可。

         当然除了上面两个基本准则外，不要忘了添加访问你的组件属性的方法，比如，如果上面的按钮是个二元按钮（相当于 JCheckbox/JToggleButton的那种按钮），你可能需要提供isPressed或者setPressed来获取和设置当前按钮的状态。注意，在设置状态按钮变化的访问方法中，比如setPressed，你需要使用repaint方法通知按钮重新渲染(复杂的实现可能包括触发propertyChange事件，这儿从简)：

         到此为止，你已经能根据上面的两条准则简单的实现你想要的组件了。但是你发现没有，你的按钮状态和外观行为都被堆到了Component （MyButton)中实现了，而且，对于各个平台都是一个样子，不能换皮肤。这对于比较简单、不想要皮肤的组件，可能没有什么，但是对于复杂的组件，比如JTable或者甚至Excel类似的电子表格的那种组件，你把数据（组件状态)和外观堆在这儿实现就严重违反了MVC原则。

         如何简化这种组件的实现呢？使你实现的此种组件容易维护、扩展以及重用，皮肤容易换呢？这就需要Swing结构中的另外三个元素：Model、UI Delegate和Renderer，后面的几个文章将讲述Model、UI Delegate和Renderer帮你逐步实现一个复杂、灵活、可扩展、高效的矢量组件。

=====================================================

         今天这样讲，不知道讲明白没有。当初刚开始学习Swing的时候，还不了解Swing的这种MVC结构，因此当时自己做的自定义组件都是这样写的，没有单独的Model和可以定制的UI Delegate，更不用说Renderer了。但是我觉得自己的这个学习过程，恰恰是人们学习Swing的最佳途径，先简化模型，然后逐步扩展，直到了解Swing模型的全部图像。

         Swing的事件处理过程为：事件调度线程(Event Dispatch Thread)从事件队列(EventQueue)中获取底层系统捕获的原生事件，如鼠标、键盘、焦点、PAINT事件等。接着调用该事件源组件的dispachEvent。该方法过滤出特殊事件后，调用processEvent进行处理。processEvent方法根据事件类型调用注册在这个组件上的相应事件处理器函数。事件处理器函数根据这些事件的特征，判断出用户的期望行为，然后根据期望行为改变组件的状态，然后根据需要刷新组件外观，触发带有特定语义的高级事件。此事件继续传播下去，直至调用应用程序注册在该组件上的处理器函数。下图是这个过程的示意图：

 

         上图所示意的过程简要说就是：

Pump an Event->Dispatch & Process Event->MouseListener.mousePressed->fireActionPerformed->ActionListener.actionPeformed->Do database query and display result to a table->Return from actionPerformed->Return from fireActionPerformed->Return from MouseListener.mousePressed->Pump another Event.

         事件调度线程在应用程序事件处理函数actionPerformed没有完成之前是不能处理下一个事件的，如果应用程序处理函数是一个时间复杂的任务(比如查询数据库并将结果显示到表格中)，后面包括PAINT事件将在长时间内得不到执行。由于PAINT事件负责将界面更新，所以这就使用户界面失去响应。

          打一个比方，事件处理线程就像进入某城唯一的单行道一样，事件相当于汽车。有种PAINT汽车负责为城市运输非常重要的生活物资。但是有一天，PAINT前面有一辆汽车突然坏掉了，司机下来修车。但是这车太难修，一修就是几天，结果后面的PAINT汽车无法前进，物资无法按时运到城里。市民急了，市长虽然不停的打电话催PAINT公司，但即使PAINT公司多添加几辆车也没用。由于进城的唯一条路被那辆车给占着，所以再多的PAINT车也只能堵在路上。

         不了解Swing的这种事件处理模型的人往往将时间复杂的任务放在处理函数中完成，这是造成Swing应用程序速度很慢的原因。用户触发这个动作，用户界面就失去了响应，于是给用户的感觉就是Swing太慢了。其实这个错误是程序员造成的，并不是Swing的过失。

         说点题外话，所有采用这种事件模型的用户界面工具都会产生这种问题，包括SWT、GTK、MFC等流行的用户界面工具。之所以只有Swing被误解，主要是和Swing的历史、市场时机、商业宣传策略和心理学相关的。

         首先Swing的历史和市场时机极差。Swing出现早期性能也差、错误也多，而Java程序员脱身于传统图形界面工具，对于Swing这种新的事件处理模型并不太了解，而此时正处于Java第一轮狂热的时期，大家都满怀希望做了大量的Swing应用程序，而这些程序中大量存在这种错误方法。于是市场上涌现了大批的这种程序。自从那个时代，因为这些程序，Swing被贴上了慢的标签。又由于当时的Swing界面也丑，和一般的Windows程序风格炯异，更加深人们的这种印象。这种印象一直持续到现在，像烙印一样深深的刻在人们的脑海里。

           其次，Swing还有一个致命的问题，就是没有涌现出一个具有标识性的好程序，这是造成它比SWT印象惨的原因。为什么SWT采用相同的事件处理模型，而获得了速度快的声誉呢？这是因为人们当时对于Java做桌面应用的期望心理达到了低谷，而SWT的出现恰恰是伴随Eclipse出现的，早期的Eclipse的确是在速度快、界面漂亮，这一扫当时人们认为Java慢，Java界面丑陋，Java无法做桌面应用的印象，继而这个印象被加在SWT身上，人们认为Eclipse速度快、漂亮是因为SWT，其实如果你知道Swing/SWT事件处理模型的话，你就明白功劳是Eclipse开发者的，Eclipse界面漂亮其实要归功于Eclipse界面设计专家，他们的高水平造就了这个好的IDE，从而也抬起了SWT的声誉。而Swing的名誉恰恰就被早期Swing低水平开发者给毁了。

        再次, 这和商业宣传策略有关。IBM和Eclipse很懂得市场宣传，人们不是认为Java慢吗，就宣传SWT使用原生组件，人们不是认为Swing丑陋、风格炯异吧，就宣传SWT风格一致性，人们不是认为Java不能做桌面应用吗，就宣传基于SWT的Eclipse。其实这一切的背后原因只是“人”的不同，Eclipse的开发者和Swing应用程序的开发者，Swing和SWT技术差异并没有造成那么大的差别，如果是相近能力的人使用他们开发的话，应该能做出相近的产品。这可以从现在Eclipse和NetBeans、Intellij IDEA、JDeveloper和JBuilder看的出来。

         最后，人类有一个心理学现象，就是一旦形成对某种事物的印象，很难摆脱旧的认识，有时甚至人们不愿意承认摆在眼前的事实。总而言之，Swing和SWT不同遭遇是因为历史、市场时机、商业宣传策略、心理学的种种原因造成的。

          那么如何避免这个问题，编写响应速度快的Swing应用程序呢？在SwingWorker的javadoc中有这样两条原则：

Time-consuming tasks should not be run on the Event Dispatch Thread. Otherwise the application becomes unresponsive. 耗时任务不要放到事件调度线程上执行，否则程序就会失去响应。

Swing components should be accessed on the Event Dispatch Thread only. Swing组件只能在事件调度线程上访问。

         因此处理耗时任务时，首先要启动一个专门线程，将当前任务交给这个线程处理，而当前处理函数立即返回，继续处理后面未决的事件。这就像前面塞车的例子似的，那个司机只要简单的把车开到路边或者人行道上修理，整个公路系统就会恢复运转。

         其次，在为耗时任务启动的线程访问Swing组件时，要使用SwingUtilties. invokeLater或者SwingUtilities.invokeAndWait来访问，invokeLater和invokeAndWait的参数都是一个Runnable对象，这个Runnable对象将被像普通事件处理函数一样在事件调度线程上执行。这两个函数的区别是，invokeLater不阻塞当前任务线程，invokeAndWait阻塞当前线程，直到Runnable对象被执行返回才继续。在前面塞车的例子中，司机在路边修车解决了塞车问题，但是他突然想起来要家里办些事情，这时他就可以打个电话让家里开车来。假如修车不受这件事情的影响，比如叫家人送他朋友一本书，他可以继续修车，这时就相当于invokeLater；假如修车受影响，比如缺少某个汽车零件，叫家人给他送过来，那么在家人来之前，他就没法继续修车，这时就相当于invokeAndWait。

         下面举一个例子说明这两点，比如按下查询按钮，查询数据量很大的数据库，并显示在一个表中，这个过程需要给用户一个进度提示，并且能动态显示表格数据动态增加的过程。假设按钮的处理函数是myButton_actionPerformed，则：

void myButton_actionPerformed(ActionEvent evt){
     new MyQueryTask().start();
}
public class MyQueryTask extends Thread{
    public void run(){
        //查询数据库
        final ResultSet result=...;
       / /显示记录
      for(;result.next();){
          //往表的Model中添加一行数据，并更新进度条，注意这都是访问组件
         SwingUtilities.invokeLater(new Runnable(){
              public void run(){
                    addRecord(result);
              }
         });
      }
   ....
   }
   void addRecord(ResultSet result){
       //往表格中添加数据
       jTable.add....
      //更新进度条
      jProgress.setValue(....);
    }
}

         JDK1.6以后，Swing提供了一个专门的类SwingWorker能帮你解决这个编程范式，你所需要做的就是继承这个类，重载doInBackground，然后在actionPeformed中调用它的execute方法，并通过publish/process方法来更新界面。SwingWorker的主要方法和它们的作用在下面的示意图：

          从上面示意图可以看出，SwingWorker实际上不过是封装了前面我所说的例子中的MyQueryTask，并做了更详尽的考虑。execute方法相当于MyQueryTask线程start，它启动这个后台线程并立刻返回。SwingWorker可以注册PropertyChangeListener，这些listener都被在事件调度线程上执行，相当于MyQueryTask中的那些访问组件的Runnable对象。另外，publish、setProgress只不过是特殊的property事件吧，process和done不过是响应publish和PropertyChangeEvent.DONE这个事件的方法罢了。因此我们很容易将上面的例子改成SwingWorker的版本：

void myButton_actionPerformed(ActionEvent evt){
    new MyQueryTask().execute();
}

public class MyQueryTask extends SwingWorker{
    public void doInBackground(){
        //查询数据库
        final ResultSet result=...;
        //显示记录
        for(;result.next();){
            //往表的Model中添加一行数据，并更新进度条，注意这都是访问组件
            publish(result);
        }
        ....
    }
    public void process(Object ... result){
        //往表格中添加数据
        jTable.add....
        //更新进度条
        jProgress.setValue(....);
    }
}

         对于一般的耗时任务这样做是比较普遍的，但是有一些任务是一旦触发之后，会周期性的触发，如何做处理这种任务呢?JDK中提供了两个Timer类帮你完成定时任务，一个是javax.swing.Timer，一个java.util.Timer。使用它们的方法很简单，对于Swing的timer，使用方法如下：

public void myActionPerformed(){
    //假设点击了某个按钮开始记时
    Action myAction=new AbstractAction(){
        public void actionPerformed(ActionEvent e){
            //做周期性的活动，比如显示当前时间
            Date date=new Date();
            jMyDate.setDate(date);//jMyDate是个假想的组件，能显示日期时间
        }
    };
    new Timer(1000, myAction).start();
}

         java.util.Timer类似，只不过使用TimerTask完成动作封装。注意这两个Timer有一个关键的区别：Swing的Timer的事件处理都是在事件调度线程上进行的，因而它里面的操作可以直接访问Swing组件。而java.util.Timer则可能在其他线程上，因而访问组件时要使用SwingUtilities.invokeLater和invokeAndWait来进行。这一点要记住。

         如果要了解更详细的信息，可以查阅SwingWorker、Swing Timer和util Timer这些类javadoc文档和其他网上资料。最重要的是要记住了那两条原则。

============================================================================

Swing事件与事件处理器模型

         Component在Swing模型中是事件触发源。前一篇文章在描述Swing的事件处理模型时就已经提到了这个事件处理过程。简单来说，Swing组件在侦听到原生事件并处理后，往往产生新的逻辑事件。逻辑事件是某些组件所特有的、具有特定语义的事件，比如JButton按下时产生ActionEvent、JComboBox一项被选中时产生ItemEvent，等等。和原生事件不同，它们并不被派发到系统事件队列中，而是由组件直接触发。事件处理器作为组件的观察者添加到组件上并侦听触发的事件。假设事件名叫XXX，Swing中实现这个模式的一般模式是：

1.定义一个XXXEvent

public class XXXEvent extends Event{
    ...
    public void XXXEvent(Object src){
        super(src);
        ...
    }
    ...
}

2.定义一个事件处理器接口XXXListener，声明所有和该事件相关的处理方法：

public interface XXXListener extends EventListener{
    void action1(XXXEvent evt);
    void action2(XXXEvent evt);
    ...
}

3.在触发它的组件中定义一下方法：

public class MyComponent extends Jcomponent{
    ...
    //存放事件处理器的队列
    private ArrayList<XXXListener>xxxListeners=new ArrayList<XXXListener>();
        //定义以下各种方法，访问符号用public，以方便添加删除处理器
        public void addXXXListener(XXXListener listener){
            xxxListeners.add(listener);
        }
        public void removeXXXListener(XXXListener listener){
            xxxListeners.remove(listener);
        }
        //定义各种触发(fire)action1、action2...的方法，注意一般使用protected，以便继承和扩展
        //每一个action都要定义一个相应触发(fire)的方法
        protected void fireAction1(XXXEvent evt){
            for(XXXListener listener:xxxListeners){
                listener.action1(evt);
            }
        }
        protected void fireAction2(XXXEvent evt){
            for(XXXListener listener:xxxListeners){
                listener.action2(evt);
        }
    }
    ...
    //在某些地方，比如鼠标处理函数中触发相应的动作
    void myMouseReleased(MouseEvent evt){
        ...
        if(应该触发action1)
            fireAction1(new XXXEvent(this));
        ...
        if(应该触发action2)
            fireAction2(new XXXEvent(this));
        ...
    }
}

         XXXEvent、XXXListener、addXXXListener、removeXXXListener以及各种fireAction函数多是重复性代码，有些Java IDE如JBuilder中能够根据开发者的指定参数的自动生成这些代码。

         实际上这个观察者模式的编程范式可以推广到任何JavaBeans，不一定是可视化的Swing组件。以前曾经见过JBuilder做的一个所谓数据库操作的JavaBeans，它没有界面，但它和Swing组件完全一样添加删除处理器。它的功能是异步操作数据库，在数据操作完了之后触发注册在上面的事件处理器，该事件处理器就可以将查询结果展现在表格中，或者输出成报表等等。

         在这个模型中，JavaBeans本身既可以是事件源（被观察对象），也可以是事件处理器（观察者），JavaBeans也可以侦听自身的事件并且处理。比如前面文章所提的MyButton在处理鼠标事件时就是自己侦听自己发出的鼠标事件，自己既是事件源，又是事件处理器，形成自反系统。各种各样的JavaBeans通过这种机制联系成一张事件网，各种JavaBeans就是这个网上的节点，而它们之间的事件触发与事件处理关系就是这张网络上的线。当某个节点被外界或自身发出的事件所触发时，行成了事件的传播。这个过程很像网络上节点的振动引起周围周围节点振动的模型。下图示意了这种JavaBeans之间的事件网：

         例如new JscrollPane(new JtextArea())这个系统，它里面包括两个JScrollBar和一个JTextArea，当鼠标拖动事件触发JScrollBar时，JScrollBar处理了这个鼠标拖动事件，并发出滚动条拖动事件，这个事件传播给JTextArea，JTextArea处理这个拖动事件，相应的更新自己显示的内容，如果JTextArea之后又根据更新发出了一个新的事件，这个事件便会继续传播下去。

Swing布局管理器

         现在高级图形用户界面工具一般都包括布局管理器机制。什么叫做布局管理器？如果所有窗口的大小是不变的，那么我们在往窗口中添加组件时，只要将组件的拖放到固定位置、调整好尺寸就可以了，就像VB的界面工具一样。可大多数情况并非如此，用户经常需要调整窗口的大小，以便和其他程序协同工作。这种情况下，在传统界面工具中，比如VB，就需要显式的侦听窗口尺寸调整事件，根据当前窗口的大小重新计算并调整各个组件的大小和位置。AWT/SWT/Swing将这个过程自动化、模块化了，抽象出一个布局管理器来负责管理界面组件的布局。

         它们实现原理是相似的：容器类组件侦听初始化、invalide/validate以及容器尺寸调整等事件，一旦发生这些事件，容器类组件检查自己是否配置了布局管理器，如果没有，则不做任何事情；如果有，则将容器内组件的布局代理给布局管理器，让它来完成容器内组件的重新布局。

         容器管理器对象对实现两类接口：LayoutManager和LayoutManager2，LayoutManager2是LayoutManager的一个扩展，允许组件在添加时指定位置参数。它们的定义和含义如下：

public interface LayoutManager {
    //添加组件comp，并和name关联起来，name可以作为位置等特殊含义参数来使用
    void addLayoutComponent(String name, Component comp);
    //删除组件comp
    void removeLayoutComponent(Component comp);
    //根据容器内的当前组件，计算容器parent的最优尺寸。
    Dimension preferredLayoutSize(Container parent);
    //根据容器内的当前组件，计算容器parent的最小尺寸。
    Dimension minimumLayoutSize(Container parent);
    //重新布局容器parent，这儿是主要布局逻辑所在。
    void layoutContainer(Container parent);
}
public interface LayoutManager2 extends LayoutManager {
    //添加组件comp，constraints用作指定如何以及位置的参数，这个函数主要是弥补LayoutManager版的addLayoutComponent表达能力欠缺而添加。
    void addLayoutComponent(Component comp, Object constraints);
    //根据容器内的当前组件，计算容器parent的最大尺寸。看来除了最优、最小，某些情况下还是需要知道最大。
    public Dimension maximumLayoutSize(Container target);
    //指定水平方向上组件之间的相对对齐方式，0表示和源组件对齐，1表示远离源组件。
    public float getLayoutAlignmentX(Container target);
    //指定垂直方向上组件之间的相对对齐方式，0表示和源组件对齐，1表示远离源组件。
    public float getLayoutAlignmentY(Container target);
    //invalidate这个布局管理器，有时布局管理器为了计算迅速，可能第一次计算之后就将一些数据给缓冲，但是后容器内的组件数目发生变化，这儿的缓冲值就需要调用这个方法通知更新
    public void invalidateLayout(Container target);


}
         Swing在java.awt和javax.swing中都分别提供大量的布局管理器，这些布局管理器有简单的如FlowLayout，有复杂的如GridBadLayout。用户还可以自己定义自己的布局管理器，由于篇幅原因，这儿略去例子。

         Java 6中在布局管理中引入了BaseLine / Anchor的概念，能协助Java IDE的用户界面设计工具，方便用户来设计布局组件。NetBeans的Matisse组件首先引入了一个GroupLayout布局管理器，结合Matisse使用，提供了非常方便的布局管理和界面设计。GroupLayout和BaseLine/Anchor概念以及Matisse可以说是Java界面设计工具的一大进步，可以说足以成为Java桌面应用史上的一个里程碑。在这之前，缺乏有力的界面设计工具是Java在桌面应用失败的一个重要原因。虽然Anchor概念早就在Delphi界面设计工具出现过，但是这个工具的出现还是Java界面设计史上的一大事件。随着Java 6桌面应用支持的增强，以及NetBeans Matisse之类界面设计工具的出现，使得Java桌面应用时代已经到来。Seeing is believing，你不妨试一下就知道了。

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

         本想再加一节讲述Swing双缓冲机制，但是想到双缓冲并不是Swing模型的核心概念，没有它并不影响理解Swing的总体模型，因此打算把它作为以后的一篇专门技术文章来写。

         这样Swing模型中的Component部分就算是描述完了，从明天开始，讲述Swing模型中的另外三个重要概念：Model、UI Delegate和Renderer。

=====================================================

         总的来说Swing/AWT和SWT在事件处理机制上是类似的，窗口组件的树状结构也是类似的。图形用户界面系统在事件处理设计上有两大类，一类是单线程模型，一类是多线程模型。在事件处理机制上，三者都是遵循单线程规则。

         单线成模型对于事件处理不保证线程安全性(Thread Safety)，所有的事件处理都在Event Dispatch Thread(EDT)上进行，此一类事件模型通常叫做单线程模型。这种模型规定所有对组件的访问操作必须在EDT上完成。为什么对于组件的访问需要在EDT上完成？这主要是为了保证对于组件状态的改变是同步的，保证了界面组件的可确定性。这中模型是大部分图形用户界面工具采用的模型，包括Swing/AWT、SWT、GTK、WinForm等等。

         这种模型的好处是，结构设计和代码实现都比较简单，避免了为了实现线程同步的复杂处理。但是也带来了一些问题，最常见的问题是，程序员容易将长时间复杂任务的处理放在事件处理函数完成，造成EDT线程被阻塞，给用户造成界面失去响应的错觉。其实人们对于Swing速度慢和反映迟钝的感觉大部分来源于此，简单的说，是程序员的问题，而不是Swing自身的问题，是因为程序员没有理解这种事件处理机制造成的。其实在SWT、GTK、WinForm等任何以这种事件模型为基础的工具都会出现。重现的方法就是你简单的将长时间处理的任务放在事件处理函数中，你的用户界面就会失去响应。

         如何解决这种问题？通用的办法就是采用异步线程处理长时间任务。但是还要记住的是，在这种任务中对于界面的更新要采用SwingUtilities.invokeLater或者在SWT采用Synchronize方法，将访问操作放到EDT上进行。关于如何写一个有效处理长时间任务的Swing程序，将会在其他文章中描述。

         多线程模型中，所有的事件处理都是在异步线程中进行，界面组件同步访问的操作需要程序员来保证。这种模型设计本身很复杂，而且对于程序员来说要求比较高，必须对线程同步编程很熟悉，而且花在同步上的操作影响了平台的性能。一般现在的图形界面工具都不再采用这种方式。

         下面比较一下Swing/AWT/SWT在API、GUI特征以及实现方法的不同。

         在API上，Swing和AWT是兼容的，SWT是单独的一套接口。

1.Swing/AWT的组件在生成时可以脱离父组件独立存在，SWT必须有父组件存在。这主要是由于SWT的资源是自己管理，SWT程序必须负责释放不用的资源，为了避免这种释放资源的重复性，SWT父组件被设计成在析构时自动递归调用子组件的析构函数。

2.Swing/AWT的资源回收由垃圾收集器负责，SWT必须由SWT程序显式释放。

3.Swing/AWT的事件线程循环不需要程序员显式启动，SWT必须要程序员来显式启动。

         Swing/AWT和SWT在布局管理器上是类似的，没有太大区别。

         在GUI特征上，有两个比较层面，一个是组件种类，一个是组件本身特征。在理解这些特征时，一定要牢牢记住这样一个准则：Java是平台无关的语言，因此它对应用程序所提供的API一定要各个平台都相同，GUI特征其实也是API，所以GUI的特征必须在各个平台都相同。

         组件类型上，AWT采用的是最大公约数方法，而Swing/SWT采用的是最小公倍数方法。简单的说AWT是各个平台所有组件集合的交集，而Swing和SWT则是各个平台组件的并集。下图所示，假设操作系统平台OS1上提供组件{C1, C2, C3, C4, C7}，而OS2提供{C1, C2,C3, C4, C6}，OS3提供{C1, C2, C3, C4, C5}，那么其中的阴影部分就是AWT所实现的组件，由于C5、C6和C7是各个平台所特有的，因此AWT中就不包含这些组件。比如Table和Tree在Java支持某些操作系统平台中不包含，所以在AWT中就没有Table和Tree。由于AWT的组件太贫乏，所以AWT在现在复杂应用程序几乎没有什么用。Swing和SWT提供的组件是各平台所有组件的并集，这样就解决AWT的组件贫乏的缺陷。也就是说，Swing和SWT提供的组件包括C1到C7的所有组件，而AWT只提供C1到C4的所有组件。

         从组件本身的特征来看，SWT和AWT采用了相同的策略，即最大公约数，而Swing采用的是最小公倍数。如下图所示，假设对于同一个组件C，如果它在OS1上提供的特征包括{a,b,c,d,e}，而OS2上提供的特征包括{a,b,c}，而OS3包括的特征有{a,b,c,d}，那么SWT和AWT提供的组件特征只包括{a,b,c}，而Swing的包含的平台特征包括{a, b, c, d, e}。比如由于Solaris平台上的按钮不提供对于图标的支持，所以SWT和AWT的独立按钮就不提供对于按钮图标的支持，而Swing提供按钮图标的支持。

         在实现方法上，AWT采用Java+Native C Peer(一种JNI调用）方法，SWT根据各平台的不同情况，一部分组件使用Java+Java Peer+JNI Wrapper，一部分采用Java模拟的方法，而Swing则采用所有组件都纯粹Java模拟的方法。

                    AWT的接口和各操作系统组件之间的差别采用Native C Peer实现的方法来填平，下面是它的结构示意图：

           其中AWT Native Peer Impl部分都是C语言写的，在各种操作系统上是不同的，但是它们和AWT Component组件之间的AWT-Peer JNI调用接口是不变的，AWT Component的Java代码实现在各个平台上都是相同的，最后AWT Component向Application提供同一的API接口。

           SWT同AWT不同，它在Native Component上进行了一层薄薄的JNI封装，所有操作系统的API调用都被映射到一个JNI调用上，然后SWT通过Java代码组合这些JNI调用实现同一的API，下面是其结构示意图：

         因此SWT的Java代码实现部分在各个平台是不同的，它的C代码部分即JNI Wrapper部分只是一个各平台GUI API的JNI简单映射，SWT通过Java Peer在各平台的不同实现填平了各平台差异，从而给Application提供同一的API接口。当然SWT对于某种平台上缺少的组件采用的方法和Swing基本类似。

         Swing和上两中方式完全不同，它直接调用Java2D，抛弃了本地操作系统平台组件的实现，完全自己画出来了整个组件，当然Java2D底层也是调用平台的图形系统。下面是它的示意图：

         当然Swing是建立在AWT基础上的，对于一些顶层容器类如Frame / Dialog / Window以及Applet是直接采用AWT的，这儿为了方便并没有画出。由于Java2D API是个平台无关的，因此Swing的Java实现代码在个平台都是一样的，都是一套，当然除了与Swing的Look And Feel相关的东西以外。

         由于篇幅原因，今天就先谈到这儿，至于这三种不同架构、实现会对它们的性能和外观以及编程难度产生什么影响，我们以后的文章逐渐讨论。

　　如何使用全屏幕模式？

　　关键是java.awt.*里面的两个与显示设备有关的类：GraphicsEnvironment和GraphicsDevice。

　　GraphicsEnvironment为Java应用程序提供了特定平台的 GraphicsDevice对象和 Font 对象集合。这些GraphicsDevice可以是各种本机和远端机器的资源，如屏幕、打印机或者是Image Buffer,甚至是Graphics2D绘图方法的目标对象。

　　而GraphicsDevice就是指特定的图形环境了，如屏幕和打印设备等。这样，我们就可以用GraphicsDevice来操纵屏幕了。GraphicsDevice提供的setFullScreenWindow()方法就是设置全屏幕用的。

　　由于GraphicsEnvironment的构造器是受保护的(protected)，我们不能直接构造一个GraphicsEnvironment 对象来获得GraphicsDevice对象。幸好它提供了getLocalGraphicsEnvironment()方法，用来获得一个 GraphicsEnvironment实例：

　　GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();

　　有了GraphicsEnvironment可以调用getDefaultScreenDevice方法获得当前的屏幕设备了：

　　GraphicsDevice gd = ge.getDefaultScreenDevice();

　　自己动手体验一下

　　有了上面的简介，写一个实例来体验一下吧：

import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import javax.swing.JWindow;
public class FullScreenTest {
    public static void main(String[] args) {
        GraphicsEnvironment ge =

             GraphicsEnvironment.getLocalGraphicsEnvironment();

        GraphicsDevice gd = ge.getDefaultScreenDevice();

        FullScreenWindow myWindow = new FullScreenWindow();

        if ( gd.isFullScreenSupported() )

           gd.setFullScreenWindow(myWindow);

        else

            System.out.println("Unsupported full screen.");

    }
    static class FullScreenWindow extends JWindow {

        public FullScreenWindow() {

           this.addMouseListener(new MouseAdapter() {

                public void mousePressed(MouseEvent evt) {

                    quit();

                }

            });

        }

        public void quit() {

            this.dispose();

        }
        public void paint(Graphics g) {

            g.setFont(new Font("Arial",Font.BOLD,30));

            g.setColor(Color.RED);

            g.drawString("这是全屏幕模式",100,100);

        }

    }

}

public class InsertTextField extends JPanel {

 /**
  * @param args
  */
 public static void main(String[] args) {
  JFrame jf = new JFrame();
  jf.setContentPane(new InsertTextField());
  jf.pack();
  jf.setVisible(true);
 }
 public InsertTextField() {
  this.setLayout(new FlowLayout());
  final JTextField jtf = new JTextField(10);
  final IntegerDocument id = new IntegerDocument(10);
  jtf.addKeyListener(new KeyListener() {
   @Override
   public void keyPressed(KeyEvent e) {
    if (e.getKeyCode() == KeyEvent.VK_INSERT) {
     id.setFlag();
    }
   }
   @Override
   public void keyReleased(KeyEvent e) {
    //    jtf.setCaretPosition(jtf.getText().length());
   }

   @Override
   public void keyTyped(KeyEvent e) {

   }

  });
  jtf.setDocument(id);
  this.add(jtf);
 }

 class IntegerDocument extends PlainDocument {

  private boolean flag = false;

  public IntegerDocument(int n) {
   super();
  }

  public void setFlag() {
   boolean f = flag ? flag = false : (flag = true);
  }

  public void insertString(int offset, String s, AttributeSet ats)
    throws BadLocationException {

   try {
    super.insertString(offset, s, ats);
    if (flag) {
     remove(offset - 1, 1);
    }
   } catch (Exception ex) {
    Toolkit.getDefaultToolkit().beep();
   }
  }
 }
}
2、拖动JPanel，还有一些小bug，以后有空再改

/**
 * DragPanel Class
 *
 * author:zhangtao
 * mail:zht_dream@hotmail.com
 * 2007-9-26
 */
public class DragPanel extends JPanel implements MouseListener,
  MouseMotionListener {

 JPanel north_JP;

 JScrollPane cen_JP;

 /**
  * @param args
  */
 public static void main(String[] args) {
  JFrame jf = new JFrame();
  jf.setContentPane(new DragPanel());
  jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  jf.pack();
  jf.setVisible(true);
 }

 public DragPanel() {
  this.setLayout(new BorderLayout());
  north_JP = new JPanel();
  north_JP.add(new JButton("1"));
  north_JP.add(new JButton("2"));
  north_JP.add(new JButton("3"));
  north_JP.add(new JButton("4"));
  this.add("North", north_JP);
  cen_JP = new JScrollPane();
  cen_JP.setViewportView(new JTree());
  this.add(cen_JP);
  north_JP.addMouseListener(this);
  north_JP.addMouseMotionListener(this);

 }

 public void mouseClicked(MouseEvent e) {

 }

 public void mouseEntered(MouseEvent e) {
  // TODO Auto-generated method stub

 }

 public void mouseExited(MouseEvent e) {
  System.out.println("exit");
  this.setCursor(Cursor.getDefaultCursor());
 }

 public void mousePressed(MouseEvent e) {
  // TODO Auto-generated method stub

 }

 public void mouseReleased(MouseEvent e) {
  this.setCursor(Cursor.getDefaultCursor());
 }

 boolean dragFlag = false;

 public void mouseDragged(MouseEvent e) {
  dragFlag = true;
  if (flag) {
   this.setCursor(new Cursor(Cursor.N_RESIZE_CURSOR));
   Point po = e.getPoint();
   Dimension di = north_JP.getPreferredSize();
   north_JP.setPreferredSize(new Dimension(di.width,
     (north_JP.getY() + po.y)));
   north_JP.revalidate();
   north_JP.repaint();
  }
 }

 boolean flag = false;

 public void mouseMoved(MouseEvent e) {
  Point point = e.getPoint();
  this.setCursor(Cursor.getDefaultCursor());
  flag = false;
  dragFlag = false;
  if (((north_JP.getY() + north_JP.getHeight() - point.y) < 5)
    && ((north_JP.getY() + north_JP.getHeight() - point.y) > -5)) {
   this.setCursor(new Cursor(Cursor.N_RESIZE_CURSOR));
   flag = true;
  } else {
   this.setCursor(Cursor.getDefaultCursor());
  }
 }

}

3、载入修改properties的例子

package proper;

import java.awt.BorderLayout;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Iterator;
import java.util.Map;
import java.util.Properties;
import java.util.Vector;
import java.util.Map.Entry;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.table.DefaultTableModel;

/**
 *
 * Test Class
 *
 * author:zht
 * mail:zht_dream@hotmail.com
 * 2007-10-31
 */
public class Test extends JPanel implements ActionListener {

 /**
  * @param args
  */
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  Test test = new Test();
  JFrame jf = new JFrame();
  jf.setContentPane(test);
  jf.pack();
  jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  jf.setVisible(true);
 }

 JTable jt;

 JButton modify_JBn;

 Properties props = null;

 public Test() {
  try {
   props = loadPro();
  } catch (FileNotFoundException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (IOException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
  this.setLayout(new BorderLayout());
  String[] tn = { "名称", " 值", };
  String[][] data = {};
  DefaultTableModel defaultModel = new DefaultTableModel(data, tn) {
   @Override
   public boolean isCellEditable(int row, int column) {
    if (column == 0) {
     return false;
    } else
     return true;
   }
  };
  jt = new JTable(defaultModel);
  this.add(new JScrollPane(jt));
  {
   Iterator itor = props.entrySet().iterator();
   while (itor.hasNext()) {
    Map.Entry vEntry = (Entry) itor.next();
    Vector<Object> vv = new Vector<Object>();
    vv.add(vEntry.getKey());
    vv.add(vEntry.getValue());
    //做一些其他的事……
    System.out.println(vEntry.getKey());
    defaultModel.addRow(vv);
   }
  }
  modify_JBn = new JButton("modify");
  modify_JBn.addActionListener(this);
  JPanel jp = new JPanel();
  jp.setLayout(new FlowLayout());
  jp.add(modify_JBn);
  this.add("South", jp);
 }

 public Properties loadPro() throws FileNotFoundException, IOException {
  Properties props = new Properties();
  props.load(new FileInputStream(new File("config/config.properties")));
  return props;
 }

 @Override
 public void actionPerformed(ActionEvent e) {
  for (int i = 0; i < jt.getRowCount(); i++) {
   String name = jt.getValueAt(i, 0).toString();
   String value = jt.getValueAt(i, 1).toString();
   props.setProperty(name, value);
   System.out.println("==");
  }
  FileOutputStream fos;
  try {
   fos = new FileOutputStream(new File("config/config.properties"));
   props.store(fos, "");
  } catch (Exception e1) {
   // TODO Auto-generated catch block
   e1.printStackTrace();
  }
 }
}

 public GetInfoThread(Test applet) {
  this.applet = applet;
 }

  public void run() {
   while (true) {
    try {
     Thread.sleep(500);
     applet.getProgressBar().setValue(Math.random() * 100);
    } catch (InterruptedException e) {
     e.printStackTrace();
    }
   }
  }
 }
 错误分析：在actionPerformed中，监听器把按钮的允许状态设置为false，由于是在事件派发线程上调用actionPerformed，所以setEnabled是一个有效的操作，但是在GetInfoThread中设置进度条是一个危险的做法，因为事件派发线程以外的线程更新了进度条，所以运行是不正常的。

   1、invokeLater使用
    class GetInfoThread extends Thread {
  Test applet;
 
  Runnable runx;
 
  int value;

  public GetInfoThread(final Test applet) {
   this.applet = applet;
   runx = new Runnable() {
    public void run() {
     JProgressBar jpb = applet.getProgressBar();
     jpb.setValue(value);
    }
   };
  }

   public void run() {
    while (true) {
     try {
      Thread.sleep(500);
      value = (int) (Math.random() * 100);
      System.out.println(value);