有些人或许对构图有天赋。不过，根据美国摄影家维利·奎克的看法，几乎所有的人都能够通过应用一些基本法则，达到具有相当水平的摄影构图能力。为此，他提出了一些简单的方法。他认为，依据这些方法，任何人都能在短时间内学会拍出较好的照片。 

维利·奎克指出，摄影者最易犯的错误是拍摄点取得过高，与被摄体离得太远，致使画面出现各种各样与拍摄目的毫无关系的东西。

他说：“请记住，画家是 把东西画进画面，而摄影者则是从画面去掉一些东西。” 他说：“一张照片应该只有一个趣味中心，画面上不能有无用的东西。如果你对某个物体是否有助于画面抱有怀疑，你就应尽可能地把它放弃掉。” 这里就是人们常说的摄影是“减法的艺术”

奎克认为：“这并不是说，趣味中心非得准确地置于交叉点上不可。正因为如此，实际上趣味中心常出现在交叉点附近。” 

奎克指出：“每一幅照片都应保持一定的平衡。这就是说，对主要被摄体的安排，不能使画、面出现向分量大的一边倾倒。但平衡并不意味着将两个同样大小和同等形状的东西置于对称的位置。这里的关系，只要你看一下在玩跷跷板的孩子就知道了。跷跷板两边的孩子，小些的一个必定坐在离中央远些的地方，而大的孩子肯定坐在靠近中央的地方。” 

奎克认为：“把突出的线条安排，指向趣味中心，是拍摄一幅悦目照片的另一个要素。这些线条被称为主导线，有效地利用主导线，可以创造出惊人的照片。把主导线安排成对角线，会产生有力的动感。 

“线条常常在照片中提供一个边框。这可以通过选择视点来进行，例如在树下通过树枝框住画面上的被摄主体。此时通常使用小光圈，以使整幅照片清晰。这样做，也有可能使边框过于突出，但安排适当，会得到好照片。 
“在一幅照片中，地平线的位置会给人以强烈的印象。拍摄时，地平线要尽量避免处在照片的等比线上，因为这样做会把照片均分为两半，给人以呆板的感觉。 

地平线处在画面下方，会给人以宁静的感觉，而处于上方，给人的感觉则是活泼、有力的。 “此外，横幅画面可以产生安宁、平静的感觉，而竖直画面则会产生动态效果。” 

奎克认为，以上方法如果运用得好，你的照片将会出现明显的改观，而且随着时间的推移，你很快就会学会鉴赏构图，从而为你增添摄影的乐趣。 

Sql的优化原则2：
1、只要能满足你的需求，应尽可能使用更小的数据类型：例如使用MEDIUMINT代替INT
2、尽量把所有的列设置为NOT NULL，如果你要保存NULL，手动去设置它，而不是把它设为默认值。
3、尽量少用VARCHAR、TEXT、BLOB类型
4、如果你的数据只有你所知的少量的几个。最好使用ENUM类型
5、正如graymice所讲的那样，建立索引。
以下是我做的一个实验，可以发现索引能极大地提高查询的效率：

我有一个会员信息表users，里边有37365条用户记录：

在不加索引的时候进行查询：
sql语句A:
select * from users where username like ’%许%’;
在Mysql-Front中的8次查询时长为：1.40,0.54,0.54,0.54,0.53,0.55,0.54 共找到960条记录

sql语句B:
select * from users where username like ’许%’;
在Mysql-Front中的8次查询时长为：0.53,0.53,0.53,0.54,0.53,0.53,0.54,0.54 共找到836条记录

sql语句C:
select * from users where username like ’%许’;
在Mysql-Front中的8次查询时长为：0.51,0.51,0.52,0.52,0.51,0.51,0.52,0.51 共找到7条记录

为username列添加索引:
create index usernameindex on users(username(6));

再次查询：
sql语句A:
select * from users where username like ’%许%’;
在Mysql-Front中的8次查询时长为：0.35,0.34,0.34,0.35,0.34,0.34,0.35,0.34 共找到960条记录

sql语句B:
select * from users where username like ’许%’;
在Mysql-Front中的8次查询时长为：0.06,0.07,0.07,0.07,0.07,0.07,0.06,0.06 共找到836条记录

sql语句C:
select * from users where username like ’%许’;
在Mysql-Front中的8次查询时长为：0.32,0.31,0.31,0.32,0.31,0.32,0.31,0.31 共找到7条记录

在实验过程中，我没有另开任何程序，以上的数据说明在单表查询中，建立索引的可以极大地提高查询速度。
另外要说的是如果建立了索引，对于like ’许%’类型的查询，速度提升是最明显的。因此，我们在写sql语句的时候也尽量采用这种方式查询。

对于多表查询我们的优化原则是：

尽量将索引建立在：left join on/right join on ...　＋条件，的条件语句中所涉及的字段上。

多表查询比单表查询更能体现索引的优势。

6、索引的建立原则：
如果一列的中数据的前缀重复值很少，我们最好就只索引这个前缀。Mysql支持这种索引。我在上面用到的索引方法就是对username最左边的6个字符进行索引。索引越短，占用的

磁盘空间越少，在检索过程中花的时间也越少。这方法可以对最多左255个字符进行索引。

在很多场合，我们可以给建立多列数据建立索引。

索引应该建立在查询条件中进行比较的字段上，而不是建立在我们要找出来并且显示的字段上

7、限制索引的使用的避归。
7.1  IN、OR子句常会使用工作表，使索引失效。
如果不产生大量重复值，可以考虑把子句拆开。拆开的子句中应该包含索引。这句话怎么理解决，请举个例子

例子如下:
如果在fields1和fields2上同时建立了索引，fields1为主索引
以下sql会用到索引
select * from tablename1 where fields1=’value1’ and fields2=’value2’
以下sql不会用到索引
select * from tablename1 where fields1=’value1’ or fields2=’value2’
7.2 使用IS NULL 或IS NOT NULL
         使用IS NULL 或IS NOT NULL同样会限制索引的使用。因为NULL值并没有被定义。在SQL语句中使用NULL会有很多的麻烦。因此建议开     发人员在建表时，把需要索引的列设成NOT NULL。如果被索引的列在某些行中存在NULL值，就不会使用这个索引（除非索引是一个位图索引，关于位图索引在稍后在详细讨论）。

7.3 使用函数
如果不使用基于函数的索引，那么在SQL语句的WHERE子句中对存在索引的列使用函数时，会使优化器忽略掉这些索引。下面的查询不会使用索引（只要它不是基于函数的索引）
   select empno,ename,deptno
          from   emp
          where  trunc(hiredate)='01-MAY-81';
          把上面的语句改成下面的语句，这样就可以通过索引进行查找。
          select empno,ename,deptno
          from   emp
          where  hiredate<(to_date('01-MAY-81')+0.9999);

7.4 比较不匹配的数据类型
比较不匹配的数据类型也是比较难于发现的性能问题之一。注意下面查询的例子，account_number是一个VARCHAR2类型，在account_number字段上有索引。下面的语句将执行全表扫描。
         select bank_name,address,city,state,zip
         from   banks
         where  account_number = 990354;
         Oracle可以自动把where子句变成to_number(account_number)=990354，这样就限制了索引的使用,改成下面的查询就可以使用索引：
         select bank_name,address,city,state,zip
         from   banks
         where  account_number ='990354';
     特别注意：不匹配的数据类型之间比较会让Oracle自动限制索引的使用，即便对这个查询执行Explain Plan也不能让您明白为什么做了一               次“全表扫描”。

补充:
1.索引带来查询上的速度的大大提升,但索引也占用了额外的硬盘空间(当然现在一般硬盘空间不成问题),而且往表中插入新记录时索引也要随着更新这也需要一定时间.
有些表如果经常insert,而较少select,就不用加索引了.不然每次写入数据都要重新改写索引,花费时间;
这个视实际情况而定,通常情况下索引是必需的.
2.我在对查询效率有怀疑的时候,一般是直接用Mysql的Explain来跟踪查询情况.
你用Mysql-Front是通过时长来比较,我觉得如果从查询时扫描字段的次数来比较更精确一些.

//t 是你的表名

现在程序里得到当前时间和3个月前的时间
Date nowDate=new Date();
Date oldDate=new Date();
oldDate.setMonth(oldDate.getMonth()-3);

select * from tab where 日期字段>oldDate and 日期字段<newDate

struts 的核心类是org.apache.struts.action.ActionServlet，这个类将会在struts第一次使用时，
作为servlet初始化并存入tomcat容器。很显然的，初始化将会调用init方法初始化相应的数据。

