JavaGUI应用程序部署

JavaGUI程序发布分类
 1)  Applet：可以嵌入到浏览器中，通过网页的方式展示给用户

 2)  application ：有两种发布方式

  ü 打包成jar包通过bat的方式运行，或者通过第三方软件打成exe(后续会再详细介绍)

  ü 通过Java Web Start的方式发布到服务器端，通过JNLP运行

 相对来说第二种方式可能更好一些，免除了更新的麻烦。

 用applet或者jws的方式发布，大部分都需要数字签名。

为什么要签名
 其实签名不是必须的，如果你的程序只是单纯的绘图，显示，只要不访问网络资源也不访问本地文件，是不用签名的，
 但是如果要访问本地或网上资源就必须签名，
 比如读取本地文件或者访问数据库，这是由java的沙箱机制决定的，即jvm内部有一组安全检查规则，要通过检查之后才能访问特定资源。

 如果要突破这个规则，可以有两个方法:

 1) 修改jre权限文件如下

  java.policy为grant {
   permission java.security.AllPermission;
        };

  一般权限文件的目录如下C:"Program Files"Java"jre6"lib"security

  但是修改每个客户端的权限文件，无论从时间还是操作上都是很麻烦的。

 2)  签名，意思就是告诉用户，这个程序是谁发布的，是不是能信任，如果客户确定，ok，这个applet或者jws就可以访问外部资源了。

如何签名

 1)首先确保你已经完全安装了Java2的环境，有keytool工具，它位于JDK的bin目录下。这一般不会有问题。

 2)到Dos状态下，进入你需发布应用程序的jar包所在的目录，运行下面这句话
   keytool -genkey -keystore myKeystore -alias jwstest -validity 1000
      它将会提示你输入用户名、密码等，按照提示随便输入即可，不输入直接回车即可，
   但一定要记住密码。运行结束它将会在当前路径下创建名为myKeystore的文件。

 3)如果你想查看一下刚才生成的myKeystore文件的内容，可以使用下面这句话：
  keytool -list -keystore myKeystore
  显示出来应该类似如下：
  Keystore type: jks
  Keystore provider: SUN
  Your keystore contains 1 entry:
  jwstest, Tue Nov 23 19:29:32 PST 2001, keyEntry,
  Certificate fingerprint (Test):
  C3:A9:CD:F3:D3:AC:4D:3F:3C:5B:AF:9E:CF:0D:46:5C

 4)对你需发布应用程序的jar包进行签名，运行下面这句话：
  jarsigner -keystore myKeystore yourtest.jar jwstest
  其中yourtest.jar是你的jar包名，你需要修改它，别的就不必修改了。
  运行时会提示你输入密码，就是你刚才在生成myKeystore文件时设定的密码。

如果有很多jar包怎么办

 在开发的过程中很可能会引用到第三方的jar包，而第三方的jar包又可能引用到其它的，所以可能有很多的jar包，需要和applet一起发布，有两个方法
  1) 分别打包签名，使用于包比较少，比如只有3、4个的情况
        2) 只 把applet的jar包签名，让用户确认访问授权，applet已经被用户授权，那么就可以在applet里改变安全管理器（SecurityManager）
   只需要继承SecurityManager类，创建自己的安全管理器类，然后覆盖checkPermission方法，允许访问任何资源。
   在applet的init方法中调用System.setSecurityManager把安全管理器设置为我们自定义的即可。

 class CustomManager extends SecurityManager {
  public void checkPermission(Permission perm, Object context) {
  }
  public void checkPermission(Permission perm) {
  }
 }
 

