BlogJava-Jiangshachina-随笔分类-Java

说地道的Java语言(译)

Sha Jiang — Tue, 09 Feb 2010 13:54:00 GMT

摘要: 说地道的Java语言 &n... 阅读全文

Sha Jiang 2010-02-09 21:54 发表评论

优秀的Java开发者应得更好的薪酬(译)

Sha Jiang — Mon, 11 Jan 2010 01:01:00 GMT

优秀的Java开发者应得更好的薪酬

来年春暖花开之时，又是许多公司调整薪资的时候了。java.net中的一篇博文道出了我们的心声--优秀的Java开发者应得更好的薪酬$_$(2010.01.11最后更新)

    我的邮箱聚集了几个Java用户组和其它的一些关于Java世界的特别信息源，其中就有像CEJUG和Java EE社区这样的特殊客人。很多关于Java社区的信息资源被用于咨询公司去雇佣聪明人了，从去年开始，我一直对技能丰富的Java开发员保持着极大的兴趣。另外，多日之前，我正与一些同事喝咖啡，一位经理就承认他正为到哪儿雇到所需人力资源而发愁，这些人员是要被分配的工作是为2010年所签订的合约。
    听着这样的谈话，并看着邮件列表中不断增长的录用通知，我只有一种结论：Java市场已萎缩，技艺精湛的Java开发者则变得稀少。原因何在？不知道，但有一些关于我们这个时期的明显观察结果：
    大肆宣传的语言和技术，如Scala，Ruby，Grails等等，并未如我们所期望的那样占领市场。那Android呢？如你所知，那可能要等到明年了。在过去两三年中，这些语言对它们的解决方案广而告之，推销出了许多书及会议演讲，但现在并不能轻易地为这些技术找到好的工作(薪资)。当然，某些地方也会有好工作，但已与三年前Java已死言论所处时期不可比拟。简单的事实是：Java仍然在IT市场中位居高位，而所有那些被大肆宣传的解决方案仍然被大肆宣传着它们的承诺。那么，年轻的开发者们是否会跟随这样的宣传呢？是的，现在他们将要接受Java工作，至少受到挫败的人们多数都不能提供高质量的服务。
    人们正变得懒惰和鲁钝，而且一日更甚一日。观看电影《蠢蛋进化论》后，你就知道这一点儿。如果你还不相信，看半个小时的MTV，你就能体验到一个鲜活的例子了:)。iPhone用户不可能在任何一个GUI中处理多个按钮，而类型不安全的语言认为"任何需要类型声明的语言都过于复杂，以至于无法使用"。说得多好啊，让开发者相信数学和域模型是过时的技术，那会怎样呢？
那Java开发者的薪资又如何呢？Java平台创建了数量巨大的能运行在全球IT市场中的软件，所支持的商业规模每年数以十亿计。没有比希望这些技术背后的人们能过上优质生活--至少是有益的生活--更自然的事情了。看吧，现实却是对烦人的管理模型的过高评价，开发者花费额外的时间，肌腱炎，以及更陡峭的学习曲线。

如何雇佣到优秀的Java开发者呢？
为防你会急于寻找优秀的Java开发者，这儿有一些提示：
1. 提高工资(没任何借口)
2. 提供学习机会，以作为工作福利的一部分(会议，书籍，课程等等)。
3. 允许开发者作出项目决策。
4. 使用现代的Java技术(还在使用Java 1.4？)
5. 给予开发者一些稳定性和载体观点，而不要使用官僚方式。
6. 弹性工作时间，远程办公也应能做到。
7. 给予开发者们更多的水和咖啡...水果又当如何？可乐或其它的饮料呢？为每位开发员每天买一瓶可乐会花多少钱？如果你认为那太贵了，请离开这个市场:)
8. 不要呆板地复制Google和IBM的思路，这些公司都比你们的公司富有。让你的开发者们富于创意，对你的开发者们诚实。
祝好运:) Java市场已萎缩，技艺精湛的开发者则变得稀少。聪明的经理是时候提高薪酬了，这样才能逮到好的Java开发员，剩下的就由阅读Scrum和Kanban手册的人们去分享吧。

Sha Jiang 2010-01-11 09:01 发表评论

使用Google Collections的理由(译)

Sha Jiang — Fri, 08 Jan 2010 01:55:00 GMT

使用Google Collections的理由

Google Collections终于发布了1.0版，本文是JavaLobby上的一篇博文，作者讲述了应该使用Google Collections的若干理由，大家有兴趣的话也可以体验一下。(2010.01.08最后更新)

在去年底看到Google Collections发布了它的1.0版之后，我想我应该看看与JDK默认提供的集合框架相比，使用Google Collections类库会有什么好处。Google Collections的发行包是一个zip文件，包含了一个jar文件，源文件和Javadoc文件。
Java Collections API就是被用来扩展的，而Google Collections则扩展的很好。很快，我就发现该类库最好的特性之一是它包含了MultiMap类。
为了证明这一点，让我们使用一个电话薄的例子，在这个例子中每个人都可一个或多个电话号码。事先，我已将电话号码存入每个人的一个单独的List中，如下所示：

Map<Person, List<PhoneNumber>> phoneBook = new HashMap<Person, List<PhoneNumber>>();

使用MultiMap，将变得十分简洁：

Multimap <Person, PhoneNumber> newPhoneBook = ArrayListMultimap.create();

且在使用MultiMap时，就没必要管理每个人的电话号码列表了。当我要加一个新的电话号码时，只需这么做：

Person me = new Person("James");
newPhoneBook.put(me, new PhoneNumber(111));
newPhoneBook.put(me, new PhoneNumber(201));

而不是使用以前的繁冗方法去管理ArrayList：

Person me = new Person("James");
if(phoneBook.get(me) == null)
{
phoneBook.put(me, new ArrayList<PhoneNumber>());
}

phoneBook.get(me).add(new PhoneNumber(111));
对需要处理的数据进行管理这个话题，Precondition允许你对传入的参数进行校验。

Preconditions.checkNotNull(me);

我知道在Java中达到上述效果也可使用断言，但上述方法可使你的校验总是有效。你能方便地进行校验，通过判定一个表达式，也可为特定的参数抛出IllegalArgumentException。

Preconditions.checkArgument((i > 0), "The value i has to be greater than zero");

还有许多其它有用的特性，例如快速创建不可变集合的能力：

ImmutableList<Integer> numbers = ImmutableList.of(1, 2, 3, 5, 8, 13, 21, 34);

以前，你需要创建一个普通的List，然后再调用Collections.unmodifiableList()方法。
为了对该类库有一个很好的概览，查看由Kevin Bourrillion在2008年给出的一段视频。
总之，该类库使你能以更优雅的方法来处理集合对象，并使你的代码更具可读性且更扼要。

Sha Jiang 2010-01-08 09:55 发表评论

奇客的2010年预言(译)

Sha Jiang — Thu, 07 Jan 2010 01:14:00 GMT

奇客的2010年预言

新年伊始，java.net的著名博客John O'Conner道出了他对可能发生在今年的一些事件的预测，大家也可以评判一二。(2010.01.07最后更新)

每个人都能对过去说些什么，但很少人能看到未来。此处是我对2010年的预言！
1. Oracle将更喜爱Eclipse，而会废弃NetBeans。我不会比你更讨厌这一点了，但他们为什么要支持两个(算上JDeveloper就是三个)相互竞争的IDE呢？Oracle现有的员工都知道也都喜爱Eclipse，他们的工具都是围绕着Eclipse而构建的，他们的插件也都是为 Eclipse而开发的。如果没必要，为什么要作出改变呢？我唯一的问题是谁将支持NetBeans，这是一个伟大的产品，绝对值得继续保有它...只是对于Oracle，这是不值得的。
2. Chrome OS和Andriod OS将会合并。这个世界将不需要两个新的来自于Google的操作系统，而不仅仅是针对Web应用。我知道这两个OS来自于Web应用的两个不领域：桌面 /便携式/笔记本机器；移动电话。然而，API也应该最大限度的被社区接受，这就意味着它们俩将成为一体。关于该预言你可以在我之前的一篇Blog中读到更多。
3. Google将收购LinkedIn。虽然LinkedIn仍是一个有用且很好的站点，但它仍需更稳定一点儿。Google将注入新的思想以创建一个好的产品，甚至还能做得更好。
4. Oracle将出售Sun的硬件业务。拥有硬件的Oracle？我无法相信。与他们的软件业务相离甚远。我认为Oracle将把硬件业务推给HP。
5. 在今年的JavaOne之前，Adobe会抢走JavaFX的风头。Adobe将发布它自己的改进了的Flex设计器工具，并且该工具在他们宣布的时候即可使用。Sun的JavaFX设计器工具将会踉踉跄跄地出现在JavaOne 2010上，而且每个人都会忘了Sun承诺过该工具会出现在2009年底。
作出了你自己的预言吗？让我们知道你的预测吧。

Sha Jiang 2010-01-07 09:14 发表评论

高效调试：条件化断点(译)

Sha Jiang — Thu, 31 Dec 2009 02:49:00 GMT

高效调试：条件化断点

本文是JavaLobby上的一篇博文，介绍了一个使用Eclipse和NetBeans进行调试的小窍门，我受益良多，也希望对大家有所助益。(2009.12.31最后更新)

最重要的开发者工作之一就是调试。在我的大学时代，我们被迫使用简单的文本编辑器开发软件，所以开始时，我使用打印语句来观察程序在什么地方出错了。现在，IDE使我们能很便捷地完成这一工作。...
我在Eclipse和NetBeans中见过的最佳特性就是条件化断点思想。这个想法很简单，打上断点，然后输入使调试线程能够停在该断点处的条件。例如，若有如下代码：

for(Employee emp: employees)
{
    if(emp.getType() == Employee.MANAGER)
    {
        addToManagers(emp);
    }
}

假设，当雇员的getType方法的值为Employee.DEVELOPER时，我想察看所有变量的值，并在单步调试时能确保不会进入IF语句块。
在Eclipse中，你可一如往常那样在IF语句中设置断点，右键点击断点，你将看到如下菜单：

通过勾选Enable Condition复选框，你可以在结果对话框中为该断点设置一个条件：

当你键入条件时，你能获得完全的内容提示。你也能改变条件的意义--当该条件为真时，或者当在最近一次遍历之后值被改变时，是否需要停止。
对于NetBeans，也十分的相似。你仍要右键点击断点以获得属性菜单：

该对话框也有熟悉的条件，命中次数和内容提示：

像这样的特性才能真正地帮助你提升调试的效率--当你知道某个特定的值导致了程序失败时，你就能直捣问题的核心了。

祝大家新年愉快 :-D

Sha Jiang 2009-12-31 10:49 发表评论

在泛型中使用通配符和继承(译)

Sha Jiang — Mon, 28 Dec 2009 05:44:00 GMT

在泛型中使用通配符和继承

    本文是Sun官方以Blog形式发布的Java核心技术窍门(JavaCoreTechTip)中的一篇，它以非常简洁的示例展示了泛型通配符的使用，初学Java泛型的朋友可以看看。(2009.12.30最后更新)
    Java2平台，标准版5.0(J2SE 5.0)为Java程序设计语言及其平台引入了泛型。在最简单的案例和典型的应用中，泛型能够识别集合容器中所存储的是否是你所期望的对象。所以，你可以特别说你有一个String或其它类型对象的List，而不是声称你的程序有一个Object的List。所以，如果你不小心向该List中加入了错误类型的对象，编译器会告之你这个错误。该错误将在编译时进行修复，而不用等到你运行该程序，且在程序运行到该处代码时，在获取对象的操作中产生一个运行时的强制类型转换异常。
这就提出了泛型的第二个好处。迭代器将变得类型安全了。Iterator接口中的next()方法将会返回集合中下一个元素的类型安全版本。
    但这并不是本文要介绍的泛型应用的窍门，那些窍门已由2005 Core Java Technologies Tip描述过了。在使用泛型时，大多数人都不能很好地理解对extends关键字的使用。一个典型的描述如何使用extends关键字的示例与绘制图形有关。与其不同的是，此处窍门所用的示例将使用Swing组件，以便你不必创建额外的新类。在一个非常有限的例子中，Swing按钮组件的类层次结构如下所示，当然，Object是实际上的根。

所有AbstractButton的子类都共同享有的一个东西就是方法getText。这就是泛型的精髓，你能定义一个方法去处理以AbstractButton为元素的List，并返回这些按钮的String类型的标签的List。下面是该方法的第一个版本：

public static List<String> getLabels(List<AbstractButton> list) {
    List<String> labelList = new ArrayList<String>(list.size());
    for (AbstractButton button: list) {
        labelList.add(button.getText());
    }
    return labelList;
}

下面就是如何使用该方法。首先，定义一个AbstractButton类型的List，然后向其中填充值，并调用该方法：

List<AbstractButton> buttonList = new ArrayList<AbstractButton>();
buttonList.add(new JButton("Hello"));
buttonList.add(new JCheckBox("World"));
buttonList.add(new JRadioButton("Hola"));
buttonList.add(new JMenuItem("Mundo"));

List labels = getLabels(buttonList);
System.out.println(labels);

根据Google，"Hola, Mundo"是"Hello, World"的西班牙译文。调用println()方法的结果如下所示：
[Hello, World, Hola, Mundo]

对于AbstractButton的List对象，一切都能正常运行，但当是其它类型，特别是AbstractButton子类型的List时，就不能正常工作了。从逻辑上，有人可能认为对于以JButton为元素的List，一切仍能正常工作。因为JButton是AbstractButton的子类。难道不能对AbstractButton子类型的List调用方法getLabels(List)？
然而，事实并非如此。因为这是一个编译时检查，同时也因为getLabels方法被定义为只接受AbstractButton的List，你不能向该方法中传入任何其它类型的List。

GetList.java:13: getLabels(java.util.List<javax.swing.AbstractButton>)
  in GetList cannot be applied to (java.util.List<javax.swing.JButton>)

    List<String> labels = getLabels(buttonList);
                          ^
1 error

这也就是extends关键字发挥作用的地方了。不将getLabes方法定义为仅仅接受AbstractButton List，而是将它定义为接受AbstractButton子类的List：

public static List<String> getLabels(
List extends AbstractButton> list)

此处的通配符?表明该方法并不关心确切的类型是什么，只要它是AbstractButton的子类型即可。下面是综合了前述所有代码片断的完整示例程序：

import java.util.*;
import javax.swing.*;

public class GetList {
    public static void main(String args[]) {
        List<JButton> buttonList =
                new ArrayList<JButton>();
        buttonList.add(new JButton("Hello"));
        buttonList.add(new JButton("World"));
        buttonList.add(new JButton("Hola"));
        buttonList.add(new JButton("Mundo"));

        List labels = getLabels(buttonList);
        System.out.println(labels);
    }