一、initInternal()方法：
    通过调用MessageResources.getMessageResources(internalName)方法生成一个
    MessageResources类，getMessageResources是通过调用MessageResourcesFactory.
    createResources(config)来实现的。至于MessageResourcesFactory是一个abstract类，任何
    继承自它的类都要实现createResources方法，生成MessageResources对象。整个程序生成
    MessageResourcesFactory使用了如下技巧：
    MessageResourcesFactory.factoryClass = factoryClass;
    MessageResourcesFactory.clazz = null;
    首先会通过factoryClass来定义一个类全名，然后通过ClassLoader.loadClass
    (factoryClass)方法来生成这个类，并赋给clazz，然后通过newInstance来生成一个对象。
    在本程序中，生成MessageResources对象实际就是对如下属性进行了初始化：
    this.factory = factory;("org.apache.struts.util.PropertyMessageResourcesFactory")
    this.config = config;("org.apache.struts.action.ActionResources")
    this.returnNull = returnNull;(true/false)

    对于MessageResources类的作用是根据不同的Locate来格式化相应的string。或者把你需要改变
    的string存放到数组中，然后通过getMessage(Locale locale, String key, Object args[])
    方法来格式化。然后把格式好的string存放到HashMap里，这样就可以为以后重用。这里的key是
    使用的locale.toString() + "." + key

    在PropertyMessageResources中的loadLocale方法用来读取resource的初始化信息。首先它会
    通过一个HashMap检测这个localKey相关的message是否已经被初始化了，如果被初始化过就跳
    出，检测的方法是locales.get(localeKey) != null。
    然后会读取如下一个文件：
    org/apache/struts/action/ActionResources_(localKey).properties，然后进行如下操作：
    Properties props = new Properties();
    ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
    is = classLoader.getResourceAsStream(name);
    props.load(is);
    Iterator names = props.keySet().iterator();
        while (names.hasNext()) {
            String key = (String) names.next();
            if (log.isTraceEnabled()) {
                log.trace("  Saving message key '" + messageKey(localeKey, key));
            }
            messages.put(messageKey(localeKey, key), props.getProperty(key));
    }

    PropertyMessageResources 就是通过上面的loadLocale方法查找与Locale locale, String key
    相对对应的Message.查找的次序如下locale.toString()，然后是
    localeKey = localeKey.substring(0, underscore)，然后是defaultLocale，然后是key。

    最后，resource类的结构如下：
    PropertyMessageResources extends MessageResources
    PropertyMessageResourcesFactory extends MessageResourcesFactory

二、initOther()方法：
    从servlet中获取config和debug两个参数，然后初始化ConvertUtils对象。由于
    ConvertUtils.deregister()的初始化，所有的Converter都是有初始值的，所以这里Struts自己
    把这些初始值设置为null，即转换出错的时候返回null，而不是初始值。使用ConvertUtils类的
    原因是由于从form传输过来的都是String类型的值，所以我们要把它们转换成相应的类型。

    提到几个技巧：
    *public boolean isIndexed() {
         if (type == null) {
             return (false);
         //技巧一：判断是否是一个Array类的方法
         } else if (type.isArray()) {
             return (true);
         //技巧二：判断type是否是List的一个父类或者父接口，或者与List为同一个类
         //要注意如果List是另一个primitive的TYPE类，那么type必须也是这个类才会
         //返回true，否则都是false。注意long.TYPE与Long.class是不同的
         } else if (List.class.isAssignableFrom(type)) {
             return (true);
         } else {
            return (false);
         }
     }

    *//componentType为Array类所存储的元素的类别
     Class componentType = indexedProperty.getClass().getComponentType();
     //生成一个新的Array
     Object newArray = Array.newInstance(componentType, (index + 1));
     System.arraycopy(indexedProperty, 0, newArray, 0, length);
     indexedProperty = newArray;
     set(name, indexedProperty);
     int newLength = Array.getLength(indexedProperty);
     for (int i = length; i < newLength; i++) {
        Array.set(indexedProperty, i, createProperty(name+"["+i+"]", componentType));
     }

三、initServlet()方法：
    这个方法主要是通过digester类解析web.xml，对String servletMapping属性进行初始化。对于
    digester说明如下：这是一个基于DOM的SAX实现的类，它是事件触发的，根据xml文件的结构，
    每次读到一个节点元素就会触发一个事件。

    InputStream input = getServletContext().getResourceAsStream("/WEB-INF/web.xml");
    这是一个比较少见的方法。首先通过this.servletName = getServletConfig().
    getServletName()获取servlet的名称，然后根据
    if (servletName.equals(this.servletName)) {
        this.servletMapping = urlPattern;
    }
    来判断当前读到的servlet名称是否是我们运行的servlet的名称，如果是，就把url-pattern作为
    我们的servletMapping。

四、getServletContext().setAttribute(Globals.ACTION_SERVLET_KEY, this)
    把自己存储到servletContext中，属性名为Globals.ACTION_SERVLET_KEY。

五、ModuleConfig moduleConfig = initModuleConfig("", config)
    这个方法使用由initOther()方法获取的config值为要解析的xml路径，用来初始化ModuleConfig。
    它首先采用与生成MessageResourcesFactory同样的方法产生一个MessageResourcesFactory对象：
    MessageResourcesFactory为一个抽象类，每一个继承它的类都要实现
    createModuleConfig(String prefix)方法。本程序使用的缺省的MessageResourcesFactory类为
    org.apache.struts.config.impl.DefaultModuleConfigFactory，它
    的createModuleConfig(String prefix)方法会生成一个ModuleConfigImpl类。

    ModuleConfigImpl类相当于一个JavaBean，用来存放一个web模块运行时所需要的配置信息。当
    然，一个web模块可以拥有多个ModuleConfig，但是缺省的是prefix长度为0的ModuleConifg。它
    的每个属性几乎都是由HashMap组成的，它通过一个configured布尔值来描述当前的ModuleConfig
    是否已经被初始化完毕，在每存放一个属性的时候都会监测这个值。如果初始化完毕而还要改变
    里面的属性值，则会报出IllegalStateException("Configuration is frozen")异常，现在对它
    的属性简单说明如下：
    * protected HashMap actionConfigs：
      这个HashMap用来存储ActionConfig对象。
    * protected HashMap dataSources
      这个HashMap用来存储DataSourceConfig对象。
    * protected HashMap exceptions
      这个HashMap用来存储ExceptionConfig对象。
    * protected HashMap formBeans
      这个HashMap用来存储FormBeanConfig对象。
    * protected HashMap forwards
      这个HashMap用来存储ForwardConfig对象。
    * protected HashMap messageResources
      这个HashMap用来存储MessageResourcesConfig对象。
    * protected ArrayList plugIns
      这个HashMap用来存储PlugInConfig对象。
    * protected ControllerConfig controllerConfig
      ControllerConfig类
    * protected boolean configured
      标志这个ModuleConfig是(true)否(false)配置完成。
    * protected String prefix
      用来标志和区分ModuleConfig类，同时在使用上面的config类初始化相应的资源以后，也是通
      过这个prefix来区分所属的不同的web模块。
    * protected String actionMappingClass = "org.apache.struts.action.ActionMapping"
      ActionMapping类名，缺省为org.apache.struts.action.ActionMapping。

    初始化ModuleConfig的方法如下：
    首先是使用getServletConfig().getInitParameter("mapping")来获取设定的ActionMapping类
    名，然后通过initConfigDigester()方法来生成一个digester。最后用","分隔config，对每一
    块调用parseModuleConfigFile(prefix, paths, config, digester, path)方法解析。注意，这
    个方法实际上只有两个参数是有意义的：path为我们要解析的xml文件，config用来初始化完成
    后保存到servletContext中。

    如果ModuleConfig中存放的FormBeanConfig为Dydamic类型，那么就调用
    DynaActionFormClass.createDynaActionFormClass(FormBeanConfig)初始化
    DynaActionFormClass，并存放到DynaActionFormClass.dynaClasses 的 static HashMap中。这
    里的key为FormBeanConfig.getName() + moduleConfig.getPrefix()。
   
    如果当前的ModuleConfig为缺省的ModuleConfig，那么将会调用如下几个方法：
    defaultControllerConfig(config)
    defaultMessageResourcesConfig(config)
    defaultFormBeansConfig(config)
    defaultForwardsConfig(config)
    defaultMappingsConfig(config)
    在struts1.1以后，这个特例将会被废弃：

    defaultControllerConfig(config)为ControllerConfig通过getInitParameter(s)方法初始化如
    下几个属性：bufferSize，content，locale(true/false)，maxFileSize，nocache(true/false)
    ，multipartClass，tempDir。

    defaultMessageResourcesConfig(config)为MessageResourcesConfig通过getInitParameter(s)
    方法初始化如下几个属性：application，factory，null(true/false)。

    其它的几个方法就是获取不同的对象，然后把它们相应的存储到servlet中。关心如下：
    ActionFormBeans=>FormBeanConfig，ActionForwards=>ForwardConfig，
    ActionMappings=>ActionConfig。

六、initModuleMessageResources(ModuleConfig config)
    通过存储在ModuleConfig中的MessageResourcesConfig对象，逐个初始化MessageResource，
    然后再把初始化好的MessageResources存放到ServletContext中，attributeName为
    MessageResourcesConfig.getKey() + ModuleConfig.getPrefix()。

