﻿<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:trackback="http://madskills.com/public/xml/rss/module/trackback/" xmlns:wfw="http://wellformedweb.org/CommentAPI/" xmlns:slash="http://purl.org/rss/1.0/modules/slash/"><channel><title>BlogJava-CONAN ZONE-文章分类-Eclipse</title><link>http://www.blogjava.net/conans/category/32368.html</link><description>你越挣扎我就越兴奋</description><language>zh-cn</language><lastBuildDate>Sat, 18 Dec 2010 10:22:47 GMT</lastBuildDate><pubDate>Sat, 18 Dec 2010 10:22:47 GMT</pubDate><ttl>60</ttl><item><title>优化JVM参数提高eclipse运行速度</title><link>http://www.blogjava.net/conans/articles/339581.html</link><dc:creator>CONAN</dc:creator><author>CONAN</author><pubDate>Thu, 02 Dec 2010 02:49:00 GMT</pubDate><guid>http://www.blogjava.net/conans/articles/339581.html</guid><description><![CDATA[转自：http://www.javaeye.com/topic/756538#1659035<br />
<br />
首先建立评估体系，将workspace里所有的项目close掉，关闭eclipse。优化的用例就是启动eclipse，open一个项目，eclipse会自动build这个项目，保证没有感觉到明显的卡，也就是没有full GC。
<br />
<br />
开始：
<br />
<br />
eclipse.ini里加入打印gc情况的参数：
<br />
<br />
<table>
    <tbody>
        <tr>
            <td>-XX:+PrintGCTimeStamps</td>
        </tr>
        <tr>
            <td>-XX:+PrintGCDetails</td>
        </tr>
        <tr>
            <td>-verbose:gc</td>
        </tr>
        <tr>
            <td>-Xloggc:gc.log</td>
        </tr>
    </tbody>
</table>
<br />
<br />
这样eclipse在运行过程中会记录gc日志，显示详细的gc情况，并打印在gc.log中，通过分析这个日志寻找eclipse的性能瓶颈和优化方式。
<br />
我最初的参数只是在原版基础上调了堆大小
<br />
<table>
    <tbody>
        <tr>
            <td>-Xms512m</td>
        </tr>
        <tr>
            <td>-Xmx512m</td>
        </tr>
    </tbody>
</table>
<br />
<br />
将堆初始化和最大值设为一样，消除堆大小根据当前堆使用情况而变化带来的影响。
<br />
启动eclipse，发现gc.log里打出了很多full gc的日志
<br />
<div>引用</div>
<div>4.226: [Full
GC 4.226: [Tenured: 18470K-&gt;19304K(30544K), 0.1159544 secs]
25154K-&gt;19304K(44368K), [Perm : 24574K-&gt;24554K(24576K)], 0.1160431
secs] [Times: user=0.13 sys=0.00, real=0.13 secs]</div>
<br />
在启动的6秒多时间里共出现了8次full gc，所以启动慢，觉得启动时候挺卡的。从日志里可以看出来
FullGC主要是在回收tenured区和Perm区，其中Perm一直都是快满的状态，Perm :
24574K-&gt;24554K(24576K)，Perm大小在不断调整，所以需要固定Perm区的大小，保证够用，eclipse.ini里加入
<br />
<table>
    <tbody>
        <tr>
            <td>-XX:PermSize=64m</td>
        </tr>
        <tr>
            <td>-XX:MaxPermSize=64m</td>
        </tr>
    </tbody>
</table>
<br />
<br />
再启动：发现没有full gc了只有数量比较多的minor gc，挑启动开始到启动完成的第一条和最后一条日志
<br />
<div>引用</div>
<div>0.209: [GC
0.209: [DefNew: 4416K-&gt;511K(4928K), 0.0034707 secs]
4416K-&gt;614K(15872K), 0.0035239 secs] [Times: user=0.00 sys=0.00,
real=0.00 secs]
<br />
&#8230;.
<br />
6.383: [GC 6.383: [DefNew: 18880K-&gt;1985K(21184K), 0.0055311 secs] 46992K-&gt;30098K(68040K), 0.0055694 secs]</div>
<br />
这6秒中GC日志打了69次， 而内存回收率还是蛮高的 young区18880-1985=16895 jvm
46992-30098=16894
都快接近100%了，可以看出young区是由小到大在不断调整大小，所以不断GC，因此设一个初始值吧，据说设置heap的1/4比较好，那就是
128M，所以eclipse.ini加入
<br />
<table>
    <tbody>
        <tr>
            <td>-Xmn128m</td>
        </tr>
    </tbody>
</table>
<br />
<br />
再重启，发现GC日志就四条了，eclipse启动自然快了
<br />
<br />
<div>引用</div>
<div>1.292: [GC
1.292: [DefNew: 104960K-&gt;10984K(118016K), 0.0334165 secs]
104960K-&gt;10984K(511232K), 0.0334603 secs] [Times: user=0.03 sys=0.00,
real=0.03 secs]
<br />
2.182: [GC 2.182: [DefNew: 115944K-&gt;1852K(118016K), 0.0221714
secs] 115944K-&gt;11466K(511232K), 0.0222142 secs] [Times: user=0.00
sys=0.02, real=0.02 secs]
<br />
3.987: [GC 3.987: [DefNew: 106779K-&gt;12531K(118016K), 0.0378228
secs] 116393K-&gt;22145K(511232K), 0.0378692 secs] [Times: user=0.03
sys=0.00, real=0.03 secs]
<br />
5.377: [GC 5.377: [DefNew: 117491K-&gt;9403K(118016K), 0.0513728 secs] 127105K-&gt;31364K(511232K), 0.0514133 secs]</div>
<br />
<br />
但是，启动后open我的多个项目，这些项目互相依赖，eclipse自动build，感觉有点小卡，发现日志里多了4次full GC，所以就卡了&#8230;
<br />
<div>引用</div>
<div>67.320:
[Full GC (System) 67.320: [Tenured: 88847K-&gt;68809K(393216K),
0.2121213 secs] 117385K-&gt;68809K(511232K), [Perm :
41915K-&gt;41915K(65536K)], 0.2121747 secs] [Times: user=0.20 sys=0.00,
real=0.20 secs]
<br />
103.759: [Full GC (System) 103.759: [Tenured:
81882K-&gt;66784K(393216K), 0.3287387 secs] 185350K-&gt;66784K(511232K),
[Perm : 53464K-&gt;53414K(65536K)], 0.3287897 secs] [Times: user=0.33
sys=0.00, real=0.33 secs]</div>
<br />
<br />
这个时候Tenured区和Perm都还没到很接近最大值，但是为什么还有full
GC呢，开始以为是JVM悲观认为Tenured区剩余空间不足以应对下一次minor GC 所以进行了full
GC调整Tenured空间，索性直接增加了堆最大值到-Xmx728m（工作电脑的内存是3.5G），但重启后full
gc还是有4次，而且有几次minor
GC用的时间超过了0.1秒，这是因为增加了堆大小，导致GC用时也增加了，不能接受。所以还是改回-Xmx512m。
<br />
再仔细观察日志，发现Full GC (System) 字样，这个意思是eclipse里调用了System.gc()手动触发了系统GC，好吧，哥已经给你分配足够空间了，你就省省吧，在eclipse.ini里加入：
<br />
<table>
    <tbody>
        <tr>
            <td>-XX:+DisableExplicitGC</td>
        </tr>
    </tbody>
</table>
<br />
<br />
这样就差不多了，整个过程没有出现full gc，再编码2个小时，中间只出现了一次full gc，在open build某50W行+的代码的时候，eclipse还是卡了&#8230;
<br />
最后又稍微调了一下各代的大小，得到目前的参数：
<br />
<table>
    <tbody>
        <tr>
            <td>-Xms512m</td>
        </tr>
        <tr>
            <td>-Xmx512m</td>
        </tr>
        <tr>
            <td>-XX:PermSize=96m</td>
        </tr>
        <tr>
            <td>-XX:MaxPermSize=96m</td>
        </tr>
        <tr>
            <td>-Xmn168m</td>
        </tr>
        <tr>
            <td>-XX:+DisableExplicitGC</td>
        </tr>
    </tbody>
</table>
<br />
另外没有去调GC策略，主要是觉得eclipse是客户端程序，默认的client单线程的GC策略应该是比较适合的，以后有时间再试试看吧。
<br />
<img src ="http://www.blogjava.net/conans/aggbug/339581.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/conans/" target="_blank">CONAN</a> 2010-12-02 10:49 <a href="http://www.blogjava.net/conans/articles/339581.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>关于jdk1.6.21与eclipse 3.6冲突的完美解决方案</title><link>http://www.blogjava.net/conans/articles/338378.html</link><dc:creator>CONAN</dc:creator><author>CONAN</author><pubDate>Thu, 18 Nov 2010 06:32:00 GMT</pubDate><guid>http://www.blogjava.net/conans/articles/338378.html</guid><description><![CDATA[jdk1.6.21在eclipse 3.6下存在冲突的问题，但说的不是很详细，有人问到，那我就再说一下吧。这是这个官方就有说明的，在下载页面很明显的标出了，只是有的同学不是在官方下载的或者太粗心没注意到。我们看官方是怎么说的。<br />
&nbsp;&nbsp;
<p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; The Eclipse 3.3 - 3.6 launchers for Windows had a problem with the Oracle/Sun Java VM version '1.6.0_21-b06'.</p>
<p><strong>UPDATE: Oracle/Sun have released a respin of their JDK/JRE to fix this</strong>, so the recommended resolution of this problem is to download and re-install version 1.6.0_21-b07' or higher from <a href="http://www.java.com/" class="external free" title="http://www.java.com" rel="nofollow">http://www.java.com</a> (alternative link is <a href="http://java.sun.com/javase/downloads/index.jsp" class="external free" title="http://java.sun.com/javase/downloads/index.jsp" rel="nofollow">http://java.sun.com/javase/downloads/index.jsp</a>). Make sure you have b07 or higher by running <tt>java -version</tt>.</p>
<p>Before the fix was released, there were three choices to work around this: </p>
<ol>
    <li>switch back to '<strong>1.6.0_20'</strong> (as of July 19, 2010 it can still be downloaded <a href="http://java.sun.com/javase/downloads/widget/jdk_javafx.jsp" class="external text" title="http://java.sun.com/javase/downloads/widget/jdk_javafx.jsp" rel="nofollow">here</a>) </li>
    <li>Change the commandline for launching or add the following line after "-vmargs" to your <tt><a href="http://wiki.eclipse.org/Eclipse.ini" title="Eclipse.ini">Eclipse.ini</a></tt> file:<br />
    <tt>-XX:MaxPermSize=256m</tt><br />
    (<a href="http://wiki.eclipse.org/Eclipse.ini" title="Eclipse.ini">Detailed instructions/examples</a>) </li>
    <li>For 32-bit Helios, download the fixed <a href="https://bugs.eclipse.org/bugs/attachment.cgi?id=174640" class="external text" title="https://bugs.eclipse.org/bugs/attachment.cgi?id=174640" rel="nofollow">eclipse_1308.dll</a> and place it into<br />
    <tt>(eclipse_home)/plugins/org.eclipse.equinox.launcher.win32.win32.x86_1.1.0.v20100503</tt></li>
</ol>
<p>The Java bug was closed for voting and comments at <a href="http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6969236" class="external text" title="http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6969236" rel="nofollow">6969236</a> on the Java BugParade because the change has been reverted; the related Eclipse bug report is open for voting and comments at <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=319514" class="external text" title="https://bugs.eclipse.org/bugs/show_bug.cgi?id=319514" rel="nofollow">bug 319514</a>.<br />
&nbsp;&nbsp;&nbsp; 已经说得很明白了，由于1.6.0_21-b06中部分包的名字被Oracle公司修改了，会造成原先的插件内存泄露，故官方也给出了三种解决方案。<br />
（1）把JDK的版本降级到 jdk <strong>1.6.0_20。下载地址：</strong><a href="http://java.sun.com/javase/downloads/widget/jdk_javafx.jsp" class="external text" title="http://java.sun.com/javase/downloads/widget/jdk_javafx.jsp" rel="nofollow">here</a><br />
（2）修改<tt><a href="http://wiki.eclipse.org/Eclipse.ini" title="Eclipse.ini">Eclipse.ini</a>文件里的设置，在</tt>-vmargs后添加或修改下面这句<tt>-XX:MaxPermSize=256m。<br />
（3）对于32位版本的Eclipse3.6，可以下载这个补丁。</tt><a href="https://bugs.eclipse.org/bugs/attachment.cgi?id=174640" class="external text" title="https://bugs.eclipse.org/bugs/attachment.cgi?id=174640" rel="nofollow">eclipse_1308.dll</a>，并且放置到<tt>(eclipse_home)/plugins/org.eclipse.equinox.launcher.win32.win32.x86_1.1.0.v20100503。<br />
（4）升级jdk</tt>1.6.0_21-b06到1.6.0_21-b07或更高。</p>
<img src ="http://www.blogjava.net/conans/aggbug/338378.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/conans/" target="_blank">CONAN</a> 2010-11-18 14:32 <a href="http://www.blogjava.net/conans/articles/338378.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>Mylyn 2.0，第 2 部分: 自动上下文管理</title><link>http://www.blogjava.net/conans/articles/209879.html</link><dc:creator>CONAN</dc:creator><author>CONAN</author><pubDate>Sun, 22 Jun 2008 10:52:00 GMT</pubDate><guid>http://www.blogjava.net/conans/articles/209879.html</guid><description><![CDATA[<blockquote>现在，在 2.0 版中，Mylyn（以前称为 Mylar）通过将任务无缝集成到 Eclipse 中并在工作时自动管理任务上下文，提高了效率。Mylyn 项目主管 Mik Kersten 更新了他撰写的分两部分的 Mylyn 使用指南。<a href="http://www.ibm.com/developerworks/cn/java/j-mylyn1/" cmimpressionsent="1">第 1 部分</a> 介绍 Mylyn 的任务管理功能和它与 Bugzilla 之类的储存库的集成。本文为第 2 部分，解释当在 Eclipse 中处理大型应用程序时，Mylyn 的上下文管理功能如何简化多任务处理以及如何减少信息超载。</blockquote><!--start RESERVED FOR FUTURE USE INCLUDE FILES--><!-- include java script once we verify teams wants to use this and it will work on dbcs and cyrillic characters --><!--end RESERVED FOR FUTURE USE INCLUDE FILES-->
<p>在 <a href="http://www.ibm.com/developerworks/cn/java/j-mylyn1/" cmimpressionsent="1">本文的前半部分</a> 中，我解释了 Mylyn 的任务管理功能如何轻松地聚焦与给定工作日或工作周相关的任务。一旦任务成为您的 Eclipse 体验中的集成部分，您很可能会注意到许多重复性行为都是以所处理的任务的<em>上下文</em> 为中心的。多任务处理是当今知识工作中很普遍的一部分，它常常需要创建和重新创建与当前任务相关的上下文。任务的上下文是指在处理任务时需要引用的所有文件、搜索结果和其它相关信息。例如，在编程时，可能只想看到与正在修复的 bug 相关的 Java&#8482; 元素。当完成修复时，您可能希望以独立于当天处理的其它任务的方式提交这些更改。或者，希望通过只运行与对任务作出的更改相关的测试来节省时间。</p>
<table cellspacing="0" cellpadding="0" width="40%" align="right" border="0">
    <tbody>
        <tr>
            <td width="10"><img height="1" alt="" src="http://www.ibm.com/i/c.gif" width="10" /></td>
            <td>
            <table cellspacing="0" cellpadding="5" width="100%" border="1">
                <tbody>
                    <tr>
                        <td bgcolor="#eeeeee"><a name="smart"><strong>什么使 Mylyn 变得 &#8220;灵巧&#8221; 呢</strong></a><br />
                        <p>尽管 Mylar 经常被称作灵巧的用户界面，但它本身并没有任何灵巧之处：它只不过是利用了您的智慧。Mylyn 通过利用这样一个事实做到这点：与每个任务涉及的细节相比，组成工作的各个部分（即您所处理的任务）更加容易检索。它以一种可预测的方式自动捕捉您所处理的所有细节，使您无需再经历重新检索或重新查找的繁琐过程。Mylar 上下文是您同系统元素及关系进行交互的一种可预测的投影，它并没有使用难于预测和理解的知识型模型。这种模型十分灵活，正逐渐被扩展到广泛的知识工作工具中。请参阅 <a href="http://www.ibm.com/developerworks/cn/java/j-mylyn2/index.html#resources" cmimpressionsent="1">参考资料</a> 小节，了解更多关于 Mylyn 内部原理和架构的信息，以及为项目扩展 Mylyn 的更多细节。</p>
                        </td>
                    </tr>
                </tbody>
            </table>
            </td>
        </tr>
    </tbody>
</table>
<p>正如 Mylyn 可以帮助您聚焦工作周所包含的任务一样，它可以使 Eclipse 工作区聚焦与当前任务相关的工件上。安装 Mylyn 的 Task-Focused UI 之后，只需指出活动的任务，您所使用的所有文件都将自动添加到该任务的上下文中。管理上下文是为了精确地表示出对所从事的各种工件的聚焦程度，即使对长期运行的任务也是如此。当切换任务时，上下文将被保存，这使您可以通过一次单击进行多任务处理，并且轻松地与其他人共享特定于任务的知识。</p>
<p>本文解释了 Mylar 如何无缝地将其置于 Eclipse UI 之上来凸现编程任务的上下文。本文首先解释 Mylyn 管理上下文的机制，然后介绍兴趣修饰、视图过滤、编辑器管理和上下文驱动的单元测试套件等 UI 工具。在文章的最后，展示了如何综合运用 Mylar 的任务管理和上下文管理来协助团队协作。</p>
<p>图 1 中的编号区域显示了 Mylyn 的一些上下文管理功能：</p>
<ol>
    <li>单击 <strong>Focus on Active Task</strong> 按钮可以使 Eclipse Package Explorer 只显示活动任务的上下文中的元素。
    <li>可以通过 Task List 切换活动任务。
    <li>切换后，Eclipse 视图和编辑器将聚焦于新激活的任务的上下文。
    <li>更改集将被自动管理，以反映任务上下文中的更改。
    <li>折叠功能和上下文可以帮助视图聚焦相关的元素。 </li>