其它一些相关资料如下

 JDK中keytool常用命令

 -genkey      在用户主目录中创建一个默认文件".keystore",还会产生一个mykey的别名，mykey中包含用户的公钥、私钥和证书
 -alias       产生别名
 -keystore    指定密钥库的名称(产生的各类信息将不在.keystore文件中
 -keyalg      指定密钥的算法   
 -validity    指定创建的证书有效期多少天
 -keysize     指定密钥长度
 -storepass   指定密钥库的密码
 -keypass     指定别名条目的密码
 -dname       指定证书拥有者信息 例如：  "CN=sagely,OU=atr,O=szu,L=sz,ST=gd,C=cn"
 -list        显示密钥库中的证书信息      keytool -list -v -keystore sage -storepass ....
 -v           显示密钥库中的证书详细信息
 -export      将别名指定的证书导出到文件  keytool -export -alias caroot -file caroot.crt
 -file        参数指定导出到文件的文件名
 -delete      删除密钥库中某条目          keytool -delete -alias sage -keystore sage
 -keypasswd   修改密钥库中指定条目口令    keytool -keypasswd -alias sage -keypass .... -new .... -storepass ... -keystore sage
 -import      将已签名数字证书导入密钥库  keytool -import -alias sage -keystore sagely -file sagely.crt
     导入已签名数字证书用keytool -list -v 以后可以明显发现多了认证链长度，并且把整个CA链全部打印出来。

 Keytool 是安全钥匙与证书的管理工具.它管理一个存储了私有钥匙和验证相应公共钥匙的与它们相关联的X.509 证书链的keystore(相当一个数据库).

 Keytool 是一个有效的安全钥匙和证书的管理工具. 它能够使用户使用数字签名来管理他们自己的私有/公共钥匙对,管理用来作自我鉴定的相关的证书,管理数据完整性和鉴定服务.它还能使用户在通信时缓存它们的公共钥匙.

 一个证书是某一实体(个人,公司等)的数字签名,指出其他实体的公共钥匙(或其他信息)的详细的值.当数据被签名后,这个签名信息被用来检验数据的完整性和真实性.完整性指数据没有被修改和篡改,真实性指数据从任何产生和签名的一方真正的传输到达.

 Keytool 把钥匙和证书储存到一个keystore.默任的实现keystore的是一个文件.它用一个密码保护钥匙.

 而另外的一个工具jarsigner用keystore中的信息产生或检验Java aRchive(jar文件)中的数字签名.

 Keystore有两个不同的入口:

 1.钥匙入口:保存了非常敏感的加密的钥匙信息,并且是用一个保护的格式存储以防止未被授权的访问.以这种形式存储的钥匙是秘密钥匙,或是一个对应证书链中公有钥匙的私有钥匙.

 2.信任证书入口:包含一个属于其他部分的单一公共钥匙证书.它之所以被称为"信任证书",是因为keystore信任的证书中的公共钥匙真正属于证书所有者的身份识别.

 Keystore的别名:

 所有的keystore入口(钥匙和信任证书入口)是通过唯一的别名访问.别名是 不区分大小写的.如别名Hugo和hugo指向同一个keystore入口.

 可以在加一个入口到keystore的时候使用-genkey参数来产生一个钥匙对(公共钥匙和私有钥匙)时指定别名.也可以用-import参数加一个证书或证书链到信任证书.

 如:

 keytool -genkey -alias duke -keypass dukekeypasswd

 其中duke为别名,dukekeypasswd为duke别名的密码.这行命令的作用是产生一个新的公共/私有钥匙对.

 假如你想修改密码,可以用:

 keytool -keypasswd -alias duke -keypass dukekeypasswd -new newpass

 将旧密码dukekeypasswd改为newpass.

 Keystore的产生:

 1.当使用-genkey 或-import或-identitydb命令添加数据到一个keystore,而当这个keystore不存在时,产生一个keystore.默认名是.keystore,存放到user-home目录.

 2.当用-keystore指定时,将产生指定的keystore.

 Keystore的实现:

 Keytool 类位于java.security包下,提供一个非常好的接口去取得和修改一个keystore中的信息. 目前有两个命令行:keytool和jarsinger,一个GUI工具Policy 可以实现keystore.由于keystore是公开的,用户可以用它写一些额外的安全应用程序.

 Keystore还有一个sun公司提供的內在实现.它把keystore作为一个文件来实现.利用了一个keystore类型(格式)"JKS".它用单独的密码保护每一个私有钥匙.也用可能不同的密码保护整个keystore的完整性.

 支持的算法和钥匙大小:

 keytool允许用户指定钥匙对和注册密码服务供应者所提供的签名算法.缺省的钥匙对产生算法是"DSA".假如私有钥匙是"DSA"类型,缺省签名算法是"SHA1withDSA",假如私有钥匙是"RSA"类型,缺省算法是"MD5withRSA".

 当产生一个DSA钥匙对,钥匙必须在512-1024位之间.对任何算法的缺省钥匙大小是1024位.

 证书:

 一个证书是一个实体的数字签名,指出其他实体的公共钥匙有明确的值.

 1.公共钥匙 :是同一个详细的实体的数字关联,并有意让所有想同这个实体发生信任关系的其他实体知道.公共钥匙用来检验签名;

 2.数字签名:假如数据已被签名,并用身份存储在一个实体中,一个签名能够证明这个实体知道这个数据.这个数据用实体私有钥匙签名并递交;

 3.身份:知道实体的方法.在一些系统中身份是公共钥匙,其他系统中可以是从一个X.509名字的邮件地址的Unix UID来的任何东西;

 4.签名:一个签名用用实体私有钥匙来计算某些加密数据;

 5.私有钥匙:是一些数字,每一个私有钥匙只能被特定的拥有该私有钥匙的实体知道.私有和公共钥匙存在所有用公共钥匙加密的系统的钥匙对中.一个公共钥匙加密(如DSA),一个私有钥匙与一个正确的公共钥匙通信.私有钥匙用来计算签名.

 6.实体:一个实体可以是一个人,一个组织,一个程序,一台计算机,一个商业,一个银行,或其他你想信任的东西.

 Keytool应用实例:

 1.产生一个keystore:

 keytool -genkey -alias User(keystore的别名) -keyalg RSA -validity 7 -keystore keystore(指定keystore).

 运行这个命令,系统提示:

 Enter keystore password:yourpassword(输入密码)

 What is your first and last name?

 [Unknown]: your name(输入你的名字)

 What is the name of your organizational unit?

 [Unknown]:your organizational(输入你所在组织单位的名字)

 What is the name of your organization?

 [Unknown]:your organization name (输入你所在组织的名字)

 What is the name of your City or Locality?

 [Unknown]:your city name(输入所在城市的名字)

 What is the name of your State or Province?

 [Unknown]:your provice name(输入所在省份名字)

 What is the two-letter country code for this unit?

 [Unknown]:cn(输入国家名字)

 Is CN=your name, OU=your organizaion, O="your organization name",

 L=your city name, ST=your province name, C=cn correct?

 [no]: yes

 2.检查一个keystore:

 keytool -list -v -keystore keystore

 Enter keystore password:your password(输入密码)

 将显示keystore內容如:

 Keystore type: jks

 Keystore provider: SUN

 Your keystore contains 1 entry

 Alias name: yourname

 Creation date: Dec 20, 2001

 Entry type: keyEntry

 Certificate chain length: 1

 Certificate[1]:

 Owner: CN=yourname, OU=your organization, O="your organization name",

 L=your city name, ST=your province name, C=CN

 Issuer: CN=Duke, OU=Java Software, O="Sun Microsystems, Inc.", L=Palo Alto, ST=CA, C=US

 Serial number: 3c22adc1

 Valid from: Thu Dec 20 19:34:25 PST 2001 until: Thu Dec 27 19:34:25 PST 2001

 Certificate fingerprints:

 MD5: F1:5B:9B:A1:F7:16:CF:25:CF:F4:FF:35:3F:4C:9C:F0

 SHA1: B2:00:50:DD:B6:CC:35:66:21:45:0F:96:AA:AF:6A:3D:E4:03:7C:74

 3.输出keystore到一个文件:testkey:

 keytool -export -alias duke -keystore keystore -rfc -file testkey

 系统输出:

 Enter keystore password:your password(输入密码)

 Certificate stored in file < td>

 4.输入证书到一个新的truststore:

 keytool -import -alias dukecert -file testkey -keystore truststore

 Enter keystore password:your new password.(输入truststore新密码)

 5.检查truststore:

 keytool -list -v -keystore truststore

 系统将显示truststore的信息.

 现在可以用适当的keystore运行你的应用程序.如:

 java -Djavax.net.ssl.keyStore=keystore -Djavax.net.ssl.keyStorePassword=password Server

 和: java -Djavax.net.ssl.trustStore=truststore

 -Djavax.net.ssl.trustStorePassword=trustword Client

 by

   张涛
    zht_dream@hotmail.com

    很多时候，我们需要在界面初始化以后对程序进行某些设置，举个例子，当界面呈现出来以后，设置下SplitPane的的百分比(关于这个为什么必须这么处理请参考java源代码)。很容易我们就想到给程序添加ComponentListener监听，然后在监听中作处理，如下所示

public class Test {
    public static void main(String[] args) {
        new Test();
    }

    public Test() {
        final JPanel panel = new JPanel();
        panel.addComponentListener(new ComponentAdapter() {
            public void componentShown(ComponentEvent e) {
                System.out.println(panel.getBounds());
                System.out.println("panel:shown");
            }
        });
        //        panel.setVisible(false);
        //        panel.setVisible(true);
        panel.addHierarchyListener(new HierarchyListener() {
            public void hierarchyChanged(HierarchyEvent e) {
                if ((e.getChangeFlags() & HierarchyEvent.SHOWING_CHANGED) != 0) {
                    if (e.getComponent().isShowing()) {
                        System.out.println(panel.getBounds());
                        System.out.println("panel:hshow");
                    }
                    else {
                        System.out.println("panel:hhide");
                    }
                }
            }
        });

        JFrame frame = new JFrame();

        frame.addComponentListener(new ComponentAdapter() {
            public void componentShown(ComponentEvent e) {
                System.out.println("frame:shown");
            }
        });

        frame.setContentPane(panel);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(500, 400);
        frame.setVisible(true);
    }
}

/**
* Title PopupMenu
*
* @author zhangtao
*
* Msn & Mail: zht_dream@hotmail.com
*/
public class ZHTPopupMenu extends JPopupMenu {

    public static final int POSITION_TOP = 1;
    public static final int POSITION_BOTTOM = 2;
    public static final int POSITION_LEFT = 3;
    public static final int POSITION_RIGHT = 4;

    private int titleSize = 30;
    private Color titleColor = Color.BLACK;
    private Color titleFillColor = Color.WHITE;
    private boolean titleGradient = true;
    private Color titleGradientColor = new Color(0, 50, 50);
    private Font titleFont = new Font("Dialog", Font.BOLD, 12);
    private int titlePosition = POSITION_LEFT;
    private int titleGap = 5;

    public ZHTPopupMenu() {
        super();
    }

    public ZHTPopupMenu(String label) {
        super(label);
    }

    @Override
    public Insets getInsets() {
        Insets insets = (Insets) super.getInsets().clone();
        switch (titlePosition) {
        case POSITION_TOP:
            insets.top += titleSize;
            break;
        case POSITION_BOTTOM:
            insets.bottom += titleSize;
            break;
        case POSITION_LEFT:
            insets.left += titleSize;
            break;
        case POSITION_RIGHT:
            insets.right += titleSize;
            break;
        }
        return insets;
    }

    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        Graphics2D g2d = (Graphics2D) g.create();
        Dimension size = this.getSize();
        GradientPaint paint;
        g2d.setColor(titleFillColor);
        String text = this.getLabel();
        int len = 0;//text.length();
        if (text != null && text.trim().length() > 0) {
            len = text.length();
        }
        boolean hasEN = false;
        for (int i = 0; i < len; i++) {
            if (isEN(text.charAt(i))) {
                hasEN = true;
                break;
            }
        }
        JLabel label = new JLabel(text);
        label.setFont(titleFont);
        label.setForeground(titleColor);
        Dimension labelSize = label.getPreferredSize();
        switch (titlePosition) {
        case POSITION_TOP: {
            if (titleGradient) {
                paint = new GradientPaint(0, 0, titleFillColor, size.width, titleSize, titleGradientColor);
                g2d.setPaint(paint);
            }
            g2d.fillRect(0, 0, size.width, titleSize);
            if (len != 0) {
                ZHTUtils.paintComponent(g2d, label, this, titleGap, titleGap, labelSize.width, labelSize.height);
            }
        }
            break;
        case POSITION_BOTTOM: {
            if (titleGradient) {
                paint = new GradientPaint(0, size.height - titleSize, titleFillColor, size.width, size.height, titleGradientColor);
                g2d.setPaint(paint);
            }
            g2d.fillRect(0, size.height - titleSize, size.width, titleSize);
            if (len != 0) {
                ZHTUtils.paintComponent(g2d, label, this, titleGap, size.height - titleGap - labelSize.height, labelSize.width, labelSize.height);
            }
        }
            break;
        case POSITION_LEFT: {
            if (titleGradient) {
                paint = new GradientPaint(0, 0, titleFillColor, titleSize, size.height, titleGradientColor);
                g2d.setPaint(paint);
            }
            g2d.fillRect(0, 0, titleSize, size.height);
            if (len != 0) {
                if (hasEN) {
                    g2d.rotate(90 * Math.PI / 180, titleGap, titleGap);
                    ZHTUtils.paintComponent(g2d, label, this, titleGap, titleGap - labelSize.height, labelSize.width, labelSize.height);
                } else {
                    int sum = 0;
                    for (int i = 0; i < len; i++) {
                        label.setText(text.charAt(i) + "");
                        labelSize = label.getPreferredSize();
                        ZHTUtils.paintComponent(g2d, label, this, titleGap, sum, labelSize.width, labelSize.height);
                        sum += labelSize.height;
                    }
                }
            }
        }
            break;
        case POSITION_RIGHT: {
            if (titleGradient) {
                paint = new GradientPaint(size.width - titleSize, 0, titleFillColor, size.width, size.height, titleGradientColor);
                g2d.setPaint(paint);
            }
            g2d.fillRect(size.width - titleSize, 0, titleSize, size.height);
            if (len != 0) {
                if (hasEN) {
                    g2d.rotate(90 * Math.PI / 180, size.width - titleSize + titleGap, titleGap);
                    ZHTUtils.paintComponent(g2d, label, this, size.width - titleSize + titleGap, titleGap - labelSize.height, labelSize.width, labelSize.height);
                } else {
                    int sum = 0;
                    for (int i = 0; i < len; i++) {
                        label.setText(text.charAt(i) + "");
                        labelSize = label.getPreferredSize();
                        ZHTUtils.paintComponent(g2d, label, this, size.width - titleGap - labelSize.width, sum, labelSize.width, labelSize.height);
                        sum += labelSize.height;
                    }
                }
            }
        }
            break;
        }
    }

    public static boolean isEN(char cn) {
        byte[] bytes = (String.valueOf(cn)).getBytes();
        if (bytes == null || bytes.length > 2 || bytes.length <= 0) { // 错误 
            return false;
        }
        if (bytes.length == 1) { // 英文字符 
            return true;
        }
        if (bytes.length == 2) { // 中文字符 
            return false;
        }
        return false;
    }

    public int getTitleSize() {
        return titleSize;
    }

    public void setTitleSize(int titleSize) {
        this.titleSize = titleSize;
        this.repaint();
    }

    public Color getTitleColor() {
        return titleColor;
    }

    public void setTitleColor(Color titleColor) {
        this.titleColor = titleColor;
        this.repaint();
    }

    public Color getTitleFillColor() {
        return titleFillColor;
    }

    public void setTitleFillColor(Color titleFillColor) {
        this.titleFillColor = titleFillColor;
        this.repaint();
    }

    public boolean isTitleGradient() {
        return titleGradient;
    }

    public void setTitleGradient(boolean titleGradient) {
        this.titleGradient = titleGradient;
        this.repaint();
    }

    public Color getTitleGradientColor() {
        return titleGradientColor;
    }

    public void setTitleGradientColor(Color titleGradientColor) {
        this.titleGradientColor = titleGradientColor;
        this.repaint();
    }

    public Font getTitleFont() {
        return titleFont;
    }

    public void setTitleFont(Font titleFont) {
        this.titleFont = titleFont;
        this.repaint();
    }

    public int getTitlePosition() {
        return titlePosition;
    }

    public void setTitlePosition(int titlePosition) {
        this.titlePosition = titlePosition;
        this.repaint();
    }

    public int getTitleGap() {
        return titleGap;
    }

    public void setTitleGap(int titleGap) {
        this.titleGap = titleGap;
        this.repaint();
    }
} 