七、initModuleDataSources(ModuleConfig config)
    通过存储在ModuleConfig中的DataSourceConfig对象，逐个初始化DataSource。然后对于每一个
    DateSource通过BeanUtils.populate(ds, dscs[i].getProperties())方法初始化其属性。再把初
    始化好的DateSource存放到ServletContext中，attributeName为
    DataSourceConfig.getKey() + ModuleConfig.getPrefix()。同时也存放到名位dataSources的
    FastHashMap中，key为DataSourceConfig.getKey()。

    这里还会根据生成的DateSource对象是否是GenericDataSource类型，如果是则调用
    GenericDataSource.open()方法。GenericDataSource是一个非常简单的数据库连接池，它的
    open()方法用来初始化连接池，生成最小数目的GenericConnection，这里的open()方法根据
    String driver变量是否为null来判断是否已经被初始化过。需要仔细说明的是getConnection()
    方法，它首先从连接池中取出GenericConnection对象，然后检查其是否是可链接的，如果是就
    返回，否则继续取出，同时activeCount-1。如果没有取到，则会检查当前可使用的
    GenericConnection是否达到最大值(activeCount < maxCount)，如果没有，调用
    createConnection()方法声成一个新的GenericConnection，然后检查其是否是可链接，如果可以
    则返回。returnConnection(GenericConnection conn)方法则是通过把GenericConnection放回到
    连接池，然后activeCount-1。

    这个方法中使用到了ServletContextWriter类，DateSource的log信息就通过这个类写入。对这个
    类说明如下：
    它继承自PrintWriter，而PrintWriter又继承自Writer。Writer类所作的事情就是在同步的情况下
    调用abstract方法：abstract public void write(char cbuf[], int off, int len)，这个方法
    将会根据调用者的需要由调用者实现。
    PrintWriter则首先通过ensureOpen()方法检验这个类中是否有写入的对象(Writer类或其子类)，
    如果有则根据不同的情况调用这个写入对象的write方法(out.write(....))。这个类的print(...)
    方法就是据不同的情况调用相应的write(...)方法。而println(...)与之的区别就是每次多写入一
    个换行字符串。还有一个区别是println(...)会根据是否需要autoflush进行flush，而write(...)
    方法不会。
    ServletContextWriter类的作用是把字符写入ServletContext中。ServletContextWriter类方法中
    真正实现了write方法：
    public void write(char c) {
        if (c == '\n')
            flush();
        else if (c != '\r')
            buffer.append(c);
    }
    public void flush() {
        if (buffer.length() > 0) {
            context.log(buffer.toString());
            buffer.setLength(0);
        }
    }

八、initModulePlugIns(moduleConfig)
    通过存储在ModuleConfig中的PlugInConfig对象，逐个初始化PlugIn对象，存放到一个数组中，
    然后再把这个数组存放到ServletContext中，attributeName为
    Globals.PLUG_INS_KEY + ModuleConfig.getPrefix()。

    对每一个生成的PlugIn对象通过
    BeanUtils.populate(plugIns[i], plugInConfigs[i].getProperties())方法初始化其属性。然后
    再把PlugInConfig对象存放到由其生成的PlugIn对象中。

    最后，通过plugIns[i].init(this, (ModuleConfig) config)初始化这个plugIn对象。

九、初始化结束
    完成了这个初始化以后，会调用ModuleConfig.freeze()令这个ModuleConfig变得不可改变。然后
    会遍历ServletConfig中的initParameterNames，如果有以"config/"开头的，则通过这个parameter
    的值继续初始化其它的ModuleConfig，且这个ModuleConfig的prefix为"config/"后的字符串。
   
    同样调用如下方法：
    initModuleMessageResources(moduleConfig);
    initModuleDataSources(moduleConfig);
    initModulePlugIns(moduleConfig);
    moduleConfig.freeze();

    最后调用destroyConfigDigester()释放内存。

二：ActionServlet分析
我们先来看一下使用Struts的配置文件。

action
org.apache.struts.action.ActionServlet

definitions-config
/WEB-INF/tiles-defs.xml,/WEB-INF/tiles-tests-defs.xml,/WEB-INF/tiles-tutorial-defs.xml,
/WEB-INF/tiles-examples-defs.xml

definitions-debug
0

definitions-parser-details
0

definitions-parser-validate
true

config
/WEB-INF/struts-config.xml

config/examples
/WEB-INF/struts-examples-config.xml

config/test
/WEB-INF/struts-tests-config.xml

config/tutorial
/WEB-INF/struts-tutorial-config.xml

validate
true

debug
2

detail
2

application
org.apache.struts.webapp.tiles.dev1-1.ApplicationResources

2

action
*.do

接下来我们来看一下ActionServlet的具体使用
javax.servlet.http.HttpServlet
|
|-->org.apache.struts.action.ActionServlet
所以本质上ActionServlet是一个普通的servlet，负责处理.do为后缀的Http请求.
servlet在执行doGet(),doPost(),之前先调用init(),
以下我们先分析一下init()方法
/**
* Initialize this servlet. Most of the processing has been factored into
* support methods so that you can override particular functionality at a
* fairly granular level.

* servlet初始化操作,注意初始化顺序
* @exception ServletException if we cannot configure ourselves correctly
*/
public void init() throws ServletException {
//注意初始化的顺序
//Initialize our internal MessageResources bundle
initInternal();
//Initialize other global characteristics of the controller servlet
//处理一些全局变量的设置如：debug，detail等
initOther();
//Initialize the servlet mapping under which our controller servlet
//is being accessed. This will be used in the &html:form>
//tag to generate correct destination URLs for form submissions
//主要是注册DTD文件以及解析web.xml关于ActionServlet的配置。如后缀名等.
// Configure the processing rules that we need
// digester.addCallMethod("web-app/servlet-mapping",
// "addServletMapping", 2);
// digester.addCallParam("web-app/servlet-mapping/servlet-name", 0);
// digester.addCallParam("web-app/servlet-mapping/url-pattern", 1);
//initServlet()的上面一段将把Struts默认的后缀名从web.xml中解析得到
//也就是web.xml中的如下配置：
//
//action
//*.do
//默认以.do结尾的请求都将由Struts来处理，你可以自己修改
//
initServlet();

// Initialize modules as needed
//在Attribute中保存类实例
getServletContext().setAttribute(Globals.ACTION_SERVLET_KEY, this);
//根据配置文件生成ModuleConfig,这是很重要的一步.下面会专门分析
//在tiles的配置中先解析注释为"Mark 0"的一个配置文件:/WEB-INF/struts-config.xml
//使用initModuleConfig方法解析XML文件.
//参数为prefix："",paths:"/WEB-INF/struts-config.xml"
ModuleConfig moduleConfig = initModuleConfig("", config);
//初始化Message
initModuleMessageResources(moduleConfig);
//初始化JDBC DataSource
initModuleDataSources(moduleConfig);
//初始化PlunIn
initModulePlugIns(moduleConfig);

moduleConfig.freeze();
//在Struts1.1以后可以使用多个配置文件,在解析完默认的配置文件也就是上面提到的
//注释为"Mark 0"的一个配置文件:/WEB-INF/struts-config.xml后解析其他的配置文件
Enumeration names = getServletConfig().getInitParameterNames();
//依次解析注释为"Mark 1"、"Mark 2"、"Mark 3"对应配置文件
while (names.hasMoreElements()) {
//每一个配置文件的文件名
String name = (String) names.nextElement();
if (!name.startsWith("config/")) {
continue;
}
//
String prefix = name.substring(6);
moduleConfig = initModuleConfig
(prefix, getServletConfig().getInitParameter(name));

initModuleMessageResources(moduleConfig);
initModuleDataSources(moduleConfig);
initModulePlugIns(moduleConfig);
moduleConfig.freeze();
}
destroyConfigDigester();

}
/**
* 此方法使用Digester解析XML,关于使用Digester的介绍参看我的另外一篇文章
*
Initialize the application configuration information for the
* specified module.

*
* @param prefix Module prefix for this module
* @param paths Comma-separated list of context-relative resource path(s)
* for this modules's configuration resource(s)
*
* @exception ServletException if initialization cannot be performed
* @since Struts 1.1
*/
protected ModuleConfig initModuleConfig
(String prefix, String paths) throws ServletException {

if (log.isDebugEnabled()) {
log.debug("Initializing module path '" + prefix +
"' configuration from '" + paths + "'");
}

// Parse the configuration for this module
ModuleConfig config = null;
InputStream input = null;
String mapping = null;
try {
//工厂方法创建ModuleConfig标记为：prefix
ModuleConfigFactory factoryObject =
ModuleConfigFactory.createFactory();
config = factoryObject.createModuleConfig(prefix);

// Support for module-wide ActionMapping type override
mapping = getServletConfig().getInitParameter("mapping");
if (mapping != null) {
config.setActionMappingClass(mapping);
}

// Configure the Digester instance we will use
//得到解析XML的digester
Digester digester = initConfigDigester();

// Process each specified resource path
while (paths.length() > 0) {
//开始解析指定路径文件名的文件
digester.push(config);
String path = null;
//文件是否为多个并且使用","分割
int comma = paths.indexOf(',');
//存在多个配置文件
if (comma >= 0) {
//先解析第一个
path = paths.substring(0, comma).trim();
//paths存放剩余的文件名下次再处理
paths = paths.substring(comma + 1);
} else {
//当前只存在一个
path = paths.trim();
//没有剩余,下次循环根据上面一句将会在唯一的循环退出点"point break"
//退出循环
paths = "";
}
//全部解析完成跳出循环
//point break
if (path.length() < 1) {
break;
}
//根据文件名取文件
URL url = getServletContext().getResource(path);
InputSource is = new InputSource(url.toExternalForm());
input = getServletContext().getResourceAsStream(path);
is.setByteStream(input);
digester.parse(is);
//全局变量的形式把解析生成的ModuleConfig实例保存起来
//如"Mark 1"处标记的"config/examples",
//key为："org.apache.struts.action.MODULEexamples"
//Globals.MODULE_KEY值为:org.apache.struts.action.MODULE
getServletContext().setAttribute
(Globals.MODULE_KEY + prefix, config);
input.close();
}

} catch (Throwable t) {
log.error(internal.getMessage("configParse", paths), t);
throw new UnavailableException
(internal.getMessage("configParse", paths));
} finally {
if (input != null) {
try {
input.close();
} catch (IOException e) {
;
}
}
}

// Force creation and registration of DynaActionFormClass instances
// for all dynamic form beans we wil be using
//根据ModuleConfig实例得到配置的FormBean的配置
//注意：因为在Struts整个运行当中FormBean的实例要在Action的实例创建之前先创建
//因为Action执行perform(1.1以前)，execute（1.1）需要使用到FormBean
FormBeanConfig fbs[] = config.findFormBeanConfigs();
for (int i = 0; i < fbs.length; i++) {
if (fbs[i].getDynamic()) {
DynaActionFormClass.createDynaActionFormClass(fbs[i]);
}
}

// Special handling for the default module (for
// backwards compatibility only, will be removed later)
//下面是生成一些实例
if (prefix.length() < 1) {
defaultControllerConfig(config);
defaultMessageResourcesConfig(config);
defaultFormBeansConfig(config);
defaultForwardsConfig(config);
defaultMappingsConfig(config);
}

// Return the completed configuration object
//config.freeze(); // Now done after plugins init
return (config);

}