</ol>
<br />
<a name="fig1"><strong>图 1. 将 Eclipse 聚焦于任务上下文</strong></a><br />
<img height="477" alt="" src="http://www.ibm.com/developerworks/cn/java/j-mylyn2/part2-overview.jpg" width="570" /> <br />
<p>单击 <a href="http://www.ibm.com/developerworks/cn/java/j-mylyn2/sidefile2.html" cmimpressionsent="1">这里</a> 查看全图。</p>
<p><a name="N100A8"><span class="atitle">以任务为中心的编程</span></a></p>
<p>设想一下，假设您正在将更改封装到新功能里，来应对迫近的代码冻结期限。在工作中，创建此功能时，构建了关于所有修改过的类和方法以及所有访问过的 API 的颇有价值的知识。由于在使用 Mylar，这个知识会自动地在任务上下文中获取到。任务要完成时，却出现了一个严重的 bug，需要立即给予注意。</p>
<p>您通过单击激活 bug 报告，并开始调查该问题。在 Mylar 的富任务编辑器中浏览该 bug 加了超链接的堆栈跟踪，新的任务上下文被探查和诊断结果所填充。当单击 Mylyn 的自动化 Context Test Suite（该套件运行与已创建的任务上下文结构相关的单元测试）时，您发现这个 bug 位于一个同事的代码中，而不在您的代码中。由于 Mylyn 提供了对任务的修改历史的链接，您可以立即查看该同事的任务，它对应于出现问题的更改。通过再一次单击，将该 bug 再分配给同事并共享由您的诊断得出的任务上下文。完成这些都未离开 Eclipse，所以通过单击 Task List 的 <strong>Back</strong> 按钮可以立即回到之前任务的上下文。同时，您的同事也恰在您停止的地方拾起该 bug 报告。这只是程序员使用 Task-Focused UI 轻松工作和协作的场景之一。</p>
<table cellspacing="0" cellpadding="0" width="40%" align="right" border="0">
    <tbody>
        <tr>
            <td width="10"><img height="1" alt="" src="http://www.ibm.com/i/c.gif" width="10" /></td>
            <td>
            <table cellspacing="0" cellpadding="5" width="100%" border="1">
                <tbody>
                    <tr>
                        <td bgcolor="#eeeeee"><a name="support"><strong>支持的工具</strong></a><br />
                        <p>类似于需要使用<em>连接器</em> 与任务储存库集成，Mylyn 使用<em>桥接器（bridge）</em>将它的上下文模型与特定于域的工具集成。Mylyn 附带了用于 Eclipse SDK 的一组核心的桥接器，其中包括对 Java 代码、JUnit、Plug-in Development Environment (PDE)、Ant 和纯文本文件的支持。为了获得完全集成的体验，Mylyn 需要一个用于所有要使用的工具和语言（例如 Ruby 和 JSP）的桥接器。如果缺少特定于您所使用的编程语言或其它文件类型的桥接器，Mylyn 仍然会提供文件级别的聚焦，但是不能监视您与文件内部结构的交互（例如编辑特定的声明）。这意味着在 Package Explorer 中只能看到感兴趣的文件，但是不能执行细粒度的声明过滤（例如在 Outline 视图中）以及在编辑器中自动折叠声明，也不具备诸如任务 Context Test Suites 等高级特性。</p>
                        <p>为了提供 <a href="http://www.ibm.com/developerworks/cn/java/j-mylyn2/index.html#changesets" cmimpressionsent="1">自动化更改集管理</a>，Mylyn 还需要对版本控制集成进行某种扩展。Mylyn 附带了对 CVS 的支持，但是对 Subversion 等其它版本控制系统的支持则需要单独安装。请查看 <a href="http://www.ibm.com/developerworks/cn/java/j-mylyn2/index.html#resources" cmimpressionsent="1">参考资料</a> 中的 Mylyn Extensions 清单，下载用于 Mylyn 的额外的桥接器和版本控制集成。</p>
                        </td>
                    </tr>
                </tbody>
            </table>
            </td>
        </tr>
    </tbody>
</table>
<p>接下来的小节展示如何利用 Mylyn 的上下文管理功能以任务为中心的方式工作。虽然这里的例子基于 Java 开发，但其中的概念和大多数特性同样适用于可能使用的任何基于文件的工件。（请参阅 <a href="http://www.ibm.com/developerworks/cn/java/j-mylyn2/index.html#support" cmimpressionsent="1">支持的工具</a>，了解更多细节。）</p>
<p><a name="N100DD"><span class="smalltitle">兴趣等级模型</span></a></p>
<p>Mylyn 中的任务上下文管理基于这样的思想：开发人员与系统的交互可以转换为一个<em>兴趣等级（degree-of-interest）模型</em>，在该模型中，系统中的每个元素都根据其与手头任务的兴趣等级来衡量其权重。这种相关度加权形成了与任务相关的所有元素的上下文。然后，就可以通过突出最重要的元素、过滤无关紧要的元素以及允许在感兴趣的元素上执行操作（例如，只提交相关更改）来使任务上下文聚焦于 UI。任务上下文是在您工作时以一种可预测的方式构建的：当您激活一个任务时，您选择或编辑的每个元素 —— 例如文件或 Java 方法 —— 就成为任务上下文的一部分。和元素交互越多，该元素相对于任务的兴趣等级就越高。如果一个元素的兴趣级别足够高，那么它就成为一个<em>里程碑（landmark）</em>，这是一个隐式创建的书签。每一次交互也导致组成任务的所有元素已积累的兴趣逐渐衰减，这样兴趣元素的集合就会同当前的兴趣相匹配，而不会无限制的扩张下去。 </p>
<p>使任务上下文模型简单易用的关键特征是它具有可预测性并且一目了然：您期望看到的内容就显示在眼前，每当您开始处理一个元素时，就立即可以看到该元素填充了上下文。还可以直接操纵元素的兴趣等级，或者使元素变得不相关，或者显式地将元素标记为里程碑。换句话说，您已经熟悉的 bookmark/starring/tagging UI 没有任何损失。但是，一旦您习惯使用 Mylyn，您很可能会发现自己对那些手动管理任务上下文的机制的依赖性大大减少。</p>
<p><a name="N100EF"><span class="smalltitle">兴趣修饰和过滤</span></a></p>
<p>Mylyn 的上下文管理功能使用传统的 Eclipse 视图以一种新的方式来凸现信息。您只需通过一次单击激活任务，就可以使 Eclipse UI 聚焦于那个任务。然后，您与之交互的每个元素都成为任务上下文的一部分。Mylar 兴趣修饰器随后使用字体着色来高亮显示每个元素从交互中积累的兴趣等级。非兴趣元素以灰色显示，兴趣元素以黑色显示，里程碑为粗体。</p>
<p>尽管只高亮显示在减少信息过载方面有其局限性，但它还是一直应用于所有能看到诸如 Java 成员和文件等元素的视图中。这便于您在查看一长串的元素时快速挑选任务上下文中的元素。例如，当查看搜索结果时，可以立即发现最感兴趣的元素，因为它们以粗体修饰为里程碑形式（参见 <a href="http://www.ibm.com/developerworks/cn/java/j-mylyn2/index.html#fig2" cmimpressionsent="1">图 2</a>）。</p>
<p>仅仅使用修饰还不足以减少包含几十万个文件的大型工作区中的信息超载。一些结构化视图，例如 Eclipse 的 Project Explorer，在浏览大型层次结构内容方面已变得令人难以置信的高效。超载问题与那些视图无关，而应该归因于开发人员使用的巨大的信息系统并不匹配与任何给定编程任务相关的相对较少的信息。对于这种不匹配，最明显的表现是，大量时间浪费在反复滚动以及展开/折叠庞大的树视图以查找完成工作所需的信息。</p>
<table cellspacing="0" cellpadding="0" width="55%" align="right" border="0">
    <tbody>
        <tr>
            <td width="10"><img height="1" alt="" src="http://www.ibm.com/i/c.gif" width="10" /></td>
            <td>
            <table cellspacing="0" cellpadding="5" width="100%" border="1">
                <tbody>
                    <tr>
                        <td bgcolor="#eeeeee"><a name="support"><strong>技巧：不过滤子节点</strong></a><br />
                        <p>为了减少需要关闭聚焦模式的次数，Mylyn 提供了 Alt+Click 机制，使您可以在树视图中暂时不过滤一个节点的子节点。例如，为了选择一个不可见的方法，可以按住 Alt 键并单击类，并选择那个方法，以便将它添加到任务上下文中。如果在视图中的空白处按住 Alt 并单击鼠标，则会显示所有的根节点（例如项目）。如果继续按住 Alt 键，可以快速地从一个项目节点导航到感兴趣的方法。</p>
                        </td>
                    </tr>
                </tbody>
            </table>
            </td>
        </tr>
    </tbody>
</table>
<p>Mylyn 的目标是消除所有不需要的滚动和单击操作。为此， Task-Focused UI 提供基于兴趣的过滤和结构化视图管理。通过 <strong>Focus on Active Task</strong> 按钮激活后，这些功能可以过滤掉所有不感兴趣的元素，从而将相应的视图聚焦于活动任务的上下文。例如，聚焦模式确保 Package Explorer 只显示您正在处理的内容：属于任务的一部分的所有源文件、库文件和方法。除了过滤外，当应用聚焦时，Mylyn 还自动维护树视图的展开状态，所以您不需要手动地展开和折叠树节点就能看到感兴趣的元素。</p>
<p>开始在视图上使用聚焦模式后，您将注意到兴趣模型如何随着工作而演进。一个元素的被选中次数越多，元素的兴趣等级就越高，直到它变为粗体的里程碑。低兴趣的元素（如只选过一次的搜索命中结果）将在兴趣等级中衰减并从过滤过的视图中消失，这确保该视图不会被非兴趣元素所胀满。由于任务上下文在一种可预见的模式下被积极地管理，上下文只包括了有兴趣等级的元素，即使在长期运行的任务中也是如此。尽管设计 Mylar 的任务上下文模型是为了能够一直反映当前与任务相关的东西，但也可以手动地增加或减少元素的兴趣等级（例如，通过使用元素的上下文菜单行为或使用快捷键 Ctrl+Alt+Shift+ 向上/向下的箭头）。</p>
<br />
<table cellspacing="0" cellpadding="0" width="100%" border="0">
    <tbody>
        <tr>
            <td><img height="1" alt="" src="http://www.ibm.com/i/v14/rules/blue_rule.gif" width="100%" /><br />
            <img height="6" alt="" src="http://www.ibm.com/i/c.gif" width="8" border="0" /></td>
        </tr>
    </tbody>
</table>
<table class="no-print" cellspacing="0" cellpadding="0" align="right">
    <tbody>
        <tr align="right">
            <td><img height="4" alt="" src="http://www.ibm.com/i/c.gif" width="100%" /><br />
            <table cellspacing="0" cellpadding="0" border="0">
                <tbody>
                    <tr>
                        <td valign="middle"><img height="16" alt="" src="http://www.ibm.com/i/v14/icons/u_bold.gif" width="16" border="0" /><br />
                        </td>
                        <td valign="top" align="right"><a class="fbox" href="http://www.ibm.com/developerworks/cn/java/j-mylyn2/index.html#main" cmimpressionsent="1"><strong>回页首</strong></a></td>
                    </tr>
                </tbody>
            </table>
            </td>
        </tr>
    </tbody>
</table>
<br />
<br />
<p><a name="N10118"><span class="atitle">以任务为中心的工作区</span></a></p>
<p>在深入探讨 Mylyn 提供的用于支持 Java 开发的高级集成之前，您需要大体了解在处理纯文本文件时，Task-Focused UI 对 Eclipse 工作区的关键贡献。图 2 演示了这些关键概念：</p>
<ul>
    <li>在左侧，Project Explorer 视图聚焦于活动任务，它只显示感兴趣的文件，并高亮显示里程碑。在这里，可以使用 Alt+Click 机制临时显示一个名为 presentations 的目录中的所有文件，以便选择其它感兴趣的文件。<br />
    <br />
    <li>在右侧，Task List 显示一个活动任务。当该任务停止活动时，Package Explorer 视图上的焦点被关闭，当前打开的所有文件被关闭。如果一个新的任务被激活，则重新应用焦点，用于处理那个任务的所有打开的编辑器立即恢复。 </li>
</ul>
<br />
<a name="fig2"><strong>图 2. 以任务为中心的工作区</strong></a><br />
<img height="544" alt="" src="http://www.ibm.com/developerworks/cn/java/j-mylyn2/part2-files.jpg" width="572" /> <br />
<p>本文后面的内容以 Java 开发为例，较详细地阐述如何以以任务为中心的方式工作。但是，任务激活、视图聚焦和编辑器管理等概念是使用 Mylyn 的最值得注意的关键方面。您只需理解任务激活的概念，就可以开始使用以任务为中心的方式工作。这种小但重要的工作方式的改变会立即使您获益：当您切换任务时，您在工作中建立起来的所有有价值的上下文不再会丢失。</p>
<table cellspacing="0" cellpadding="0" width="55%" align="right" border="0">
    <tbody>
        <tr>
            <td width="10"><img height="1" alt="" src="http://www.ibm.com/i/c.gif" width="10" /></td>
            <td>
            <table cellspacing="0" cellpadding="5" width="100%" border="1">
                <tbody>
                    <tr>
                        <td bgcolor="#eeeeee"><a name="support"><strong>技巧： 配置 Task-Focused UI </strong></a><br />
                        <p>默认情况下大多数 Task-Focused UI 特性都是打开的，但是可以通过视图或编辑器中相应的按钮或者偏好设置关闭它们。要了解更详细的信息，请参阅 Mylyn FAQ （见 <a href="http://www.ibm.com/developerworks/cn/java/j-mylyn2/index.html#resources" cmimpressionsent="1">参考资料</a>）。</p>
                        </td>
                    </tr>
                </tbody>
            </table>
            </td>
        </tr>
    </tbody>
</table>
<p><a name="N10152"><span class="atitle">在 Java 开发中使用 Mylyn</span></a></p>
<p>将 Mylyn 用于 Java 编程的开发人员常常使 Package Explorer 处于聚焦模式。因此，默认情况下，当激活一个任务时，<strong>Focus on Active Task</strong> 按钮自动打开，当将一个任务变为不活动时，该按钮自动关闭。当该功能打开时，只能看到上下文中的 Java 元素。当选择一个 Java 类时，不管是通过浏览还是通过常用的 Open Type 机制（Ctrl+Shift+T），这种类型就成为上下文的一部分，并显示在过滤后的 Package Explorer 中。您选择和编辑的每个方法都被添加到任务上下文中，因此会显示在 Package Explorer 中。图 3 显示聚焦模式下的 Package Explorer。注意 Package Explorer 和 Debug 视图中 Java 元素的基于兴趣的修饰和活动过滤。</p>
<br />
<a name="fig3"><strong>图 3. 使 Java 元素视图聚焦于任务上下文</strong></a><br />
<img height="453" alt="" src="http://www.ibm.com/developerworks/cn/java/j-mylyn2/part2-java.jpg" width="572" /> <br />
<p>当视图在聚焦模式时，Eclipse 用于打开元素的工具运行良好（使用 Ctrl+Shift+T 打开一个类型，使用 Ctrl+Shift+R 打开一项资源，Ctrl+O 用于就地打开大纲，Ctrl+T 用于就地打开层次结构）。为使在 Open Type 对话框中选择类型更加简单，感兴趣的类型被自动放在列表的最上面。当切换任务时，列表中包含新任务感兴趣的类型。当没有活动任务时，该列表恢复为最近使用类型的 Eclipse 全局列表。</p>
<p>如果使用 Java Browsing 透视图，请使用窗口的工具栏按钮，通过单击将三种 Java 元素视图设为聚焦模式，而不必逐个聚焦每个视图。</p>
<table cellspacing="0" cellpadding="0" width="40%" align="right" border="0">
    <tbody>
        <tr>
            <td width="10"><img height="1" alt="" src="http://www.ibm.com/i/c.gif" width="10" /></td>
            <td>
            <table cellspacing="0" cellpadding="5" width="100%" border="1">
                <tbody>
                    <tr>
                        <td bgcolor="#eeeeee"><a name="support"><strong>技巧：快速视图</strong></a><br />
                        <p>如果使用没有可见导航视图的透视图（例如 Debug 视图），或者将编辑器区域最大化，那么仍然可以从 <strong>Navigate &gt; Quick Context View</strong>（快捷键为 Ctrl+Shift+Alt+右箭头）导航上下文。和 Quick Outline (Ctrl+O) 等其它快速视图一样，这种弹出视图的优点是允许您输入，以导航到感兴趣的文件或元素。</p>
                        </td>
                    </tr>
                </tbody>
            </table>
            </td>
        </tr>
    </tbody>