在此介绍下，如何可视化开发Swing组件。现在Java主流的两款开发工具NetBeans和Eclipse都提供了可视化的功能。

一、NetBeans
这个无需多言，Sun官方推荐的Swing开发工具，自身已经集成了可视化工具。
下载地址：
http://www.netbeans.org/downloads/index.html

二、Eclipse
Eclipse本身不提供可视化功能，需要插件来辅助。
我了解到的，比较常用的插件有两种
1、Visual Editor  简称VE
关于安装 请参考
http://wiki.eclipse.org/VE/Installing/Archived

说明如下:
VE Installation
Make sure eclipse is close.
Go to http://sourceforge.net/project/showfiles.php?group_id=131065&package_id=154855
Click "Visual Editor patched as in bug 202562"
Click org.eclipse.visualeditor-1.3.0.200709121813.zip
Unpack the .zip file somewhere
In that extracted folder, there is an " org.eclipse.visualeditor-1.3.0.200709121813" subdir, copy what's in that directory to your eclipse installation dir, say yes if prompted to overwrite.
Open eclipse again and go to Window->Preferences->Java. If after expanding 'Java' you see Visual Editor at the bottom, then you are good to go.

下载地址
http://sourceforge.net/projects/easyeclipse/files/Various%20Patches/Visual%20Editor%20patched%20as%20in%20bug%20202562/org.eclipse.visualeditor-1.3.0.200709121813-2.zip/download