到此初始化工作基本结束，下面将处理具体的Http请求。在Servlet协议中所有的post方法将调用
以下方法来处理
public void doPost(HttpServletRequest request,
HttpServletResponse response)
throws IOException, ServletException {}
get方法也调用类似的方法来处理

在Struts中post,get方法都调用同一个方法
process(request, response);来处理具体的请求
如下：
/**
* 对每一个提交过来的Action进行处理
* Perform the standard request processing for this request, and create
* the corresponding response.
*
* @param request The servlet request we are processing
* @param response The servlet response we are creating
*
* @exception IOException if an input/output error occurs
* @exception ServletException if a servlet exception is thrown
*/
protected void process(HttpServletRequest request,
HttpServletResponse response)
throws IOException, ServletException {
//设置或删除Attribute
RequestUtils.selectModule(request, getServletContext());
//具体的处理交给RequestProcessor去处理HttpRequest,HttpResponse
//这是一个很典型的设计模式
//下面我们将详细来分析RequestProcessor，很容易理解Struts的运行方式
getRequestProcessor(getModuleConfig(request)).process(request, response);
}

三:RequestProcessor分析
通过前面的分析我们知道Struts中对HttpRequest,HttpResponse的处理都交给RequestProcessor
的process（）方法来处理。下面我们来看看process方法
/**
*
Process an HttpServletRequest and create the
* corresponding HttpServletResponse.

*
* @param request The servlet request we are processing
* @param response The servlet response we are creating
*
* @exception IOException if an input/output error occurs
* @exception ServletException if a processing exception occurs
*/
public void process(HttpServletRequest request,
HttpServletResponse response)
throws IOException, ServletException {

// Wrap multipart requests with a special wrapper
//如果是upload,返回一个MultipartRequestWrapper()
request = processMultipart(request);

// Identify the path component we will use to select a mapping
//对request进行分析得到提交过来的Form Action
String path = processPath(request, response);
if (path == null) {
return;
}
if (log.isInfoEnabled()) {
log.info("Processing a '" + request.getMethod() +
"' for path '" + path + "'");
}

// Select a Locale for the current user if requested
//本地化处理
processLocale(request, response);

// Set the content type and no-caching headers if requested
processContent(request, response);
//设置Cache不保存
processNoCache(request, response);

// General purpose preprocessing hook
if (!processPreprocess(request, response)) {
return;
}

// Identify the mapping for this request
//得到path以后，根据配置文件(struts-config.xml)的相关配置来得到一个
//ActionMapping的实例
//ActionMapping继承ActionConfig
//仔细看一下ActionMapping的代码就能发现：
//下面的一段将解析影射一个ActionMapping的实例
//在ActionServlet在初始化的时候实际上已经把所有的ActionMapping的实例
//都已经创建好了。processMapping方法实际上是从Attribute中去得到已经
//保存好的ActionMapping的实例，可以理解为在Tomcat启动的时候已经
//把所有的ActionMapping保存在Attribute里面。所以在Tomcat启动的时候
//比较慢，如果Struts-config.xml有问题启动就会出错。
/***

type="org.apache.struts.webapp.tiles.test.TestActionTileAction">

**/
//****注意得到创建实例的顺序
//ActionMapping实例已经创建好了，现在从Atribute中取到
ActionMapping mapping = processMapping(request, response, path);
if (mapping == null) {
return;
}

// Check for any role required to perform this action
if (!processRoles(request, response, mapping)) {
return;
}

// Process any ActionForm bean related to this request
//根据mapping得到ActionForm的实例。
//同名ActionForm在系统中只会创建一次。
ActionForm form = processActionForm(request, response, mapping);
//压栈
processPopulate(request, response, form, mapping);
//处理校验,调用ActionForm的validate方法
//假如出错将会返回到前一页面
//也就是说在Action还没有创建之前就将做校验
if (!processValidate(request, response, form, mapping)) {
return;
}

// Process a forward or include specified by this mapping
if (!processForward(request, response, mapping)) {
return;
}
if (!processInclude(request, response, mapping)) {
return;
}

// Create or acquire the Action instance to process this request
//在得到ActionMapping、ActionForm的实例后接下来得到Action实例
//实例如果已经创建从Map里面去取如果没有创建一个并保存在Map里面
//对保存Action实例的Map 实现线程同步
Action action = processActionCreate(request, response, mapping);
if (action == null) {
return;
}

// Call the Action instance itself
//在ActionMapping、ActionForm、Action实例创建好以后
//调用Action的execute()方法得到一个ActionForward
//因为所有的可执行Action都必须有override Action的execute()/perform()方法
ActionForward forward =
processActionPerform(request, response,
action, form, mapping);

// Process the returned ActionForward instance
//Action已经正常执行，执行结束后将返回到另外一个页面
processActionForward(request, response, forward);

}

仔细阅读上面的代码，要特别注意ActionMapping、ActionForm、Action的实例是依次创建的。
创建完以后才去执行Action的execute()方法。为什么要依次创建ActionMapping、ActionForm
、Action??????

四:ModuleConfig分析
现在我们很有必要了解一下ModuleConfig这个类，因为太多地方用到了。
实际上ModuleConfig是一个接口有一个实现。org.apache.struts.config.impl.ModuleConfigImpl
具体实现我就没有不要去分析了。我们来看看这个接口。

package org.apache.struts.config;