</table>
<p><a name="N10184"><span class="smalltitle">自动折叠和内容辅助排序</span></a></p>
<p>Eclipse 成熟的 Java 编辑器使您可以在编辑器中处理大多数结构导航。此外，Mylyn 还提供了自动折叠和内容辅助排序，以帮助 Java 编辑器聚焦与当前任务相关的元素。如果打开窗口工具栏中 Mylyn 的 <strong>Automatically Fold Uninteresting Elements</strong> 按钮，那么在编辑器中只有感兴趣的元素被展开。这可以增加编辑器的信息密度，并且更易于导航大型文件中的声明，而不必打开 Outline 视图。当选择一个元素时，它立即成为任务上下文的一部分，并且被展开。注意，在图 4 中，大多数元素都是折叠的，因为它们没有被选择或编辑过；同时，活动元素是打开的，左边的编辑器装订线提示它是一个里程碑：</p>
<br />
<a name="fig4"><strong>图 4. 自动折叠和内容辅助排序</strong></a><br />
<img height="356" alt="" src="http://www.ibm.com/developerworks/cn/java/j-mylyn2/part2-java-editor.jpg" width="572" /> <br />
<p>与视图中的过滤相似，Mylyn 还根据兴趣等级对 Java 内容辅助建议进行排序。在兴趣分隔符下的所有条目都使用 Java Development Tools 的标准排序试探法进行排序。这意味着，只需按几次向下箭头键就可以选择感兴趣的建议。如果在选择建议前开始输入，该列表会恢复为典型排序。还应注意到，在图 4 中，诸如 <code>getTask()</code> 等感兴趣的方法在编辑器中也是展开的。公开元素兴趣等级的各种机制间的一致性有助于 Focused UI 变得可预见且易于使用。</p>
<p><a name="N101A6"><span class="smalltitle">自动编辑器和透视图管理</span></a></p>
<p>Mylar 也使用任务上下文来动态地管理和任务相关的打开编辑器的数目。当文件中的元素从兴趣等级中衰减，该编辑器会自动关闭。当停用一个任务时，它所有的编辑器都会关闭，任务激活时重新打开。减少元素的兴趣等级会关闭其编辑器，且反之亦然，关闭一个文件也会减少其兴趣等级。这可能需要一点时间才能适应，但是这意味着您不再需要自己管理打开的编辑器的状态，并且打开的编辑器的数量也不至于太多。确保所有打开的编辑器与感兴趣的元素相对应，这还使您可以使用 Eclipse 的编辑器导航功能在感兴趣的文件之间导航。例如，如果 Package Explorer 之类的导航视图不可见，可以使用 Ctrl+E 和 Ctrl+F6 方便地在编辑器之间切换。</p>
<p>同样，Mylar 也能通过恢复上次完成一项任务时激活的透视图（通过单击 <strong>Window &gt; Preferences &gt; Mylyn &gt; Context</strong> 启用）来管理 Eclipse 的透视图。当不同的任务对应于 Eclipse 提供的不同视图（例如，有些任务对应于 Java 开发，有些任务对应于 PHP 开发）时，这一点很有用。当使用 Mylyn 的 Planning 透视图时，该功能特别管用。如果在没有活动任务时切换到 Planning 透视图，那么当停止要处理的下一个任务时，就会自动切换到那个透视图。使用 Planning 透视图可以更容易地发现接下来要处理哪个任务，因为这个透视图会将任务编辑器和 Task List 的区域最大化。</p>
<p><a name="N101B5"><span class="smalltitle">使用 Ant、PDE 和其它源文件</span></a></p>
<p>Mylyn 的聚焦功能可以应用于所有在 Eclipse SDK 中显示上下文的视图：Package Explorer、Navigator、Project Explorer、Outline、Problems、Tasks、Debug、Packages、Types 和 Members。任何树视图的聚焦模式，如 Project Explorer 都添加了兴趣修饰、过滤和展开管理。在聚焦模式下，列表视图，例如 Problems，也会按照兴趣等级分类。由于这种通用的支持，即使定制的桥接器不支持您的工具（见 <a href="http://www.ibm.com/developerworks/cn/java/j-mylyn2/index.html#support" cmimpressionsent="1">支持的工具</a>），仍然可以将 Mylyn 用于非 Java 项目，例如 PHP 开发。本节简要地概述如何将 Mylyn 用于使用其它语言和工具的编程。要了解更多信息，请访问 <a href="http://www.ibm.com/developerworks/cn/java/j-mylyn2/index.html#resources" cmimpressionsent="1">参考资料</a> 中的 Mylyn Extensions 链接。</p>
<p>例如，考虑使用 Ant 和 PDE 开发一个应用程序。在这个场景中，Eclipse 工作区看上去和图 5 类似，其中有多个视图被打开，并显示上下文：</p>
<br />
<a name="fig5"><strong>图 5. 使通用 IDE 视图聚焦于任务上下文</strong></a><br />
<img height="431" alt="" src="http://www.ibm.com/developerworks/cn/java/j-mylyn2/part2-ant.jpg" width="572" /> <br />
<table cellspacing="0" cellpadding="0" width="40%" align="right" border="0">
    <tbody>
        <tr>
            <td width="10"><img height="1" alt="" src="http://www.ibm.com/i/c.gif" width="10" /></td>
            <td>
            <table cellspacing="0" cellpadding="5" width="100%" border="1">
                <tbody>
                    <tr>
                        <td bgcolor="#eeeeee"><a name="support"><strong>技巧：清理 to-do 标记</strong></a><br />
                        <p>与 Mylyn 的 Task List 视图相比，Eclipse SDK 的 Tasks 视图显示 to-do 标签等标记，这种标记指示与一个资源有关的本地问题，类似于编译器警告。与 Mylyn 的任务相比，这些标记的粒度要小得多，因为它们对应于数行源代码，而一个 Mylyn 任务可能包含多个标记。由于 Tasks 视图很快会发生超载，因此使用聚焦模式可以很方便地提醒开发人员在提交前清理 to-do 标记。</p>
                        </td>
                    </tr>
                </tbody>
            </table>
            </td>
        </tr>
    </tbody>
</table>
<p>注意，图 5 中的 Project Explorer 视图只显示任务上下文中的文件，这里包括一些图像和 XML 文件。打开的文件是 build.xml，该文件由数十个 Ant 声明组成。在 Outline 视图中，只能看到您正在处理的声明，而不是许多不感兴趣的声明。Problems 视图也聚焦于活动任务，只能看到感兴趣的东西（如所有的错误及警告或任务上下文中其他的元素标记），而不是被数百条无关的警告堆满而超载。最后，Eclipse Tasks 视图也处于聚焦模式，因而将只看到与任务上下文相关的标记，而不会看到数百条不会立即去做的 to-do 标记。</p>
<p><a name="N101E8"><span class="smalltitle">Context Test Suite</span></a></p>
<p>在以任务为中心的方式下编程更易于频繁运行单元测试。通常来说，单元测试实践让您为一个或多个当前正在从事的枯燥测试创建一个新的测试启动程序。其他的测试方案是：在一个项目上运行所有测试，这会错过一些相关测试；或运行一整套测试，这很慢。为解决这些问题，Mylar 在任务上下文中自动维护了元素的单元测试套件 —— 称为 Context Test Suite（见图 6）—— 并在操作任务时使重复运行测试变得很简单（用快捷键 F11）：</p>
<br />
<a name="fig6"><strong>图 6. Context Test Suites</strong></a><br />
<img height="270" alt="" src="http://www.ibm.com/developerworks/cn/java/j-mylyn2/part2-suite.jpg" width="497" /> <br />
<p>要启用该特性，为 JUnit Plug-in 测试或普通 JUnit 测试创建一个 Context Test Suite。Context Test Suite 被自动更新，以包括当前活动上下文中的所有测试用例。</p>
<br />
<table cellspacing="0" cellpadding="0" width="100%" border="0">
    <tbody>
        <tr>
            <td><img height="1" alt="" src="http://www.ibm.com/i/v14/rules/blue_rule.gif" width="100%" /><br />
            <img height="6" alt="" src="http://www.ibm.com/i/c.gif" width="8" border="0" /></td>
        </tr>
    </tbody>
</table>
<table class="no-print" cellspacing="0" cellpadding="0" align="right">
    <tbody>
        <tr align="right">
            <td><img height="4" alt="" src="http://www.ibm.com/i/c.gif" width="100%" /><br />
            <table cellspacing="0" cellpadding="0" border="0">
                <tbody>
                    <tr>
                        <td valign="middle"><img height="16" alt="" src="http://www.ibm.com/i/v14/icons/u_bold.gif" width="16" border="0" /><br />
                        </td>
                        <td valign="top" align="right"><a class="fbox" href="http://www.ibm.com/developerworks/cn/java/j-mylyn2/index.html#main" cmimpressionsent="1"><strong>回页首</strong></a></td>
                    </tr>
                </tbody>
            </table>
            </td>
        </tr>
    </tbody>
</table>
<br />
<br />
<p><a name="N10203"><span class="atitle">将上下文用于协作</span></a></p>
<p>协作性工具都是关于共享信息的，任务上下文能聚焦于该信息而阻止信息超载和分散。开发人员不断来回发送电子邮件、即时消息及文件，来交换执行日常任务所需的必要消息。尽管 Mylar 仍没有排除对即时消息或电子邮件的需要，但它能够通过将它们锁定在任务周围来简化一些协作活动。由于任务定义了清晰、易于理解的工作单元，且任务上下文定义了与工作相关的信息，所以用单击来共享任务上下文的功能能够减少协作通信负担。</p>
<p>在 <a href="http://www.ibm.com/developerworks/cn/java/j-mylyn1/" cmimpressionsent="1">第 1 部分</a> 中，我演示了 Mylyn 的任务管理如何将基于 Web 的储存库（如 Bugzilla）集成起来，从而提供了您期待从电子邮件客户机中得到的那种协作集成程度和响应程度。这一节则解释 Mylar 对跟踪更改集和任务活动的自动支持（联合了对上下文共享的支持）是如何进一步便利了团队工作及获取专门技术的。通常，您可以根据需要以及 Mylar 同源文件及任务存储库集成的程度挑选要使用的功能。</p>
<p><a name="changesets"><span class="smalltitle">自动化的更改集</span></a></p>
<table cellspacing="0" cellpadding="0" width="40%" align="right" border="0">
    <tbody>
        <tr>
            <td width="10"><img height="1" alt="" src="http://www.ibm.com/i/c.gif" width="10" /></td>
            <td>
            <table cellspacing="0" cellpadding="5" width="100%" border="1">
                <tbody>
                    <tr>
                        <td bgcolor="#eeeeee"><a name="support"><strong>技巧：更改集模式</strong></a><br />
                        <p>Eclipse 有两种更改集模式，3.2 版中新出现的基于模型的更改集和标准更改集。尽管这些模式实际上很难辨别，但是基于模型的模式较为可取，因为它同时显示引入和传出的更改。要了解关于在这两种模式之间切换的详细信息，请参阅 Mylyn FAQ（参见 <a href="http://www.ibm.com/developerworks/cn/java/j-mylyn2/index.html#resources" cmimpressionsent="1">参考资料</a>）。 </p>
                        </td>
                    </tr>
                </tbody>
            </table>
            </td>
        </tr>
    </tbody>
</table>
<p><em>更改集</em> 是一项用于对资源分组的内置的 Eclipse 工具，可以在 Synchronize 视图中对其进行操作，以提交、更新或创建补丁。除非在一个静态的项目中工作，否则手动管理更改集常常得不偿失。Mylar 通过自动管理更改集便利了对源存储库的操作。一旦激活一项任务，该任务的更改集即被添加，并随后显示在 Synchronize 视图（见图 7）中。操作该任务时做出的更改被添加到该更改集中。可以使用位于视图的 Change Set 节点的上下文菜单来覆盖、提交或创建一个补丁。由团队成员做出的更改按照任务分组显示，可以通过右键单击一个引入的更改集来打开相应的任务。如果有了更改，但任务停用，更改集不变，使您可以同时操作多项传出更改。Mylar 确保在上下文和更改集之间的一对一映射，所以如果将一份文件手动地添加到更改集中（通过 Synchronize 视图中的上下文菜单），该文件也会被添加到上下文中。当前支持的源存储库是 CVS 和 Subversion（包括 Subclipse 和 Subversive）。</p>
<br />
<a name="fig7"><strong>图 7. 更改集管理并将其映射到任务</strong></a><br />
<img height="435" alt="" src="http://www.ibm.com/developerworks/cn/java/j-mylyn2/part2-changeset.jpg" width="481" /> <br />
<table cellspacing="0" cellpadding="0" width="60%" align="right" border="0">
    <tbody>
        <tr>
            <td width="10"><img height="1" alt="" src="http://www.ibm.com/i/c.gif" width="10" /></td>
            <td>
            <table cellspacing="0" cellpadding="5" width="100%" border="1">
                <tbody>
                    <tr>
                        <td bgcolor="#eeeeee"><a name="support"><strong>技巧：将项目与任务储存库关联</strong></a><br />
                        <p>为了对文本和 Java 编辑器的引用启用超链接，例如对于 Bugzilla 的 &#8220;see bug 123&#8221;，或者对于 JIRA 的 &#8220;ABC-123&#8221;，必须将与资源对应的项目与一个任务储存库相关联。为此，可以右键单击项目，选择 <strong>Properties</strong>，然后选择 <strong>Task Repository</strong>。每当 Mylyn 解析资源中对任务的引用时，都要使用项目到任务储存库之间的这种关联，所以这种关联对于 History 或 Team Annotation 超链接也是必需的。如果项目是共享的，可以将该设置放入版本控制中。</p>
                        </td>
                    </tr>
                </tbody>
            </table>
            </td>
        </tr>
    </tbody>
</table>
<p>尽管一开始效果也许不明显，Mylar 使用上下文将任务和资源绑到一起的方法将对您工作的方式产生根本性影响。例如，对于 Mylar 项目本身，不需要编写提交消息，因为它们是由 Mylar 的更改集集成（使用 <strong>Window &gt; Preferences &gt; Mylyn &gt; Team</strong> 页面编辑用于生成自动提交消息的模板）自动生成的。这使我们能够通过单击从 History 视图导航至与修订相对应的任务，这节省了跟踪更改及修订至原始任务的时间。相反地，这也使得可以通过 CVS 日志查询所有针对一个特定任务更改过的文件。这个功能与 Eclipse 用于显示 Team Annotations 的功能和 Mylyn 的普通超链接（见图 8）相结合，意味着您将大量减少花费在查找与一个更改相关的 bug 或任务上的时间，因为通常只需一次单击即可完成。（注意，为了在弹出的文本编辑器中显示超链接，必须按下 Ctrl 键，如果要将弹出窗口放在最前面，需要按 F2 键）。</p>
<br />
<a name="fig8"><strong>图 8. 超链接和团队注释</strong></a><br />
<img height="143" alt="" src="http://www.ibm.com/developerworks/cn/java/j-mylyn2/part2-annotations.jpg" width="544" /> <br />
<p><a name="N10268"><span class="smalltitle">共享上下文</span></a></p>
<p>任务上下文获取执行任务时创建的知识。重新激活一个任务会立即将您带回到该任务的上下文，而不是迫使您恢复与该任务相关的那部分系统。如果半途将任务移交给团队成员，任务上下文会为他或她提供一个起点。由于上下文是从交互中创建的，而不仅从更改中创建，每个任务上下文都包含了相关信息，如处理该任务时访问过的 API 以及引用过的文档。为支持这个及类似的协作场景（如结对编程），上下文能被轻易地共享。可以通过 Task List（如图 9）中的上下文菜单或通过单击任务编辑器中相应的复选框来激活上下文共享： </p>
<br />
<a name="fig9"><strong>图 9. 通过任务附件进行上下文共享</strong></a><br />
<img height="391" alt="" src="http://www.ibm.com/developerworks/cn/java/j-mylyn2/part2-sharing.jpg" width="540" /> <br />
<p>当使用支持附件的任务存储库连接器时，可以将任务上下文附加在 bug 报告中来轻易地实现共享。当获取一个共享上下文时，可以从所有可用的上下文中选择（如果当前有多个上下文的话）。例如，在 Mylar 项目中，我们将上下文附在每一个解决了的 bug 报告中，并且要求每一个贡献的补丁都要附上上下文。这种通过上下文共享专门技术的方法使应用补丁、与团队成员协作处理 bug 报告、在结对编程会话结束后清理代码变得更加简单。所有已解决的 bug 都存储了一个上下文，这一事实意味着只要 bug 被重新打开或类似的错误发生，我们都能立即恢复并使用过去的技术。</p>
<br />
<table cellspacing="0" cellpadding="0" width="100%" border="0">
    <tbody>
        <tr>
            <td><img height="1" alt="" src="http://www.ibm.com/i/v14/rules/blue_rule.gif" width="100%" /><br />
            <img height="6" alt="" src="http://www.ibm.com/i/c.gif" width="8" border="0" /></td>
        </tr>
    </tbody>
</table>
<table class="no-print" cellspacing="0" cellpadding="0" align="right">
    <tbody>
        <tr align="right">
            <td><img height="4" alt="" src="http://www.ibm.com/i/c.gif" width="100%" /><br />
            <table cellspacing="0" cellpadding="0" border="0">
                <tbody>
                    <tr>
                        <td valign="middle"><img height="16" alt="" src="http://www.ibm.com/i/v14/icons/u_bold.gif" width="16" border="0" /><br />
                        </td>
                        <td valign="top" align="right"><a class="fbox" href="http://www.ibm.com/developerworks/cn/java/j-mylyn2/index.html#main" cmimpressionsent="1"><strong>回页首</strong></a></td>
                    </tr>
                </tbody>
            </table>
            </td>
        </tr>
    </tbody>
</table>
<br />
<br />
<p><a name="N10283"><span class="atitle">结束语</span></a></p>
<table cellspacing="0" cellpadding="0" width="40%" align="right" border="0">
    <tbody>
        <tr>
            <td width="10"><img height="1" alt="" src="http://www.ibm.com/i/c.gif" width="10" /></td>
            <td>
            <table cellspacing="0" cellpadding="5" width="100%" border="1">
                <tbody>
                    <tr>
                        <td bgcolor="#eeeeee"><a name="performance"><strong>性能方面如何？</strong></a><br />
                        <p>Mylyn 的设计确保它的上下文管理功能不影响 Eclipse 的性能。无论您使用的系统大小如何，Mylyn 都可以做到这一点，因为任务上下文只与您所做的少量交互对应，而与您使用的系统的大小没有关系。Mylyn 对内存或速度的任何明显影响都被视作一个 bug，都应该作为严重问题进行报告。而且，当没有活动任务时，Mylyn 的任务上下文管理是完全休眠的。要了解关于 Mylyn 性能的更多信息，请参阅 Mylyn FAQ（参见 <a href="http://www.ibm.com/developerworks/cn/java/j-mylyn2/index.html#resources" cmimpressionsent="1">参考资料</a>）。要打开 Eclipse 的内存监视器，可以使用 <strong>Window &gt; Preferences &gt; General &gt; Show Heap Status</strong>。</p>
                        </td>
                    </tr>
                </tbody>
            </table>
            </td>
        </tr>
    </tbody>