    public static List<String> getLabels(
            List extends AbstractButton> list) {
        List<String> labelList = new ArrayList<String>(list.size());
        for (AbstractButton button: list) {
            labelList.add(button.getText());
        }
        return labelList;
    }
}

现在，当你要用泛型来定义你自己的类和方法时，就要考虑接受作为泛型参数的抽象类，或它的任一超类，记得使用通配符以便相同的方法对于子类也能很好地工作。
更多关于泛型的信息，请见两篇较早前由Gilad Bracha撰写的教程：一篇是2004年的教程(PDF)，另一篇是在线的Java Tutorial中的泛型章节。

Sha Jiang 2009-12-28 13:44 发表评论

数据加载模糊进度指示面板的实现与应用(原)

Sha Jiang — Sun, 29 Nov 2009 12:33:00 GMT

数据加载模糊进度指示面板的实现与应用

当在加载数据(或其它耗时工作)时，需要显示一个进度指示面板，本文介绍了一种简易的实现方式。(2009.11.30最后更新)

对于许多Swing应用，在与用户的交互过程中可能需要与数据库进行通信(如，加载数据)。而这个过程往往比较耗时，为了不造成"假死"现象，一般都会显示一个模糊进度指示器(不一定使用JProgressBar，简单地用一个图片代替即可)，当数据加载完毕后，该进度指示器自动消失。
一般地，该模糊进度指示器不会展示在一个弹出的对话框中(因为这样不美观)，而是直接显示在需要展示被加载数据的面板中，并且对该面板进行模糊处理。实现这一功能的关键就在于，在屏幕的同一区域内展示两层面板：一层是展示数据的面板；另一层是展示进度指示器的面板。当加载数据时，显示进度指示器面板，并模糊数据面板；当数据加载完毕后，隐藏进度指示器面板，并使数据面板清晰显示。下面将使用org.jdesktop.swingx.StackLayout方式来实现上述功能。

1. LoadingPanel--加载指示器面板
首先创建一个加载指示器面板。如前所述，我们不必使用真正的进度条作为进度指示器，仅需要使用一张动态图片来代替即可。LoadingPanel的完整代码如下所示，

public class LoadingPanel extends JPanel {

    private static final long serialVersionUID = 1962748329465603630L;

    private String mesg = null;

    public LoadingPanel(String mesg) {
        this.mesg = mesg;
        initUI();
        interceptInput();
        setOpaque(false);
        setVisible(false);
    }

    private void initUI() {
        JLabel label = new JLabel(mesg);
        label.setHorizontalAlignment(JLabel.CENTER);
        label.setIcon(new ImageIcon(getClass().getResource("/path/to/spinner.gif")));

        setLayout(new BorderLayout());
        add(label, BorderLayout.CENTER);
    }

    private void interceptInput() {
        addMouseListener(new MouseAdapter() {});
        addMouseMotionListener(new MouseMotionAdapter() {});
        addKeyListener(new KeyAdapter() {});

        addComponentListener(new ComponentAdapter() {
            @Override
            public void componentShown(ComponentEvent e) {
                requestFocusInWindow();
            }
        });
        setFocusTraversalKeysEnabled(false);
    }
}

上述代码很容易理解，LoadingPanel中仅有一个JLabel，它会展示一张图片(spinner.gif)及一段信息。但有两段代码需要特别说明：
[1]构造器中的两行代码

setVisible(false);
setOpaque(false);

LoadingPanel只在加载数据时才显示，其它时候是不显示的，所以它默认不可见。另外，在显示LoadingPanel的同时，我们仍然希望能看到数据面板，所以LoadingPanel应该是透明的。
[2]interceptInput方法
当LoadingPanel显示之后，我们不希望用户还能够操作数据面板，那么就需要屏蔽掉用户(鼠标，键盘)输入。

addMouseListener(new MouseAdapter() {});
addMouseMotionListener(new MouseMotionAdapter() {});
addKeyListener(new KeyAdapter() {});

上述三行代码就使得LoadingPanel能捕获所有的鼠标与键盘事件，并忽略掉它们。但仅仅如此还不够，在展示LoadingPanel时，数据面板中的某个UI组件很可能已经获得焦点了，那么用户仍然可以通过键盘操控数据面板中的组件(因为系统会把键盘事件发送给当前获取焦点的组件)。而且，即使数据面板中没有任何组件获得焦点，用户仍然可以通过Tab键把焦点转移到数据面板中的组件上。为了阻止这一操作，还需要加上如下几行代码，

addComponentListener(new ComponentAdapter() { // 一旦LoadingPanel可见，即获取焦点
    @Override
    public void componentShown(ComponentEvent e) {
        requestFocusInWindow();
    }
});
setFocusTraversalKeysEnabled(false); // 阻止用户转移焦点

2. 示例程序
在此处的示例程序中，数据面板(dataPanel)中仅有一个按钮，当点击该按钮时会显示loadingPanel，且模糊掉dataPanel，并会启动一个新的线程，该线程会在睡眠大约3秒(模拟耗时的数据加载工作)之后隐藏loadingPanel，且使dataPanel重新清晰可见。
值得注意的是，该示例程序使用了SwingX中的两个组件：JXPanel和StackLayout。JXPanel提供了一个方法(setAlpha)以方便地设置Panel的透明度(Alpha值)；而StackLayout允许在同一块区域内添加多层组件，并能同时展示所有层的组件(而，CardLayout一次只能显示某一层的组件)。完整的示例程序如下所示，

public class LoadDataDemo extends JFrame {

    private static final long serialVersionUID = 5927602404779391420L;

    private JXPanel dataPanel = null; // 使用org.jdesktop.swingx.JXPanel，以方便设置清晰度

    private LoadingPanel loadingPanel = null;

    public LoadDataDemo() {
        super("LoadData Demo");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        initUI();
    }

    private void initUI() {
        JButton button = new JButton("Load Data");
        button.addActionListener(handler);
        dataPanel = new JXPanel(new FlowLayout(FlowLayout.CENTER));
        dataPanel.add(button);

        loadingPanel = new LoadingPanel("Loading");

        // 使用org.jdesktop.swingx.StackLayout，将loadingPanel置于dataPanel的上方
        JPanel centerPanel = new JXPanel(new StackLayout());
        centerPanel.add(dataPanel, StackLayout.TOP);
        centerPanel.add(loadingPanel, StackLayout.TOP);

        Container container = getContentPane();
        container.setLayout(new BorderLayout());
        container.add(centerPanel, BorderLayout.CENTER);
    }

    transient private ActionListener handler = new ActionListener() {

        public void actionPerformed(ActionEvent e) {
            // 将dataPanel及其子组件的清晰度设置为50%；并显示loadingPanel
            dataPanel.setAlpha(0.5F);
            loadingPanel.setVisible(true);

            Thread thread = new Thread() {
                public void run() {
                    try {
                        Thread.sleep(3000L); // 睡眠约3秒钟，以模拟加载数据的过程
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    // 数据加载完毕后，重新隐藏loadingPanel；并使dataPanel及其子组件重新清晰可见
                    loadingPanel.setVisible(false);
                    dataPanel.setAlpha(1F);
                };
            };
            thread.start();
        }
    };

    public static void main(String[] args) {
        LoadDataDemo demo = new LoadDataDemo();
        demo.setSize(new Dimension(400, 300));
        demo.setVisible(true);
    }
}

3. 不使用SwingX
SwingX为我们提供了一系列功能强大，使用简易的Swing扩展组件，我强烈建议你去使用它。但若因故，你不准备使用它时，我们仍然有替代的解决方案，但此处仅简述一二。
[1]对于设置Alpha值，需要创建一个继承自JPanel的DataPanel类，覆写paintComponent方法，在其中使用Alpha合成，

Graphics2D.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, alpha));

[2]对于StackLayout，我们可以使用GlassPane(玻璃窗格)或LayeredPane(分层窗格)进行替换，将LoadingPanel设置为GlassPane或LayeredPanel中的一层。由于一个JFrame只有一个GlassPane，为了程序的灵活性，一般首选使用LayeredPane。

Sha Jiang 2009-11-29 20:33 发表评论

NO Sun Tech Days 2009(China)!!!(原)

Sha Jiang — Thu, 22 Oct 2009 04:20:00 GMT

NO Sun Tech Days 2009(China)!!!

今年的Sun科技日(中国站)将无法举办，最新一届Sun科技日将在2010年4月29-30日举行。(2009.10.23最后更新)

在每年的下半年，都会举办Sun科技日(中国站)，但今年的Sun科技日却迟迟没有任何消息。由于Sun被Oracle收购的原故，一直担心以后再也不会有Sun科技日了(JavaOne正处于这样的猜测与争论之中)。幸运地是，Sun科技日还将举办下去；不幸地是，我今天上午刚刚确认了，今年中国站的Sun科技日将会缺失，最新的一次的Sun科技日将会在2010年4月29-30日举行。我猜想，这应该是由于Sun被收购造成了Sun科技日的不确定性，而当决定仍然举办时，已经无法在今年年内安排好会议了。从最新日程表来看，受影响的国家和地区不仅仅是中国，实际上2009年下半年只有巴西的圣保罗能举办Sun科技日。
一心等着今年的Sun科技日，看到这样的结果，只能说是悲喜参半。这其中掺杂着我对Sun科技日，Java，甚至是Sun Microsystems的一些私人情感，究其原因，无非我是一名Java开发者，特别是一位真心想学好Java，用好Java的开发者罢了。Sun Microsystems已经有了新的归宿，现在只希望Java的明天仍能美好，这也算是我的一点点私心吧。

Sha Jiang 2009-10-22 12:20 发表评论

利用SwingX与TimingFramework实现淡入淡出(原)

Sha Jiang — Mon, 28 Sep 2009 01:46:00 GMT

利用SwingX与TimingFramework实现淡入淡出

本文使用SwingX与TimingFramework展示了如何实现淡入淡出效果，程序简洁实用，希望对大家能有所助益。(2009.09.28最后更新)

在Swing中使用AlphaComposite设置界面的半透明度，再配合javax.swing.Timer可以比较容易地实现淡入淡出效果。但需要我们继承具体的UI组件，并重写它的paintComponent方法，同时还要为Timer提供一个ActionListener的实现。这些对于程序员来说，显得有些乏味。
幸运地是，SwingX中的JXPanel(JPanel的子类)通过setAlpha方法来设置半透明度，JXPanel中的所有UI组件都可随之半透明化。TimingFramework提供的Animator可以帮助我们非线性地设置JXPanel中的alpha值。故，我们在实现淡入淡出时，可以使用JXPanel来替代JPanel，用Animator来替代Timer。

下面是一个非常简单的示例，该示例在一个使用CardLayout的JPanel--cardPanel，中另包含了两个JXPanel--panelA和panelB，这两个子容器中又分别有一个JButton--buttonA和buttonB。当点击buttonA时，将淡入显示panelB；当点击buttonB时，将淡入显示panelA。

1 public class FadingCardDemo extends JFrame {
2
3     private static final long serialVersionUID = 8005909309849021746L;
4
5     private String CARD_A = "CARD_A";
6     private String CARD_B = "CARD_B";
7
8     private JPanel cardPanel = null;
9     private JXPanel panelA = null;
10     private JXPanel panelB = null;
11     private JButton buttonA = null;
12     private JButton buttonB = null;
13
14     public FadingCardDemo() {
15         super("FadingButton Demo");
16         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
17         initUI();
18     }
19
20     private void initUI() {
21         cardPanel = new JPanel(new CardLayout());
22
23         buttonA = new JButton("Button A");
24         buttonA.addActionListener(actionHandler);
25         panelA = new JXPanel(new BorderLayout());
26         panelA.add(buttonA, BorderLayout.CENTER);
27         cardPanel.add(panelA, CARD_A);
28
29         buttonB = new JButton("Button B");
30         buttonB.addActionListener(actionHandler);
31         panelB = new JXPanel(new BorderLayout());
32         panelB.add(buttonB, BorderLayout.CENTER);
33         cardPanel.add(panelB, CARD_B);
34
35         Container container = getContentPane();
36         container.setLayout(new BorderLayout());
37         container.add(cardPanel, BorderLayout.CENTER);
38     }
39
40     private ActionListener actionHandler = new ActionListener() {
41
42         private Animator animator = null;
43
44         public void actionPerformed(ActionEvent e) {
45             if (animator == null) {
46                 animator = new Animator(2000);
47                 animator.setDeceleration(0.2F);
48                 animator.setAcceleration(0.4F);
49             } else if (animator.isRunning()) {
50                 animator.stop();
51             }
52
53             JButton button = (JButton) e.getSource();
54             if (button == buttonA) {
55                 animator.addTarget(new PropertySetter(panelB, "alpha", 1.0F));
56                 panelB.setAlpha(0.1F);
57                 ((CardLayout) cardPanel.getLayout()).show(cardPanel, CARD_B);
58             } else if (button == buttonB) {
59                 animator.addTarget(new PropertySetter(panelA, "alpha", 1.0F));
60                 panelA.setAlpha(0.1F);
61                 ((CardLayout) cardPanel.getLayout()).show(cardPanel, CARD_A);
62             }
63             animator.start();
64         }
65     };
66
67     public static void main(String[] args) {
68         SwingUtilities.invokeLater(new Runnable() {
69             public void run() {
70                 FadingCardDemo demo = new FadingCardDemo();
71                 demo.setSize(new Dimension(400, 300));
72                 demo.setVisible(true);
73             }
74         });
75     }
76 }

Sha Jiang 2009-09-28 09:46 发表评论

最大限度利用Maven settings.xml文件(译)

Sha Jiang — Fri, 14 Aug 2009 11:13:00 GMT

最大限度利用Maven settings.xml文件

John Ferguson在他的最新Blog中，介绍了使用Maven settings.xml文件的一些鲜为人知的技巧，希望对大家也有所助益。(2009.08.14最后更新)

如果你在任何程度中使用过Maven，你应该知道settings.xml文件。settings.xml文件包含有与系统环境相关的配置细节，例如代理配置，仓库，服务器的用户名和密码，等等。
下面是一个典型的settings.xml文件的示例：

<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0
                      http://maven.apache.org/xsd/settings-1.0.0.xsd">
  <localRepository>C:/maven/repositorylocalRepository>

  <proxies>
    <proxy>
      <id>localproxyid>
      <active>trueactive>
      <protocol>httpprotocol>
      <host>proxy.acme.comhost>
      <port>8080port>
      <username>scottusername>
      <password>t0ps3cr3tpassword>
      <nonProxyHosts>*.acme.comnonProxyHosts>
    proxy>
  proxies>

  <servers>
    <server>
      <id>dbserverid>
      <username>scottusername>
      <password>tigerpassword>
    server>
  servers>

settings>