/**
*
The collection of static configuration information that describes a
* Struts-based module. Multiple modules are identified by
* a prefix at the beginning of the context
* relative portion of the request URI. If no module prefix can be
* matched, the default configuration (with a prefix equal to a zero-length
* string) is selected, which is elegantly backwards compatible with the
* previous Struts behavior that only supported one module.

*
* @author Rob Leland
* @version $Revision: 1.2 $ $Date: 2002/12/22 05:31:14 $
* @since Struts 1.1
*/
public interface ModuleConfig {
/**
* Has this module been completely configured yet. Once this flag
* has been set, any attempt to modify the configuration will return an
* IllegalStateException.
*/
boolean getConfigured();

/**
* The controller configuration object for this module.
*/
ControllerConfig getControllerConfig();
/**
* The controller configuration object for this module.
* @param cc The controller configuration object for this module.
*/

void setControllerConfig(ControllerConfig cc);

/**
* The prefix of the context-relative portion of the request URI, used to
* select this configuration versus others supported by the controller
* servlet. A configuration with a prefix of a zero-length String is the
* default configuration for this web module.
*/
String getPrefix();

/**
* The prefix of the context-relative portion of the request URI, used to
* select this configuration versus others supported by the controller
* servlet. A configuration with a prefix of a zero-length String is the
* default configuration for this web module.
*/
public void setPrefix(String prefix);
/**
* The default class name to be used when creating action mapping
* instances.
*/
String getActionMappingClass();
/**
* The default class name to be used when creating action mapping
* instances.
* @param actionMappingClass default class name to be used when creating action mapping
* instances.
*/

void setActionMappingClass(String actionMappingClass);

/**
* Add a new ActionConfig instance to the set associated
* with this module.
*
* @param config The new configuration instance to be added
*
* @exception java.lang.IllegalStateException if this module configuration
* has been frozen
*/
void addActionConfig(ActionConfig config);

/**
* Add a new DataSourceConfig instance to the set associated
* with this module.
*
* @param config The new configuration instance to be added
*
* @exception java.lang.IllegalStateException if this module configuration
* has been frozen
*/
void addDataSourceConfig(DataSourceConfig config);

/**
* Add a new ExceptionConfig instance to the set associated
* with this module.
*
* @param config The new configuration instance to be added
*
* @exception java.lang.IllegalStateException if this module configuration
* has been frozen
*/
void addExceptionConfig(ExceptionConfig config);

/**
* Add a new FormBeanConfig instance to the set associated
* with this module.
*
* @param config The new configuration instance to be added
*
* @exception java.lang.IllegalStateException if this module configuration
* has been frozen
*/
void addFormBeanConfig(FormBeanConfig config);

/**
* Add a new ForwardConfig instance to the set of global
* forwards associated with this module.
*
* @param config The new configuration instance to be added
*
* @exception java.lang.IllegalStateException if this module configuration
* has been frozen
*/
void addForwardConfig(ForwardConfig config);

/**
* Add a new MessageResourcesConfig instance to the set
* associated with this module.
*
* @param config The new configuration instance to be added
*
* @exception IllegalStateException if this module configuration
* has been frozen
*/
void addMessageResourcesConfig(MessageResourcesConfig config);

/**
* Add a newly configured {@link org.apache.struts.config.PlugInConfig} instance to the set of
* plug-in Actions for this module.
*
* @param plugInConfig The new configuration instance to be added
*/
void addPlugInConfig(PlugInConfig plugInConfig);

/**
* Return the action configuration for the specified path, if any;
* otherwise return null.
*
* @param path Path of the action configuration to return
*/
ActionConfig findActionConfig(String path);

/**
* Return the action configurations for this module. If there are
* none, a zero-length array is returned.
*/
ActionConfig[] findActionConfigs();

/**
* Return the data source configuration for the specified key, if any;
* otherwise return null.
*
* @param key Key of the data source configuration to return
*/
DataSourceConfig findDataSourceConfig(String key);

/**
* Return the data source configurations for this module. If there
* are none, a zero-length array is returned.
*/
DataSourceConfig[] findDataSourceConfigs();

/**
* Return the exception configuration for the specified type, if any;
* otherwise return null.
*
* @param type Exception class name to find a configuration for
*/
ExceptionConfig findExceptionConfig(String type);

/**
* Return the exception configurations for this module. If there
* are none, a zero-length array is returned.
*/
ExceptionConfig[] findExceptionConfigs();

/**
* Return the form bean configuration for the specified key, if any;
* otherwise return null.
*
* @param name Name of the form bean configuration to return
*/
FormBeanConfig findFormBeanConfig(String name);

/**
* Return the form bean configurations for this module. If there
* are none, a zero-length array is returned.
*/
FormBeanConfig[] findFormBeanConfigs();

/**
* Return the forward configuration for the specified key, if any;
* otherwise return null.
*
* @param name Name of the forward configuration to return
*/
ForwardConfig findForwardConfig(String name);

/**
* Return the form bean configurations for this module. If there
* are none, a zero-length array is returned.
*/
ForwardConfig[] findForwardConfigs();

/**
* Return the message resources configuration for the specified key,
* if any; otherwise return null.
*
* @param key Key of the data source configuration to return
*/
MessageResourcesConfig findMessageResourcesConfig(String key);

/**
* Return the message resources configurations for this module.
* If there are none, a zero-length array is returned.
*/
MessageResourcesConfig[] findMessageResourcesConfigs();

/**
* Return the configured plug-in actions for this module. If there
* are none, a zero-length array is returned.
*/
PlugInConfig[] findPlugInConfigs();

/**
* Freeze the configuration of this module. After this method
* returns, any attempt to modify the configuration will return
* an IllegalStateException.
*/
void freeze();

/**
* Remove the specified action configuration instance.
*
* @param config ActionConfig instance to be removed
*
* @exception java.lang.IllegalStateException if this module configuration
* has been frozen
*/
void removeActionConfig(ActionConfig config);

/**
* Remove the specified exception configuration instance.
*
* @param config ActionConfig instance to be removed
*
* @exception java.lang.IllegalStateException if this module configuration
* has been frozen
*/
void removeExceptionConfig(ExceptionConfig config);

/**
* Remove the specified data source configuration instance.
*
* @param config DataSourceConfig instance to be removed
*
* @exception java.lang.IllegalStateException if this module configuration
* has been frozen
*/
void removeDataSourceConfig(DataSourceConfig config);

/**
* Remove the specified form bean configuration instance.
*
* @param config FormBeanConfig instance to be removed
*
* @exception java.lang.IllegalStateException if this module configuration
* has been frozen
*/
void removeFormBeanConfig(FormBeanConfig config);

/**
* Remove the specified forward configuration instance.
*
* @param config ForwardConfig instance to be removed
*
* @exception java.lang.IllegalStateException if this module configuration
* has been frozen
*/
void removeForwardConfig(ForwardConfig config);

/**
* Remove the specified message resources configuration instance.
*
* @param config MessageResourcesConfig instance to be removed
*
* @exception java.lang.IllegalStateException if this module configuration
* has been frozen
*/
void removeMessageResourcesConfig(MessageResourcesConfig config);
}

上面的注释已经非常清晰了。我就不去浪费大家的时间了，再想仔细看就去看他的实现。
其实主要是对HashMap()的处理。

五：ActionMapping分析
最后我们实现很有必要看一下ActionMapping,因为你如果想清楚的了解Struts-config.xml
这个配置文件的作用，你应该要知道ActionMapping
前面已经说过ActionMapping继承ActionConfig
以下就是ActionMapping加的四个方法。
/**
*
Find and return the ExceptionConfig instance defining
* how exceptions of the specified type should be handled. This is
* performed by checking local and then global configurations for the
* specified exception's class, and then looking up the superclass chain
* (again checking local and then global configurations). If no handler
* configuration can be found, return null.

*
* @param type Exception class for which to find a handler
* @since Struts 1.1
*/
public ExceptionConfig findException(Class type) {

}

/**
*
Find and return the ForwardConfig instance defining
* how forwarding to the specified logical name should be handled. This is
* performed by checking local and then global configurations for the
* specified forwarding configuration. If no forwarding configuration
* can be found, return null.

*
* @param name Logical name of the forwarding instance to be returned
*/
public ActionForward findForward(String name) {

}

/**
*
Return the logical names of all locally defined forwards for this
* mapping. If there are no such forwards, a zero-length array
* is returned.
*/
public String[] findForwards() {
}

/**
*

Create (if necessary) and return an {@link ActionForward} that
* corresponds to the input property of this Action.
*
* @since Struts 1.1b2
*/
public ActionForward getInputForward() {

}

还是看以下他的基类ActionConfig吧
public class ActionConfig implements Serializable {

/**
* Has configuration of this component been completed?
*/
protected boolean configured = false;

/**
* The set of exception handling configurations for this
* action, if any, keyed by the type property.
*/
protected HashMap exceptions = new HashMap();

/**
* The set of local forward configurations for this action, if any,
* keyed by the name property.
*/
protected HashMap forwards = new HashMap();

/**
* The module configuration with which we are associated.
*/
protected ModuleConfig moduleConfig = null;

/**
* The request-scope or session-scope attribute name under which our
* form bean is accessed, if it is different from the form bean's
* specified name.
*/
protected String attribute = null;

/**
* Context-relative path of the web application resource that will process
* this request via RequestDispatcher.forward(), instead of instantiating
* and calling the Action class specified by "type".
* Exactly one of forward, include, or
* type must be specified.
*/
protected String forward = null;

/**
* Context-relative path of the web application resource that will process
* this request via RequestDispatcher.include(), instead of instantiating
* and calling the Action class specified by "type".
* Exactly one of forward, include, or
* type must be specified.
*/
protected String include = null;

/**
* Context-relative path of the input form to which control should be
* returned if a validation error is encountered. Required if "name"
* is specified and the input bean returns validation errors.
*/
protected String input = null;

/**
* Fully qualified Java class name of the
* MultipartRequestHandler implementation class used to
* process multi-part request data for this Action.
*/
protected String multipartClass = null;

/**
* Name of the form bean, if any, associated with this Action.
*/
protected String name = null;

/**
* General purpose configuration parameter that can be used to pass
* extra iunformation to the Action instance selected by this Action.
* Struts does not itself use this value in any way.
*/
protected String parameter = null;

/**
* Context-relative path of the submitted request, starting with a
* slash ("/") character, and omitting any filename extension if
* extension mapping is being used.
*/
protected String path = null;

/**
* Prefix used to match request parameter names to form ben property
* names, if any.
*/
protected String prefix = null;

/**
* Comma-delimited list of security role names allowed to request
* this Action.
*/
protected String roles = null;

/**
* Identifier of the scope ("request" or "session") within which
* our form bean is accessed, if any.
*/
protected String scope = "session";

/**
* Suffix used to match request parameter names to form bean property
* names, if any.
*/
protected String suffix = null;

/**
* Fully qualified Java class name of the Action class
* to be used to process requests for this mapping if the
* forward and include properties are not set.
* Exactly one of forward, include, or
* type must be specified.
*/
protected String type = null;

/**
* Should the validate() method of the form bean associated
* with this action be called?
*/
protected boolean validate = true;
}

其实ActionConfig是一个很典型的ValueObject.所以其他的get/set方法我就不写出来了。
看这个代码一定要和struts-config.xml一起来看，根据struts-config.xml去找找
每一段配置文件最终要生成一个ActionConfig,他们之间的对应关系。
如果你想扩展Struts,ActionMapping估计你一定要修改。还有ActionServlet你也要修改。

六：结束语
分析了一些代码下面做一些概述。先来整体的了解一下Struts的工作流程.
在实现一个基于Struts的运用之前我们首先是做环境设置，Struts正常工作需要至少两个
配置文件web.xml,struts-config.xml.
web.xml告诉App Server所有以.do结尾的请求最终提交给ActionServlet去处理。
2就规定ActionServlet是在App Server启动的时候
创建的并且一直存在。
ActionServlet在创建的时候会做如下的工作：
保存一些后面需要使用的实例在Attribute(内存)里面。
根据web.xml的配置解析struts-config.xml文件。
根据struts-config.xml的配置生成ActionMapping实例并且保存。