</table>
<p>在这个由两部分组成的文章中，我介绍了如何用 Mylar 进行以任务为中心的编程。我展示了 Mylar 是如何通过将任务作为 Eclipse 中头等重要的部分对待而让您日常的工作变得相当地简单。我也介绍了 Mylar 如何使用 Eclipse 视图来帮助您聚焦于手边的任务，并为个人及团队的使用凸现这些任务的上下文。</p>
<p>Mylar 背后的哲学是<em>少就是多</em>。它将集成的任务管理和自动上下文管理工具结合使用，使您能够在不丢失上下文的情况下进行多任务处理，并确保您只需要查看感兴趣的信息。一个针对于将 Mylar 用于日常工作的业内开发人员所做的现场用户的研究已经验证了 Mylar 的任务上下文模型（参见 <a href="http://www.ibm.com/developerworks/cn/java/j-mylyn2/index.html#resources" cmimpressionsent="1">参考资料</a>）。根据统计，这些用户的生产率有了显著的提高。而且，由于进行了数千个 bug/增强报告，Mylyn 2.0 很快成熟起来，满足其快速增长的用户社区的需要。自从在 2004 年 8 月创建 0.1 原型以来，我一直将 Mylyn 用于我的所有工作。和很多其它 Mylyn 用户一样，我已经无法想象还要手动寻找并识别工作中的相关信息的情景了。我完全依赖 Mylyn 来管理工作中的大量以任务为中心的交互和多任务处理。</p>
<p>如果 Mylar 支持您的任务存储库，它能使您的日常工作变得更加简单、更加有效且更加专注。如果它不支持您的任务存储库，您可以试着用它来完成个人任务。不管何种情况，都请使用 Bugzilla 集成来给出回馈并为您愿意看到被支持的其他连接器投票。（参见 <a href="http://www.ibm.com/developerworks/cn/java/j-mylyn2/index.html#resources" cmimpressionsent="1">参考资料</a>）。您的贡献将帮助我们进一步改进 Mylyn，因为它将持续围绕严密的回馈机制快速发展，该工具本身允许我们通过用户社区建立这种回馈机制。其他 Mylyn 提交者和我一样，都期待收到您的回馈。</p>
<table cellspacing="0" cellpadding="0" width="150" align="right" border="0">
    <tbody>
        <tr>
            <td width="10"><img height="1" alt="" src="http://www.ibm.com/i/c.gif" width="10" /></td>
            <td>
            <table cellspacing="0" cellpadding="5" width="100%" border="1">
                <tbody>
                    <tr>
                        <td bgcolor="#eeeeee"><a name="N102B5"><strong>分享这篇文章&#8230;&#8230;</strong></a><br />
                        <p>
                        <table cellspacing="0" cellpadding="0" width="135" border="0">
                            <tbody>
                                <tr>
                                    <td colspan="2"><img height="5" alt="" src="http://www.ibm.com/i/c.gif" width="1" border="0" /> </td>
                                </tr>
                                <tr valign="top" align="left">
                                    <td width="21"><a href="http://digg.com/submit?phase=2&amp;url=http://www.ibm.com/developerworks/cn/java/j-mylyn2/" cmimpressionsent="1"><img height="10" alt="digg" src="http://www.ibm.com/i/v14/icons/10x10-digg-thumb.gif" width="10" border="0" /> </a></td>
                                    <td><a href="http://digg.com/submit?phase=2&amp;url=http://www.ibm.com/developerworks/cn/java/j-mylyn2/" cmimpressionsent="1">提交到 Digg </a></td>
                                </tr>
                                <tr>
                                    <td colspan="2"><img height="5" alt="" src="http://www.ibm.com/i/c.gif" width="1" border="0" /> </td>
                                </tr>
                                <tr valign="top" align="left">
                                    <td width="21"><a href="http://del.icio.us/post" cmimpressionsent="1"><img height="10" alt="del.icio.us" src="http://del.icio.us/static/img/delicious.small.gif" width="10" border="0" /> </a></td>
                                    <td><a href="http://del.icio.us/post" cmimpressionsent="1">发布到 del.icio.us</a> </td>
                                </tr>
                                <tr>
                                    <td colspan="2"><img height="5" alt="" src="http://www.ibm.com/i/c.gif" width="1" border="0" /> </td>
                                </tr>
                                <tr valign="top" align="left">
                                    <td width="21"><a href="javascript:location.href='http://slashdot.org/bookmark.pl?url='+encodeURIComponent(location.href)+'&amp;title='+encodeURIComponent(document.title)" cmimpressionsent="1"><img height="16" alt="Slashdot" src="http://images.slashdot.org/favicon.ico" width="16" border="0" /> </a></td>
                                    <td><a href="javascript:location.href='http://slashdot.org/bookmark.pl?url='+encodeURIComponent(location.href)+'&amp;title='+encodeURIComponent(document.title)" cmimpressionsent="1">提交到 Slashdot！</a> </td>
                                </tr>
                                <tr>
                                    <td colspan="2"><img height="5" alt="" src="http://www.ibm.com/i/c.gif" width="1" border="0" /> </td>
                                </tr>
                            </tbody>
                        </table>
                        </p>
                        </td>
                    </tr>
                </tbody>
            </table>
            </td>
        </tr>
    </tbody>
</table>
<p><a name="N10354"><span class="smalltitle">致谢</span></a></p>
<p>Mylyn 能获得成功并且走到现在，很大程度上得益于大量的用户参与，他/她们报告 bug 并贡献补丁。正是这种协作让 Mylar 从一个研究原型发展成为了 Eclipse 用户在日常工作中所依赖的一个重要部分。</p>
<p>Athen O'Shea、Robert Elves、Gail Murphy 和 Ducky Sherwood 对本文提供了有帮助的回馈。</p>
<img src ="http://www.blogjava.net/conans/aggbug/209879.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/conans/" target="_blank">CONAN</a> 2008-06-22 18:52 <a href="http://www.blogjava.net/conans/articles/209879.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>Mylyn 2.0，第 1 部分: 集成的任务管理</title><link>http://www.blogjava.net/conans/articles/209878.html</link><dc:creator>CONAN</dc:creator><author>CONAN</author><pubDate>Sun, 22 Jun 2008 10:51:00 GMT</pubDate><guid>http://www.blogjava.net/conans/articles/209878.html</guid><description><![CDATA[<blockquote>现在，在 2.0 版中，Mylyn（以前称为 Mylar）通过将任务无缝集成到 Eclipse 中并在工作时自动管理任务上下文，提高了效率。Mylyn 项目主管 Mik Kersten 更新了他撰写的分两部分的 Mylyn 使用指南，以便包括根据 Mylyn 1.0 的大量用户反馈而作出的改进。第 1 部分介绍 Mylyn 的任务管理功能和它与 Bugzilla、Trac 和 JIRA 等储存库的集成。在 <a href="http://www.ibm.com/developerworks/cn/java/j-mylyn2/" cmimpressionsent="1">第 2 部分</a>，您将了解上下文管理如何简化多任务执行，以及如何减少信息超载。</blockquote><!--start RESERVED FOR FUTURE USE INCLUDE FILES--><!-- include java script once we verify teams wants to use this and it will work on dbcs and cyrillic characters --><!--end RESERVED FOR FUTURE USE INCLUDE FILES-->
<p>虽然软件系统、框架和工具可以无限制地发展，但开发人员实际处理信息的能力具有一个上限。大多数集成开发环境（IDE）尝试使用结构化视图、编辑器和高级搜索功能来解决这个限制。这些机制虽然可以使大型系统的导航变得更容易，但是它们常常不足以帮助您管理完成典型编程任务所必须处理的大量信息。因此，结构化视图越来越不堪负荷 —— 例如，即使在导航一个小型的企业应用程序时，Eclipse Package Explorer 也常常会显示数千个源文件 —— 您要浪费大量的时间来滚动、导航和跟踪这些信息。</p>
<p>有趣的是，在大多数情况下，不需要查看系统的整个层次结构或者某个特定方法的每个引用就可以完成编程任务。例如，对于要修复的任何 bug 或者要添加的任何特性，您只对系统的某一部分感兴趣。Mylyn 是一种交互技术，通过将<em>集成的任务管理</em> 和<em>自动上下文管理</em> 这两个功能添加到 Eclipse 中，可以突出显示您感兴趣的系统内容。任务管理将 task/bug/defect/ticket/story/issue 跟踪器集成到 Eclipse 中，并提供高级的任务编辑和任务调度功能。上下文管理监视您与 Eclipse 的交互，自动识别与当前任务相关的信息，并聚焦结构化视图和编辑器，使其只显示相关信息。这两个功能一起组成了 Mylyn 的 Task-Focused（以任务为中心）UI，使多任务处理变得更容易，并且极大减少了信息超载。（至于实际研究结果，请参阅 <a href="http://www.ibm.com/developerworks/cn/java/j-mylyn1/#resources" cmimpressionsent="1">参考资料</a> 小节中研究论文 &#8220;Using Task Context to Improve Programmer Productivity&#8221; 的链接。）</p>
<table cellspacing="0" cellpadding="0" width="40%" align="right" border="0">
    <tbody>
        <tr>
            <td width="10"><img height="1" alt="" src="http://www.ibm.com/i/c.gif" width="10" /></td>
            <td>
            <table cellspacing="0" cellpadding="5" width="100%" border="1">
                <tbody>
                    <tr>
                        <td bgcolor="#eeeeee"><a name="N1006A"><strong>加速思考</strong></a><br />
                        <p>myelin（髓磷脂）是体内自然产生的一种物质，它通过使神经元更高效地导电而加快我们的思考。Mylyn 这个名称源于 myelin，因为很多用户声称 Mylyn 大大提高了工作效率，能够以思考的速度编写代码。以前，这个项目被称为 Mylar，与一种朔料薄膜的名称相同。</p>
                        </td>
                    </tr>
                </tbody>
            </table>
            </td>
        </tr>
    </tbody>
</table>
<p>这个由两部分组成的文章是一份 Mylyn 使用指南。本文的某些内容（尤其指关注编程而不是任务管理的内容）假设您熟悉 Eclipse IDE。第 1 部分是 Mylyn 入门，并介绍了它在任务管理方面的功能。<a href="http://www.ibm.com/developerworks/cn/java/j-mylyn2/" cmimpressionsent="1">第 2 部分</a> 介绍 Mylyn 的上下文管理功能，并讨论它的 Task-Focused UI 对编程和开发方法的影响。为方便起见，将同时发表这两部分内容。</p>
<p>第 1 部分并不适用于编程活动，它适用于在任何 Eclipse 发行版或者集成 Mylyn 的独立应用程序中使用 Mylyn。<a href="http://www.ibm.com/developerworks/cn/java/j-mylyn2/" cmimpressionsent="1">第 2 部分</a> 主要讨论 Java&#8482; 编程，但是也讨论了适用于所有基于 Eclipse 的工具的一些特性。在本文的例子中，我使用 Bugzilla 作为任务储存库，但是这里的概念和 UI 同样适用于 <a href="http://www.ibm.com/developerworks/cn/java/j-mylyn1/#repositories" cmimpressionsent="1">Mylyn 支持的其它任务跟踪器</a>。即使您打算通过不同的连接器使用 Mylyn，建议您还是看看使用 Bugzilla Connector 的步骤，以便熟悉关键特性。</p>
<p><a name="N10087"><span class="atitle">Mylyn 简介</span></a></p>
<p>Mylyn 通过任务跟踪这样的复杂机制扩展了 Eclipse SDK（从 <a href="http://www.ibm.com/developerworks/cn/java/j-mylyn1/#resources" cmimpressionsent="1">参考资料</a> 小节查看受支持的版本）。<em>任务（task）</em>是您希望回调或与他人共享的任何工作单元，例如一个用户报告的 bug，或者关于一个特性改进的说明。Mylyn 使您可以在工作区本地存储任务，或者处理一个或多个任务储存库中的任务。（<em>任务储存库</em> 指诸如 Bugzilla、Trac 或 JIRA 之类的问题跟踪器）。要连接到一个特定的任务储存库，还必须安装用于该储存库的 <em>Mylyn 连接器</em>。</p>
<p>集成任务之后，Mylyn 将监视这些任务上的活动，以识别与当前任务相关的信息。此时，Mylyn 创建一个<em>任务上下文</em> —— 与任务相关的所有工件的集合。这可以包括浏览过的文档、编辑过的方法和引用过的 API。Mylyn 使用任务上下文使 UI 聚焦感兴趣的信息、隐藏不感兴趣的信息、自动发现相关的信息。具备了完成任务所需的信息，就可以减少执行搜索、导航和滚动操作的时间，从而提高工作效率。通过突出任务上下文，Mylyn 还有助于多任务处理、计划、重用过去的工作以及共享专家经验。</p>
<p>使用 Mylyn 一段时间之后，您的工作方式会发生微妙但是重要的变化。一旦习惯了以任务为中心的工作方式，您很可能会发现工作效率有了极大的提高。您的工作变得井井有条，可以统筹管理数十个协作任务并跟踪进程，这些事情都变得非常容易。</p>
<p>图 1 中的编号区域显示了 Mylyn 的一些任务管理和上下文管理特性：</p>
<ol>
    <li>含活动任务的任务列表（Task List）和当天计划好的 Bugzilla 报告
    <li>由任务上下文管理的更改集
    <li>具有离线支持的富任务编辑器
    <li>Eclipse Package Explorer 上以任务为中心的模式 </li>
</ol>
<br />
<a name="fig1"><strong>图 1. Mylyn 的 Task-Focused UI </strong></a><br />
<img height="420" alt="" src="http://www.ibm.com/developerworks/cn/java/j-mylyn1/part1-overview.jpg" width="572" /> <br />
<p>单击 <a href="http://www.ibm.com/developerworks/cn/java/j-mylyn1/sidefile.html" cmimpressionsent="1">这里</a> 查看全图。</p>
<p>接下来的小节讲解 Mylyn 的安装和配置，并介绍它的关键特性。对 Mylyn 任务管理功能有了大致了解后，您将更深入地了解它对日常工作流程的影响。 </p>
<br />
<table cellspacing="0" cellpadding="0" width="100%" border="0">
    <tbody>
        <tr>
            <td><img height="1" alt="" src="http://www.ibm.com/i/v14/rules/blue_rule.gif" width="100%" /><br />
            <img height="6" alt="" src="http://www.ibm.com/i/c.gif" width="8" border="0" /></td>
        </tr>
    </tbody>
</table>
<table class="no-print" cellspacing="0" cellpadding="0" align="right">
    <tbody>
        <tr align="right">
            <td><img height="4" alt="" src="http://www.ibm.com/i/c.gif" width="100%" /><br />
            <table cellspacing="0" cellpadding="0" border="0">
                <tbody>
                    <tr>
                        <td valign="middle"><img height="16" alt="" src="http://www.ibm.com/i/v14/icons/u_bold.gif" width="16" border="0" /><br />
                        </td>
                        <td valign="top" align="right"><a class="fbox" href="http://www.ibm.com/developerworks/cn/java/j-mylyn1/#main" cmimpressionsent="1"><strong>回页首</strong></a></td>
                    </tr>
                </tbody>
            </table>
            </td>
        </tr>
    </tbody>
</table>
<br />
<br />
<p><a name="repositories"><span class="atitle">任务储存库连接器</span></a></p>
<p>在本文中，我使用 Mylyn 的 Bugzilla Connector 来展示使用任务储存库集成的关键概念。对于其它受支持的任务储存库，这些概念是相同的，只是集成级别和连接器的成熟度有所不同。与 Mylyn 捆绑的 Bugzilla 和 Trac 连接器非常成熟，并且被视作参考实现。Mylyn Extensions 页面（参阅 <a href="http://www.ibm.com/developerworks/cn/java/j-mylyn1/#resources" cmimpressionsent="1">参考资料</a> 小节）列出了用于其它问题跟踪器和项目管理工具的连接器（例如 CollabNet、Rally、Mantis 和 XPlanner）。</p>
<p>完全集成的连接器提供以下特性：</p>
<ul>
    <li><strong>查询（Queries）</strong>：查询是用于将各组任务取回到 Mylyn 的 Task List 中的一种机制。查询编辑和检索功能特定于连接器，它们可以提供一个基于 Eclipse 的查询设计器，或者从服务器中的一个帐户检索查询，或者同时提供这两种功能。 <br />
    <br />
    <li><strong>富编辑（Rich editing）</strong>：可以用一个集成的编辑器编辑任务和查询。该功能提供任务和其它结构化元素的超链接，以及 Eclipse 和桌面集成，例如拖放功能。提供富编辑的连接器仍然可以提供在 Eclipse 的嵌入式浏览器中打开任务和查询的功能。 <br />
    <br />
    <li><strong>附件（Attachments）</strong>：可以将文件附加到储存库中，或者从储存库中检索文件。该特性允许从操作系统或 Eclipse 工作区附加文件，并且支持上下文共享等功能（请参阅 <a href="http://www.ibm.com/developerworks/cn/java/j-mylyn2/" cmimpressionsent="1">第 2 部分</a>）。<br />
    <br />
    <li><strong>离线（Offline）支持</strong>：可以在断开连接的情况下工作，直接访问文件和查询，而不必等到与服务器建立连接。该功能还提供更改通知，可以使用 Task List 作为任务收件箱，而不用依赖于电子邮件客户端。 </li>
</ul>
<p>为了让您从 Mylyn 获得完整的集成，并停止对外部或基于 Web 的 UI 的依赖，连接器必须支持这里列出的所有四个功能。但是，只要 Eclipse 具备<em>足够</em> 可用于处理任务的功能，则仍然可以从 Mylyn 的 Task-Focused UI 中获益。如果连接器的任务储存库不可用，您仍然可以：</p>
<ul>
    <li>使用 Mylyn 对 <a href="http://www.ibm.com/developerworks/cn/java/j-mylyn1/#startedwithlocal" cmimpressionsent="1">本地任务</a> 的支持。如果不受支持的储存库有一个基于 Web 的 UI，那么可以从浏览器中将 URL 拖放到 Mylyn 中，从而创建任务。<br />
    <br />
    <li>使用 Generic Web Repository Connector，它为很多基于 Web 的储存库提供基本查询支持：Google Code Hosting (code.google.com)、IssueZilla (java.net、dev2dev、tigris.org)、GForge (objectweb.org)、SourceForge (sf.net)、JIRA、Trac、phpBB 和 vBulletin。请参阅 <a href="http://www.ibm.com/developerworks/cn/java/j-mylyn1/#resources" cmimpressionsent="1">参考资料</a> 小节，了解更多信息。<br />
    <br />
    <li>请求任务储存库提供商创建一个用于 Mylyn 的连接器。还可以考虑在 Mylyn bug 网页为您的连接器投票（参阅 <a href="http://www.ibm.com/developerworks/cn/java/j-mylyn1/#resources" cmimpressionsent="1">参考资料</a> 小节）。<br />
    <br />
    <li>创建自己的连接器（请参阅 <a href="http://www.ibm.com/developerworks/cn/java/j-mylyn1/#resources" cmimpressionsent="1">参考资料</a> 小节，提供了到 Integrator Reference 的链接）。 </li>