例如，若你使用公司的环境，在该环境中，你的Maven主目录是每天早晨当你登录时由网络传输的，localRepository元素就会非常有用。在这种情况下，将本地仓库置于你本地磁盘的不同目录中，将会节约大量的带宽。
你也可以在settings.xml文件中定义仓库，镜像，概述和属性。在此处，我不想涉及上述内容，因为在其它地方已经有关于它们的很好的文档了。
很少为人所知，或至少是很少被使用的功能是，在你的pom.xml文件中使用定义在settings.xml文件中的数据。事实上，你能使用settings.xml中的任一元素，然而其中的一些则更为有用。
一个普遍且方便的例子就是使用localRepository变量。你可能需要将该变量置于一个脚本中，或使用它来引用仓库中的某个特定的JAR文件(尽管通常有更优雅的方案来解决这一问题)。你可以通过简单地引用${settings.localRepository}来使用localRepository属性。例如，在下面的代码中，我们调用一个Ant脚本，并通过名为"localRepository"的属性传给它一个本地仓库路径：

<plugin>
  <groupId>org.apache.maven.pluginsgroupId>
  <artifactId>maven-antrun-pluginartifactId>
  <executions>
    <execution>
      <id>generate-stuffid>
      <phase>pre-comilephase>
      <goals>
        <goal>rungoal>
      goals>
      <configuration>
        <tasks>
          <ant target="generate">
            <property name="localRepository"  value="${settings.localRepository}"/>
          ant>
        tasks>
      configuration>
    execution>
  executions>
plugin>

做更多有趣的事情，特别是当你也在构建中集成了Groovy时。例如，假设在集成测试阶段期间，我们需要确保特定的SQL脚本已在数据库中执行过了。我们有一个名为update-scripts.groovy的Groovy脚本来做这件事情，但它需要以命令行参数的形式提供用户名和密码。在集成测试阶段之前，你应如何使用定义在settings.xml中的用户名和密码呢？是的，只需一点儿Groovy魔术，没有比这儿更简单的了。settings对象可用于任何集成到pom.xml中的Groovy脚本，所以你可像使用一个普通对象那样方便地使用它，如下示例：

<plugin>
  <groupId>org.codehaus.groovy.mavengroupId>
  <artifactId>gmaven-pluginartifactId>
  <version>1.0-rc-5version>
  <executions>
    <execution>
      <id>process-db-scriptsid>
      <phase>pre-integration-testphase>
      <goals>
        <goal>executegoal>
      goals>
      <configuration>
        <source>
        def server = settings.servers.find{ it.id.equals('dbserver') }
        """groovy update-scripts.groovy -Ddb.username=${server.username}
        -Ddb.password=${server.password}""".execute()
        source>
      configuration>
    execution>
  executions>
plugin>

简单！事实上，一旦你既知道如何访问顶级变量，又知道如何访问settings.xml中的各个元素，那么其功效将不可限量！只需记住一定要使你的构建保持弹性--例如，不要在settings.xml文件中定义那些在pom.xml文件中无有效默认值的属性。
如果你想学习更多关于应用Maven的酷炫方法，查看最新的来自于Sonatype的在线课程。或者，为了有一个更具全景的视角，可以参加Java Power Tools bootcamp会议--很快在堪培拉，悉尼，布里斯班和惠灵顿就有研讨会了。

Sha Jiang 2009-08-14 19:13 发表评论

一个简单的CheckBox Tree实现(原)

Sha Jiang — Wed, 05 Aug 2009 13:10:00 GMT

一个简单的CheckBox Tree实现

CheckBox Tree是一个十分常用的UI组件，它能使用户方便地按特定规则勾选树中的节点。本文实现了一种简单的Checking规则：当勾选了某节点后，该节点的所有下级节点全部被勾选；当取消勾选某节点后，该节点的所有下级节点全部被取消勾选。(2009.08.05最后更新)

实现CheckBox Tree的常用方法，就是使用JCheckBox作为JTree的TreeCellRendrer，并且需要实现特定的Checking规则来勾选/取消勾选CheckBox。

1. 树节点
DefaultMutableTreeNode是最常用的TreeNode实现，此处我们将扩展这一实现--CheckBoxTreeNode，增加一个属性isChecked，用于标识该节点是否要被勾选上。该类的完整代码如下所示：

public class CheckBoxTreeNode extends DefaultMutableTreeNode {

       private static final long serialVersionUID = 3195314943599939279L;

       private boolean isChecked = false;

       public CheckBoxTreeNode(Object userObject) {
               super(userObject);
       }

       public boolean isChecked() {
               return isChecked;
       }

       public void setChecked(boolean isChecked) {
               this.isChecked = isChecked;
       }
}

2. 渲染器
如本文开头所述，我们将使用JCheckBox作为树节点展现形式的渲染器，同时确定对节点进行勾选或取消勾选的规则。CheckBoxTreeCellRenderer本身即是一个JCheckBox，那么在实现getTreeCellRendererComponent方法时，只简单地返回它自己的实例即可，而对于勾选或取消勾选的条件，则由CheckBoxTreeNode中的isChecked属性来确定，完整的代码如下所示：

public class CheckBoxTreeCellRenderer extends JCheckBox implements TreeCellRenderer {

       private static final long serialVersionUID = -6432020851855339311L;

       public CheckBoxTreeCellRenderer() {
               setOpaque(false);
       }

       public Component getTreeCellRendererComponent(JTree tree, Object value,
                       boolean selected, boolean expanded, boolean leaf, int row,
                       boolean hasFocus) {
               CheckBoxTreeNode node = ((CheckBoxTreeNode) value); // 获取树节点对象。
               setText(node.toString()); // 设置CheckBox所展示的文本。

               // 当树节点被设置为勾选时，则该节点对应的CheckBox被勾选上；否则，取消勾选。
               if (node.isChecked()) {
                       setSelected(true);
                       setForeground(Color.BLUE);
               } else {
                       setSelected(false);
                       setForeground(tree.getForeground());
               }
               return this;
       }
}

3. 树
此处对JTree进行扩展，创建CheckBoxTree，该类只是为JTree添加了一个MouseListener，以侦听鼠标选中树节点后，如何设置勾选标记，并重绘树。

public class CheckBoxTree extends JTree {

       private static final long serialVersionUID = -217950037507321241L;

       public CheckBoxTree(TreeModel newModel) {
               super(newModel);
               addCheckingListener();
       }

       private void addCheckingListener() {
               addMouseListener(new MouseAdapter() {

                       @Override
                       public void mousePressed(MouseEvent e) {
                               int row = getRowForLocation(e.getX(), e.getY());
                               TreePath treePath = getPathForRow(row);
                               if (treePath == null) {
                                       return;
                               }

                               CheckBoxTreeNode node = ((CheckBoxTreeNode) treePath.getLastPathComponent());
                               boolean checking = !node.isChecked(); // 如果该节点已被勾选上，则此次将取消勾选；反之，亦反。
                               checkNode(node, checking);

                               repaint(); // 重绘整棵树。
                       }

                       // 递归地勾选或取消勾选指定节点及其所有下级节点的CheckBox。
                       private void checkNode(CheckBoxTreeNode node, boolean checking) {
                               node.setChecked(checking);
                               if (!node.isLeaf()) {
                                       Enumeration<CheckBoxTreeNode> children = node.children();
                                       while (children.hasMoreElements()) {
                                               checkNode(children.nextElement(), checking);
                                       }
                               }
                       }
               });
       }
}

上述程序有两个关键点：1. 设置当前节点及其子节点的勾选标记--checkNode；2. 重绘树--repaint。调用repaint方法对树进行绘制时，方法TreeCellRenderer.getTreeCellRendererComponent就会被调用，此时程序就会根据checkNode方法设定的isChecked来勾选或取消勾选对应的树节点CheckBox。简言之，就是先设置树型数据中的勾选标记，然后渲染器再根据这些标记来渲染CheckBox。

Sha Jiang 2009-08-05 21:10 发表评论

Java Store, Q&A(译)

Sha Jiang — Sun, 05 Jul 2009 01:48:00 GMT

Java Store, Q&A

在今年的JavaOne中，比较重要的议题之一就是Java应用商店。目前还没机会亲身体会一下这个商店，但我至少认为Java应用商店为广大Java程序员提供了一个新的展示自我的平台。Please show yourself! (2009.07.05最后更新)

Java Store是JavaOne中最重大的消息之一。我格外为之骄傲，因为在过去的几个月中我一直秘密地为其工作。由于这一消息，我收到了一大堆关于该商店的问题，以及如何将它与Java生态系统中的其它部分相关联。出于对已极佳的FAQ的补充，我想应该再回答一些问题。

简约概括一下你所宣布的消息
我们已经发布了Java Store的私有Beta版，是一个桌面的客户端应用，它允许大家浏览并购买桌面Java应用；还有一个Java仓库的开放Beta版，为了分发应用程序，开发者们可将这些应用程序上传到这个仓库中。现在你就可以登录并浓度一下这个商店和仓库。目前，这个商店和仓库只针对美国用户，很快将有更多的国家能够使用。

我可以使用除JavaFX之外的其它语言来做用于Java Store的程序吗？
是的！不仅仅是Java和JavaFX，所有基于JVM的语言都是允许的。记住，最终用户并不关心你的应用是用什么语言写的。他们只关心你所做的应用是有用的，看起来和用起来都很好。

商店中的应用程序有哪些限制？
查看FAQ，可以得到全部的细节，但简要的回答是：任何的JVM语句；必须面向消费者；(目前)小于50M；必须是未签名，或使用有效认证的签名。在该商店商用之前，所有的应用都是免费的，商用之后你就需要付费。此处包含的细节很少，但这些都是基本的。

何时才允许我贩卖应用程序？
我们将尽快。商店还未开张。但最终，你不会拥有一个货架空空如也的商店。这就是为什么我们要给你们，开发者，时间去准备好你们的应用。当我们向商用开放这个商店时，你就能够标上价格并开始售卖了。

顾客将如何找到我的应用程序？
你在JavaOne大会上看到的桌面客户端只是第一个版本。我们已在努力工作，向商店加上新的特性，这将使得顾客们找到你的应用。将有诸如查找，过滤，排序和评论之类的新特性。最后，Java Store将会随Java发布，这就使得你的应用能被近百万人发现。

移动和TV应用将会怎样？
Java Store实际包含两个方面。店面是一个桌面客户端程序，它使你能够购买桌面应用。还有一个Java Warehouse，这是你，即开发者，存放待售应用程序的地方。在未来，还会增加针对电视和移动应用的店面，可能会carrier branded。你所存放应用程序的Java Warehouse将为所有的这些店面提供服务。桌面应用只是令人激动的第一步罢了。

现在商店里都哪些应用了？他们来自于何处？
我们与许多伙伴公司一同工作为这个商店构建新的应用，以及修改已有的应用程序。我个人的最爱是Astronomy Picture of the Day，由位于俄勒冈州Eugene的一个名为Concentric Sky的公司创建的。这个程序与NASA的太空图片相连接，能使你浏览以前的图片，阅读图片说明，甚至还能使用Google Translate将文本翻译成其它语言。请看Concentric Sky的CEO在他们的博客中对Java Store和JavaFX的描述。

为什么开发者们不能在其它国家登录？什么时候才能允许我们在其它国家贩卖应用程序？
我们将尽可能快的在其它国家开放这个商店。国际贸易要比你所想象的还要复杂的多(作为一个工程师，我感到十分的吃惊)。每个国家在税率，私有权和商业方面都有不同的法规。现在我们有法律和商业方面的伙记们在这些问题而工作。当前，我们计划在2010年的早些时候实现这一目标，但是如果我们能做得更快些，那一定会告诉你。

为了使消息更清晰，我们让Jeet Kaul，Java的高管之一，作一些解释：(点击观看)

如果你有任何关于Java Store的问题，请发邮件给我，或者在我们的反馈页面中提交你的评论。

Sha Jiang 2009-07-05 09:48 发表评论

树的汇总(原)

Sha Jiang — Thu, 25 Jun 2009 23:11:00 GMT

树的汇总

继上次浅谈了树的遍历之后，这次再浅谈一下树的汇总。此处的汇总是指将树中某个节点的数据按指定的规则汇集到它的父节点中。例如，可以将树节点中的数值累加到它的父节点中。仍如树的遍历一文，我将使用两种简单的算法，递归与和迭代，来实现这一功能。(2009.08.09最后更新)

1. 树节点
仍然沿用树的遍历一文中的TreeNode/GenericTreeNode，为便于阅读，将GenericTreeNode中的若干关键属性展示如下，

2. 递归法
仍然先从最简单的递归法开始，

public static Double recursiveGatherValue(GenericTreeNode<Double> node) {
    Double sumValue = null;
    if (node.isLeaf()) {
        return node.getUserObject();
    } else {
        sumValue = node.getUserObject();
        List<GenericTreeNode<Double>> children = node.getChildren();
        for (int i = 0, size = children.size(); i < size; i++) {
            Double bufGatherValue = recursiveGatherValue(children.get(i));
            sumValue += bufGatherValue;
        }
    }

    node.setUserObject(sumValue);
    return sumValue;
}

递归法还是一如既往的简单易懂。与递归遍历树相比，递归汇总树的程序基本上没大的变化，我就不赘述了...

3. 迭代法
与迭代遍历树相比，迭代汇总树的程序有一些明显的变化。当初在思考迭代法时，有个问题一直困绕着我：如何将下级节点的值赋给它的父节点，并且父节点的值要不断的进行累加。在JavaWorld@TW中提出这个问题之后，很快就得到了清晰的解答(真的很感谢社区里的大大们)。毫无疑问，用迭代法遍历一棵树时需要使用一个栈，但同时，为了维护节点与汇总值之间的关系，还需要另一个栈进行辅助。具体程序如下所示，

public static void iterativeGatherValue(GenericTreeNode<Double> node) {
    Stack<NodeValueTuple<Double>> nodeValueStack = new Stack<NodeValueTuple<Double>>();
    Stack<GenericTreeNode<Double>> nodeStack = new Stack<GenericTreeNode<Double>>();

    nodeStack.push(node);
    Double sumValue = new Double(0.0D);
    while (!nodeStack.isEmpty()) {
        GenericTreeNode<Double> bufNode = nodeStack.pop();
        if (bufNode == null) {
            NodeValueTuple<Double> bufNodeValueTuple = nodeValueStack.pop();
        bufNodeValueTuple.node.setUserObject(sumValue);

        sumValue += bufNodeValueTuple.value;
        } else if (bufNode.isLeaf()) {
            sumValue += bufNode.getUserObject();
        } else {
            nodeValueStack.add(new NodeValueTuple<Double>(bufNode, sumValue));

            sumValue = new Double(0.0D);
            nodeStack.push(null);
            nodeStack.addAll(bufNode.getChildren());
        }
    }
}