ActionServlet在生命周期就一直等待Http 请求
每一个.do结尾的Http 请求都由ActionServlet先截获然后根据请求路径得到具体调用那
一个Action去处理，在这之前生成、处理ActionForm。具体知道那一个Action去处理请求
后调用Action的execute()/perform()处理完成，返回。

Author：sungo
Date：2004/06/16 (三)

◎閱讀說明：冒號 ( : )後的藍色標註熱鍵為Eclipse預設的標準熱鍵，空
白即表示Eclipse並未對該項目設熱鍵；紅色標註選項表示常用或重要熱
鍵；淡粉紅色標註選項，表示可以啟動該熱鍵的範圍。

◎熱鍵修改處：
Window->Preference->Workbench->Keys

◎FAQ，如果沒設熱鍵的功能要如何啟動？
方法一.自己增設熱鍵。
方法二.熱鍵設定裡的選項，其實功能表大部分都有，可以由功能表中直接點選。

◎給所有在看這篇文章的朋友：
T55555為了JavaWorld週年慶把DG2拿出來了，為了效法他的精神，所以我決定把
我的第一次也貢獻出來，加入JavaWorld這半年來我第一次打這麼長的文章...XD
。本來打算3.0 Release出來後再整理熱鍵表，但3.0 RC系列架構已經趨於平穩，
Release出來也不會有多大的變動，所以就先整理了。熱鍵表所列的功能，只要您
全部實際操作過一遍，將會為您在操作Eclipse上，帶來莫大的助益。

-------------------------------------------------------------------------------------------------------------

Compare - 比較
Copy All from Left to Right (由左向右複製全部)
Copy All from Right to Left (由右向左複製全部)
Copy from Left to Right (由左向右複製)
Copy from Right to Left (由右向左複製)
Select Next Change (選取下一個變更)
Select Previous Change (選取上一個變更)

CVS - Concurrent Versions System (版本控制系統)
Checkout from CVS (由CVS檢查)

Edit - 編輯
Add Bookmark (新增書籤)
Add Task (新增作業)
Collapse (程式碼折疊) ： Ctrl+鍵盤右方數字區的'-' <Editing Text>
Content Assist (內容輔助 - Code Templetes啟動)： Alt+/ 或 Ctrl+Space <In Dialogs and Windows>
Context Information (內容資訊) ： Alt+？ 或 ALT+Shift+？或 Ctrl+Shift+Space <In Windows>
Copy (複製選取文字到OS剪貼簿) ： Ctrl+C <In Dialogs and Windows>
Custom Encoding (自訂編碼)
Cut (剪下選取文字並加至OS剪貼簿) ： Ctrl+X <In Dialogs and Windows>
Default Encoding (使用預設編碼)
Delete (刪除選取的文字) ： Delete <In Windows>
Expand (程式碼展開) ： Ctrl+鍵盤右方數字區的'+' <Editing Text>
Expand All (程式碼全部展開) ： Ctrl+鍵盤右方數字區的'*' <Editing Text>
Find and Replace (尋找並取代文字) ： Ctrl+F <In Windows>
Find Next (尋找下一個項目) ： Ctrl+K <Editing Text>
Find Previous (尋找上一個項目) ： Ctrl+Shift+K <Editing Text>
Incremental Find (漸進式尋找) ： Ctrl+J <Editing Text>
Incremental Find Reverse (逆向漸進式尋找) ： Ctrl+Shift+J <Editing Text>
ISO-8859-1 Encoding (將編碼變更為 ISO-8859-1)
Paste (從OS剪貼簿貼上文字) ： Ctrl+V <In Dialogs and Windows>
Quick Diff Toggle (QuickDiff 開啟/關閉) ： Ctrl+Shift+Q <Editing Text>
Quick Fix (快速套件修正) ： Ctrl+1 <Editing Java Source>
Redo (重做上一次作業) ： Ctrl+Y <In Windows>
Restore Last Selection (恢復最後選取) ： Alt+Shift+方向鍵'↓' <Editing Java Source>
Revert to Saved (回復至已儲存)
Select All (選擇全部文字) ： Ctrl+A <In Dialogs and Windows>
Select Enclosing Element ： (選取含括的元素) Alt+Shift+方向鍵'↑' <Editing Java Source>
Select Next Element (選取下一個元素) ： Alt+Shift+方向鍵'→' <Editing Java Source>
Select Previous Element (選取上一個元素) ： Alt+Shift+方向鍵'←' <Editing Java Source>
Shift Left (將該行文字往左移動一個縮排)
Shift Right (將該行文字往右移動一個縮排)
Show Tooltip Description (在游標位置顯示元素的工具提示說明) ： F2 <Editing Java Source>
System Encoding (將編碼變更為系統編碼)
Toggle Folding (程式碼折疊、展開功能 開啟/關閉) ： Ctrl+鍵盤右方數字區的'/' <Editing Text>
Toggle Insert Model (Smart Insert模式 開啟/關閉) ： Ctrl+Shift+Insert <Editing Text>
Undo (復原前次作業) ： Ctrl+Z <In Windows>
US ASCII Encoding (將編碼變更為 ASCII)
UTF-16BE Encoding (將編碼變更為 UTF-16BE)
UTF-16 Encoding (將編碼變更為 UTF-16)
UTF-16LE Encoding (將編碼變更為 UTF-16LE)
UTF-8 Encoding (將編碼變更為 UTF-8)

File - 檔案
Close (關閉檔案) ： Ctrl+W 或 Ctrl+F4 <In Windows>
Close All (關閉全部檔案) ： Ctrl+Shift+W 或 Ctrl+Shift+F4 <In Windows>
Exit (關閉螢幕最上層視窗) ： Alt+F4 <In Dialogs and Windows>   0
(註：3.0RC2並沒預設這組熱鍵，但仍然可以使用。)

Export (開啟匯出功能表)
Import (開啟匯入功能表)
Move (移動檔案)
New (開啟檔案建立精靈Wizard) ： Ctrl+N <In Windows>
New menu (顯示File->New選單) ： ALT+Shift+N <In Windows>
Open External File (開啟外部檔案)
Open Workspace (開啟Workspace設定視窗)
Print (列印檔案) ： Ctrl+P <In Windows>
Properties (org.eclipse.ui.file.properties) (顯示檔案內容) ： Alt+Enter <In Windows>
Refresh (重新整理) ： F5 <In Windows>
Rename (重新命名) ： F2 <In Windows>
Revert (回復至已儲存)
Save (儲存檔案) ： Ctrl+S <In Windows>
Save All (儲存全部檔案) ： Ctrl+Shift+S <In Windows>
Save As (另存新檔)

Help - 說明
About (開啟關於對話框)
Help Contents (開啟Eclipse說明文件)
Tips and Tricks (開啟要訣和技巧說明頁面)
Weclome (開啟歡迎使用頁面)

Navigate - 導覽
Back (向後導覽)
Backward History (在編輯器導覽歷程中向後移動) ： Alt+方向鍵'←' <In Windows>
Forward (向前導覽)
Forward History (在編輯器導覽歷程中向前移動) ： Alt+方向鍵'→' <In Windows>
Go Into (進入選取的目錄內)
Go to Line (移至某一行文字) ： Ctrl+L <Editing Text>
Go to Matching Bracket (將游標移至對稱的方括弧) ： Ctrl+Shift+P <Editing Java Source>
Go to Next Member (移至下一個Member) ： Ctrl+Shift+方向鍵'↓' <Editing Java Source>
Go to Package (移至套件，用於Package Explorer)
Go to Previous Member (移至上一個Member) ： Ctrl+Shift+方向鍵'↑' <Editing Java Source>
Go to Resource (移至資源)
Go to Type (移至類別，用於Package Explorer)
Last Edit Loaction (移至前次編輯位置) ： Ctrl+Q <In Windows>
Next (移至下一個標示元素) ： Ctrl+. <In Windows>
(註：元素類型可由Toolbar的Next Annotation小倒三角圖示設定。)

Open Call Hierarchy (開啟Call Hierarchy視窗) ： Ctrl+Alt+H <In Windows>
Open Declaration (瀏覽所選取的Java元素) ： F3 <In Windows> (註：效果等於Ctrl+滑鼠左鍵點選。)
Open External Javadoc (開啟外部Javadoc) ： Shift+F2 <In Windows>
Open Resource (開啟資源選取對話方塊) ： Ctrl+Shift+R <In Windows>
Open Structure (顯示所選元素的結構) ： Ctrl+F3 <Editing Java Source>
Open Super Implementation (開啟super類型中的實作)
Open Type (開啟類別) ： Ctrl+Shift+T <In Windows>
Open Type Hierarchy (開啟類別階層顯示視窗) ： F4 <In Windows>
Open Type in Hierarchy (在類別階層的視圖中開啟類別) ： Ctrl+Shift+H <In Windows>
Previous (移至上一個標示元素) ： Ctrl+, <In Windows>
(註：元素類型可由Toolbar的Previous Annotation小倒三角圖示設定。)

Quick Hierarchy (以浮動方式將類別階層視窗顯示在編輯器上) ： Ctrl+T <Editing Java Source>
Quick Outline (以浮動方式將概要視窗顯示在編輯器上) ： Ctrl+O <Editing Java Source>
Show In menu (顯示當前Show In功能表可用的選項) ： Alt+Shift+W <In Windows>
Show in Package Explorer (在套件瀏覽器中顯示所選元素)
Up (導覽上一層)