</ul>
<br />
<table cellspacing="0" cellpadding="0" width="100%" border="0">
    <tbody>
        <tr>
            <td><img height="1" alt="" src="http://www.ibm.com/i/v14/rules/blue_rule.gif" width="100%" /><br />
            <img height="6" alt="" src="http://www.ibm.com/i/c.gif" width="8" border="0" /></td>
        </tr>
    </tbody>
</table>
<table class="no-print" cellspacing="0" cellpadding="0" align="right">
    <tbody>
        <tr align="right">
            <td><img height="4" alt="" src="http://www.ibm.com/i/c.gif" width="100%" /><br />
            <table cellspacing="0" cellpadding="0" border="0">
                <tbody>
                    <tr>
                        <td valign="middle"><img height="16" alt="" src="http://www.ibm.com/i/v14/icons/u_bold.gif" width="16" border="0" /><br />
                        </td>
                        <td valign="top" align="right"><a class="fbox" href="http://www.ibm.com/developerworks/cn/java/j-mylyn1/#main" cmimpressionsent="1"><strong>回页首</strong></a></td>
                    </tr>
                </tbody>
            </table>
            </td>
        </tr>
    </tbody>
</table>
<br />
<br />
<p><a name="N10141"><span class="atitle">安装和设置</span></a></p>
<p>Mylyn 现在被包括在大多数 Eclipse 发行版中，所以获得它的最简单方法是从 Eclipse Downloads 页面下载一个包含 Mylyn 的包（见 <a href="http://www.ibm.com/developerworks/cn/java/j-mylyn1/#resources" cmimpressionsent="1">参考资料</a> 小节）。但是，对于更新至新的 Mylyn 版本，或者将 Mylyn 安装到没有捆绑 Mylyn 的 Eclipse 版本中，下面的说明仍然会提供帮助。</p>
<table cellspacing="0" cellpadding="0" width="40%" align="right" border="0">
    <tbody>
        <tr>
            <td width="10"><img height="1" alt="" src="http://www.ibm.com/i/c.gif" width="10" /></td>
            <td>
            <table cellspacing="0" cellpadding="5" width="100%" border="1">
                <tbody>
                    <tr>
                        <td bgcolor="#eeeeee"><a name="N10152"><strong>技巧：Mylyn 要求 Java 5 或更高版本</strong></a><br />
                        <p>Mylyn 构建在 Java 5 的基础上。如果试图用 JRE 1.4 或更早的版本运行它，那么它不能工作，并且会在启动时报错。可以通过 <strong>Help &gt; About Eclipse SDK &gt; Configuration Details</strong> 检查 Eclipse 使用哪个版本的 JRE。有关安装方面的故障排除，请参考 Mylyn FAQ （参阅 <a href="http://www.ibm.com/developerworks/cn/java/j-mylyn1/#resources" cmimpressionsent="1">参考资料</a> 小节）。 </p>
                        </td>
                    </tr>
                </tbody>
            </table>
            </td>
        </tr>
    </tbody>
</table>
<p>要安装适合您使用的 Eclipse 版本的 Mylyn，可以使用 Eclipse Update Manager: <strong>Help &gt; Software Updates &gt; Find and install &gt; Search for new features to install</strong>。 当对 Eclipse 3.2 更新时，最好使用这种机制，而不是 <strong>Search for updates</strong>，因为后者不会执行正确的依赖性检查。在 Eclipse 3.3 上，这两种方法都可行。想要了解提供 Update Manager 的最新 Mylyn 更新站点，请参考 Mylyn 的下载页面（参阅 <a href="http://www.ibm.com/developerworks/cn/java/j-mylyn1/#resources" cmimpressionsent="1">参考资料</a> 小节）。</p>
<p>Mylyn 的一个关键设计目标是与 Eclipse 已有的 UI 工具无缝集成。另一个目标是要求用户只安装和使用需要的特性。图 2 显示了用于选择要安装的特性的 UI。例如，如果您的任务是 bug 归类（triaging）而不是开发，那么可以安装 Mylyn 的 Task List，而不必安装 Task-Focused UI，并且可以独立地选择用于问题跟踪器的连接器。软件开发人员很可能要同时安装这两个特性。</p>
<br />
<a name="fig2"><strong>图 2. 选择 Mylyn 特性和储存库连接器 </strong></a><br />
<img height="164" alt="" src="http://www.ibm.com/developerworks/cn/java/j-mylyn1/part1-install.jpg" width="267" /> <br />
<p>当从更新站点选择要安装的特性时，可以选择一个或多个要使用的任务储存库。注意，正如 Mylyn Downloads 页面提示的，您可能需要添加额外的更新站点，以获得所需的连接器。当安装推荐的 Task-Focused UI 特性时，还应该选择所有可安装到当前 Eclipse 版本的桥接器。（关于桥接器的详细信息，请参阅 <a href="http://www.ibm.com/developerworks/cn/java/j-mylyn2/" cmimpressionsent="1">第 2 部分</a>）。重新启动 Eclipse 3.3 或更高版本之后，可以看到图 3 所示的欢迎屏幕。如果当前使用的是 Eclipse 3.2，那么可以从 Help 菜单手动打开这个欢迎屏幕。</p>
<br />
<a name="fig3"><strong>图 3. 欢迎屏幕</strong></a><br />
<img height="303" alt="" src="http://www.ibm.com/developerworks/cn/java/j-mylyn1/part1-welcome.jpg" width="569" /> <br />
<br />
<table cellspacing="0" cellpadding="0" width="100%" border="0">
    <tbody>
        <tr>
            <td><img height="1" alt="" src="http://www.ibm.com/i/v14/rules/blue_rule.gif" width="100%" /><br />
            <img height="6" alt="" src="http://www.ibm.com/i/c.gif" width="8" border="0" /></td>
        </tr>
    </tbody>
</table>
<table class="no-print" cellspacing="0" cellpadding="0" align="right">
    <tbody>
        <tr align="right">
            <td><img height="4" alt="" src="http://www.ibm.com/i/c.gif" width="100%" /><br />
            <table cellspacing="0" cellpadding="0" border="0">
                <tbody>
                    <tr>
                        <td valign="middle"><img height="16" alt="" src="http://www.ibm.com/i/v14/icons/u_bold.gif" width="16" border="0" /><br />
                        </td>
                        <td valign="top" align="right"><a class="fbox" href="http://www.ibm.com/developerworks/cn/java/j-mylyn1/#main" cmimpressionsent="1"><strong>回页首</strong></a></td>
                    </tr>
                </tbody>
            </table>
            </td>
        </tr>
    </tbody>
</table>
<br />
<br />
<p><a name="N10198"><span class="atitle">任务和查询</span></a></p>
<p>Mylyn 提供了使用两种类型任务的支持：</p>
<ul>
    <li><strong>本地任务</strong>存储在 Eclipse 工作区，提供基本的任务管理特性，例如调度。本地任务是私有的，并只对您可见。<br />
    <br />
    <li><strong>储存库任务</strong>存储在与一个外部应用程序或服务器对应的一个任务储存库中。储存库任务常常在多人之间共享，但是仍然提供所有的本地任务功能，例如个人调度和注解。 </li>
</ul>
<p>本节展示如何创建和编辑本地任务，并考察用于使用储存库任务的可用特性。这里谈到的特性的可用性取决于连接器的 <a href="http://www.ibm.com/developerworks/cn/java/j-mylyn1/#repositories" cmimpressionsent="1">集成级别</a>，所以只需参考那些适用的特性。无论连接器集成级别是多少，都可以使用 <a href="http://www.ibm.com/developerworks/cn/java/j-mylyn1/#planning" cmimpressionsent="1">任务管理和个人计划</a> 中讨论的 Mylyn 的所有任务管理功能。</p>
<p><a name="startedwithlocal"><span class="smalltitle">本地任务初解</span></a></p>
<p>安装 Mylyn 之后，遵循以下步骤：</p>
<ol>
    <li>在 Task List 视图上单击 <strong>New Task</strong> 工具栏按钮，创建一个新任务。
    <li>选择 <strong>Local Tasks</strong> 储存库。
    <li>输入一个任务概要。
    <li>单击 Eclipse 工具栏上的 <strong>Save</strong> 或按 Ctrl+S，保存更新后的描述。 </li>
</ol>
<p>创建本地任务的快捷方式是 Insert 键，或者也可以从 Web 浏览器中将文本或 URL 拖放到 Task List 中。新任务的描述将由相应 Web 页面的标题自动填充。（在 Firefox 中，只需常规的拖动动作；而在 Internet Explorer 中，在拖动的同时还需按下 Ctrl 键。）在 Task List 中双击任务可以打开任务编辑器（如图 4 所示），在该编辑器中可以创建注解、粘贴相关超链接或者调度特定日期的任务。默认情况下，新创建的任务是在创建之日调度的。</p>
<br />
<a name="fig4"><strong>图 4. 编辑本地任务</strong></a><br />
<img height="411" alt="" src="http://www.ibm.com/developerworks/cn/java/j-mylyn1/part1-editor.jpg" width="572" /> <br />
<p>创建了十几个或者更多的本地任务之后，您可能想通过创建<em>类别</em> 来组织它们。如果创建任务时没有在 Task List 中选择类别，那么该任务被放入到 Uncategorized 容器中。可以使用 Task List 中的 <strong>Move to</strong> 弹出菜单或者任务编辑器或者通过拖放操作将一个创建好的任务转移到另一个类别中。</p>
<p>要将本地任务标记为已完成，可以使用任务的弹出菜单或者任务编辑器。 默认情况下，被标记为已完成的任务会被过滤掉，但是也可以通过 Task List 的视图菜单（使用 Task List 视图工具栏右侧的倒三角形打开）选择不过滤它们。为了避免凌乱，不要显示那些不显示任何任务的类别（例如，所包含的任务全部完成的类别）。使用 Task List 顶端的 <strong>Find:</strong> 框访问被过滤的任务。最后，可以通过任务编辑器为本地任务设置优先级和计划信息。<a href="http://www.ibm.com/developerworks/cn/java/j-mylyn1/#planning" cmimpressionsent="1">任务管理和个人计划</a> 小节将更深入地讨论计划。</p>
<p>为了熟悉 Mylyn 的图标模式，可以使用 Task List 视图菜单中的 <strong>Show UI Legend</strong> 动作（见图 5）。 我将在整个文章中引用该图标模式。</p>
<br />
<a name="fig5"><strong>图 5. Mylyn UI 图例</strong></a><br />
<img height="641" alt="" src="http://www.ibm.com/developerworks/cn/java/j-mylyn1/part1-ui-legend.jpg" width="300" /> <br />
<p><a name="N1021B"><span class="smalltitle">添加任务储存库</span></a></p>
<p>不同任务储存库在功能和任务管理的指代方面可能有较大差别。Mylyn 的任务管理功能提供了一种统一的方式使用多种储存库，包括：</p>
<table cellspacing="0" cellpadding="0" width="32%" align="right" border="0">
    <tbody>
        <tr>
            <td width="10"><img height="1" alt="" src="http://www.ibm.com/i/c.gif" width="10" /></td>
            <td>
            <table cellspacing="0" cellpadding="5" width="100%" border="1">
                <tbody>
                    <tr>
                        <td bgcolor="#eeeeee"><a name="N10227"><strong>技巧：添加储存库后确认设置</strong></a><br />
                        <p>Mylyn 的最常见问题和任务储存库的连接有关。使用 <strong>Validate Settings</strong> 按钮来验证您输入的凭证是正确的。如果需要任何其它设置，例如网络代理，可以使用提供的其它区域中的其中一个再次验证。通常，如果验证失败，任务储存库连接器应该会提供一条有用的消息。如果没有提供消息，则可以参考连接器的文档或者 Mylyn FAQ（参阅 <a href="http://www.ibm.com/developerworks/cn/java/j-mylyn1/#resources" cmimpressionsent="1">参考资料</a> 小节），对连接问题进行故障排除。还应注意，有些连接器要求在服务器上进行特殊的设置。</p>
                        </td>
                    </tr>
                </tbody>
            </table>
            </td>
        </tr>
    </tbody>
</table>
<ul>
    <li><strong>本地任务</strong>：用于使用存储在 Eclipse 工作区的简单任务的一种特殊的储存库。<br />
    <br />
    <li><strong>共享任务</strong>：如果您的团队使用共享任务储存库，例如 Bugzilla 服务器，那么可以使用这种储存库来与其他人协作完成任务。 <br />
    <br />
    <li><strong>项目管理任务</strong>：有些连接器，例如 XPlanner，提供用于将任务组织到项目阶段和用户事件中的任务管理功能。<br />
    <br />
    <li><strong>bug 和增强报告</strong>：这是一种特殊的任务，通常在产品用户与支持团队之间共享。Mylyn 提供集成的 bug 报告，以帮助跟踪与其它任务一起归档的 bug 报告。 </li>
</ul>
<p>要创建一个任务储存库，可以打开 Task Repositories 视图（<strong>Window &gt; Show View &gt; Mylyn &gt; Task Repositories</strong>），或者使用一个包含它的透视图，例如 Team Synchronizing 透视图。打开后，使用视图的工具栏添加一个新的储存库。然后，可以输入储存库凭证和任何其它连接细节，或者从可用模板中选择一个模板。图 6 中的 bugs.eclipse.org 储存库是在安装 Mylyn 时自动创建的，这是为了便于报告 Mylyn 和 Eclipse 的 bug 和特性请求。</p>
<br />
<a name="fig6"><strong>图 6. 添加 Eclipse.org Bugzilla 储存库</strong></a><br />
<img height="561" alt="" src="http://www.ibm.com/developerworks/cn/java/j-mylyn1/part1-repository.jpg" width="572" /> <br />
<p><a name="N10273"><span class="smalltitle">查询储存库</span></a></p>
<p>成功地添加了任务储存库之后，就可以通过 Task List 的弹出菜单中的 <strong>New Query</strong> 动作创建查询来访问那个储存库上的任务。例如，可以编写一个查询来访问指定到我的电子邮箱地址的所有 Bugzilla 报告，如图 7 所示： </p>
<br />
<a name="fig7"><strong>图 7. 创建新的 Bugzilla 查询</strong></a><br />
<img height="685" alt="" src="http://www.ibm.com/developerworks/cn/java/j-mylyn1/part1-query.jpg" width="572" /> <br />
<table cellspacing="0" cellpadding="0" width="56%" align="right" border="0">
    <tbody>
        <tr>
            <td width="10"><img height="1" alt="" src="http://www.ibm.com/i/c.gif" width="10" /></td>
            <td>
            <table cellspacing="0" cellpadding="5" width="100%" border="1">
                <tbody>
                    <tr>
                        <td bgcolor="#eeeeee"><a name="query_configuration"><strong>查询设置建议 </strong></a><br />
                        <p>为了支持各种不同的组织样式，Mylyn 的 Task List 可以灵活地设置和使用类别和查询。例如，如果您的团队对于管理重复任务和使用里程碑（milestone）标识每个 Bugzilla 报告很谨慎，那么可以设置与这些里程碑对应的查询，并使用这些查询来跟踪项目的进度。但是，根据我与 Mylyn 团队和其他 Mylyn 采用者的合作经验，我建议，如果与其他人之间有很多合作，则根据人员范围界设置查询，如果主要是完成分配给自己的任务，则根据组件或产品范围设置查询。然后，可以使用 Task List 的 <strong>Go Into</strong> 动作（位于所有任务容器的弹出菜单中）聚焦被分配的任务或与一个特定组件相关的任务。可以使用 Task Search (Ctrl+H) 功能随时更新里程碑的进度。具体而言，建议执行如下操作： </p>
                        <ul>
                            <li>为所有分配给您的任务设置一个查询（例如 &#8220;All Mine&#8221;）。如果有不同的产品或组件范围，则可以将这个查询拆分成多个查询。通常，一个查询应该就足够了，它可以帮助您更容易地确定下一步执行什么，因为 Task List 会按照处理顺序排列任务。 <br />
                            <br />
                            <li>如果与其他人密切协作，那么可以为他们中的每个人设置一个查询。然后，Mylyn 的传入（incoming）通知可以帮助您对此进行响应，并排列与这些个体进行讨论的优先次序。 <br />
                            <br />
                            <li>为已经报告、注释或者用 CC 处理过的（例如 &#8220;Products - Eclipse&#8221; 和 &#8220;Products - Mozilla&#8221;）所有 bug 设置另一个查询。对于感兴趣的每个任务储存库都执行这个操作，以确保可以收到您感兴趣的每个报告的更改通知。通过排除为自己的任务设置的查询中所包括的组件，可以避免查询之间的重复任务。 <br />
                            <br />
                            <li>如果对 bug 进行归类，那么可以为 bug 收件箱帐户设置一个单独的查询，以便监视即将来临的报告。 </li>
                        </ul>
                        <p>虽然设置查询时通常只包括打开的/未决的/未完成的任务，但是我强烈建议包括所有任务。默认情况下 Mylyn 会过滤完成的任务，并且使这些任务很容易通过 Task List 顶端的 <strong>Find:</strong> 框来检索。如果查询只包括未完成的任务，那么一旦这些任务完成之后，就不再会在查询下显示。注意，我的用于所有 Mylyn 任务的查询目前返回 1,420 个元素，其中大多数已经完成。通常，这样大的结果集不会造成问题。 </p>
                        <p>查询中不显示的已经完成的任务在 Archive 中仍然会显示，那里包含所有您工作过的任务。</p>
                        <p>为调度信息（例如里程碑）设置查询会很有用，但是这也会造成 Task List 中充塞着彼此重复的查询。考虑使用 Search 功能来查询像目标里程碑之类的内容。通常，查询对于设置 Task List，使之尽可能简明地显示正在处理的和与人协作的任务很有用，而搜索可以快速给出 &#8220;在这个里程碑之后应执行什么操作&#8221; 之类问题的答案。</p>
                        </td>
                    </tr>
                </tbody>
            </table>
            </td>
        </tr>
    </tbody>