在遍历树的过程中，会将某节点N与它的汇总值一同置入一个栈(nodeValueStack)中，当节点N有子节点时，则将它的子节点及其汇总值也置入栈中，节点N与它的子节点之间使用一个NULL值进行分隔；如果节点N是叶节点则累加汇总值；如果节点N为NULL，则表示子节点们的汇总已结束。
NodeValueTuple是一个二元组，用于维护节点与它的汇总值之间的关系，代码如下所示，

public class NodeValueTuple<V> {

    public final GenericTreeNode<V> node;
    public final V value;

    public NodeValueTuple(GenericTreeNode<V> node, V value) {
        this.node = node;
        this.value = value;
    }
}

在上述的汇总中，均只累加了叶节点中的数值，而不管分枝节点和根节点本身所拥有的数值。如果要累加这些节点本身的数值，应该如何做呢？大家自己做做看吧，肯定非常简单 ^_^

4. 小结
树的汇总肯定是一个十分常见的应用，除了汇总数据之外，我们还可以汇集节点中的对象，如汇总挂载在节点上的集合对象中的元素，使得父节点能够拥有所有子节点所拥有的元素。上述方法的效率应该不算低，主要是因为所有的树节点只需要访问一次。

Sha Jiang 2009-06-26 07:11 发表评论

Duke's Choice Award 2009(译)

Sha Jiang — Thu, 04 Jun 2009 08:42:00 GMT

Duke's Choice Award 2009

在一年一度的JavaOne中，总会选出几个当年度最具代表性、创造性的Java应用，今年当然也不能例外。就在昨天，2009年度的Duke's Choice Award新鲜出炉了，我相信其中的一些应用大家也会很感兴趣的。(2009.06.08最后更新)

每年，Duke's Choice Award委员会将邀请Java社区的成员提名得到认可的最好且最具创新性的Java应用。委员会的领导小组--包括James Gosling，为人熟知的Java技术之父--会根据这些基于Java的应用和服务的创造性来选出其中的优胜者。现在在它的第七个年头里，委员会认可了2009年度Duke's Choice Award的胜出者们，由于他们酷炫的工具，技术和产品。
今年，该委员会在如下领域中给出了10项大奖：
# 终身成就奖：金Duke奖
# 最佳桌面游戏
# Java无处不在!
# Java技术在开发者解决方案中
# Java技术在教育领域中
# Java技术在环境领域中
# Java技术在网络解决方案中
# Java技术工具

终身成就奖：金Duke奖
LincVolt, Perrone Robotics
使用新方法来添加燃料，19.5英尺长，2.5吨重的1959款林肯大陆敞篷汽车已处于创新的领导地位了。LincVolt轿车寻找清洁的汽车动力技术，并完全不需要在路边加油。这项令人鼓舞的项目由一些最受人尊敬的技术，包括Java技术，所支撑。Perrone Robotics是这项空前构想背后的助力，该公司致力于利用开源技术创建跨越平台和软件的机器人技术。可在JavaOne的Change (Y)our World Playground中观看LincVolt。

最佳桌面游戏
Runescape, Jagex, Ltd.
Jagex, Ldt.已成为在线视频游戏行业中的领导者，它创建了世界上最大的大型多人在线游戏(MMOG)之一，Runescape。从2001该项目启动开始，Runescape已成为全球最大的MMOG之一，并完成了一个支持高清游戏的引擎。同时，Jagex, Ltd.还启动了游戏门户网站FunOrb.com，该站点为所有类型的客户提供奇妙的基于Java技术的游戏。

Java无处不在!
Terracotta 3.0
Terracotta 3.0为将基于Java的应用程序部署到所需众多的计算机中提供了一种廉价且方便的方法，该方法同时确保了高可用性和高扩展性。由于减少了部署时间，Terracotta极大地减少了支撑Web应用所需要的运营和资金成本。Terracotta 3.0已应用众多跨行业领域，例如旅游，游戏，金融服务，通信，健康服务和社会化网络。因为Terracotta使用Java技术，如果你知道Java，你就知道Terracotta。

Java技术在开发者解决方案中
DataBox, ReportMill Software, Inc.
来自于ReportMill的软件，DataBox，是一个即时的Java应用程序构建工具，它提供你所需的一切以便捷地创建及部署基于Java技术的应用。从创建数据库表到设置应用程序表单和报表，DataBox能够在任一浏览器中部署Applet应用。原本常常需要多种工具，广博技术和大量时间的程序部署，在使用DataBox后将会很快完成。

Java技术在教育领域中
Alice 3, Carnegie Mellon University
由卡内基-梅隆大学的学生们创建的Alice是一个one-of-a-kind项目，它帮助孩子们学习复杂的Java程序设计语言及其语法，并能带来无穷乐趣。3D动画提供可视化的自然的程序，以帮助学生们理解程序的执行，并捕捉由程序产生的逻辑错误。由Electronic Arts捐赠的，来自于Sims 2.0的成果为学生们提供了许多角色，场景和高水平的动画，以创建电影和游戏，这些将成为富有刺激的环境和充满活力的体验。可在JaveOne的Change (Y)our World Playground中访问到卡内基-梅隆大学的该团队。

Java技术在教育领域中
Worcester Polytechnic Institute
伍斯特理工学院(WPI)，美国最历史最悠久、最具领导性的理工学院之一，寻找一种方法来应用在教室中所学到的知识以去影响社会，并改善其他人的生活。这就是WPI全体教师的一项使命，他们教育具有天赋的学生们为每个人去创造，发现和传播知识，并展示知识如何用于日常生活中。使用像Java和 NetBeans这样的开源软件，WPI发起了FIRST Robotics竞赛，该竞赛旨在于帮助高中年龄段的年轻人们发现工程化生活是如何的有趣、有益。

Java技术在环境领域中
Unique GSM Modules With Java Technology, Sealite Company
Sealite公司创建的产品只需要很低的电能，使用的是太阳能，并通常只需要很少甚至不需要任何维护。Sealite最负盛名的创新就是一种独一无二的使用Java技术的基于GSM移动电话的监控与报警系统。该系统允许用户监控一种适用于特制SIM卡的航标灯，每个SIM卡都有一个特定的编号，无需离开海岸就能检查这些航标灯。该GSM监控与报警系统能从全球任何地方提供实时的信息。这种低成本和高度集成的系统降低了维护与运营成本，并提高了航行的安全性。

Java技术在网络解决方案中
The NetBeans Satellite Tracking System, ND SatCom Network Management Systems
在卫星网络与系统行业有着超过25年经验的ND SatCom公司已成长为该领域的领导性公司之一。ND SatCom公司针对国防网络的网络管理系统，由1116个NetBeans平台模块组成，它基于一个符合国际标准的、开放的，层次化的架构。系统管理模块作用于系统层次的网络计划，资源管理和配置管理，同时该系统可由多个网络组成。NetBeans卫星跟踪系统由大约一百万行手写代码，三百五十万行生成的代码，超过十万行用于元器件通信的C++代码和超过1000个NetBeans模块组成。

Java技术在开源社区中
Mifos
基于Wbs的管理信息系统Mifos利用一个中央化的开源技术平台去帮助小额金融机构(MFI)高效地为穷人提供金融服务，并对抗全球性的贫困。为了满足数百万人对金融服务的需要，MFI需要一个可靠且可扩展的系统--Java SE 6平台。作为一个健壮而成熟的程序设计语言，它还拥有着世界范围的忠实且睿智的开发者社区，Java SE 6帮助Mifos构建一个社区驱动的平台，使技术赋予穷人力量，以使他们自己摆脱贫穷。由于这个由相关个体参与，协作，创造和采用的社区，Mifos选择了开源技术，同时也为透明性，高品质性，弹性和长效性提供了空间。

Java技术工具
Clover, Atlassian
Clover是一个Java代码覆盖工具，它拥有测试级别的洞察力，即时IDE反馈，交互式报表和测试优化。除了覆盖率之外，Clover通过识别项目风险及速效来深入到用户的测试中。Clover可识别特定的测试以覆盖代码中的不同行，也能识别执行哪些测试去覆盖所作的特定改变。由于可集成到IDE中，你不废吹灰之力就能利用Clover洞察测试的能力了。

Sha Jiang 2009-06-04 16:42 发表评论

无人使用的Java语言特性(译)

Sha Jiang — Tue, 28 Apr 2009 14:24:00 GMT

无人使用的Java语言特性

JavaLobby上的一位读者兼作者读了Java十大最无用特性之后，也列出了自己心中无人使用的Java语言特性，大家也可以过来评评...(2009.04.28最后更新)

之前，我在JavaLobby上读了Anthony Goubard的"Java10大最无用的特性"。我同意他的一些选择，但我认为他忽略了一些无人使用的关键特性。我仅将自己限制在语言级特性上(API 太庞大了)，下面是另外4个未被使用的Java特性。
4. short数据类型
你在使用它？我不相信。每个人当他想使用整型时，都会使用int，即便他们并不需要32位的范围。

3. 八进制字面量
现在谁会使用八进制数？对于二进制数值，十六进制会更加方便。更糟糕的是，以0开头的八进制字面量会令人困惑：
int a = 60;
int b = 060;
System.out.println(a + b); // Prints 108.

2. 局部类
Java有4种内部类，其中的3种被广泛使用。如同静态内部类，命名的内部类，以及匿名内部类，你也可以在方法内部定义命名的类，尽管在现实中很少看到这一情况。
public class TopLevelClass
{
    public void someMethod()
    {
        class LocalClass
        {
            // Some fields and methods here.
        }

        LocalClass forLocalPeople = new LocalClass();
    }
}

1. 严格的浮点数
也许在某个地方，Java的strictfp关键字对某个程序员十分重要，但我还没遇到过他/她。如果你知道如何使用strictfp，你可能就是前5% 的Java程序员了。如果你还不知道strictfp，你该看看这儿，欢迎进入前5%的行列。但基本上有必要先确定你的计算在所有平台下都是错误的。

Sha Jiang 2009-04-28 22:24 发表评论

Java十大最无用特性(译)

Sha Jiang — Fri, 17 Apr 2009 14:42:00 GMT

Java十大最无用特性

Java已经很庞大了，其中确实充斥了很多不常用的功能，JavaLobby中的一篇文章评出了十大最无用特性。但我并不完全认同作者的观点，大家也可以过来点评一二...(2009.04.18最后更新)

10) const，goto
什么？没错，它们都是Java的关键字，但它们什么也不干。

9) Java的些许趣味
像Personal Java，JavaOS。

8) 索引化的Jar
索引化的Jar是指这样的Jar文件中包含有一个特殊的索引文件(META-INF/INDEX.LIST)，该文件用于指定该Jar中有哪些包。在Ant中，可用index="true"。它的目的是为了Applet和Webstart应用能够延迟加载Jar文件，并提高类加载的速度。

7) bin目录中的多数exe文件
例如，javah.exe，javadoc.exe，jdb.exe，jar.exe。它们已被Ant，Maven和IDE取代了。
译者：虽然较少直接使用这些工具，但学会使用它们还是很有好处的。比如，在某时，我们手边并没有Ant，Maven或Eclipse之类的工具，特别当只是出于简单的应用，直接使用命令会更加便捷。

6) Applet
它在10年前很流行，从那开始，它的流行度就一直在下降。但Applet将会在Java SE 6 update 10中卷土重来。
译者：Applet还是有它的空间。如果一定要说有问题，那就是整个Java桌面应用的问题。

5) CORBA
该API可能会从开发者的"你最想从Java中删除的API"竟选中胜出。

4) javax.accessibility和accessibility
这个包始于Java 1.2，但就没怎么被用过。一方面，Swing确实能为你做很多事，但另一方面，它不能为你做每一件事。特别是，空的文本框和文本域需被说明。

3) MIDI库
是的，Java有内建的MIDI API。所以，从1.1开始，Java就能够播放音乐。当时，他们加入了一个音源库，音质听起来比较好。而现在，音源库就没声卡听起来那么好了。
在谈到模块化JRE时，多数时候，CORBA被认为是不需要被下载的，而音源库API则可能是最不需要的。

2) Java 6 API
这是Apple最需被责备之处，因为他们决定不在32位平台中支持Java 6，那么就会有许多API和程序被阻止在Java 5处。

1) 断言
在Java1.4中，Sun加入了断言。我记得在那时有一些评论谈到Java缺少断言/前置/后置条件，所以就加了这一特性。
但让我们直面它，断言确实很少使用。
译者：断言是一个很基本的语言级特性，但我真的从未使用过它，因为断言在默认情况下是被关闭的 :-)

Sha Jiang 2009-04-17 22:42 发表评论

注册JavaOne(译)

Sha Jiang — Wed, 15 Apr 2009 14:43:00 GMT

注册JavaOne

今年的JavaOne已经开始接受注册了，Games Gosling向大家发出了邀请... (2009.04.16最后更新)

Sun的Java同仁们为今年的JavaOne大会再次做好了充分的准备。提交的论文很惊人：它们将会贡献内容格为丰富的技术议程。Java EE 6将是企业级方面的主要看点。Swing和JavaFX则将无处不在。嵌入式领域会继续更有趣的事情：LincVolt将会出现在一堆酷炫的电子器件中。
我知道经济处于混乱，好像世界正在溶化，但JavaOne是一个很好的机会，使你能够置身其外，过一个奇客的假期。来加入我们吧！

Sha Jiang 2009-04-15 22:43 发表评论

树的遍历(原)

Sha Jiang — Wed, 01 Apr 2009 12:40:00 GMT

树的遍历

之前的工作都没有接触到树，也就很少研究它。幸运地的是，在目前的工作中多次遇到树型结构的数据，那么访问树节点中的数据就是必然的了，而且还需要按照指定规则对节点中的数据进行额外处理。经过学习之后，对与树相关的基本算法有了一些认知，就计划写几篇小文。其实这样的文章早已是汗牛充栋，而我只是把它当作我的学习总结罢了，以加深记忆与理解，如能对其他朋友有所助益，则更感愉悦了 :-) (2009.04.03最后更新)

这次先从最基础的开始--树的遍历。本文使用了两种极常用的方法来遍历树中的所有节点--递归；迭代，但它们实现的都是深度优先(Depth-First)算法。

1. 树节点与数据
先定义树节点及数据(用户对象)，并创建测试用的数据。
TreeNode是树节点的定义。

/**
* 树节点的定义。
*/
public interface TreeNode {

    /**
     * 获取指定下标处的子节点。
     *
     * @param index
     *            下标。
     * @return 子节点。
     */
    public TreeNode getChildAt(int index);

    /**
     * 返回指定子节点的下标。
     *
     * @param index
     *            下标。
     * @return 子节点。
     */
    public int getChildIndex(TreeNode index);

    /**
     * 获取子节点的数量。
     *
     * @return 子节点的数量。
     */
    public int getChildCount();