2、jigloo
这个以前用过，感觉还可以。
官方网站是
http://cloudgarden.com/jigloo/

下载网址
http://cloudgarden.com/jigloo/dnld_redirect.html

安装说明
Please note: if you have installed 4.0 RC1 or RC2 you will need to delete these folders from the plugins and features folders in eclipse before installing version 4.0.
Alternatively, you can download the zip file from here. Unzip it into the eclipse folder so that the structure is eclipse/plugins/com.cloudgarden.jigloo_4.0.0

安装都很简单，建议使用link的方式来安装Eclipse插件，方便插件管理，如下所示:
解压yourplugin.zip到任意目录下，比如D:\eclipseplugins\yourplugin。
在Eclipse的目录下有个links文件夹，在里面新建文件，命名为anyname.link，编辑此文件，加入如下内容并保存。path = D:/eclipseplugins/yourplugin
详细使用，请自行搜索。

其它还有

附
使用可视化工具拖拽编写Swing程序，一定要注意变量名和代码的可读性，否则代码非常让人崩溃。

                                                                                                                                                                                                             2009.6.7

关于“Java做不好桌面”的争论已经由来已久。虽然Swing和Java2D已经有超过十年的历史，也有JIDE、JGoodies、TWaver等不少开源Swing组件，但是用Java做桌面程序仍然不是一件轻松的事。本《Java也惊艳》系列文章，就是想通过一些简单生动的例子，和大家一起认识Java、探索Swing。其实你只需要多一点创意、多一点耐心，你的Java程序也可以“惊艳”！本文就带您一起进入Java的惊艳之旅。