</table>
<p>设置参数并单击 <strong>Finish</strong> 之后，Task List 中的查询容器被相应的任务填充。在查询执行同步时，Mylyn 在后台检索任务的信息。下载完任务信息之后，可以立即打开任务，因为不需要往返服务器来检索任务的信息。要更改查询的参数，可以重新打开它（通过在 Task List 中双击查询）并编辑所选择的值。虽然对于不同的连接器查询参数的设置不尽相同，但是查询参数设置都是用于反映连接器的 Web UI 所提供的功能。有关创建查询的详细信息，请参阅连接器文档或服务器 Web UI 文档。</p>
<p>默认情况下，查询每隔 20 分钟自动进行同步，并显示与查询参数匹配的新任务。（可以通过 <strong>Preferences &gt; Mylyn &gt; Task List</strong> 更改这个时间。）当与 Web 断开连接时，不需要使 Mylyn 处于离线模式。但是，如果想关闭同步 —— 例如，假设您要长时间离线工作，或者直接根据所使用的带宽付费 —— 那么可以这么做，方法是在 Task List 视图菜单中切换 <strong>Synchronize Automatically</strong> 设置。然后，可以通过工具栏上的按钮手动地同步所有任务和查询，或者通过弹出菜单或快捷键 F5 单独同步每个任务或查询。必要时，可以从弹出菜单中将一个任务储存库置于离线模式。当储存库不可用，需要长时间离线工作时，这样做很有用。</p>
<p>对于可以通过 Web 浏览器访问的连接器，Mylyn 集成了用户已熟知的 Web UI，如果 Mylyn 的富编辑功能不支持某些操作，您可能需要依赖于这个 Web UI。可以右键单击任何任务或查询，以便用 Web 浏览器打开它（Eclipse 浏览器设置位于 <strong>Window &gt; Preferences &gt; General &gt; Web Browser</strong> 中），具有关联 URL 的所有储存库任务都可以通过 Task Editor 的工具栏或者任务的弹出菜单上的 Open with Browser 动作打开。还可以用浏览器打开 Bugzilla 查询（例如，假设您想将它粘帖到一封电子邮件中，以便使用 Bugzilla Web UI 对它进行改进）。然后，可以按照 New Query 向导的提示粘帖它，从而使用更新后的 URL 在 Task List 中创建一个新的查询。</p>
<p><a name="N102D9"><span class="smalltitle">搜索任务</span></a></p>
<p>搜索任务类似于创建查询，但是它不将结果存储在 Task List 中。使用 Ctrl+H 或 Search 菜单（<strong>Search &gt; Task Search</strong>），选择感兴趣的储存库，输入搜索条件，然后单击 <strong>Search</strong>。搜索视图随之打开，在该视图中可以打开与搜索匹配的任务，如图 8 所示。要改进搜索，只需再次打开 Search 对话框，以恢复之前的搜索条件。可以在 Search 视图中将搜索结果从弹出菜单转移到一个查询中。 </p>
<br />
<a name="fig8"><strong>图 8. 任务搜索和结果</strong></a><br />
<img height="267" alt="" src="http://www.ibm.com/developerworks/cn/java/j-mylyn1/part1-search.jpg" width="564" /> <br />
<p><a name="N102F7"><span class="smalltitle">创建储存库任务</span></a></p>
<p>要创建新的储存库任务，可以在 Task List 工具栏或 <strong>File &gt; New</strong> 菜单中选择相应的动作，如果有多个储存库，那么要选择一个储存库。然后，连接器会要求输入任务的其它属性，例如它的 Bugzilla 组件。然后会打开一个新的编辑器，在其中可以填入任务的属性和描述。有些属性会自动选好，例如，如果使用 Bugzilla 连接器，则会自动选择操作系统。 </p>
<table cellspacing="0" cellpadding="0" width="40%" align="right" border="0">
    <tbody>
        <tr>
            <td width="10"><img height="1" alt="" src="http://www.ibm.com/i/c.gif" width="10" /></td>
            <td>
            <table cellspacing="0" cellpadding="5" width="100%" border="1">
                <tbody>
                    <tr>
                        <td bgcolor="#eeeeee"><a name="N10306"><strong>技巧：右键单击一个查询节点</strong></a><br />
                        <p>作为一种快捷方式，可以在一个查询节点上单击右键，这样可以自动选择与查询对应的储存库和产品。通常，当调用需要输入的功能时，Mylyn 会尝试使用您的选择来预先选定相关输入。</p>
                        </td>
                    </tr>
                </tbody>
            </table>
            </td>
        </tr>
    </tbody>
</table>
<p>您可能要创建的另一种任务是有关 Mylyn 或使用的另一个基于 Eclipse 的工具的 bug 报告。通过自动添加 bugs.eclipse.org 储存库，以及添加可以从 Eclipse 的 Error Log 视图和 Help 菜单中访问的用于自动报告 bug 的动作，制作 bug 报告很容易。如果要查看想要进行报告的错误事件，只需右键单击它，选择 <strong>Report as Bug</strong>。然后会打开 New Repository Task 编辑器，其中包括所有相关信息，例如栈跟踪。</p>
<p>由于这种通过一次单击生成 bug 报告的方式可能导致大量重复的 bug 归档文件，因此 Mylyn 还提供自动的重复检测。<strong>Search for Duplicates</strong> 按钮使用报告的 Description 中的自动插入式或手动粘帖式栈跟踪来查询相应的储存库，以发现潜在的重复内容。重复检测的结果显示在 Search 视图中，如图 9 所示。如果发现匹配，可以打开它，作出注释，而不是创建新的 bug 报告。 </p>
<br />
<a name="fig9"><strong>图 9. 集成的 bug 报告和重复检测</strong></a><br />
<img height="520" alt="" src="http://www.ibm.com/developerworks/cn/java/j-mylyn1/part1-duplicate.jpg" width="505" /> <br />
<p><a name="N1032B"><span class="smalltitle">编辑和同步</span></a></p>
<p>在打开一个 Bugzilla 任务时，您将注意到在编辑器上有一个 Bugzilla 和一个 Planning 选项卡。储存库连接器提供一个富编辑器，例如这个 Bugzilla 选项卡，用于编辑在储存库上共享的任务信息。而且，Planning 选项卡提供使用本地任务创建个人注解的相同功能。</p>
<p>当查看 bug 上的注释时，可以使用 Outline 视图在注释之间导航，但是未读注释的自动折叠意味着可以在 Task Editor 中进行大多数导航操作。对其它任务和其它结构化元素（例如 Java 栈跟踪元素）的引用被设置为超链接（参见图 10 和 <a href="http://www.ibm.com/developerworks/cn/java/j-mylyn1/#fig1" cmimpressionsent="1">图 1</a>）。超链接的语法特定于连接器。通常，在任务编辑器左上角出现的引用可用于对 bug 进行超链接。连接器的 Web UI 支持的其它语法也受支持。始终支持 <em>task &lt;key&gt;</em> 语法。</p>
<br />
<a name="fig10"><strong>图 10. 储存库任务编辑器和内容辅助</strong></a><br />
<img height="514" alt="" src="http://www.ibm.com/developerworks/cn/java/j-mylyn1/part1-editor-repository.jpg" width="559" /> <br />
<p>如果连接器支持离线编辑，则 Mylyn 维护打开的任何任务的一个缓存副本，并且每当相应的查询或任务进行同步时，对这个副本进行更新。如果作出任何更改，例如设置一个属性或者编制部分注释，那么可以通过按下 Ctrl+S 在本地保存更改。这将导致任务上出现一个 <em>outgoing</em> 指示符。当准备好提交任务时，单击编辑器底端的 <strong>Submit</strong>。</p>
<p>如果一个任务之前已经被打开，那么再次打开它时将检索离线副本，并开始在后台对任务执行同步。这样可以确保不需要等待往返服务器就可以开始读取和处理任务。如果发现新的更改，或者当编辑器打开时他人更改了任务，那么编辑器的标题栏会显示出来，并提示刷新编辑器。</p>
<table cellspacing="0" cellpadding="0" width="40%" align="right" border="0">
    <tbody>
        <tr>
            <td width="10"><img height="1" alt="" src="http://www.ibm.com/i/c.gif" width="10" /></td>
            <td>
            <table cellspacing="0" cellpadding="5" width="100%" border="1">
                <tbody>
                    <tr>
                        <td bgcolor="#eeeeee"><a name="N1035C"><strong>技巧：整理电子邮箱收件箱</strong></a><br />
                        <p>由于使用了 Mylyn 的后台同步功能，不需要依赖电子邮件通知就能知道 Bugzilla 中最新的 bug 报告更改。只需设置可捕捉您感兴趣的所有任务（例如复制的每个报告）的查询，就可以收到简明的进入式箭头形式的通知，这种通知不会使您的收件箱超载。通过选择 <strong>Window &gt; Preferences &gt; Mylyn &gt; Tasks</strong> 设置同步调度。通过右键单击树中的节点并选择 <strong>Synchronize</strong>，可以手动地同步查询和任务。 </p>
                        </td>
                    </tr>
                </tbody>
            </table>
            </td>
        </tr>
    </tbody>
</table>
<p>如果有其他人更改了储存库中的任务，例如添加一条新的注释，那么在屏幕的右下角会弹出一个窗口显示更改，而任务则使用<em>进入式</em> 箭头标记显示。如果打开任务，则被更改的部分会高亮显示，被添加的新的注释自动展开。如果本地副本和服务器上的副本都被更改，那么可以看到一个红色的冲突指示符，并提示解决冲突。如果看到冲突，那么应该单击任务编辑器的 <strong>Synchronize</strong> 按钮，并且提交您的更改，或者通过弹出菜单的 <strong>Mark &gt; Clear Outgoing</strong> 放弃您的更改，以确保任务被同步。 </p>
<p><a name="N10378"><span class="smalltitle">附件</span></a></p>
<p>可以用任务编辑器的 Attachments 区的 <strong>Add...</strong> 按钮将附件添加到储存库中。还可以从工作区或窗口管理器将文件或文本直接拖到编辑器的 Attachments 区。添加附件时会出现一个向导，通过该向导可以选择根据剪切板内容、计算机中的一个文件还是从 Eclipse 工作区中创建附件。通过 Attachments 表，可以用 Web 浏览器或编辑器打开附件，并通过上下文菜单执行特定的动作，例如保存或复制到剪切板。</p>
<br />
<table cellspacing="0" cellpadding="0" width="100%" border="0">
    <tbody>
        <tr>
            <td><img height="1" alt="" src="http://www.ibm.com/i/v14/rules/blue_rule.gif" width="100%" /><br />
            <img height="6" alt="" src="http://www.ibm.com/i/c.gif" width="8" border="0" /></td>
        </tr>
    </tbody>
</table>
<table class="no-print" cellspacing="0" cellpadding="0" align="right">
    <tbody>
        <tr align="right">
            <td><img height="4" alt="" src="http://www.ibm.com/i/c.gif" width="100%" /><br />
            <table cellspacing="0" cellpadding="0" border="0">
                <tbody>
                    <tr>
                        <td valign="middle"><img height="16" alt="" src="http://www.ibm.com/i/v14/icons/u_bold.gif" width="16" border="0" /><br />
                        </td>
                        <td valign="top" align="right"><a class="fbox" href="http://www.ibm.com/developerworks/cn/java/j-mylyn1/#main" cmimpressionsent="1"><strong>回页首</strong></a></td>
                    </tr>
                </tbody>
            </table>
            </td>
        </tr>
    </tbody>
</table>
<br />
<br />
<p><a name="planning"><span class="atitle">任务管理和个人计划</span></a></p>
<p>现在，我将讨论如何使 Mylyn 成为您的一个单独的任务列表和收件箱，以管理工作周内所有相关的任务。对于很多开发人员，要在一个给定的工作周内跟踪和调度的任务的范围包括：</p>
<ul>
    <li>为您正在开发的产品解决产品缺陷并分析特性
    <li>由您的同事完成的任务，这些同事包括您的搭档、上司或属下
    <li>针对您所使用的框架、API 和软件的 bug 报告
    <li>个人待办事项和提醒 </li>
</ul>
<p>将所有任务集成到一个视图中，可以使它们更易于管理，因为只需查看一个位置就知道接下来该做什么。为了进一步简化任务管理，Mylyn 隐式包含了一些公认的任务管理最佳实践，例如调度和延迟任务，并且还包括了 XP 式开发的即时性和适应性。Mylyn 的任务管理工具使您可以轻松地适应一周内的任务变化需求，而不会丢失对长期优先级的跟踪。除了将工作周的控制权交到您手上之外，Mylyn 通过简化使用共享的储存库属性（例如里程碑和优先级），在 Eclipse 中执行所有操作，从而帮助您更好地集成团队实践。 </p>
<p><a name="N103A0"><span class="smalltitle">预定日期与到期日期</span></a></p>
<p>Mylyn 提供两种用于调度的日期：<em>预定日期（scheduled date）</em> 和<em>到期日期（due date）</em>。（您可能已经注意到，任务编辑器中显示了这两种日期）。预定日期可以帮助管理和优先排列自己的工作周，而到期日期则对应于最后期限之类的固定事件。</p>
<p>任务的预定日期是根据个人日程安排的可变日期，可以根据优先级的变化而推迟。它定义您计划开始处理任务的时间。当任务到达预定日期时，任务变成红色，以指示您应该开始处理它或者考虑推迟它的起始日期。定在今天执行的任务会变成蓝色而不是红色，并且在工作日的最后进行安排，避免重新安排整个工作日的任务。</p>
<p>相反，任务的到期日期是固定的日期：任务必须完成的日期。这个日期常常与外部的约束（例如最后期限）相关。如果使用共享的任务储存库或者日历工具，到期日期会进行同步，以便使团队的其它成员可见。例如，如果 Bugzilla 的时间跟踪功能被启用，那么可以通过任务编辑器的 Attributes 区中的 Time Tracking 区设置 Bugzilla 任务的到期日期，团队中的其他成员可以看到这个日期，还可以编辑它。到期日期的临近是通过任务图标上的一个小钟指示的，这个小钟在到期日期之前为蓝色，在到期日期之后为红色。</p>
<p><a name="N103B5"><span class="smalltitle">聚焦工作周任务</span></a></p>
<p>由于 Mylyn 使得创建和共享任务变得如此容易，似乎您一旦开始使用它，Task List 中很快就会装满数十个甚至数千个任务。对于 Mylyn 的早期用户，包括我在内，确实会发生这样的事情。也许是因为我是第一批用户，目前我的 Task List 包含超过 5,000 个任务，其中有超过 1,000 个任务尚未完成。乍一看来，这似乎与 Mylyn 减少而不是增加信息超载的目标有冲突。为了解决这个问题，Mylyn 提供了改进的功能来调度和推迟任务，使用这些信息让 Task List 只显示与您的工作周有关的任务。新创建的任务定在创建日调度，并且可以通过任务编辑器的 Planning 区或上下文菜单快速地将任务推迟到靠后的一个时间或日期。</p>
<p>当任务到达预定日期之后，任务和它的容器（例如一个查询）变成红色，桌面上显示一个弹出窗口作为提醒。（和其它 Mylyn 颜色和字体设置一样，可以用 <strong>Window &gt; Preferences &gt; General &gt; Appearance &gt; Colors and Fonts</strong> 将任务设置为高亮显示）。当任务被推迟到将来的日期执行时，<strong>Window &gt; Mylyn &gt; Tasks &gt; Scheduling</strong> 中设置的工作日起始时间决定任务被调度的时间。通过更改工作日的结束时间，可以确定被定为那天调度的任务在什么时间到期。</p>
<p>Mylyn 任务管理模型的关键是基于兴趣的分类和过滤，您可以通过 Task List 工具栏上的 Focus on Workweek 动作启用该功能。聚焦模式导致只有与工作周相关的任务才可以显示。这包括以下任务：</p>
<ul>
    <li>预定在本周执行或者超过预定日期的任务
    <li>有新的更改和注释的储存库任务 </li>
</ul>
<p>如图 11 所示，任务被着色和分类，以帮助您快速确定下一步任务：</p>
<ul>
    <li>逾期任务为红色，总是显示在列表的顶部。
    <li>调度为在今天执行的任务以蓝色突出显示。
    <li>调度为在本周靠后时间执行的任务为黑色。
    <li>今天完成的任务为绿色。
    <li>之前完成的任务为灰色。 </li>
</ul>
<br />
<a name="fig11"><strong>图 11. 调度任务</strong></a><br />
<img height="506" alt="" src="http://www.ibm.com/developerworks/cn/java/j-mylyn1/part1-scheduling.jpg" width="560" /> <br />
<p><a name="N103F7"><span class="smalltitle">每天执行预定的任务</span></a></p>
<p>通过轻松地调度和推迟任务，并将视图限制为显示给定工作周内预定的任务，Mylyn 帮助您全盘考虑优先级。为了突出工作日，Mylyn 用蓝色高亮显示所有在当天调度的任务。由于在聚焦模式下工作时不大可能看到滚动条，因而 Task List 保持展开，所以您总是知道应该考虑对什么作出响应或者下一步执行什么。</p>
<p>考虑使用 Mylyn 的聚焦功能管理工作周的示例流程：</p>
<ol>
    <li>在工作周的开始，任务列表包含很多红色的任务，这些任务是之前定在本周执行或者推迟到本周执行的。<br />
    <br />
    <li>红色不是令人愉快的颜色，所以您使用上下文菜单将每个任务安排在今天或本周靠后某一天执行。当所有红色都消失之后（定在今天执行的任务变成了蓝色，定在本周靠后时间执行的任务变成黑色），您可以查看这周的日程安排，确认它符合实际，必要时推迟或委托他人执行任务。<br />
    <br />
    <li>当 Task List 被激活时，可以将鼠标悬停在 Task List 顶端附近的绿色进度条上（如图 11 所示），以检查是否为工作周安排了太多的任务。如果有些任务要比其它任务花费更长的时间，那么可以打开任务的 Planning 区，调整预计时间，这样可以相应地调整工作周进度条。<br />
    <br />
    <li>在工作日的最后，所有已经完成的任务变成了令人愉快的绿色。然后，您可以检查剩下的蓝色或红色的任务，将它们推迟到明天或更靠后的日期。<br />
    <br />
    <li>在第二天的开始，安排在这一天的所有任务都为蓝色，而所有逾期的任务为红色。在安排工作日时，您会将某些任务推迟到本周靠后的日期，因此可见的蓝色任务表示您可以当天完成的所有任务。任务完成后变为绿色。<br />
    <br />
    <li>在工作周结束时，滚动条应该会消失，列表上的大多数任务应该都变成绿色。 </li>