    /**
     * 返回父节点。
     *
     * @return 父节点。
     */
    public TreeNode getParent();

    /**
     * 设置父节点。注：此处不需要改变父节点中的子节点元素。
     *
     * @param parent
     *            父节点。
     */
    public void setParent(TreeNode parent);

    /**
     * 获取所有的子节点。
     *
     * @return 子节点的集合。
     */
    public List getChildren();

    /**
     * 是否为叶节点。
     *
     * @return 是叶节点，返回true；否则，返回false。
     */
    public boolean isLeaf();
}

GenericTreeNode是一个通用的树节点实现。

public class GenericTreeNode<T> implements TreeNode {

    private T userObject = null;

    private TreeNode parent = null;

    private List<GenericTreeNode<T>> children = new ArrayList<GenericTreeNode<T>>();

    public GenericTreeNode(T userObject) {
        this.userObject = userObject;
    }

    public GenericTreeNode() {
        this(null);
    }

    /**
     * 添加子节点。
     *
     * @param child
     */
    public void addChild(GenericTreeNode<T> child) {
        children.add(child);
        child.setParent(this);
    }

    /**
     * 删除指定的子节点。
     *
     * @param child
     *            子节点。
     */
    public void removeChild(TreeNode child) {
        removeChildAt(getChildIndex(child));
    }

    /**
     * 删除指定下标处的子节点。
     *
     * @param index
     *            下标。
     */
    public void removeChildAt(int index) {
        TreeNode child = getChildAt(index);
        children.remove(index);
        child.setParent(null);
    }

    public TreeNode getChildAt(int index) {
        return children.get(index);
    }

    public int getChildCount() {
        return children.size();
    }

    public int getChildIndex(TreeNode child) {
        return children.indexOf(child);
    }

    public List<GenericTreeNode<T>> getChildren() {
        return Collections.unmodifiableList(children);
    }

    public void setParent(TreeNode parent) {
        this.parent = parent;
    }

    public TreeNode getParent() {
        return parent;
    }

    /**
     * 是否为根节点。
     *
     * @return 是根节点，返回true；否则，返回false。
     */
    public boolean isRoot() {
        return getParent() == null;
    }

    public boolean isLeaf() {
        return getChildCount() == 0;
    }

    /**
     * 判断指定的节点是否为当前节点的子节点。
     *
     * @param node
     *            节点。
     * @return 是当前节点的子节点，返回true；否则，返回false。
     */
    public boolean isChild(TreeNode node) {
        boolean result;
        if (node == null) {
            result = false;
        } else {
            if (getChildCount() == 0) {
                result = false;
            } else {
                result = (node.getParent() == this);
            }
        }

        return result;
    }

    public T getUserObject() {
        return userObject;
    }

    public void setUserObject(T userObject) {
        this.userObject = userObject;
    }

    @Override
    public String toString() {
        return userObject == null ? "" : userObject.toString();
    }
}

UserObject是节点上的用户对象，相当于是数据。

public class UserObject {

    private String name = null;

    private Integer value = Integer.valueOf(0);

    public UserObject() {

    }

    public UserObject(String code, Integer value) {
        this.name = code;
        this.value = value;
    }

    public String getName() {
        return name;
    }

    public void setName(String code) {
        this.name = code;
    }

    public Integer getValue() {
        return value;
    }

    public void setValue(Integer value) {
        this.value = value;
    }

    @Override
    public String toString() {
        StringBuilder result = new StringBuilder();
        result.append("[name=").append(name).append(", value=").append(value).append("]");
        return result.toString();
    }
}

TreeUtils是用于创建树的工具类。

public class TreeUtils {

    public static GenericTreeNode<UserObject> buildTree() {
        GenericTreeNode<UserObject> root = new GenericTreeNode<UserObject>();
        root.setUserObject(new UserObject("ROOT", Integer.valueOf(0)));

        GenericTreeNode<UserObject> node1 = new GenericTreeNode<UserObject>();
        node1.setUserObject(new UserObject("1", Integer.valueOf(0)));
        GenericTreeNode<UserObject> node2 = new GenericTreeNode<UserObject>();
        node2.setUserObject(new UserObject("2", Integer.valueOf(0)));
        GenericTreeNode<UserObject> node3 = new GenericTreeNode<UserObject>();
        node3.setUserObject(new UserObject("3", Integer.valueOf(5)));

        root.addChild(node1);
        root.addChild(node2);
        root.addChild(node3);

        GenericTreeNode<UserObject> node11 = new GenericTreeNode<UserObject>();
        node11.setUserObject(new UserObject("11", Integer.valueOf(0)));
        GenericTreeNode<UserObject> node21 = new GenericTreeNode<UserObject>();
        node21.setUserObject(new UserObject("21", Integer.valueOf(0)));

        node1.addChild(node11);
        node2.addChild(node21);

        GenericTreeNode<UserObject> node111 = new GenericTreeNode<UserObject>();
        node111.setUserObject(new UserObject("111", Integer.valueOf(3)));
        GenericTreeNode<UserObject> node112 = new GenericTreeNode<UserObject>();
        node112.setUserObject(new UserObject("112", Integer.valueOf(9)));
        GenericTreeNode<UserObject> node211 = new GenericTreeNode<UserObject>();
        node211.setUserObject(new UserObject("211", Integer.valueOf(6)));
        GenericTreeNode<UserObject> node212 = new GenericTreeNode<UserObject>();
        node212.setUserObject(new UserObject("212", Integer.valueOf(3)));

        node11.addChild(node111);
        node11.addChild(node112);
        node21.addChild(node211);
        node21.addChild(node212);

        return root;
    }
}

2. 递归法
使用递归法的最大好处就是--简单，但一般地，我们都认为递归的效率不高。

private static void recursiveTravel(GenericTreeNode<UserObject> node) {
    travelNode(node); // 访问节点，仅仅只是打印该节点罢了。
    List<GenericTreeNode<UserObject>> children = node.getChildren();
    for (int i = 0; i < children.size(); i++) {
        recursiveTravel(children.get(i)); // 递归地访问当前节点的所有子节点。
    }
}

大家肯定知道，系统在执行递归方法(对于其它方法也是如此)时是使用运行时栈。对方法的每一次调用，在栈中都会创建一份此次调用的活动记录--包括方法的参数，局部变量，返回地址，动态链接库，返回值等。
既然系统能够隐式地使用栈去执行递归方法，那么我们就可以显式地使用栈来执行上述递归程序，这也是将递归程序转化为迭代程序的常用思想。下面的iterativeTravel方法就运用了这一思想。

3. 迭代法

private static void iterativeTravel(GenericTreeNode<UserObject> node) {
    Stack<GenericTreeNode<UserObject>> nodes = new Stack<GenericTreeNode<UserObject>>();

    nodes.push(node); // 将当前节点压入栈中。
    while (!nodes.isEmpty()) {
        GenericTreeNode<UserObject> bufNode = nodes.pop(); // 从栈中取出一个节点。
        travelNode(bufNode); // 访问节点。
        if (!bufNode.isLeaf()) { // 如果该节点为分枝节点，则将它的子节点全部加入栈中。
            nodes.addAll(bufNode.getChildren());
        }
    }
}

与递归法相比，迭代法的代码略多了几行，但仍然很简单。

4. 小结
由于上述两种方法均(隐式或显式地)使用了运行栈，所以此处的迭代法并不能提高整个程序的效率。相反地，由于在应用程序中显式地使用栈(java.util.Stack)，iterativeTravel方法的效率可能反而更低。但iterativeTravel的最大好处是，能够有效地避免运行时栈溢出(java.lang.StackOverflowError)。
如果树的层次不太深，每层的子节点数不太多，那么使用递归法应该是没有问题的。毕竟，简洁地程序会提供更多的好处。

Sha Jiang 2009-04-01 20:40 发表评论

Sun Tech Days 2008 -- Photos(原)

Sha Jiang — Sun, 23 Nov 2008 14:37:00 GMT