二、立体套管效果

在网络通讯中，经常要表达协议之间的“承载”关系。例如，IP协议作为高层协议可以承载在SDH上，也可以承载在ATM协议上。同样，IP作为协议还可以承载更多的高层协议，例如Voice over IP，甚至电信中Everything over IP的概念。在表现上，用相互嵌套的立体套管来表现协议的“承载”是再合适不过了（如下图）。

三、总结

本文知识要点：
 渐变填充：创建GradientPaint并设置“亮-暗-亮”的填充模式；
 使用Clip：类似蒙版/剪切的Java2D技术。看看Graphics的setClip函数即可；
 Area的使用：主要是Area的相交、合并等几个常见图形处理手法。详细请看java.awt.geom.Area类；
 使用随机色：这个就太简单了，如果有twaver.jar，可以直接使用TWaverUtil.getRandomColor()；如果没有，就直接new Color就行了，注意使用第四个int参数增加Alpha透明度的变化；

如果大家感兴趣，可以尝试用上述Java2D技巧实现下图效果：

六、参考资料

http://java.sun.com/j2se/1.4.2/docs/guide/2d/spec/j2d-bookTOC.html

http://java.sun.com/j2se/1.4.2/docs/guide/2d/spec.html

http://www.apl.jhu.edu/~hall/java/Java2D-Tutorial.html

一、序言

关于“Java做不好桌面”的争论已经由来已久。虽然Swing和Java2D已经有超过十年的历史，也有JIDE、JGoodies、TWaver等不少开源Swing组件，但是用Java做桌面程序仍然不是一件轻松的事。本《Java也惊艳》系列文章，就是想通过一些简单生动的例子，和大家一起认识Java、探索Swing。其实你只需要多一点创意、多一点耐心，你的Java程序也可以“惊艳”！本文就带您一起进入Java的“水晶之恋”。

二、立体水晶效果

受苹果公司的影响，现在立体水晶风格的界面非常流行。Java也可以吗？我们不妨先尝试一下用Java绘制一个立体水晶风格的按钮到底有多难。一个立体的水晶按钮应当有一个图标、一个圆角矩形区域、边框以及一些立体反光效果，如下图：

 

简单思路如下：先画矩形区域，然后画图标，然后设置clip并画高亮反光区域，最后画外部边框。

具体实现比较简单，主要代码如下：

Color color = TWaverUtil.getRandomColor(); 
 RoundRectangle2D body = new RoundRectangle2D.Float(x, y, size, size, size / 3, size / 3); 

//draw body 
g2d.setColor(color); 
GradientPaint paint = new GradientPaint(x, 
                    y, 
                    color.darker(), 
                    x, 
                    y + size, 
                    color.brighter().brighter()); 
g2d.setPaint(paint); 
g2d.fill(body); 