</ol>
<p>由于任务调度是任务管理最重要的部分，Mylyn 在 Task List 中提供了 <strong>Scheduled</strong> 表示，它根据到期日期而不是类别和查询来组织任务。在聚焦模式下，这种表示会显示这一周每天必须完成的所有任务。这对于平衡整周的工作负载很有用。它的另一个优点是当您使用共享任务时可以避免分心，因为不会显示有新注释但是未调度的任务。要检查新到来的任务，需要切换回 <strong>Categorized</strong> 表示，重新确定优先次序，然后再重新审视时间表。当不在聚焦模式下，可以使用 scheduled 表示来平衡未来工作周的任务负载 —— 例如，通过将鼠标悬停在 Next Week 容器上检查有多少任务被推迟。</p>
<p><a name="N10435"><span class="smalltitle">创建工作集</span></a></p>
<p>到目前为止，本文描述的所有功能都是将 Task List 当作一个统一的相关任务的集合，您可以灵活地调度这些任务。此外，可以用查询来组织任务，还可以进一步嵌套子任务，前提是储存库连接器提供这种支持（例如 Bugzilla 连接器就提供这种支持；可以从 Task List 的视图菜单中启用该选项）。但是，由于 Mylyn 2.0 对<em>工作集（working sets）</em>的支持，还可以对由完全不相关的任务组成的集合进行处理。假设您在开发一个产品和两个不同的开源项目。您可能想把工作日的大多数时间花在最重要的产品上，但是还想跟进其它项目。Mylyn 的工作集使您可以组织与一个特定产品或项目相关的查询和类别，并提供限定在 Eclipse 工作区中显示的文件和其它资源的数量的功能。</p>
<table cellspacing="0" cellpadding="0" width="40%" align="right" border="0">
    <tbody>
        <tr>
            <td width="10"><img height="1" alt="" src="http://www.ibm.com/i/c.gif" width="10" /></td>
            <td>
            <table cellspacing="0" cellpadding="5" width="100%" border="1">
                <tbody>
                    <tr>
                        <td bgcolor="#eeeeee"><a name="N10444"><strong>技巧：显示所有元素</strong></a><br />
                        <p>可以从工作集切换器下拉列表中选择 <strong>Show All</strong> 来查看所有元素，就好像没有设置任何工作集一样。这对于定期获得 Task List 的整体概况非常有用。</p>
                        </td>
                    </tr>
                </tbody>
            </table>
            </td>
        </tr>
    </tbody>
</table>
<p>使用 Task List 顶端的切换条，创建包括相关查询、类别和工作区资源的工作集（参见图 12）。只要 Eclipse 视图被设置为显示 <em>Window Working Set</em>（默认设置），切换 Mylyn 工作集可导致 Task List 和 Eclipse 都只显示属于工作集的任务和项目。例如，如果为一个开源项目设置了一个工作集，并用下拉列表启用该功能，那么 Eclipse Task List、Package Explorer 和 Problems 视图都只显示与那个项目相关的内容。Task List Find 只显示工作集中的匹配项。甚至可以通过 Search (Ctrl+H) 只查找工作集中的内容，如果工作区较大的话，这样做很有用。换句话说，整个 Eclipse 只显示与您创建的工作集相关的东西。工作集可以减少工作区的凌乱，并且可以避免使用多个工作区。在 <a href="http://www.ibm.com/developerworks/cn/java/j-mylyn2/" cmimpressionsent="1">第 2 部分</a> 中，您将看到 Mylyn 如何进一步利用这种聚焦思想，将 Eclipse 中的可见内容缩小到单个任务。</p>
<br />
<a name="fig12"><strong>图 12. 编辑和切换工作集</strong></a><br />
<img height="607" alt="" src="http://www.ibm.com/developerworks/cn/java/j-mylyn1/part1-working-sets.jpg" width="572" /> <br />
<p><a name="N1046A"><span class="smalltitle">过滤、分类和搜索</span></a></p>
<p>除了一些自动化功能外，Mylyn 还提供手动分类和过滤功能：</p>
<ul>
    <li>通过视图菜单中的 <strong>Sort by</strong> 项，根据 Priority 之类的属性分类。
    <li>使用视图菜单中的 <strong>Filter Priority Lower Than</strong> 项，根据优先级进行过滤。
    <li>通过视图菜单过滤所有 Archive 类别和完成的任务（建议启用该功能，在聚焦模式下会自动启用）。
    <li>通过单击 <strong>Go Into</strong> 过滤特定类别或查询中的任务（在聚焦模式下同样适用）。
    <li>通过拖放操作手动分类；将储存库任务分类到各类别中。 </li>
</ul>
<p>图 13 显示了可用的手动 Task List 过滤器：</p>
<br />
<a name="fig13"><strong>图 13. 手动 Task List 过滤器</strong></a><br />
<img height="476" alt="" src="http://www.ibm.com/developerworks/cn/java/j-mylyn1/part1-filters.jpg" width="491" /> <br />
<p>手动搜索和过滤会增加重复切换不同过滤器和分类器的负担。对于默认模式下的操作不建议使用，但是它们对于计划和组织任务的确有用。注意，当 Focus on Workweek 活动时，手动过滤和分类设置被禁用；可以通过关闭聚焦模式来恢复它们。</p>
<p>当组织 Task List 时，可以通过 <strong>Move to Category</strong> 上下文菜单或者选择上下文菜单中的 <strong>Remove from Category</strong> 移动任何任务。除非通过上下文菜单显式地删除任务，否则即使任务已经从查询中消失或者从类别中删除，仍然会显示在 Task List 中。被删除的任务可以在 Archive 容器中找到。可以通过 Task List 顶端的 Find 框方便地搜索 Archive 或其它地方的旧任务。单击它右边的 <strong>Clear</strong> 按钮或按下 Esc 键可以恢复之前可见的任务。Archive 容器对于查看之前已解决且被注释的任务也很有用，因为创建查询的一种通用方法是排除已解决任务（但是请参阅 <a href="http://www.ibm.com/developerworks/cn/java/j-mylyn1/#query_configuration" cmimpressionsent="1">查询设置建议</a>，了解有关这一做法的注意事项）。</p>
<p><a name="N104B3"><span class="smalltitle">备份和导出</span></a></p>
<table cellspacing="0" cellpadding="0" width="55%" align="right" border="0">
    <tbody>
        <tr>
            <td width="10"><img height="1" alt="" src="http://www.ibm.com/i/c.gif" width="10" /></td>
            <td>
            <table cellspacing="0" cellpadding="5" width="100%" border="1">
                <tbody>
                    <tr>
                        <td bgcolor="#eeeeee"><a name="N104BC"><strong>技巧：共享任务数据</strong></a><br />
                        <p>当使用多个工作区时，可以不通过 Import 获得任务，而是通过选择 <strong>Window &gt; Preferences &gt; Mylyn &gt; Tasks</strong>，将任务数据目录设置为一个共享的位置。如果将这个位置放在一个网络驱动器上，那么它应该可以通过一个快速的连接进行访问，因为它将被频繁访问。这是一个高级选项，只建议那些手动管理其工作区位置的用户使用。</p>
                        </td>
                    </tr>
                </tbody>
            </table>
            </td>
        </tr>
    </tbody>
</table>
<p>聚焦模式使用得越频繁，您的 Task List 就变得越有价值。默认情况下，Task List 的自动备份已被启用，可以通过 <strong>Window &gt; Preferences &gt; Mylyn &gt; Tasks</strong> 设置备份目录。 要从备份恢复 Task List，可以选择相应的单选按钮，并选择一个备份快照。默认情况下，Mylyn 每天为所有任务数据制作快照，并保留 30 天的备份（通过 <strong>Preferences &gt; Tasks</strong> 配置）。可以通过单击 <strong>File &gt; Export</strong> 导出任务。</p>
<br />
<table cellspacing="0" cellpadding="0" width="100%" border="0">
    <tbody>
        <tr>
            <td><img height="1" alt="" src="http://www.ibm.com/i/v14/rules/blue_rule.gif" width="100%" /><br />
            <img height="6" alt="" src="http://www.ibm.com/i/c.gif" width="8" border="0" /></td>
        </tr>
    </tbody>
</table>
<table class="no-print" cellspacing="0" cellpadding="0" align="right">
    <tbody>
        <tr align="right">
            <td><img height="4" alt="" src="http://www.ibm.com/i/c.gif" width="100%" /><br />
            <table cellspacing="0" cellpadding="0" border="0">
                <tbody>
                    <tr>
                        <td valign="middle"><img height="16" alt="" src="http://www.ibm.com/i/v14/icons/u_bold.gif" width="16" border="0" /><br />
                        </td>
                        <td valign="top" align="right"><a class="fbox" href="http://www.ibm.com/developerworks/cn/java/j-mylyn1/#main" cmimpressionsent="1"><strong>回页首</strong></a></td>
                    </tr>
                </tbody>
            </table>
            </td>
        </tr>
    </tbody>
</table>
<br />
<br />
<p><a name="N104D5"><span class="atitle">第 1 部分结束语</span></a></p>
<p>在这个 Mylyn 使用指南的前半部分中，我介绍了 Mylyn 的任务管理功能。我向您展示了这些功能如何支持个性化的任务管理，以及它们如何将 Bugzilla 之类的基于 Web 的问题跟踪器完全集成到 Eclipse 中。我还对 Mylyn 管理的典型的工作周或工作日作了概述，并展示如何管理 Task List。</p>
<p>无论您感兴趣的任务储存库有多少，Task List 视图只提供一个单独的位置来从中管理所有工作。这使您可以将工作日中的更多时间花在高效的 Eclipse 中，而不必频繁切换到外部的浏览器窗口。这还意味着您可以获得基于 Web 的问题跟踪器的富客户机体验，例如拖放附件和离线支持。</p>
<table cellspacing="0" cellpadding="0" width="150" align="right" border="0">
    <tbody>
        <tr>
            <td width="10"><img height="1" alt="" src="http://www.ibm.com/i/c.gif" width="10" /></td>
            <td>
            <table cellspacing="0" cellpadding="5" width="100%" border="1">
                <tbody>
                    <tr>
                        <td bgcolor="#eeeeee"><a name="N104E5"><strong>分享这篇文章&#8230;&#8230;</strong></a><br />
                        <p>
                        <table cellspacing="0" cellpadding="0" width="135" border="0">
                            <tbody>
                                <tr>
                                    <td colspan="2"><img height="5" alt="" src="http://www.ibm.com/i/c.gif" width="1" border="0" /> </td>
                                </tr>
                                <tr valign="top" align="left">
                                    <td width="21"><a href="http://digg.com/submit?phase=2&amp;url=http://www.ibm.com/developerworks/cn/java/j-mylyn1/" cmimpressionsent="1"><img height="10" alt="digg" src="http://www.ibm.com/i/v14/icons/10x10-digg-thumb.gif" width="10" border="0" /> </a></td>
                                    <td><a href="http://digg.com/submit?phase=2&amp;url=http://www.ibm.com/developerworks/cn/java/j-mylyn1/" cmimpressionsent="1">提交到 Digg</a> </td>
                                </tr>
                                <tr>
                                    <td colspan="2"><img height="5" alt="" src="http://www.ibm.com/i/c.gif" width="1" border="0" /> </td>
                                </tr>
                                <tr valign="top" align="left">
                                    <td width="21"><a href="http://del.icio.us/post" cmimpressionsent="1"><img height="10" alt="del.icio.us" src="http://del.icio.us/static/img/delicious.small.gif" width="10" border="0" /> </a></td>
                                    <td><a href="http://del.icio.us/post" cmimpressionsent="1">发布到 del.icio.us</a> </td>
                                </tr>
                                <tr>
                                    <td colspan="2"><img height="5" alt="" src="http://www.ibm.com/i/c.gif" width="1" border="0" /> </td>
                                </tr>
                                <tr valign="top" align="left">
                                    <td width="21"><a href="javascript:location.href='http://slashdot.org/bookmark.pl?url='+encodeURIComponent(location.href)+'&amp;title='+encodeURIComponent(document.title)" cmimpressionsent="1"><img height="16" alt="Slashdot" src="http://images.slashdot.org/favicon.ico" width="16" border="0" /> </a></td>
                                    <td><a href="javascript:location.href='http://slashdot.org/bookmark.pl?url='+encodeURIComponent(location.href)+'&amp;title='+encodeURIComponent(document.title)" cmimpressionsent="1">提交到 Slashdot！</a> </td>
                                </tr>
                                <tr>
                                    <td colspan="2"><img height="5" alt="" src="http://www.ibm.com/i/c.gif" width="1" border="0" /> </td>
                                </tr>
                            </tbody>
                        </table>
                        </p>
                        </td>
                    </tr>
                </tbody>
            </table>
            </td>
        </tr>
    </tbody>