Sun Tech Days 2008 -- Photos

    今年Sun科技日会场的一些照片，大家可以浏览一下。(2008.11.23最后更新)

    虽然报名参加了今年的Sun科技日，但由于工作的原因，实际上没有亲临现场，所以这次就不能把自己的所见，所闻，所思，所感呈现给大家了:-(
    当得知周六也无法参会时，就让一位朋友拿着我的门票去参加了最后一天的会程，拍了一些照片，算是弥补了一点儿小小的遗憾吧。大家有兴趣的话，可以看看...噢，请关注可爱的小Duke(这是我亲手拍的*_*)

    也请关注我的系列博文--Sun Tech Days。

Sha Jiang 2008-11-23 22:37 发表评论

Sun Tech Days 2008 -- Preview(原)

Sha Jiang — Sun, 16 Nov 2008 03:06:00 GMT

Sun Tech Days 2008 -- Preview

    一年一度的Sun Tech Days(STD)又将开幕了，本文简介了本届STD中我所期待的若干主题，有兴趣的朋友可以浏览一下。(2008.11.16最后更新)

    虽然已经报名了(前几天刚拿到门票)，但今年最终是否能够参会，还要看是否有时间(刚换了新工作，任务比较重，还要学习很多新知识)。如果能够如愿参加，那么这将是我连续第四年参加STD了(也很不容易啊^_^)，关于以前的参会情况，大家可以看看我的系列博文Sun Tech Days。
    世界在不断地变化，...，说到这里，先插几句题外话。在刚开始动笔写这篇文章的时候，从TSS上看到Sun裁员6000人的消息，这也算是一种变化吧。不过也没什么特别的，很正常的商业行为(特别是在当前经济气候下)。言归正传，Java在过去的一年中也有了新的进展，但我学识浅薄，不可能对其进行深入地分析与总结，不过对于自己感兴趣的几个方面还是有些了解的，每年STD的主题自然也与这些新技术或新进展密不可分。
    Java SE 6 Update 10
    在经过了"漫长"地等待之后，就在前不久，Java SE 6 Update 10(曾名Consumer JRE，Java SE 6 Update N)终于正式发布了。对于新鲜出炉的Update 10，STD自然不会放过，今年就有一个名为"Java SE 6 Update 10和配置"的技术session。我一直在关注Update 10，也在关注桌面应用，希望这次能好好听听。之前也写有两篇相关的文章--Java SE 6 Update 10发布了和下一代Java Applet插件技术，大家也可以看看。

    JavaFX
    由于十分喜欢Java桌面开发，所以对JavaFX也有几分兴趣，但一直没有体验过。JavaFX的发展似乎并不如人意，较为缓慢，与其它的主流RIA技术相比，真不知道它最终会有多少市场份额。这次会有一个"RIA使用JavaFX"的主题，正好该时段也没有其它中意的session，那就听听它好了。

    MySQL
    数据库永远都是我最关注的领域之一，而且MySQL正是我最喜欢、最擅长的数据库。Sun在今年年初收购了MySQL(还好年初就收购了，如果到了下半年，Sun肯定就没那么多钱了，世界真是瞬息万变啊)，虽然这与Java没有直接的关系，但仍然值得Java人兴奋一下。"MySQL: Web 2.0数据库"，这个主题应该是吸引人的。另，今年没有Java DB的主题，略感遗憾。不过，如果仍然像前两年那样，只是简介一下Java DB，而且内容基本相同，那确实也没必要再要这个主题了。

    Comet
    之前对Comet知之甚少，但经常看到这个名词。有人说它是下一代Ajax技术...，但我是不懂了，那就去听听吧。

    Java性能
    程序的性能总是大家最关心的问题之一，我也不例外。希望这次能在"提高Java性能"这个session中学习到一些窍门 *_*

Sha Jiang 2008-11-16 11:06 发表评论

更好的Applet体验：海报帧(译)

Sha Jiang — Sun, 02 Nov 2008 02:57:00 GMT

更好的Applet体验：海报帧

本文是Joshua Marinacci的系列博客A Better Applet Experience中的第二篇，介绍了如何使用海报帧去加快页面的加载。(2008.11.02最后更新)

    在本系列文章的第一部分中，我向你展示了如何使用设置加载时图片，包括动态的GIF自旋体图片。这次，我将向展示如何使用屏幕截图或海报帧去加快页面的加载。
    Quicktime电影就有海报帧的思想。电影中的一帧(经常就是其中的第一帧)将会放到该电影出现的地方。当用户点击海报帧时，实现的电影才会通过网络被加载进来。这就能极大地加快该电影所在Web页面的加载速度。使用少许JavaScript，完全可以为Java Applet实现相同的功能。

Applet的海报帧
    在研究这个Demo之前，我必须要提到，我个人尚未在IE浏览器中测试过这个Demo。如果你发现这个Demo不能在某个浏览器中运行，请向错误信息发送给我，以便我能更新这个JavaScript。
    基本思想非常的简单，创建一个div，它包含一个链接和一张屏幕截图。当用户点击该链接时，我们使用一个新的applet元素去替换页面中的a和img元素。一旦浏览器察觉到了这个新的applet元素，它将下载Java插件并启动这个Applet。
    这就有一个例子：如果你点击了这张图片，一个Applet就会被加载到该图片所在的位置，并会说"applet loaded"。

JavaScript
    如下就是这个JavaScript脚本：

该脚本的第一部分初始化了两个哈希表，它们包含了applet元素的属性与嵌套的param标签。然后，它会使用document.createElement()方法去创建这个applet，并配置其中的属性与PARAM元素。到目前为止，还很直接。真正地奇妙之事发生在generateInlineAppletTag函数的最后四行。它使用传入的appletID参数与包含着上述链接与图片的div元素相联在一起，然后它会找到并删除该链接，而用新的applet元素去替代这个链接。

HTML
要使用上述javascript函数，你只需将它放到页面的顶部，并通过那张屏幕截图链接的href去调用它。在本例中，我使用了：

这个div被命名为appletDiv，链接被命名为screenshot1。该链接的href会调用上述javascript函数，并传入div与链接的名称。最后该图片就只是显示将要运行的Applet的一张屏幕截图，该图被一个播放按钮覆盖着。就这么简单，在这里你可以看到完整的javascript和HTML语句。

结论
这个javascript只是一个开始。你还能很容易的扩展它，使图片上能展现关于这个Applet的更多信息。你也可以把这个javascript重写为一个更加可重用的形式，使它能够被你的整个站点所共享。
下次我将向你展示如何使用新的发布工具包去侦测当前已安装的Java版本，并启动更新程序。
重复一遍，如果你在某个平台或浏览器中发现了任何错误，请让我知道，以便更新这个脚本。

Sha Jiang 2008-11-02 10:57 发表评论

出错时的软件开发(译)

Sha Jiang — Mon, 27 Oct 2008 00:44:00 GMT

出错时的软件开发

在开发的过程中有错误发生了，此时你该如何应对呢？John Ferguson Smart在他的最新博客中提出了一些想法，大家可以参考一下(2008.10.27最后更新)

    现今比以后任何时候，都需要开发者更加高效。极度高效。组织需要提高从它们的开发项目中得到的附加值，并且它们也乐于寻找实现这一目标的方法。
当然，你可以采用传统的方法--努力工作。为了消除项目中不可预见的症状，每天工作16个小时，还没有周末。但做的更聪明一点儿，会不会更好些？
在引进新的实践方法及改进现有方法方面投入的相对多一些，以使组织能努力获得更多回报，这就是开发的过程。一般而言，事物中有许多方面都可以被改进，但此处有一些小窍门能使你的开发流程更加合理，只是为你开个头罢了。

持续集成(CI)通知策略的再思考
    到目前为止，最通用的CI通知机制就是陈旧的邮件服务器。然而，你能肯定在你手边能完成这项任务的最合适系统就是电子邮件吗？尝试不使用电子邮件，而使用即时消息去完成你的CI通知。记住，电子邮件易成为一种干扰--如果你仅仅大约每两小时才查阅一次邮件，你就会变得十分高效。电子邮件只是，或至少是，用于构建失败--人们需要快速地知晓失败任务。

积极地优化构建过程
    构建度量(Build Metrics)是一种监控构建过程健康状况的极好方法。为什么过去3周中，代码覆盖率一直在下降？为什么单元测试的数量并未呈有规律的增长？为什么要花费很长的时间去修复这样的构建？运行单元测试需要多长时间--是否有一些测试需要执行过分长的时间？这些信息并非华而不实的东西--在不断改进构建过程的工作中，它们都扮演着关键的角色。现代CI工具，如Hudson，Bamboo和TeamCity，能为构建展示丰富的统计。Bamboo在这方面做的尤佳。无论你正使用何种CI工具，都要学习如何最大限度地使用它的报表特性，并使用这些特性去定位及修复开发过程中讨厌污点。如果你的CI工具不能给你所需要的全部信息，那就找一个能做到的。

合理化发布过程
    在发布过程中有许多必做的工作，如准备发行说明，确定该版本中哪些问题已被解决了，标记版本，等等。这些都是软件生命周期的重要部分，如果你忽略了它们，QA们和最终用户可能会很生气。但要尽量自动地去做这些工作。许多CI工具能很好地与问题追踪系统(如JIRA和Trac)进行集成，以便你能基于版本控制日志看到某个问题是在哪次特定的构建中被解决的。如果你在使用Eclipse，Mylyn能帮你将处理过的问题归总成逻辑变化组，并使用标准的模板列出在某项工作中已被解决的(或仅是影响到的)问题。或者你可使用Subversion的hook脚本去确保每次向Subversion做的提交都能对应到一个有效的问题编号。
    这只是一些想法罢了--还有更多。底线就是--你不需要忍耐一个次理想的开发过程--相反，要进入其中，并做些能改进它的事情。祝好运!

Sha Jiang 2008-10-27 08:44 发表评论

Java SE 6 Update 10发布了!(原)

Sha Jiang — Fri, 17 Oct 2008 13:37:00 GMT

Java SE 6 Update 10发布了!

    在经过了漫长的期待之后，Java SE 6 Update 10终于正式发布了。本文主要简介了该版本在客户端应用方面的改进。(2008.10.18最后更新)

Java SE 6本就加入了许多关于客户端应用的新特性，在Java SE 6的十大新特性中，直接关于客户端/桌面领域的新特性就有两处。此次Update 10更是集中地在该领域内做出了重大改进。此处，主要基于Java SE 6 Update 10 Release Notes的说明，简介了该版本在客户端应用方面的改进。

下一代Java Plug-in
    下一代Java插件包含了Applet和Java Web Start技术的最佳架构特性。它为在Web浏览器中发布Java和Java FX内容提供了健壮的平台。下一代Java插件为高级用户内容和企业级应用提供了许多强大的特性。
    * 允许为Applet申请更多的内存；可为每个Applet应用指定不同的命令行参数。
    * 为每个Applet应用选择不同的JRE。
    * 提高了可靠性。
    * 能在Java和JavaScript程序设计语言之间进行更好、更便捷的整合。
    * 增强了对访问Web页面中DOM的支持。
    * 增加了对Web Services的支持。
内建支持JNLP，使得Applet应用可立即复用之前由Java Web Start应用使用的JNLP扩展，例如JavaFX运行时组件，对基于硬件加速的3D图形，视频回放等等。
    P.S. 在我较早前的一篇译文下一代Java Applet插件技术中，对这个新的插件有较详尽的描述。

Java Quick Starter
    Java Quick Starter(JQS)为了提高Applet程序和Java应用程序的初始启动速度，会周期性预加载一些常用的JRE文件到内存(占用不多于20M的内存)。之后，当Java程序启动时，磁盘I/O将会显著减少，那么启动速度也就大大加快了。JQS会作为一个Windows服务启动，在任务管理器中会看到一个名为jqs.exe的进程。
    注：JQS仅能用于x86架构下的Windows 2000和Windows XP系统；由于Windows Vista系统有其自己的预加载机制，JQS将不能使用。

Deployment Toolkit
    为了避免浏览器的兼容性问题，Deployment Toolkit提供了一组JavaScript方法，能够自动生成部署Applet和Java Web Start程序时所使用的HTML语句。

Nimbus
    Nimbus是一个新的Java跨平台外观。在JDK 6 Update 10自带的demo中新加了一个SwingSet3应用，但与其它的demo应用(如SwingSet2)不同，这个demo应用没有包含源代码和可执行的jar文件，而需要通过Java Web Start运行(我猜想SwingSet3应该还处于开发阶段)。官方的介绍中有一张图片，大家可以看看，确实漂亮多了(此前，默认的Metal外观已经多年未更新了)。

Sha Jiang 2008-10-17 21:37 发表评论

NetBeans vs. Eclipse RCP: 插件机制比较(译)

Sha Jiang — Wed, 15 Oct 2008 06:40:00 GMT

NetBeans vs. Eclipse RCP: 插件机制比较

本文是JavaLobby上的一篇小文，作者对NetBeans和Eclipse的插件机制进行了一些比较，如有兴趣，可以看看。(2008.10.15最后更新)

NetBeans与Eclipse处理扩展点及扩展的方式是不同的。让我们看看这些不同之处。请注意，本文仅针对那些对这两个平台的插件机制都具备相当知识的人。

NetBeans Platform:

定义扩展点	创建一个接口，并将它置入一个公共模块包中。
创建扩展	创建上述接口的实现，并通过layer.xml文件将它注册到虚拟文件系统中。
读取可用的扩展	使用org.openide.util.Lookup类去获取上述接口实现的实例。

Eclipse RCP:

定义扩展点	创建一个扩展点的描述符方案，该方案定义了扩展点的元素与属性，以及这些元素之间的关系。可用的属性类型为：boolean，string，java，resource和identifer。可向该方案的任何部分添加文档。最后，向plugin.xml文件注册你的扩展点。
创建扩展	根据上述方案，在plugin.xml文件中创建一个子部分，在此处向属性赋予值。如果属性类型为java，则也要创建被引用的Java类。
读取可用的扩展	使用org.eclipse.core.runtime.IExtensionPoint获取扩展的列表。从每个扩展中获取IConfigurationElement的列表：每个IConfigurationElement对应于plugin.xml文件中的一个XML标签。

NetBeans平台		Eclipse RCP
优点	缺点	优点	缺点
非常简单，易于学习	扩展点没有定义它自己：没有关于是哪个公共模块接口作为扩展点使用的信息。	扩展点清晰地定义了它自己：快速查看jar文件，你就能立即知道该插件提供了哪些扩展点，以及它们是由哪些元素组成的。	比较复杂，需要更多时间去学习
	使用的查找名也未作定义	有许多属性类型：可以在XML文件中描述特定的结果。
	扩展和其它的内容都混写在layer.xml文件中：难以确定该模块用于哪些扩展。	可生成扩展的多数组成部分，见PDE。
		定义好了文档的位置。

Sha Jiang 2008-10-15 14:40 发表评论

支持Unicode并不意味着应用是国际化的(译)

Sha Jiang — Tue, 14 Oct 2008 02:51:00 GMT

支持Unicode并不意味着应用是国际化的

    John O'Conner在他的最新Blog中介绍了在使用Unicode^[1]进行软件国际化的过程中普遍存在的一种误解，希望大家对有些启示。(2008.10.14最后更新)

    多年以来，我已经帮助了许多组织去国际化它们的软件产品。最普遍的误解之一就是Unicode会如何帮助它们的产品。有时候，客户会错误地相信，支持Unicode对于国际化他们的产品是足够的了。有时，他们相信"支持"Unicode只是一个单纯的是或不是，行或不行的能力问题，而不认为是在不同的场合和层次中去实现对Unicode的支持。
    Unicode是一个字符编码标准。它是一个很大的标准，有着许多的细微差别。你的产品可使用许多不同的方法去实现"Unicode支持"。其结果就是，那些产品将能以不同，但通常不会是所有的方式去操纵，处理，存储，甚至可能是展示世界上的文本。你的产品支持Unicode的能力并不是二元(是或不是)的；相反，你要理解到，产品是在各种不同层次上实现"Unicode支持"的。在多数简单的情况下，你的产品只需正确地存储并获取Unicode字符。在一种更复杂的层次下，你的产品可能要能够存储，查询或展示Unicode字符。再说一次，产品"支持"Unicode的能力并不能由一个单纯的是或不是的答案去评判。一般来说，产品会以某些方式，而不是别的什么方式，去支持Unicode。
    哪怕是在最复杂的层次中实现了Unicode支持，也不意味着你的产品是国际化的。国际化是使一个软件代码库易于本地化的过程。国际化过程会创建一个产品，该产品没有针对某个单一文化或语言的特殊偏见。该产品可对特定文化进行本地化。支持Unicode是国际化工作的一个关键组成部分，但它也仅仅只是一个组成部分罢了。与支持Unicode一样，你的国际化支持也有着在不同层次上的复杂度与能力。
    概述之，产品可用不同的方式去支持Unicode。支持Unicode通常并不表示你的产品有能力去完成各种可能的针对Unicode的功能。相反，"支持"常意味着你可以使用Unicode，而不是别的什么东西，去做某些事情。另外，对Unicode的支持并不是国际化你的产品的唯一步骤。 Unicode只是其中的一个步骤，重要的一步罢了。国际化是创建一个易于进行本地化的产品的过程，这样的产品消除了文化偏见，以便在对其进行了本地化之后仍能够很容易地去支持另一种文化或地域。你可将Unicode作为国际化工作的一个步骤，但Unicode本身并不能创建一个国际化产品。
    如果你有问题关于Unicode如何才能帮助你的产品，请联系我或留下评论。如果我能帮忙，就会回复。如果我不能，我也知道谁能。

译注
[1]Unicode是一个字符集标准。该标准为全球书面和口头语言，计算机平台，或应用程序所使用的每个字符分配了一个独一无二的数值。Unicode包含了其它有限字符集所使用的全部字符。在Unicode之前，小字符集彼此之间分配的字符数值是不同的。Unicode统一了所有的其它字符集；每个字符拥有它自己的，唯一的数值。
P.S. 这段Unicode的简介也出自于Conner的一篇Blog--What is Unicode。

Sha Jiang 2008-10-14 10:51 发表评论

编写好的面向对象代码(译)

Sha Jiang — Tue, 07 Oct 2008 09:06:00 GMT

编写好的面向对象代码

    本文是java.net上的一篇博客，作者Curtis Cooley对编写好的面向对象代码有些建议，希望对大家都有所帮助。(2008.10.08最后更新)

获取经验没有捷径。编写好的面向对象代码需要经验，但这儿有三种做法能帮你在一开始就很顺利，即便你是老顽固：
    1. 使用测试驱动开发(TDD)编写你所有的代码
    2. 遵循简单法则
    3. 告之而非问之

使用TDD编写所有代码
    按测试先行编写的代码与按测试后行编写的代码是极为不同的代码。按测试先行编写的代码是松耦合与高聚合的。当某个属性或私有方法需要暴露给测试程序时，按测试后行编写的代码常会打破封装，因为该类并不是为了测试而设计的。如果你首先编写测试代码，你的依赖将会更好，你的代码将是松耦合与高聚合的。后面会有更多关于测试能帮助你设计更佳代码的内容。

遵循简单法则
    代码是简单的，只要当它：
    1. 执行了所有的测试
    2. 不包含重复
    3. 表达了所有的意图
    4. 使用最少的类和方法
注意到我用的是个被排序了的列表是很重要的。顺序是重要的。只有一个main()方法的的GodClass^[1]不会是简单的。这个类可能执行了所有的测试，但在任何比"Hello, world!"更复杂的程序中，它肯定包含了重复，并且也没有表达出全部的意图。
我努力使用简单法则去关注If问题。我不知道如何使用简单法则去阻止某人编写重量级的If代码。有人可能会提出不同意见，我也尝试过，但这样的重量级If代码确实无法表达意图。但当你阅读如下代码时

if (mobile.getType() == MobileTypes.STANDARD) {
alert();
}

确实难以看出其中的意图。这些代码无论处于哪个方法的上下文环境中，我们都能知道，如果mobile是STANDARD类型的话，那么就报警。而你所需要的更多意图呢？
我还有一点儿灵感显现。如果有那样的代码，那么在其它地方肯定还会有更多那样的代码。这些代码可能就像：

if (mobile.getType() == MobileTypes.GAS) {
registerGasReading();
}

和

if (mobile.getType() == MobileTypes.TEXT) {
sendTextMessage();
}

和

if (mobile.getType() == MobileTypes.LOCATION) {
notifyLocation();
}

你看出来了吗？我是看出来了。它违反了规则2，有很多地方都违反了规则2，并且是一种最坏的情形。这段代码有多处重复。重复将极难发现。所以，请帮助防止这种情形的发生，我已包含其中了。

告之而非问之
简言之，告之而非问之意指不要先问一个对象的状态，然后才让它去工作。而应该告之对象如何去工作。这就意味着之前所有的那些If例子应该变为：

mobile.alert();

和

mobile.registerGasReading();

和

mobile.sendTextMessage();

和

mobile.notifyLocation();

现假设遍布该程序中的一些If语句块有重复的实现。在"重量级If"版本的程序中，可能很难发现它们；但在"告之而非问之"版本的程序中，所有的实现都在Mobile中。所有的实现都在一处，这就便于察觉并根除问题。
倾听你的测试程序也能帮助你保持代码的简洁。

public interface Alarm {
  void alert(Mobile mobile);
}

public class Siren implements Alarm {
  public void alert(Mobile mobile) {
    if (mobile.getType == MobileTypes.STANDARD) {
      soundSiren();
    }
  }
}

public class TestSiren extends TestCase {
  public void test_alert() {
    LocationMobile mobile = new LocationMobile();
    Siren siren = new Siren();
    siren.alert(mobile);
    assert(sirenSounded());
  }
}

如果你密切地倾听测试程序，它可能会问你，"为什么你需要一个LocationMobile去测试Siren呢？"的确，为什么呢？看起来，Siren应该还不知道LocationMobile吧。

public class LocationMobile {
  private Alarm alarm;
  public LocationMobile(Alarm alarm) {
    this.alarm = alarm;
  }
  public void alert() {
    alarm.alert(); // alert on Alarm no longer needs a mobile
  }
}

public class TestLocationMobile() extends TestCase {
  public void test_alert() {
    Alarm alarm = EasyMock.createMock(Alarm.class);
    alarm.alert();
    EasyMock.replay(alarm);
    Mobile mobile = new LocationMobile(alarm);
    mobile.alert();
    EasyMock.verify(alarm);
}

好像我只是交换了依赖关系。Alarm不再依赖Mobile，现在是Mobile依赖Alarm。但如果你仔细地观察这个测试程序，你会发现真正的依赖关系是，Siren知晓了LocationMobile。一个具体类依赖另一个具体类，这违反了依赖反转原则(DIP)。第二个例子就让LocationMobile依赖Alarm接口。具体类依赖抽象，这就满足DIP了。
如果你使用TDD，并遵循简单法则和告之而非问之原则去编写所有的代码，你就处于成为一个更好的面向对象程序员的道路上了。好的面向对象代码易于阅读和维护，但难以编写，至少，在开始时是这样的。你写的越多，你就会变得越好，也会获得更多的经验。同时，这些实践经验也会使你在自己的道路上受益匪浅。

译注
[1]GodClass(上帝类)指包含了太多内容的类。

Sha Jiang 2008-10-07 17:06 发表评论

JStockChart -- Getting Started(Timeseries)(原)

Sha Jiang — Mon, 08 Sep 2008 08:12:00 GMT

JStockChart -- Getting Started(Timeseries)

     本文以一个示例介绍了如何利用JStockChart生成金融时序图。(2009.11.23最后更新)

1. 环境要求
    需要JDK 1.5或更高版本。

2. 下载与安装
    从JStockChart的站点中下载它的最新版本，当前版本是0.4.2。
    解压JStockChart的zip文件(jstockchart-0.4.2.zip)后，将jstockchart目录中的jstockchart-0.4.2.jar和jstockchart/lib目录中的jcommon-1.0.16.jar和jfreechart-1.0.13.jar加到classpath中。

3. 示例
    在JStockChart的发行包中，有一个demo目录。该目录包含了一个简单的例子，展示了如何利用JStockChart去生成时序图。demo目录中有一个Ant脚本build.xml，在该目录下执行命令ant即可运行该示例程序。下面是该示例的关键代码及其说明。

public class TimeseriesChartDemo {

    public static void main(String[] args) throws IOException {
        //

        // 创建一个包含TimeseriesItem的List实例。
        // 在此处，通过查询db4o的数据库文件，直接获得该List．
        // 注意：所有的数据，都必须在"同一天"内。
        List data = ;

        // 创建SegmentedTimeline实例，表示时间区间"00:00-11:30，13:00-24:00"(即24小时中空缺了"11:31-12:59"这段时间)。
        SegmentedTimeline timeline = new SegmentedTimeline(
                SegmentedTimeline.MINUTE_SEGMENT_SIZE, 1351, 89);
        timeline.setStartTime(SegmentedTimeline.firstMondayAfter1900()
                + 780 * SegmentedTimeline.MINUTE_SEGMENT_SIZE);

        // 创建TimeseriesDataset实例，时间间隔为1分钟。
        TimeseriesDataset dataset = new TimeseriesDataset(Minute.class, 1, timeline, true);
        // 向dataset中加入TimeseriesItem的List。
        dataset.addDataItems(data);

        // 创建逻辑价格坐标轴。指定中间价为21，显示9个坐标值，坐标值的格式为".00"。
        CentralValueAxis fixedPriceAxis = new CentralValueAxis(new Double("21"), new Range(
                dataset.getMinPrice().doubleValue(), dataset.getMaxPrice().doubleValue()),
                9, new DecimalFormat(".00"));
        // 创建价格区域
        PriceArea priceArea = new PriceArea(fixedPriceAxis);

        // 创建逻辑量坐标轴。显示5个坐标值，坐标值的格式为"0"。
        FixedNumberAxis fixedVolumeAxis = new FixedNumberAxis(new Range(dataset
                .getMinVolume().doubleValue(), dataset.getMaxVolume()
                .doubleValue()), 5, new DecimalFormat("0"));
        // 创建量区域
        VolumeArea volumeArea = new VolumeArea(fixedVolumeAxis);

        // 创建时序图区域
        TimeseriesArea timeseriesArea = new TimeseriesArea(priceArea,
                volumeArea, createFixedDateAxis(DateUtils.createDate(2008, 1, 1)));

        // 通过JStockChartFactory的工厂方法生成JFreeChart实例。
        // 指定了该图的标题为"Timeseries Chart Demo"，并且不生成图例(legend)。
        JFreeChart jfreechart = JStockChartFactory.createTimeseriesChart(
                "Timeseries Chart Demo", dataset, timeline, timeseriesArea, false);



        // 创建图像文件。图像格式为PNG，长为545，宽为300。
        ChartUtilities.saveChartAsPNG(new File(imageFile), jfreechart, 545, 300);
    }

    // 指定时期坐标轴中的逻辑坐标。
    private static FixedDateAxis createFixedDateAxis(Date baseDate) {
        FixedDateAxis fixedDateAxis = new FixedDateAxis(baseDate,
                new SimpleDateFormat("HH:mm"));
        fixedDateAxis.addDateTick("09:30", TickAlignment.START);
        fixedDateAxis.addDateTick("10:00");
        fixedDateAxis.addDateTick("10:30");
        fixedDateAxis.addDateTick("11:00");
        fixedDateAxis.addDateTick("11:30", TickAlignment.END);
        fixedDateAxis.addDateTick("13:00", TickAlignment.START);
        fixedDateAxis.addDateTick("13:30");
        fixedDateAxis.addDateTick("14:00");
        fixedDateAxis.addDateTick("14:30");
        fixedDateAxis.addDateTick("15:00", TickAlignment.END);
        return fixedDateAxis;
    }
}

运行该示例程序后，可以生成如下图片：

4. 定制图表
由于JFreeChart具有高度的可定制性，所以当生成了JFreeChart实例后，你可以从中获取图表中的各个元素，如Plot，然后再定制它们的属性。详细信息请参见JFreeChart的站点和论坛。
另外，在创建JStockChart的XXXArea对象时，也可以直接定制若干属性。如，通过PriceArea类，可以设置价格线的颜色(PriceArea.setPriceColor)，均线的颜色(PriceArea.setAverageColor)；是否显示均线(PriceArea.setAverageVisible)；是否显示涨跌幅(PriceArea.setRateVisible)；...。详细信息请参见JStockChart的API文档。

Sha Jiang 2008-09-08 16:12 发表评论

JStockChart -- Preview(原)

Sha Jiang — Thu, 28 Aug 2008 09:11:00 GMT

JStockChart -- Preview

JStockChart是一款简单但实用的开源图表工具，是对JFreeChart的扩展，仅关注于金融时序图与K线图。(2008.08.29最后更新)

    JStockChart对利用JFreeChart生成金融时序图与K线图进行了简化。目前，JStockChart已实现了时序图部分，包括价格线，均线，量图，中间价和涨跌幅。用户仅需传入指定格式的数据，JStockChart即可生成期望的图片。
    对于时序图，如果提供的数据不是"连续"的，JStockChart能够自动补全缺失的数据--被补数据的价格与最近一笔数据的价格相同，而量为0；价格图的纵坐标以指定的"中间价"为中心均匀分布，可重点突出中间价。
    该项目的源文件会在晚些时候上传到Google Code中，但可以通过下面一组图片先预览一下JStockChart生成的金融时序图。

允许指定中间价(20.88)，以中间价为基准向上和向下均匀地分布坐标点；允许自由地指定单个坐标点标签的对齐方式--左对齐，右对齐，居中(对于时间坐标，这尤其有用)。

自动补全缺失的数据(黑色方框指示的区域)。

允许指定各个坐标轴显示的坐标点的个数。

允许指定是否显示某些图线元素(中间价，均线，涨跌幅，...)。

允许只显示价格线图。

允许只显示量图。

对于时序线图，目前我认为JStockChart的三个功能比较重要：
(a)自动补全非连续数据序列中的"缺失"数据。
(b)以"中间价"为中心，价格坐标均匀分布。
(c)"自由"地定制每个坐标的对齐方式，这对于时间坐标尤为重要。
目前JFreeChart就没有提供上述功能，而
[1]JStockChart扩展了JFreeChart中的DateAxis和NumberAxis，根据用户指定的数据与坐标对齐方式，重新计算并生成了DateTick和NumberTick。
[2]JStockChart对JFreeChart中的TimeSeries进行了修饰，结合SegmentedTimeline，新创建了SegmentedTimeSeries，使得能够自动补全缺失的数据。

P.S.
由于近期赋闲在家，在欣赏奥运比赛之余，就将自己早前的一些想法付诸实现，并发起了这个开源项目。
虽然JStockChart关注的功能点有限，在设计方面肯定也有不如人意之处，但我仍然认为这是一次很有益的尝试。

Sha Jiang 2008-08-28 17:11 发表评论

判定一个点是否在三角形内(原)

Sha Jiang — Thu, 24 Jul 2008 09:02:00 GMT

判定一个点是否在三角形内

如何判定一个点P是否存在于指定的三角形ABC内，这肯定是一个简单的问题，本文仅用一个图形界面程序展示了该问题，有兴趣的朋友可以看看。(2008.07.24最后更新)

在此处使用一种常见且简便的方法：如果三角形PAB，PAC和PBC的面积之和与三角形ABC的面积相等，即可判定点P在三角形ABC内(包括在三条边上)。
可知，该方法的关键在于如何计算三角形的面积。幸运地是，当知道三角形顶点(A，B和C)的坐标((Ax, Ay)，(Bx, By)和(Cx, Cy))之后，即可计算出其面积：

S = |(Ax * By + Bx * Cy + Cx * Zy - Ay * Bx - By * Cx - Cy * Ax) / 2|

关键的代码如下，

// 由给定的三个顶点的坐标，计算三角形面积。
// Point(java.awt.Point)代表点的坐标。
private static double triangleArea(Point pos1, Point pos2, Point pos3) {
    double result = Math.abs((pos1.x * pos2.y + pos2.x * pos3.y + pos3.x * pos1.y
            - pos2.x * pos1.y - pos3.x * pos2.y - pos1.x * pos3.y) / 2.0D);
    return result;
}

// 判断点pos是否在指定的三角形内。
private static boolean inTriangle(Point pos, Point posA, Point posB,
        Point posC) {
    double triangleArea = triangleArea(posA, posB, posC);
    double area = triangleArea(pos, posA, posB);
    area += triangleArea(pos, posA, posC);
    area += triangleArea(pos, posB, posC);
    double epsilon = 0.0001;  // 由于浮点数的计算存在着误差，故指定一个足够小的数，用于判定两个面积是否(近似)相等。
    if (Math.abs(triangleArea - area) < epsilon) {
        return true;
    }
    return false;
}

执行该应用程序，用鼠标在其中点击三次，即可绘制一个三角形，如下组图所示：

然后仅需移动鼠标，就会出现一个空心圆圈。如果圆圈的中心在三角内(包含在三条边上)，则圆圈显示为红色；否则，显示为蓝色。如下组图所示：

完整代码如下：

public class CanvasPanel extends JPanel {

    private static final long serialVersionUID = -6665936180725885346L;

    private Point firstPoint = null;

    private Point secondPoint = null;

    private Point thirdPoint = null;

    public CanvasPanel() {
        setBackground(Color.WHITE);
        addMouseListener(mouseAdapter);
        addMouseMotionListener(mouseAdapter);
    }

    public void paintComponent(Graphics g) {
        super.paintComponent(g);
        drawTriangel(g);
    }

    private void drawTriangel(Graphics g) {
        if (firstPoint != null && secondPoint != null) {
            g.drawLine(firstPoint.x, firstPoint.y, secondPoint.x, secondPoint.y);
            if (thirdPoint != null) {
                g.drawLine(firstPoint.x, firstPoint.y, thirdPoint.x, thirdPoint.y);
                g.drawLine(secondPoint.x, secondPoint.y, thirdPoint.x, thirdPoint.y);
            }
        }
    }

    private static boolean inTriangle(Point pos, Point posA, Point posB,
            Point posC) {
        double triangeArea = triangleArea(posA, posB, posC);
        double area = triangleArea(pos, posA, posB);
        area += triangleArea(pos, posA, posC);
        area += triangleArea(pos, posB, posC);
        double epsilon = 0.0001;
        if (Math.abs(triangeArea - area) < epsilon) {
            return true;
        }
        return false;
    }

    private static double triangleArea(Point pos1, Point pos2, Point pos3) {
        double result = Math.abs((pos1.x * pos2.y + pos2.x * pos3.y + pos3.x * pos1.y
                            - pos2.x * pos1.y - pos3.x * pos2.y - pos1.x * pos3.y) / 2.0D);
        return result;
    }

    private MouseInputAdapter mouseAdapter = new MouseInputAdapter() {

        public void mouseReleased(MouseEvent e) {
            Point pos = e.getPoint();
            if (firstPoint == null) {
                firstPoint = pos;
            } else if (secondPoint == null) {
                secondPoint = pos;
                Graphics g = CanvasPanel.this.getGraphics();
                CanvasPanel.this.paintComponent(g);
                g.drawLine(firstPoint.x, firstPoint.y, secondPoint.x, secondPoint.y);
            } else if (thirdPoint == null) {
                thirdPoint = pos;
                Graphics g = CanvasPanel.this.getGraphics();
                CanvasPanel.this.paintComponent(g);
                g.drawLine(firstPoint.x, firstPoint.y, secondPoint.x, secondPoint.y);
                g.drawLine(firstPoint.x, firstPoint.y, thirdPoint.x, thirdPoint.y);
                g.drawLine(secondPoint.x, secondPoint.y, thirdPoint.x, thirdPoint.y);
            }
        }

        public void mouseMoved(MouseEvent e) {
            Point pos = e.getPoint();
            Graphics2D g2 = (Graphics2D) CanvasPanel.this.getGraphics();
            CanvasPanel.this.paintComponent(g2);
            if (firstPoint != null && secondPoint == null) {
                g2.drawLine(firstPoint.x, firstPoint.y, pos.x, pos.y);
            } else if (firstPoint != null && secondPoint != null && thirdPoint == null) {
                g2.drawLine(firstPoint.x, firstPoint.y, pos.x, pos.y);
                g2.drawLine(secondPoint.x, secondPoint.y, pos.x, pos.y);
            } else if (firstPoint != null && secondPoint != null && thirdPoint != null) {
                if (inTriangle(pos, firstPoint, secondPoint, thirdPoint)) {
                    g2.setColor(Color.RED);
                } else {
                    g2.setColor(Color.BLUE);
                }
                int radius = 4;
                g2.drawOval(pos.x - radius, pos.y - radius, radius * 2, radius * 2);
            }
        }
    };
}

public class Triangle extends JFrame {

    private static final long serialVersionUID = 1L;

    private CanvasPanel mainPanel = null;

    public Triangle() {
        setTitle("Triangle");
        setSize(new Dimension(300, 200));
        setResizable(false);

        init();

        Container container = getContentPane();
        container.add(mainPanel);

        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setVisible(true);
    }

    private void init() {
        mainPanel = new CanvasPanel();
    }

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

Sha Jiang 2008-07-24 17:02 发表评论

下一代Java Applet插件技术(译)

Sha Jiang — Mon, 14 Jul 2008 11:56:00 GMT

下一代Java Applet插件技术

Java SE 6对Java桌面应用进行较大的升级，并启动了Java SE 6 Update N计划，该计划旨在简化JRE的大小，增进用户的安装体验，并提供了一个新的Applet浏览器插件，该插件将会随Java SE 6 Update 10发布。本文全面介绍了这个新插件的关键特性，并以NASA的World Wind为例介绍了该插件的应用。(2008.07.15最后更新)

Applet回来了！
为了在网络中传递你的程序，是时候再次考虑Java Applet技术了。下一代Java插件技术以一种不同的，比过去更高效、更可靠的途径来运行Applet。现在你可以获得如下好处：

增强的可靠性
改进的用户体验
在后台启动Applet
内建的JNLP支持
针对每个Applet的命令行参数
堆内存大小，Java 2D API加速选项
改进的Java/JavaScript程序设计语言集成
改进的Windows Vista支持
签名的Applet现在可以在Internet Explorer的保护模式中正常运行

下一代Java插件提供了一种完全重新设计的架构，它将出现在Java SE 6 Update 10中。该插件为运行在网络浏览器中的Applet提供了强大的新功能，它以向后兼容的方式改进了整个Applet的可靠性及功能。
下一代Java插件最有意义的新特性是它内建支持通过JNLP文件启动Applet。使用JNLP文件格式作为Applet的描述符就能允许Applet马上复用之前为Java Web Start应用所写的JNLP扩展。

执行Applet的新途径
执行Applet的新途径在结构上与Java Web Start技术相似，但与浏览器整合的更为紧密。Applet不在运行于网络浏览器内的JVM中，而是会启动一个独立的JVM进程去运行Applet。默认地，只有一个JVM将被启动，但你也能启动多个JVM，并且可以为每个Applet都设置命令行参数，所以你能影响堆内存的大小或其它的要求。

Figure 1. Applet Architecture
在上图中，云表示JVM实例。在浏览器内有一个小的，headless JVM被用于管理一个或多个客户端JVM之间的连接，这些JVM运行着Applet。在该图中，Duke表示Applet。其中，一个JVM实例运行着两个Applet，另一个运行着一个Applet。
Applet直接从JNLP文件启动，它使用的JNLP文件与Java Web Start软件使用的描述符文件相同，并且允许使用比典型的"archive"，"code"和"cache_archive"更为强大的参数。
新的插件提供了：

能够访问之前仅由Java Web Start软件专用的高级JNLP扩展。之前有少部分参数能够使用，但有一些限制，现在这些限制则被去除。
通过Applet访问JNLP API。
支持PersistenceService和DownloadService。
能够控制堆内存大小，命令行参数，JRE版本选择和自动下载。你具有Java Web Start软件所拥有的相同功能。

现在你就可以在Web页面中使用像下面这样的语句了：

<applet width=”500” height=”500”>
<param name=”jnlp_href” value=”my_applet.jnlp”>
applet>

调用Applet生命周期方法init，start，stop和destroy会更为确定，并且已经改进了跨浏览器行为。完全支持Applet类装载器缓存，遗留的Applet生命周期及对向后兼容性的需求，并且这些行为都已得到了改进。
Applet运行的就像一个由Java Web Start启动的应用。参数jnlp_href在Web页面和Applet的JNLP描述之间起到了桥接的作用。在如宽度与高度这样的特定方面，Applet标签与JNLP文件具有重叠的机制。
一般地，你应该使用Deployment Toolkit，这也是一个出现在Java SE 6 Update 10中的新工具，它能自动地为Applet标签生成HTML。部署建议指南展示了如何使用Deployment Toolkit简便地发布Applet。

配置Applet
现在也能更为简单地在多个方面来配置Applet，包括堆内存大小，需要被使用的Java版本，类加载器缓存，边界，及其它。
与JNLP文件在针对某些参数时有重叠的机制。这些冲突可以用如下方法解决：

width and height：这些属性将总是从
，而不是JNLP文件，中获取。这是假设浏览器知道Applet在Web页面上应该显示多大，也只有浏览器才能支持相对于页面的宽度与高度(例如，width="50%")。
codebase：如果JNLP文件在标签中指定了一个绝对的codebase，那么就使用它。否则，将使用在codebase handling一节中描述的规则进行组织。

code：当指定了jnlp_href参数，Applet的主类名将从main-class参数换成JNLP文件中的applet-desc标签，并且code属性会被忽略。注意，该特性允许你为经典Java插件写一个拥有反馈的Applet标签，但在新的Java插件中，该标签可使用更高级的功能。请见下面的"兼容性"一节。
任何一个由标签指定的Applet参数将与JNLP文件中指定的参数进行合并。如果标签和JNLP文件都指定了同一个参数，标签中的版本将覆盖JNLP文件中的版本，除了参数java_arguments和java_version。
新的java_arguments和java_version参数在JNLP Applet中是不必要的。会替换为通过JNLP文件请求JRE版本或向JVM传递参数的机制。所以，命令行参数和JNLP文件请求的JRE版本将会覆盖HTML中为Applet指定的这些值。

特定的参数，例如image，boxbgcolor等等，在Applet的启动过程中是有用的。在HTML而不是JNLP文件中指定这些参数可能更好些，以便于在加载Web页面时就可立即获取它们，而不用再等到单独下载JNLP文件之后。
过去，通过Java控制面板设置最大堆内存是有限制的。在新的Java插件中，这些限制被取消。现在Applet可以像命令行应用那样使用大量堆空间。
指定一个比默认值大的堆空间：

<APPLET archive="my_applet.jar" code="MyApplet" width="300" height="300">
    <PARAM name="java_arguments" value="-Xmx128m">
APPLET>
指定一个非默认大小的堆内存以及一个Java 2D硬件加速器选项，该选项常通过JOGL使用OpenGL应用于Applet。

<APPLET archive="my_applet.jar" code="MyApplet" width="300" height="300">
    <PARAM name="java_arguments" value="-Xmx256m -Dsun.java2d.noddraw=true">
APPLET>
如果你喜欢，一个Applet可强制进入一个属于它自己的JVM实例，而与所有其它的Applet隔离开：

<param name=”separate_jvm” value=”true” />
当把某些桌面应用移植到Web浏览器时，这就有用了。
你也能使特定的Applet运行在特定版本的JRE上，如下所示：

<j2se version=”1.4+” >
<j2se version=”1.5*” >
当想针对特定版本的JRE，或Applet取代早期版本的选择机制(如同IE浏览器中的CLSID)，进行质量测评时，该方法就很有用了。如果请求了一个非常老的JRE版本，就会强制执行限制；如果Applet试图加载未签名的代码，将会提示用户。
注意，因为支持JNLP的Java插件是在Java SE 6 Update 10中才首次出现的，所以指定像“1.4+”这样的版本基本上没有意义的。当需要“1.7+”时，这才有意义。
另外，你可以在JNLP文件中使用标签来显著降低第二次及接下来各次启动的时间。

<update check=”background”>
在这种情况下，将使用缓存中已有的Applet程序，并且在后台下载该应用的更新版本。在下次启动时，就会使用新版本。
新的插件也能更好地对图像进行定制，在Applet被加载之前会展示该图像。image参数会以支持动画GIF文件作为目标，Java Plug-in Developers' Guide的Special Attributes一节对此有描述。此外，现也支持如下新的参数：
boxborder
一个布尔型参数，用于指定在Applet被加载之前是否在Applet区域的边缘绘制一个宽度一象素的边框。默认为true。我们建议将该值设置为false，特别是将一个动画GIF用作加载期图像时，以避免可能的闪烁。
centerimage
一个布尔型参数，用于指定是否将加载期图像在Applet区域内居中显示，而不是从左上角起始。默认为false。
使用参数boxborder和centerimage的例子：

<APPLET archive="large_archive.jar"
    code="MyApplet"
    width="300" height="300">

    <PARAM NAME="image" VALUE="animated_gif.gif">

    <PARAM NAME="boxborder" VALUE="false">

    <PARAM NAME="centerimage" VALUE="true">
APPLET>

兼容性
现在可更容易维护向后兼容性。你可创建运行在更早Java插件版本上的程序，但仅需提供一个与jnlp_href参数一样的格式完整的标签就可使用这些新特性了。早期版本的JRE会忽略jnlp_href参数，转而使用标签。新的Java插件技术将忽略archive和code参数，而仅使用JNLP文件去启动Applet。

World Wind Applet示例
由World Wind Java开发组创建的NASA World Wind Java Applet示例阐述了如果发布像NASA World Wind Java这样的领先类库。同样地，也用示例说明了如何使用JavaScript在Web页面中高效地整合HTML和Applet内容。

               Figure 2. NASA World Wind Applet
该Web页面包含了关于喀斯喀特山脉的信息(要感谢维基百科)，并且将World Wind Java作为一个Applet嵌入其中，以图示该山脉中各山的位置。

<applet id="wwjApplet" width=600 height=380
    code="gov.nasa.worldwind.examples.applet.WWJApplet"
    archive="BackwardCompatibility.jar">
    <param name="jnlp_href" value="WWJApplet.jnlp">
applet>
WWJApplet随标准的World Wind Java发行包发布。如下所述，你可选择编写你自己的Applet类并将World Wind嵌入其中：
下面是WWJApplet.jnlp文件中相关的部分：

<jnlp href="WWJApplet.jnlp">
<resources os="Windows">
<property name="sun.java2d.noddraw" value="true"/>
resources>
<resources>
<j2se href="http://java.sun.com/products/autodl/j2se" version="1.4+"/>
<jar href="worldwind.jar" main="true" />
<extension name="jogl"
href="http://download.java.net/media/jogl/builds/archive/jsr-231-webstart-current/jogl.jnlp" />
resources>
<applet-descname="WWJ Applet"
    main-class="gov.nasa.worldwind.examples.applet.WWJApplet"

    width="100"
    height="100">
applet-desc>
jnlp>
注意几点：

在本例中，worldwind.jar作为主类使用。理想地，从NASA的网站引用它，将其作为一个JNLP扩展，这就使得许多不同的都嵌入了World Wind的应用程序或Applet共享相同的jar文件。详情请见下面的内容。

为了它的硬件加速的3D图形，World Wind Java使用了针对OpenGL API的Java绑定，JOGL。注意，JOGL JNLP扩展仅使用一行代码与应用程序进行结合。也要注意，在Windows平台上，由于OpenGL API与DirectDraw/Direct3D API(该API用于Windows平台默认的Java 2D实现)之间在驱动层面的冲突，需要指定系统参数-Dsun.java2d.noddraw=true。Windows平台上所有使用JOGL的应用程序与Applet程序都需要该系统参数。

Web页面中的HTML链接调用JavaScript函数，该函数会与Applet进行交互并将其导向合适的山峰。下面是这些链接中的一个：

<a href="javascript:gotoLocation(MOUNT_RAINIER);">Mount Rainiera>
    (southeast of Tacoma, Washington)
当点击该链接后，将会调用JavaScript函数gotoLocation。该函数定义在同一个Web页面中：

function gotoLocation(locationString) {
    var params = locationString.split(';');
    if(params.length == 3)  // Lat/lon
    getWWJApplet().gotoLatLon(parseFloat(params[1]),
    parseFloat(params[2]));

}
Web页面HTML中的山峰位置将被解码为JavaScript字符串。将从这些字符串中解析出纬度，经度及其它视觉信息，并将它们传递给Applet。 gotoLatLon方法是在WWJApplet类中定义的；上面的方法调用将起动一个JavaScript-to-Java调用，把参数从JavaScript引擎传给Java。World Wind Applet接收该通知，并将视点以动画的方式切换到适当的地方。注意，gotoLatLon方法会迅速地返回，以便浏览器不必等待它的完成；该动画会在一个单独的Java线程中运行。

   Figure 3. World Wind Applet with Mount St. Helen's Clicked
如上所述，将World Wind Java集成到你的应用程序或Applet程序中的最好方法是将其作为一个JNLP扩展。这允许很多来自网络的集成了World Wind Java的应用程序或Applet程序能够共享World Wind代码资源。为了引用World Wind JNLP扩展，你需将下面的语句行加入到你的应用程序或Applet程序的JNLP文件中的部分：

<extension name="worldwind" href="http://worldwind.arc.nasa.gov/java/0.4.1/webstart/worldwind.jnlp"/>
<extension name="jogl"
    href="http://download.java.net/media/jogl/builds/archive/jsr-231-webstart-current/jogl.jnlp"/>
注意，World Wind扩展JNLP是区分版本的，所以你需参考World Wind文档或访问论坛去找到你的JNLP会引用到的扩展的最新版本。World Wind Central是一个关于World Wind最新信息的有用资源。
将World Wind作为一个扩展使用就意味着你不能将WWJApplet直接作为你的main-class使用。由于JNLP文件格式的语义，主jar (main="true")必须定义在主JNLP文件中。但很容易就能适应该限制，你可简单地创建你自己的WWJApplet子类(称之为MyWWJApplet)，而它并不做任何事情：

class MyWWJApplet extends WWJApplet {}
将worldwind.jar置于classpath中，并编译上述类，然后将该类放入它自己的jar文件中。引入这个jar作为你的主jar，MyWWJApplet就成为了你的main-class，然后将其作为JNLP扩展引入到World Wind中。

结论
介绍了Java插件对JNLP的支持，这为Applet的发布提供了很多新的可能，这对在浏览器内外发布Java内容的方法的统一又进了一大步。Applet自从它们起始已过了很长的时间，现在随着对JNLP的支持，它们会比以往更快，也更易于定制。

Sha Jiang 2008-07-14 19:56 发表评论