//draw image 
g2d.setClip(body); 
Image image = TWaverUtil.getImage("/glass/" + i + ".png"); 
g2d.drawImage(image, 
               x + (size - image.getWidth(null)) / 2, 
               y + (size - image.getHeight(null)) / 2, 
               null); 
g2d.setClip(null); 

//draw highlight. 
Shape highlightArea = createHighlightShape(x, y, size, body); 
g2d.setColor(new Color(255, 255, 255, 150)); 
g2d.fill(highlightArea); 

//draw outline. 
g2d.setColor(color.darkGray); 
g2d.draw(body);

运行程序效果如下：

 

三、更多变化

唯一略有不同的部分是，水晶球的高亮区域要用两个圆形拼切：

运行效果如下：


如果再来点儿循环、随机大小、随机位置、随机颜色，就可以做出绚丽的“吹肥皂泡”的效果


 

四、融入Swing组件

以上例子仅使用了Java2D进行绘图。在实际使用中，需要将这些效果应用的Swing组件中，例如按钮等。一个简单的方式是：将以上图形效果在内存中生成内存图片并封装到一个ImageIcon中，然后将ImageIcon图标作为JButton的图标进行显示。

然后，用这些Icon创建一些按钮并显示：

效果如下图：

本例子没有使用Look And Feel。你也可以使用JGoodies来美化一下，效果肯定更好。

五、总结

可以看出，画出这类立体水晶效果并不难，只需仔细观察这些效果的光学细节，并用Java2D的API来实现即可。这些例子稍作改进，就可以用来绘制JButton等Swing组件，并用在实际项目中。或者，也可以应用这些技巧来做一些复杂图形界面，如在TWaver中做出的网络拓扑图效果：

 

本文知识要点：

n         渐变填充：这个使用GradientPaint就行了；

n         使用Clip：类似蒙版/剪切的Java2D技术。看看Graphics的setClip函数就明白了；

n         Area的使用：主要是Area的相交、合并等几个常见图形处理手法。详细请看java.awt.geom.Area类；

n         生成内存图片：主要是BufferedImage类的使用；

如果大家感兴趣，可以尝试用上述Java2D技巧实现下图效果：

以上内容转载请注明
 

六、参考资料

http://java.sun.com/j2se/1.4.2/docs/guide/2d/spec/j2d-bookTOC.html

http://java.sun.com/j2se/1.4.2/docs/guide/2d/spec.html

http://www.apl.jhu.edu/~hall/java/Java2D-Tutorial.html

       下面表格列出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);
      SwingUtilities.invokeLater(runx);
     } catch (InterruptedException e) {
      e.printStackTrace();
     }
    }
   }
  }
   
   2、invokeAndWait
   与invoikeLater一样，invokeAndWait也把可运行对象排入事件派发线程的队列中，invokeLater在把可运行的对象放入队列后就返回，而invokeAndWait一直等待知道已启动了可运行的run方法才返回。如果一个操作在另外一个操作执行之前必须从一个组件获得信息，则invokeAndWait方法是很有用的。
   class GetInfoThread extends Thread {
   Runnable getValue,setValue;
   int value,currentValue;
   public GetInfoThread(final Test applet){
   getValue=new Runnable(){
   public void run(){
    JProgressBar pb=applet.getProgressBar();
    currentValue=pb.getValue();
    }
   };
   setValue=new Runnable(){
    public void run(){
     JProgressBar pb=applet.getProgressBar();
     pb.setValue(value);
    }
   }
   }
   public void run(){
    while(true){
    try{
    Thread.currentThead().sleep(500);
    value=(int)(Math.random()*100);
    try{
    SwingUtilities.invokeAndWait(getValue);//直到getValue可运行的run方法返回后才返回
      }catch(Exception ex){
      }
      if(currentValue!=value){
      SwingUtilities.invokeLater(setValue);
      }
     }
     }catch(Exception ex){
      }
    }
   }
   invokeLater和invoikeAndWait的一个重要区别：可以从事件派发线程中调用invokeLater，却不能从事件派发线程中调用invokeAndWait，从事件派发线程调用invokeAndWait的问题是：invokeAndWait锁定调用它的线程，直到可运行对象从事件派发线程中派发出去并且该可运行的对象的run方法激活，如果从事件派发线程调用invoikeAndWait，则会发生死锁的状况，因为invokeAndWait正在等待事件派发，但是，由于是从事件派发线程中调用invokeAndWait，所以直到invokeAndWait返回后事件才能派发。
   ex）actionPerformed();返回的时候事件派发线程才能派发线程，而在actionPerformed中使用invokeAndWait则会导致actionPerformed不能返回。所以也就无法派发invokeAndWait中的线程。

由于Swing是线程不安全的，所以，从事件派发线程之外的线程访问Swing组件是不安全的，SwingUtilities类提供这两种方法用于执行事件派发线程中的代码

虽然网上商店形式多样,每个站点有自己的特色,但也有其一般的共性,单就"商品的变化,以便及时通知订户"这一点,是很多网上商店共有的模式,这一模式类似Observer patern.

具体的说,如果网上商店中商品在名称 价格等方面有变化,如果系统能自动通知会员,将是网上商店区别传统商店的一大特色.这就需要在商品product中加入Observer这样角色,以便product细节发生变化时,Observer能自动观察到这种变化,并能进行及时的update或notify动作.

Java的API还为为我们提供现成的Observer接口Java.util.Observer.我们只要直接使用它就可以.