</table>
<p>使用 Mylyn 的最精彩部分即将出现。一旦任务显式呈现为工作的组成部分，Mylyn 就开始自动管理它们的上下文。本文的第 2 部分介绍 Mylyn 的上下文管理功能，并展示这些功能如何减少信息超载，以及如何使多任务处理简单到只需一次单击即可完成。现在就请阅读 <a href="http://www.ibm.com/developerworks/cn/java/j-mylyn2/" cmimpressionsent="1">第 2 部分</a>。</p>
<img src ="http://www.blogjava.net/conans/aggbug/209878.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/conans/" target="_blank">CONAN</a> 2008-06-22 18:51 <a href="http://www.blogjava.net/conans/articles/209878.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title> Eclipse加速插件KeepResident(转)</title><link>http://www.blogjava.net/conans/articles/209602.html</link><dc:creator>CONAN</dc:creator><author>CONAN</author><pubDate>Fri, 20 Jun 2008 15:13:00 GMT</pubDate><guid>http://www.blogjava.net/conans/articles/209602.html</guid><description><![CDATA[<div class="blog_content">
<p>原理:利用两个 Windows API - SetProcessWorkingSetSize 与 VirtualLock (适用于 Windows 平台)。<br />
<br />
切换时果然快很多。<br />
<br />
官方建议最小值设定在 100 MB，最大值 250 MB 左右。 </p>
<p>&nbsp;</p>
<p>----------------------------------------------------------- </p>
<p>&nbsp;</p>
<p>下载地址：<br />
<span style="color: #000000"><a href="http://suif.stanford.edu/pub/keepresident/keepresident-0.2.zip" target="_blank">http://suif.stanford.edu/pub/keepresident/keepresident-0.2.zip</a></span><br />
<br />
安装方法：<br />
解压到Eclipse安装目录，它实际上会增加一个plugins目录下的子目录，然后重启Eclipse，对于3.1版本的Eclipse，建议使用-clean命令行参数启动，这样会明确告诉Eclipse刷新</p>
<p><strong class="kgb" style="border-top-width: 0px; padding-right: 0px; padding-left: 0px; font-weight: normal; border-left-width: 0px; border-bottom-width: 0px; padding-bottom: 0px; margin: 0px; color: #0000ff; padding-top: 0px; border-right-width: 0px; text-decoration: underline">插件</strong>等的配置。<br />
<br />
使用：<br />
在Eclipse <strong class="kgb" style="border-top-width: 0px; padding-right: 0px; padding-left: 0px; font-weight: normal; border-left-width: 0px; border-bottom-width: 0px; padding-bottom: 0px; margin: 0px; color: #0000ff; padding-top: 0px; border-right-width: 0px; text-decoration: underline">工作台</strong>的Windows-&gt;Preferences中会看到新增的KeepResident选项页，在这里我们可以配置三个东东，最小<strong class="kgb" style="border-top-width: 0px; padding-right: 0px; padding-left: 0px; font-weight: normal; border-left-width: 0px; border-bottom-width: 0px; padding-bottom: 0px; margin: 0px; color: #0000ff; padding-top: 0px; border-right-width: 0px; text-decoration: underline">工作</strong>集大小、最大工作集大小、VirtualLock，分别指定希望Windows分配给Eclipse的最小物理内存、最大物理内存和是否强制<strong class="kgb" style="border-top-width: 0px; padding-right: 0px; padding-left: 0px; font-weight: normal; border-left-width: 0px; border-bottom-width: 0px; padding-bottom: 0px; margin: 0px; color: #0000ff; padding-top: 0px; border-right-width: 0px; text-decoration: underline">保持</strong>这部分内存。具体设置因人而异，可以给大家参考我个人的配置：我的环境是<strong class="kgb" style="border-top-width: 0px; padding-right: 0px; padding-left: 0px; font-weight: normal; border-left-width: 0px; border-bottom-width: 0px; padding-bottom: 0px; margin: 0px; color: #0000ff; padding-top: 0px; border-right-width: 0px; text-decoration: underline">Windows XP</strong> SP2，256MB内存，三个选项分别是：80MB、128MB、选中。最使用情况来看，运行很顺畅。<br />
<br />
<strong class="kgb" style="border-top-width: 0px; padding-right: 0px; padding-left: 0px; font-weight: normal; border-left-width: 0px; border-bottom-width: 0px; padding-bottom: 0px; margin: 0px; color: #0000ff; padding-top: 0px; border-right-width: 0px; text-decoration: underline">简单</strong>原理：<br />
首先，我们知道，Windows的内存实际上是物理内存+虚拟内存，必要的时候它会把应用程序占用的物理内存page到硬盘；其次，对于普通的应用程序 Windows默认只会分配少量物理内存，并且这对需要相对大量内存的Eclipse来说是不能接受的；再次，一旦Eclipse窗口最小化， Windows默认就会认为它暂时不再被使用，于是会将它使用的物理内存挪出来给其他的进程使用，这样我们最小化和再次打开就会感到严重的延迟。 KeepResident非常小，其实就是调用Windows的SetProcessWorkingSetSize()和VirtualLock()这两个API来实现指定Eclipse运行时内存分配的具体设置。</p>
</div>
&nbsp;
<img src ="http://www.blogjava.net/conans/aggbug/209602.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/conans/" target="_blank">CONAN</a> 2008-06-20 23:13 <a href="http://www.blogjava.net/conans/articles/209602.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>eclipse 3.4 M5 最值得使用的9个新功能</title><link>http://www.blogjava.net/conans/articles/209587.html</link><dc:creator>CONAN</dc:creator><author>CONAN</author><pubDate>Fri, 20 Jun 2008 15:02:00 GMT</pubDate><guid>http://www.blogjava.net/conans/articles/209587.html</guid><description><![CDATA[<strong>1, 浮动窗口注释改进</strong> <br />
你是否在eclipse里使用过这样一个功能： <br />
当鼠标移动到有javadoc注释的接口方法时， 会出现一个悬浮窗。框内显示该接口方法的详细javadoc内容。（如果没有显示，请调大eclipse.ini里的最大内存量-Xmx256m） <br />
<br />
而当鼠标离开方法或移动到悬浮框上时，悬浮框将消失。为了不让悬浮框消失，你需要按 F2 固定住框体，才可以继续查看并可使用滚动条功能（内容比较多）。 <br />
<br />
3.4 M5里一个新的改进，就是，可以设置，当出现悬浮框并移动到悬浮框上时， 框仍旧保留，并增强了悬浮框的周边功能。 <br />
<br />
<img alt="" src="http://pic.yupoo.com/imkenwu/470635225327/medium.jpg" _counted="undefined" /> <br />
<br />
<img alt="" src="http://pic.yupoo.com/imkenwu/178075225329/medium.jpg" _counted="undefined" /> <br />
<br />
周边功能包括： <br />
1，可以直接点击doc里的元素进行定位。 <br />
2，框体最下面新增，跳转到javadoc视图 <br />
3，框体最下方新增，定位到正确的申明处，类似Declarations。 <br />
<br />
<strong>2, 查找/替换时的正则表达式新增 &#8220;保留大小写格式&#8221; 关键字。</strong> <br />
当替换时， 可以保留匹配到的文本原有的大小写格式。 <br />
<br />
<img alt="" src="http://pic.yupoo.com/imkenwu/984615225328/medium.jpg" _counted="undefined" /> <br />
<br />
例如： 在 "Test test= TEST" 这个字符串中，替换 "test" 为 "\CFoo", 结果为 "Foo foo= FOO" . <br />
<br />
<strong>3, 新增全标签视图，即在同一视图中显示 &#8220;problems, bookmarks and tasks&#8221;</strong> <br />
<br />
<img alt="" src="http://pic.yupoo.com/imkenwu/878885225327/medium.jpg" _counted="undefined" /> <br />
<br />
<strong>4, java编辑器新增 面包屑导航（很不错的功能，不过会消耗一点资源）</strong> <br />
首先，这还是个实验性的功能。 <br />
你可以通过点击 Toggle Breadcrumb 按钮启用这一功能。 <br />
（隶属于 java editor presentation 组, 怎么禁用？ 右键点击上部导航栏，选择 Commands 选项卡，如下图:） <br />
<br />
<img alt="" src="http://pic.yupoo.com/imkenwu/191525225328/medium.jpg" _counted="undefined" /> <br />
<br />
<img alt="" src="http://pic.yupoo.com/imkenwu/047055225327/medium.jpg" _counted="undefined" /> <br />
<br />
它的作用是： <br />
1， 可以快速定位到当前类的某一个方法，而不需要再按 ctrl + 0 (显示当前类的所有方法，并可以进行定位) <br />
<br />
<img alt="" src="http://pic.yupoo.com/imkenwu/868055225327/medium.jpg" _counted="undefined" /> <br />
<br />
2， 可以快速定位到同一包下的其他类。 <br />
<br />
<img alt="" src="http://pic.yupoo.com/imkenwu/837585225329/medium.jpg" _counted="undefined" /> <br />
<br />
3， 可以定位到同一项目下的其他包。 <br />
<br />
<img alt="" src="http://pic.yupoo.com/imkenwu/755605225328/medium.jpg" _counted="undefined" /> <br />
<br />
4， 可以定位到其他文件夹。 <br />
5， 可以定位到其他项目。 <br />
<br />
5， 快速解决与快速援助(Quick Fix and Quick Assist) <br />
<br />
当鼠标移动到需要解决问题的代码行时， <br />
<br />
<img alt="" src="http://pic.yupoo.com/imkenwu/570545225328/medium.jpg" _counted="undefined" /> <br />
<br />
按 ctrl + 1 可以提示解决方案，并实施快速解决。 <br />
<br />
<img alt="" src="http://pic.yupoo.com/imkenwu/730825225328/medium.jpg" _counted="undefined" /> <br />
<br />
<img alt="" src="http://pic.yupoo.com/imkenwu/923235225328/medium.jpg" _counted="undefined" /> <br />
<br />
6, 增强了注释的格式化 <br />
<br />
<img alt="" src="http://pic.yupoo.com/imkenwu/9109752255c2/medium.jpg" _counted="undefined" /> <br />
<br />
7， 错误日志视图，可以快速查看日志配置。 <br />
<br />
<img alt="" src="http://pic.yupoo.com/imkenwu/969455225328/medium.jpg" _counted="undefined" /> <br />
<br />
8, 更清晰转换jar包到插件项目 <br />
为了鼓励eclipse插件开发用户，不要使用已经被嵌套在其他项目里的jar包（其他项目更改依赖或删除时，会报错），提供了快速转换入口。 <br />
<br />
<img alt="" src="http://pic.yupoo.com/imkenwu/339175225328/medium.jpg" _counted="undefined" /> <br />
<br />
9， OSGI R4.1 Bundle-ActivationPolicy 支持 <br />
为了进一步统一 OSGI R4.1 规范， PDE支持 Bundle-ActivationPolicy 。 <br />
下图是，将已经不再使用的 Eclipse-LazyStart 替换成 Bundle-ActivationPolicy 。 <br />
<br />
<img alt="" src="http://pic.yupoo.com/imkenwu/090845225327/medium.jpg" _counted="undefined" />&nbsp;
<img src ="http://www.blogjava.net/conans/aggbug/209587.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/conans/" target="_blank">CONAN</a> 2008-06-20 23:02 <a href="http://www.blogjava.net/conans/articles/209587.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>eclipse快捷键</title><link>http://www.blogjava.net/conans/articles/209577.html</link><dc:creator>CONAN</dc:creator><author>CONAN</author><pubDate>Fri, 20 Jun 2008 14:56:00 GMT</pubDate><guid>http://www.blogjava.net/conans/articles/209577.html</guid><description><![CDATA[<table cellspacing="0" cellpadding="0" border="1">
    <tbody>
        <tr>
            <td valign="top" width="115">
            <div>作用域</div>
            </td>
            <td valign="top" width="312">
            <div>功能</div>
            </td>
            <td valign="top" width="132">
            <div>快捷键</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>查找并替换</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+F</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>文本编辑器</div>
            </td>
            <td valign="top" width="312">
            <div>查找上一个</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+Shift+K</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>文本编辑器</div>
            </td>
            <td valign="top" width="312">
            <div>查找下一个</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+K</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>撤销</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+Z</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>复制</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+C</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>恢复上一个选择</div>
            </td>
            <td valign="top" width="132">
            <div>Alt+Shift+&#8595;</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>剪切</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+X</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>快速修正</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl1+1</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>内容辅助</div>
            </td>
            <td valign="top" width="132">
            <div>Alt+/</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>全部选中</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+A</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>删除</div>
            </td>
            <td valign="top" width="132">
            <div>Delete</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>上下文信息</div>
            </td>
            <td valign="top" width="132">
            <div>Alt+？</div>
            <div>Alt+Shift+?</div>
            <div>Ctrl+Shift+Space</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>Java编辑器</div>
            </td>
            <td valign="top" width="312">
            <div>显示工具提示描述</div>
            </td>
            <td valign="top" width="132">
            <div>F2</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>Java编辑器</div>
            </td>
            <td valign="top" width="312">
            <div>选择封装元素</div>
            </td>
            <td valign="top" width="132">
            <div>Alt+Shift+&#8593;</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>Java编辑器</div>
            </td>
            <td valign="top" width="312">
            <div>选择上一个元素</div>
            </td>
            <td valign="top" width="132">
            <div>Alt+Shift+&#8592;</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>Java编辑器</div>
            </td>
            <td valign="top" width="312">
            <div>选择下一个元素</div>
            </td>
            <td valign="top" width="132">
            <div>Alt+Shift+&#8594;</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>文本编辑器</div>
            </td>
            <td valign="top" width="312">
            <div>增量查找</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+J</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>文本编辑器</div>
            </td>
            <td valign="top" width="312">
            <div>增量逆向查找</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+Shift+J</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>粘贴</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+V</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>重做</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+Y</div>
            </td>
        </tr>
    </tbody>
</table>
<div><font size="3"></font>&nbsp;</div>
<div><font size="3">查看</font></div>
<table cellspacing="0" cellpadding="0" border="1">
    <tbody>
        <tr>
            <td valign="top" width="115">
            <div>作用域</div>
            </td>
            <td valign="top" width="312">
            <div>功能</div>
            </td>
            <td valign="top" width="132">
            <div>快捷键</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>放大</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+=</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>缩小</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+-</div>
            </td>
        </tr>
    </tbody>
</table>
<div><font size="3"></font>&nbsp;</div>
<div><font size="3">窗口</font></div>
<table cellspacing="0" cellpadding="0" border="1">
    <tbody>
        <tr>
            <td valign="top" width="115">
            <div>作用域</div>
            </td>
            <td valign="top" width="312">
            <div>功能</div>
            </td>
            <td valign="top" width="132">
            <div>快捷键</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>激活编辑器</div>
            </td>
            <td valign="top" width="132">
            <div>F12</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>切换编辑器</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+Shift+W</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>上一个编辑器</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+Shift+F6</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>上一个视图</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+Shift+F7</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>上一个透视图</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+Shift+F8</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>下一个编辑器</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+F6</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>下一个视图</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+F7</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>下一个透视图</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+F8</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>文本编辑器</div>
            </td>
            <td valign="top" width="312">
            <div>显示标尺上下文菜单</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+W</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>显示视图菜单</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+F10</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>显示系统菜单</div>
            </td>
            <td valign="top" width="132">
            <div>Alt+-</div>
            </td>
        </tr>
    </tbody>
</table>
<div><font size="3"></font>&nbsp;</div>
<div><font size="3">导航</font></div>
<table cellspacing="0" cellpadding="0" border="1">
    <tbody>
        <tr>
            <td valign="top" width="115">
            <div>作用域</div>
            </td>
            <td valign="top" width="312">
            <div>功能</div>
            </td>
            <td valign="top" width="132">
            <div>快捷键</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>Java编辑器</div>
            </td>
            <td valign="top" width="312">
            <div>打开结构</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+F3</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>打开类型</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+Shift+T</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>打开类型层次结构</div>
            </td>
            <td valign="top" width="132">
            <div>F4</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>打开声明</div>
            </td>
            <td valign="top" width="132">
            <div>F3</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>打开外部javadoc</div>
            </td>
            <td valign="top" width="132">
            <div>Shift+F2</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>打开资源</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+Shift+R</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>后退历史记录</div>
            </td>
            <td valign="top" width="132">
            <div>Alt+&#8592;</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>前进历史记录</div>
            </td>
            <td valign="top" width="132">
            <div>Alt+&#8594;</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>上一个</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+,</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>下一个</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+.</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>Java编辑器</div>
            </td>
            <td valign="top" width="312">
            <div>显示大纲</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+O</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>在层次结构中打开类型</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+Shift+H</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>转至匹配的括号</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+Shift+P</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>转至上一个编辑位置</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+Q</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>Java编辑器</div>
            </td>
            <td valign="top" width="312">
            <div>转至上一个成员</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+Shift+&#8593;</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>Java编辑器</div>
            </td>
            <td valign="top" width="312">
            <div>转至下一个成员</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+Shift+&#8595;</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>文本编辑器</div>
            </td>
            <td valign="top" width="312">
            <div>转至行</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+L</div>
            </td>
        </tr>
    </tbody>
</table>
<div><font size="3"></font>&nbsp;</div>
<div><font size="3">搜索</font></div>
<table cellspacing="0" cellpadding="0" border="1">
    <tbody>
        <tr>
            <td valign="top" width="115">
            <div>作用域</div>
            </td>
            <td valign="top" width="312">
            <div>功能</div>
            </td>
            <td valign="top" width="132">
            <div>快捷键</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>出现在文件中</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+Shift+U</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>打开搜索对话框</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+H</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>工作区中的声明</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+G</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>工作区中的引用</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+Shift+G</div>
            </td>
        </tr>
    </tbody>
</table>
<div><font size="3"></font>&nbsp;</div>
<div><font size="3">文本编辑</font></div>
<table cellspacing="0" cellpadding="0" border="1">
    <tbody>
        <tr>
            <td valign="top" width="115">
            <div>作用域</div>
            </td>
            <td valign="top" width="312">
            <div>功能</div>
            </td>
            <td valign="top" width="132">
            <div>快捷键</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>文本编辑器</div>
            </td>
            <td valign="top" width="312">
            <div>改写切换</div>
            </td>
            <td valign="top" width="132">
            <div>Insert</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>文本编辑器</div>
            </td>
            <td valign="top" width="312">
            <div>上滚行</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+&#8593;</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>文本编辑器</div>
            </td>
            <td valign="top" width="312">
            <div>下滚行</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+&#8595;</div>
            </td>
        </tr>
    </tbody>
</table>
<div><font size="3"></font>&nbsp;</div>
<div><font size="3">文件</font></div>
<table cellspacing="0" cellpadding="0" border="1">
    <tbody>
        <tr>
            <td valign="top" width="115">
            <div>作用域</div>
            </td>
            <td valign="top" width="312">
            <div>功能</div>
            </td>
            <td valign="top" width="132">
            <div>快捷键</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>保存</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+X </div>
            <div>Ctrl+S</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>打印</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+P</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>关闭</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+F4</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>全部保存</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+Shift+S</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>全部关闭</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+Shift+F4</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>属性</div>
            </td>
            <td valign="top" width="132">
            <div>Alt+Enter</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>新建</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+N</div>
            </td>
        </tr>
    </tbody>
</table>
<div><font size="3"></font>&nbsp;</div>
<div><font size="3">项目</font></div>
<table cellspacing="0" cellpadding="0" border="1">
    <tbody>
        <tr>
            <td valign="top" width="115">
            <div>作用域</div>
            </td>
            <td valign="top" width="312">
            <div>功能</div>
            </td>
            <td valign="top" width="132">
            <div>快捷键</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>全部构建</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+B</div>
            </td>
        </tr>
    </tbody>
</table>
<div><font size="3"></font>&nbsp;</div>
<div><font size="3">源代码</font></div>
<table cellspacing="0" cellpadding="0" border="1">
    <tbody>
        <tr>
            <td valign="top" width="115">
            <div>作用域</div>
            </td>
            <td valign="top" width="312">
            <div>功能</div>
            </td>
            <td valign="top" width="132">
            <div>快捷键</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>Java编辑器</div>
            </td>
            <td valign="top" width="312">
            <div>格式化</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+Shift+F</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>Java编辑器</div>
            </td>
            <td valign="top" width="312">
            <div>取消注释</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+\</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>Java编辑器</div>
            </td>
            <td valign="top" width="312">
            <div>注释</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+/</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>Java编辑器</div>
            </td>
            <td valign="top" width="312">
            <div>添加导入</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+Shift+M</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>Java编辑器</div>
            </td>
            <td valign="top" width="312">
            <div>组织导入</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+Shift+O</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>Java编辑器</div>
            </td>
            <td valign="top" width="312">
            <div>使用try/catch块来包围</div>
            </td>
            <td valign="top" width="132">
            <div>未设置，太常用了，所以在这里列出,建议自己设置。<br />
            也可以使用Ctrl+1自动修正。</div>
            </td>
        </tr>
    </tbody>
</table>
<div><font size="3"></font>&nbsp;</div>
<div><font size="3">运行</font></div>
<table cellspacing="0" cellpadding="0" border="1">
    <tbody>
        <tr>
            <td valign="top" width="115">
            <div>作用域</div>
            </td>
            <td valign="top" width="312">
            <div>功能</div>
            </td>
            <td valign="top" width="132">
            <div>快捷键</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>单步返回</div>
            </td>
            <td valign="top" width="132">
            <div>F7</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>单步跳过</div>
            </td>
            <td valign="top" width="132">
            <div>F6</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>单步跳入</div>
            </td>
            <td valign="top" width="132">
            <div>F5</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>单步跳入选择</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+F5</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>调试上次启动</div>
            </td>
            <td valign="top" width="132">
            <div>F11</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>继续</div>
            </td>
            <td valign="top" width="132">
            <div>F8</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>使用过滤器单步执行</div>
            </td>
            <td valign="top" width="132">
            <div>Shift+F5</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>添加/去除断点</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+Shift+B</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>显示</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+D</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>运行上次启动</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+F11</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>运行至行</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+R</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>执行</div>
            </td>
            <td valign="top" width="132">
            <div>Ctrl+U</div>
            </td>
        </tr>
    </tbody>
</table>
<div><font size="3"></font>&nbsp;</div>
<div><font size="3">重构</font></div>
<table cellspacing="0" cellpadding="0" border="1">
    <tbody>
        <tr>
            <td valign="top" width="115">
            <div>作用域</div>
            </td>
            <td valign="top" width="312">
            <div>功能</div>
            </td>
            <td valign="top" width="132">
            <div>快捷键</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>撤销重构</div>
            </td>
            <td valign="top" width="132">
            <div>Alt+Shift+Z</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>抽取方法</div>
            </td>
            <td valign="top" width="132">
            <div>Alt+Shift+M</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>抽取局部变量</div>
            </td>
            <td valign="top" width="132">
            <div>Alt+Shift+L</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>内联</div>
            </td>
            <td valign="top" width="132">
            <div>Alt+Shift+I</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>移动</div>
            </td>
            <td valign="top" width="132">
            <div>Alt+Shift+V</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>重命名</div>
            </td>
            <td valign="top" width="132">
            <div>Alt+Shift+R</div>
            </td>
        </tr>
        <tr>
            <td valign="top" width="115">
            <div>全局</div>
            </td>
            <td valign="top" width="312">
            <div>重做</div>
            </td>
            <td valign="top" width="132">
            <div>Alt+Shift+Y</div>
            </td>
        </tr>
    </tbody>
</table>
&nbsp;
<img src ="http://www.blogjava.net/conans/aggbug/209577.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/conans/" target="_blank">CONAN</a> 2008-06-20 22:56 <a href="http://www.blogjava.net/conans/articles/209577.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item></channel></rss>