Project - 專案
Build All (建置所有專案) ： Ctrl+B <In Windows>
Build Clean (清除專案)
Build Project (建置專案)
Close Project (關閉專案)
Generate Javadoc (產生Javadoc)
Open Project (開啟專案)
Properties (org.eclipse.ui.project.properties) (開啟專案屬性設定視窗)
Rebuild All (重新建置所有專案)
Rebuild Project (重新建置專案)
Repeat Working Set Build (重複建置所設定的專案) (註：Build Automatically 關閉時才可使用。)

Refactor - Java (重構 - Java)
Change Method Signature (變更方法簽章) ： Alt+Shift+C <In Windows>
Convert Anonymous Class to Nested (將匿名類別轉換成巢狀類別)
Convert Local Variable to Field (將區域變數轉換成欄位) ： Alt+Shift+F <Editing Java Source>
Encapsulate Field (封裝欄位：為欄位建立getting和setting方法，並只用這些方法來存取欄位)
Extract Constant (擷取成常數：將數字擷取至新的Static欄位，並使用新的Static欄位)

註：<-START->

如下段程式碼經由Extract Constant重構數字10後...
12345
 public class Test {
    public static void main(String[] args) {
        int x = 10;
    }
}

 
會變成下列程式碼：(常數欄位名稱，在重構時可以自由設定。)123456
 public class Test {
    public static final int TEN = 10;
    public static void main(String[] args) {
        int x = TEN;
    }
}

 
註：<-END->

Extract Interface (擷取成介面：將原類別內的方法擷取至新介面中，原類別將實作該介面)
(註：新介面會存成一個新的*.java檔。若是在interface中執行此功能，舊介面則會繼承新介面。)
Extract Local Variable (擷取成區域變數：將數字擷取為新的區域變數) ： Alt+Shift+L <In Windows>
Extract Method (擷取成方法：將選取的表示式擷取成一個新方法) ： Alt+Shift+M <In Windows>
Generalize Type (將reference的類別型態更改可以取代的Superclass)
Inline (列入常數、區域變數或方法) ： Alt+Shift+I <In Windows>
Introduce Factory (採用代理：利用方法來取得建構子)

註：<-START->

如下段程式碼經由Introduce Factory重構Test建構子後...
123456789
 public class Test {
    private int number;
    Test(int x) {
        number = x;
    }
    public static void main(String[] args) {
        System.out.println(new Test(5).number);
    }
}

 
會變成下列程式碼：123456789101112
 public class Test {
    private int number;
    public Test(int x) {
        number = x;
    }
    public static void main(String[] args) {
        System.out.println(createTest(5).number);
    }
    public static Test createTest(int x) {
        return new Test(x);
    }
}

 
註：<-END->

Introduce Parameter (採用參數：將區域變數改成參數方式傳遞)

註：<-START->

如下段程式碼經由Introduce Parameter重構數字5後...
12345
 public class Test {
    public static void main(String[] args) {
        int x = 5;
    }
}

 
會變成下列程式碼：12345
 public class Test {
    public static void main(String[] args, int five) {
        int x = five;
    }
}

 
註：<-END->

Move Member Type to New File (將類別成員移至一個新檔)
Move - Refactoring (移動 - 重構：將所選取的元素移至新位置) ： Alt+Shift+V <In Windows>
Pull Up (將類別成員<欄位與方法>上推到類別的父類別中)
Push Down (將類別成員(欄位與方法)下推到類別的子類別中)
Redo - Refactoring (重做 - 重構：重做前次的重構) ： Alt+Shift+Y <In Windows>
Refactor Quick Menu (在編輯區顯示重構的快速功能表) ： Alt+Shift+T <In Windows>
Rename - Refactoring (更名 - 重構：將所選取的元素重新命名，類別名稱、區域變數名稱等...) ：
Alt+Shift+R <In Windows>
Undo - Refactoring (復原 - 重構：復原前次的重構) ： Alt+Shift+Z <In Windows>
Use Supertype Where Possible (啟動「適當時使用父類別」重構對話框。)

◎補充命名規則：(重構時不照此規則命名時，Eclipse將會警示，
雖然可以不管警示，但這是個好風格。)

1.介面(interface)名稱：開頭大寫。
2.區域變數(Local Variable)名稱：開頭小寫 。
3.常數欄位(public static final int...)名稱：全部大寫。

Run/Debug - 執行/除錯
Add Class Load Breakpoint (新增一個類別載入中斷點))
Add Java Exception Breakpoint (新增一個Java異常狀況中斷點)
Debug... (開啟除錯啟動配置對話框)
Debug Last Launched (開啟最近一次啟動作業的除錯模式) ： F11 <In Windows>
Display (org.eclipse.jdt.debug.ui.commands.Display) (顯示) ： Ctrl+Shift+D <In Windows>
(註：當執行緒暫停時，此指令會使用「顯示」檢視畫面，顯示在該執行緒之堆疊框或變數的環境定義下
，評估所選表示式的結果。)

Execute (執行：開啟執行啟動配置對話框) ： Ctrl+U <In Windows>
Inspect (觀察)： Ctrl+Shift+I <In Windows>
(註：當執行緒暫停時，此指令會使用「表示式」檢視畫面，顯示在該執行緒之堆疊框或變數的環境定義
下，視察所選表示式或變數的結果。)

Profile Last Launched (最近一次作業的概況)
Resume (繼續執行緒的執行) ： F8 <Debugging>
Run Last Launched (在執行模式下迅速執行最近一次的啟動作業)： Ctrl+F11 <In Windows>
Run Last Launched External Tool (執行前一次啟動的外部工具)
Run to Line (執行至指定行，可在沒有設定中斷點之處暫停執行) ： Ctrl+R <Debugging>
Skip All Breakpoints (在不清除中斷點的情況下，執行時跳過所有的中斷點)
Step Into (進入副程序) ： F5 <Debugging>
Step Into Selection (進入目前所選的陳述式進行副程序除錯) ： Ctrl+F5 <Debugging>
Step Over (跳過副程序) ： F6 <Debugging>
Step Return (跳出副程序)： F7 <Debugging>
Suspend (暫停執行緒)
Terminate (終止執行緒)
Toggle Breakpoint (新增/移除，中斷點) ： Ctrl+Shift+B <In Windows>
Toggle Method Breakpoint (新增/移除，方法中斷點)
Toggle Step Filters (以過濾條件逐步除錯) ： Shift+F5 <In Windows>
Toggle Watchpoint (新增/移除，欄位的監視點)

Search - 搜索
Declaration in Hierarchy (在它的階層中搜尋所選元素的宣告)
Declaration in Project (在專案中搜尋所選元素的宣告)
Declaration in Working Set (在工作集中搜尋所選元素的宣告)
Declaration in Workspace (在工作區中搜尋所選元素的宣告) ： Ctrl+G <In Windows>
Exception Occurrences (搜索例外事件)
File Search (開啟搜尋對話框的檔案搜尋頁面)
Implementors in Project (在專案中搜尋所選介面的實作者)
Implementors in Working Set (在工作集中搜尋所選介面的實作者)
Implementors in Workspace (在工作區中搜尋所選介面的實作者)
Occurrences in File (在它的宣告檔案中搜尋所選元素的所有出現處) ： Ctrl+Shift+U <In Windows>
Open Search Dialog (開啟搜尋對話框) ： Ctrl+H <In Windows>
Read Access in Hierarchy (在它的階層中搜尋所選元素的讀取參考)
Read Access in Project (在專案中搜尋所選元素的讀取參考)
Read Access in Working Set (在工作集中搜尋所選元素的讀取參考)
Read Access in Workspace (在工作區中搜尋所選元素的讀取參考)
References in Hierarchy (在它的階層中搜尋所選元素的參考)
References in Project (在專案中搜尋所選元素的參考)
References in Working Set (在工作集中搜尋所選元素的參考)
References in Workspace (在工作區中搜尋所選元素的參考) ： Ctrl+Shift+G <In Windows>
Referring Tests (查詢測試)
Write Access in Hierarchy (在它的階層中搜尋所選元素的寫入參考)
Write Access in Project (在專案中搜尋所選元素的寫入參考)
Write Access in Working Set (在工作集中搜尋所選元素的寫入參考)
Write Access in Workspace (在工作區中搜尋所選元素的寫入參考)

Source - 程式碼
Add Block Comment (將選取的字行以多行註解/**/包起來) ： Ctrl+Shift+/ <Editing Java Source>
Add Constructors from Superclass (從父類別增加一個建構子)
Add Import (為目前所選的類別參考建立一項匯入宣告) ： Ctrl+Shift+M <Editing Java Source>
Add Javadoc Comment (新增Javadoc註解) ： Alt+Shift+J <In Windows>
Comment (註解)
Externalize Strings (開啟「外部化字串」精靈)
Find Strings to Externalize (尋找要外部化的字串)
Format (程式碼自動排版) ： Ctrl+Shift+F <Editing Java Source>
Format Element (格式化元素)
Generate Constructor using Fields (使用欄位來產生建構子)

註：<-START->

如下段程式碼，選取欄位名稱money並經由Generate Constructor using Fields指令後...
12345
 public class Test {
    int money;
    public static void main(String[] args) {
    }
}

 
會變成下列程式碼：12345678
 public class Test {
    int money;
    public Test(int money) {
        this.money = money;
    }
    public static void main(String[] args) {
    }
}

 
註：<-END->