我们必须extends Java.util.Observer才能真正使用它:
1.提供Add/Delete observer的方法;
2.提供通知(notisfy) 所有observer的方法;

我们注意到,在product类中 的setXXX方法中,我们设置了 notify(通知)方法, 当调用setXXX,实际上就触发了notisfyObservers方法,这将通知相应观察者应该采取行动了.

下面看看这些观察者的代码,他们究竟采取了什么行动:

import javax.swing.JButton;
import javax.swing.JEditorPane;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextPane;
import javax.swing.UIManager;
import javax.swing.WindowConstants;
import javax.swing.text.AttributeSet;
import javax.swing.text.DefaultStyledDocument;
import javax.swing.text.Document;
import javax.swing.text.EditorKit;
import javax.swing.text.MutableAttributeSet;
import javax.swing.text.SimpleAttributeSet;
import javax.swing.text.StyleConstants;
import javax.swing.text.StyledDocument;
import javax.swing.text.StyledEditorKit;

public class NewJFrame extends javax.swing.JFrame implements ActionListener {
 private JPanel jp1;

 private JButton color;

 private JTextPane jep;

 private JScrollPane jsp;

 private JButton font;

 /**
  * Auto-generated main method to display this JFrame
  */
 public static void main(String[] args) {
  NewJFrame inst = new NewJFrame();
  inst.setVisible(true);
 }

 public NewJFrame() {
  super();
  initGUI();
 }

 private void initGUI() {
  try {
   BorderLayout thisLayout = new BorderLayout();
   getContentPane().setLayout(thisLayout);
   setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
   {
    jp1 = new JPanel();
    getContentPane().add(jp1, BorderLayout.NORTH);
    {
     font = new JButton();
     font.addActionListener(this);
     jp1.add(font);
     font.setText("font");
    }
    {
     color = new JButton();
     jp1.add(color);
     color.addActionListener(this);
     color.setText("color");
    }
   }
   {
    jsp = new JScrollPane();
    getContentPane().add(jsp, BorderLayout.CENTER);
    {
     jep = new JTextPane();
     jsp.setViewportView(jep);
     jep.setDocument(new DefaultStyledDocument());
    }
   }
   pack();
   setSize(400, 300);
  } catch (Exception e) {
   e.printStackTrace();
  }
 }

 public static void setFontSize(JEditorPane editor, int size) {
  if (editor != null) {
   if ((size > 0) && (size < 512)) {
    MutableAttributeSet attr = new SimpleAttributeSet();
    StyleConstants.setFontSize(attr, size);
    setCharacterAttributes(editor, attr, false);
   } else {
    UIManager.getLookAndFeel().provideErrorFeedback(editor);
   }
  }
 }

 public static void setForeground(JEditorPane editor, Color fg) {
  if (editor != null) {
   if (fg != null) {
    MutableAttributeSet attr = new SimpleAttributeSet();
    StyleConstants.setForeground(attr, fg);
    setCharacterAttributes(editor, attr, false);
   } else {
    UIManager.getLookAndFeel().provideErrorFeedback(editor);
   }
  }
 }

 public static final void setCharacterAttributes(JEditorPane editor,
   AttributeSet attr, boolean replace) {
  int p0 = editor.getSelectionStart();
  int p1 = editor.getSelectionEnd();
  if (p0 != p1) {
   StyledDocument doc = getStyledDocument(editor);
   doc.setCharacterAttributes(p0, p1 - p0, attr, replace);
  }
  StyledEditorKit k = getStyledEditorKit(editor);
  MutableAttributeSet inputAttributes = k.getInputAttributes();
  if (replace) {
   inputAttributes.removeAttributes(inputAttributes);
  }
  inputAttributes.addAttributes(attr);
 }

 protected static final StyledDocument getStyledDocument(JEditorPane e) {
  Document d = e.getDocument();
  if (d instanceof StyledDocument) {
   return (StyledDocument) d;
  }
  throw new IllegalArgumentException("document must be StyledDocument");
 }

 protected static final StyledEditorKit getStyledEditorKit(JEditorPane e) {
  EditorKit k = e.getEditorKit();
  if (k instanceof StyledEditorKit) {
   return (StyledEditorKit) k;
  }
  throw new IllegalArgumentException("EditorKit must be StyledEditorKit");
 }

 public void actionPerformed(ActionEvent e) {
  Object obj = e.getSource();
  if (obj == font) {
   JEditorPane editor = jep;
   setFontSize(editor, 20);
  }
  if (obj == color) {
   JEditorPane editor = jep;
   setForeground(editor, Color.red);
  }
 }

}
其他操作如下：
1、对字体的操作
MutableAttributeSet attr = new SimpleAttributeSet();
    StyleConstants.setFontFamily(attr, family);
    setCharacterAttributes(editor, attr, false);
family为字体
2、对字体大小的操作
MutableAttributeSet attr = new SimpleAttributeSet();
    StyleConstants.setFontSize(attr, size);
    setCharacterAttributes(editor, attr, false);
size为字号
3、是否是粗体的操作
StyledEditorKit kit = getStyledEditorKit(editor);
   MutableAttributeSet attr = kit.getInputAttributes();
   boolean bold = (StyleConstants.isBold(attr)) ? false : true;
   SimpleAttributeSet sas = new SimpleAttributeSet();
   StyleConstants.setBold(sas, bold);
   setCharacterAttributes(editor, sas, false);