Generate Delegate Methods (開啟「產生委派方法」對話框，可新增類型欄位的委派方法)
Generate Getters and Setters (開啟「產生Getter與Setter」對話框，可以為欄位自動
建立Getter和Setter方法)
Indent Line (單行縮排，其會遵照Formatter設定的格式) ： Ctrl+I <Editing Java Source>
Mark Occurrences (標註事件)： Alt+Shift+O <Editing Java Source>
Organize Imports (組織匯入) ： Ctrl+Shift+O <In Windows>
(註：這是個很方便的功能，簡易說明一下使用時機：假設我們在程式中打，JFrame src;而並未
import任何swing類別，此時Eclipse便會出現錯誤警示，用紅底線將JFrame標起來，此時只要按
下Ctrl+Shift+O，Eclipse便會自動將：import javax.swing.JFrame;加到程式碼中了。)

Override/Implement Methods (開啟「覆寫/實作方法」對話框，可覆寫或實作現行類別中的方法)
Remove Block Comment (移除多行註解/**/) ： Ctrl+Shift+\ <Editing Java Source>
Remove Occurrence Annotations (移除事件書籤)： Alt+Shift+U <Editing Java Source>
Sort Members (排序成員)
Source Quick Menu (在編輯區顯示Source的快速功能表) ： Alt+Shift+S <In Windows>
Surround with try/catch Block (以try/catch區塊包覆所選文字)
Toggle Comment (加上單行註解/取消單行註解) ： Ctrl+/ 或 Ctrl+7 或 Ctrl+Shift+C
<Editing Java Source>
Uncomment (取消註解)

◎補充，Source 隱藏熱鍵：
1.Shift Right (向右移位，增加目前所選字行的內縮層次) ： Tab <Editing Java Source>
2.Shift Left (向左移位，減少目前所選字行的內縮層次) ： Shift+Tab <Editing Java Source>

Team - 團隊
Synchronize (同步化)

Text Editing - 文字編輯
Claer Mark (清除標記)
Copy Lines (將選取的文字，複製成新行) ： Ctrl+Alt+方向鍵'↓' <Editing Text>
Cut Line (剪下單行文字)
Cut to Beginning of Line (剪下文字，範圍為選取處至單行開頭)
Cut to End of Line (剪下文字，範圍為選取處至單行尾端)
Delete Line (刪除單行文字) ： Ctrl+D <Editing Text>
Delete Next (刪除下一行)
Delete Next Word (刪除下一個字組) ： Ctrl+Delete <Editing Text>
Delete Previous (刪除前一行)
Delete Previous Word (刪除前一個字組) ： Ctrl+Backspace <Editing Text>
Delete to Beginning of Line (刪除文字，範圍為選取處至單行開頭)
Delete to End of Line (刪除文字，範圍為選取處至單行尾端)
Duplicate Lines (將選取的文字，複製成新行) ： Ctrl+Alt+方向鍵'↑' <Editing Text>
Insert Line Above Current Line (在游標處的該行上方插入新行) ： Ctrl+Shift+Enter <Editing Text>
Insert Line Below Current Line (在游標處的該行下方插入新行) ： Shift+Enter <Editing Text>
Line Down (游標往下移一行)
Line End (游標移至該行尾端)
Line Start (游標移至該行開頭)
Line Up (游標往上移一行)
Move Lines Down (將該行文字往下移動) ： Alt+方向鍵'↓' <Editing Text>
Move Lines Up (將該行文字往上移動) ： Alt+方向鍵'↑' <Editing Text>
Next Column (游標移至下一列)
Next Word (游標移至下一個字組) ： Ctrl+方向鍵'→' <Editing Text>
Page Down (移至下一頁)
Page Up (移至上一頁)
Previous Column (游標移至上一列)
Previous Word (游標移至上一個字組) ： Ctrl+方向鍵'←' <Editing Text>
Scroll Line Down (向下捲動) ： Ctrl+方向鍵'↓' <Editing Text>
Scroll Line Up (向上捲動) ： Ctrl+方向鍵'↑' <Editing Text>
Select Line Down (選取下一行)
Select Line End (選取至文字尾端)
Select Line Start (選取至文字開頭)
Select Line Up (選取上一行)
Select Next Column (選取下一列)
Select Next Word (選取下一個字組)： Ctrl+Shift+方向鍵'→' <Editing Text>
Select Page Down (選取下一頁)
Select Page Up (選取上一頁)
Select Previous Column (選取上一列)
Select Previous Word (選取前一個字組) ： Ctrl+Shift+方向鍵'←' <Editing Text>
Select Text End (選取至文字編輯器尾端)
Select Text Start (選取至文字編輯器開頭)
Select Window End (選取至視窗尾端)
Select Window Start (選取至視窗開頭)
Set Mark (設定標記)
Swap Mark (交換標記)
Text End (游標移至文字編輯器最底端)
Text Start (游標移至文字編輯器最頂端)
Toggle Overwrite (覆寫/插入 模式選擇) ： Insert <Editing Text>
To Lower Case (將選取的英文字轉為小寫) ： Ctrl+Shift+Y <Editing Text>
To Upper Case (將選取的英文字轉為大寫) ： Ctrl+Shift+X <Editing Text>
Window End (將游標移至視窗尾端)
Window Start (將游標移至視窗開頭)

Views - 檢視
Ant (開啟Ant檢視視窗)
Bookmarks (開啟書籤檢視視窗)
Breakpoints (開啟中斷點檢視視窗)
Classic Search (開啟傳統的搜索檢視視窗)
Console (開啟主控台檢視視窗)
CVS Annotate (開啟CVS Annotate檢視視窗)
CVS Editors (開啟CVS Editor檢視視窗)
CVS Repositories (開啟CVS Repositories檢視視窗)
CVS Resource History (開啟CVS Resource History檢視視窗)
Debug (開啟除錯檢視視窗)
Display (org.eclipse.jdt.debug.ui.DisplayView) (開啟除錯-顯示檢視視窗)
Error Log (開啟錯誤記錄檢視視窗)
Expressions (開啟除錯-表示式檢視視窗)
Java Call Hierarchy (開啟Call Hierarchy檢視視窗)
Java Declaration (開啟宣告檢視視窗)
Javadoc (開啟Javadoc檢視視窗)
Java Members (開啟類別成員檢視視窗)
Java Package Explorer (開啟套件瀏覽器) ： Alt+Shift+Q,P <In Windows>
Java Packages (開啟Java套件檢視視窗)
Java Projects (開啟Java專案檢視視窗)
Java Type Hierarchy (開啟類別階層檢視視窗) ： Alt+Shift+Q,T <In Windows>
Java Types (開啟Java類別檢視視窗)
JUnit (開啟JUnit檢視視窗)
Memory (開啟除錯-記憶體檢視視窗)
Navigator (開啟導覽器)
Outline (開啟概要檢視視窗) ： Alt+Shift+Q,O <In Windows>
Plug-in Dependencies (開啟Plug-in Dependencies檢視視窗)
Plug-in Registry (開啟Plug-in Registry檢視視窗)
Plug-ins (開啟Plug-ins檢視視窗)
Problems (開啟問題檢視視窗) ： Alt+Shift+Q,X <In Windows>
Progress (開啟執行進度檢視視窗)
Properties (org.eclipse.ui.views.Property/Sheet) (開啟屬性檢視視窗)
Registers (開啟除錯-暫存器檢視視窗)
Search (開啟搜索檢視視窗) ： Alt+Shift+Q,S <In Windows>
Synchronize (開啟同步化檢視視窗) ： Alt+Shift+Q,Y <In Windows>
Tasks (開啟作業檢視視窗)
Threads and Monitors (開啟除錯-執行緒檢視視窗)
Variables (開啟除錯-變數檢視視窗)

◎補充：Views 檢視視窗的開啟處：
Window->Show View->Other。

Window - 視窗
Activate Editor (啟動編輯器) ： F12 <In Windows>
Close All Perspectives (關閉全部視景)
Close Perspective (關閉視景)
Customize Perspective (自訂視景)
Hide Editors (隱藏編輯器)
Lock the Toolbars (鎖定工具列)
Maximize Active View or Editor (編輯區最大化) ： Ctrl+M <In Windows>
Next Editor (切換至下一個編輯器) ： Ctrl+F6 <In Windows>
Next Perspective (切換至下一個視景) ： Ctrl+F8 <In Windows>
Next View (切換至下一個視圖) ： Ctrl+F7 <In Windows>
Open Editor Drop Down (以浮動的方式在編輯區，顯示快速切換編輯器功能表) ： Ctrl+E <In Windows>
Pin Editor (固定編輯器)
Preferences (開啟偏愛設定)
Previous Editor (切換至上一個編輯器) ： Ctrl+Shift+F6 <In Windows>
Previous Perspective (切換至上一個視景) ： Ctrl+Shift+F8 <In Windows>
Previous View (切換至上一個視圖) ： Ctrl+Shift+F7 <In Windows>
Reset Perspective (重新設定視景)
Save Perspective As (儲存為新視景)
Show Ruler Context Menu (顯示尺規的內容功能表) ： Ctrl+F10 <Editing Text>
Show Selected Element Only (僅顯示所選元素的程式碼)
Show System Menu (顯示系統功能表) ： Alt+- <In Windows>
Show View Menu (顯示視圖功能表) ： Ctrl+F10 <In Windows>
Switch to Editor (切換至編輯器) ： Ctrl+Shift+E <In Windows>