4、是否是斜体的操作
StyledEditorKit kit = getStyledEditorKit(editor);
   MutableAttributeSet attr = kit.getInputAttributes();
   boolean italic = (StyleConstants.isItalic(attr)) ? false : true;
   SimpleAttributeSet sas = new SimpleAttributeSet();
   StyleConstants.setItalic(sas, italic);
   setCharacterAttributes(editor, sas, false);
5、是否有下划线的操作
StyledEditorKit kit = getStyledEditorKit(editor);
   MutableAttributeSet attr = kit.getInputAttributes();
   boolean underline = (StyleConstants.isUnderline(attr)) ? false
     : true;
   SimpleAttributeSet sas = new SimpleAttributeSet();
   StyleConstants.setUnderline(sas, underline);
   setCharacterAttributes(editor, sas, false);
6、左中右对齐的处理
MutableAttributeSet attr = new SimpleAttributeSet();
   StyleConstants.setAlignment(attr, a);
   setParagraphAttributes(editor, attr, false);
public static final void setParagraphAttributes(JEditorPane editor,
   AttributeSet attr, boolean replace) {
  int p0 = editor.getSelectionStart();
  int p1 = editor.getSelectionEnd();
  StyledDocument doc = getStyledDocument(editor);
  doc.setParagraphAttributes(p0, p1 - p0, attr, replace);
 }
a:0：左，1：中，2：右

 public void init() {
  Container contentPane = getContentPane();
  JPanel panel = new JPanel();
  JCheckBox checkbox = new JCheckBox("checkbox");
  JButton southButton = new JButton("south button");
  Listener listener = new Listener();

  panel.setBorder(BorderFactory
    .createTitledBorder(("Ancestor of button and checkbox")));

  checkbox.registerKeyboardAction(listener, KeyStroke.getKeyStroke(
    KeyEvent.VK_F, 0, false), JComponent.WHEN_FOCUSED);

  panel.registerKeyboardAction(listener, KeyStroke.getKeyStroke(
    KeyEvent.VK_A, InputEvent.ALT_MASK, false),
    JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);

  southButton.registerKeyboardAction(listener, KeyStroke.getKeyStroke(
    KeyEvent.VK_W, 0, true), JComponent.WHEN_IN_FOCUSED_WINDOW);

  panel.add(button);
  panel.add(checkbox);

  contentPane.add(panel, "Center");
  contentPane.add(southButton, "South");
 }
}

class Listener implements ActionListener {
 public void actionPerformed(ActionEvent e) {
  Object src = e.getSource();
  String cname = src.getClass().getName();

  if (src instanceof JCheckBox) {
   System.out.print("'f' key PRESSED when checkbox");
   System.out.println(" had focus");
  } else if (src instanceof JPanel) {
   System.out.print("'ALT-a' key PRESSED when ancestor");
   System.out.println(" of titled panel had focus");
  } else if (src instanceof JButton) {
   System.out.print("'w' key RELEASED when any");
   System.out.println(" component in window had focus");
  }
  System.out.println("Source: " + cname);
  System.out.println();
 }
}

2、
public class T {
 public static void main(String[] args) {
  try {
   UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
  } catch (Exception e) {
  }

  final JTextField tf = new JTextField();
  tf.setEnabled(false);

  JPanel p = new JPanel(new GridLayout(0, 3, 5, 5));
  for (int i = 0; i <= 9; i++) {
   final JButton btn = new JButton(String.valueOf(i));
   p.add(btn);

   btn.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(
     KeyStroke.getKeyStroke((char) (i + '0')), "PressKeyAction");
   btn.getActionMap().put("PressKeyAction", new AbstractAction() {
    public void actionPerformed(ActionEvent e) {
     btn.doClick();
    }
   });

   btn.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
     tf.setText(tf.getText() + btn.getText());
    }
   });
  }

  JFrame f = new JFrame();
  JComponent contentPane = (JComponent) f.getContentPane();
  contentPane.setLayout(new BorderLayout(0, 5));
  contentPane.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));

  f.getContentPane().add(p, BorderLayout.CENTER);
  f.getContentPane().add(tf, BorderLayout.NORTH);
  f.pack();
  f.setLocationRelativeTo(null);
  f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  f.setVisible(true);
 }
}

看了下java的源代码发现registerKeyboardAction方法其实就是把
btn.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(
     KeyStroke.getKeyStroke((char) (i + '0')), "PressKeyAction");
   btn.getActionMap().put("PressKeyAction", new AbstractAction() {
    public void actionPerformed(ActionEvent e) {
     btn.doClick();
    }
   });封装了一下


    public void registerKeyboardAction(ActionListener anAction,String aCommand,KeyStroke aKeyStroke,int aCondition) {

 InputMap inputMap = getInputMap(aCondition, true);

 if (inputMap != null) {
     ActionMap actionMap = getActionMap(true);
     ActionStandin action = new ActionStandin(anAction, aCommand);
     inputMap.put(aKeyStroke, action);
     if (actionMap != null) {
  actionMap.put(action, action);
     }
 }
    }
不过api中提到
registerKeyboardAction方法现在已过时，对于类似的操作，请结合使用 getActionMap() 和 getInputMap()，即第二种方法为java推荐的方法
好像在哪看到过java中不提倡使用addKeyListener();
知道的可以说以下