antlr.jar
ANTLR(ANother Tool for Language Recognition)它是这样的一种工具，它可以接受词文法语言描述,并能产生识别这些语言的语句的程序。作为翻译程序的一部分,你可以使用简单的操作符和动作来参数化你的文法，使之告诉ANTLR怎样去创建抽象语法树(AST)和怎样产生输出。ANTLR知道怎样去生成识别程序，语言包括Java，C++，C#.
主页：http://www.antlr.org/
参考链接：
http://www.blogjava.net/calvin/archive/2005/08/29/11463.html
http://www.blogjava.net/huanzhugege/archive/2007/10/29/156798.html
cglib.jar
CGLIB库，Hibernate用它来实现PO字节码的动态生成。
commons-collections.jar：
Apache Commons包中的一个，包含了一些Apache开发的集合类，功能比java.util.*强大。必须使用的jar包。
commons-beanutils.jar
Apache Commons包中的一个，包含了一些Bean工具类。必须使用的jar包。
commons-lang.jar
Apache Commons包中的一个，包含了一些数据类型工具类，是java.lang.*的扩展。必须使用的jar包。
commons-logging.jar
Apache Commons包中的一个，包含了日志功能，必须使用的jar包。这个包本身包含了一个Simple Logger，但是功能很弱。在运行的时候它会先在CLASSPATH找log4j，如果有，就使用log4j，如果没有，就找JDK1.4带的 java.util.logging，如果也找不到就用Simple Logger。commons-logging.jar的出现是一个历史的的遗留的遗憾，当初Apache极力游说Sun把log4j加入JDK1.4，然而JDK1.4项目小组已经接近发布JDK1.4产品的时间了，因此拒绝了Apache的要求，使用自己的java.util.logging，这个包的功能比log4j差的很远，性能也一般。
后来Apache就开发出来了commons-logging.jar用来兼容两个 logger。因此用commons-logging.jar写的log程序，底层的Logger是可以切换的，你可以选择log4j， java.util.logging或者它自带的Simple Logger。不过我仍然强烈建议使用log4j，因为log4j性能很高，log输出信息时间几乎等于System.out，而处理一条log平均只需要5us。你可以在Hibernate的src目录下找到Hibernate已经为你准备好了的log4j的配置文件，你只需要到Apache 网站去下载log4j就可以了。commons-logging.jar也是必须的jar包。
c3p0.jar
C3PO是一个数据库连接池，Hibernate可以配置为使用C3PO连接池。如果你准备用这个连接池，就需要这个jar包。
proxool.jar
也是一个连接池，同上。
commons-pool.jar、commons-dbcp.jar
DBCP数据库连接池，Apache的Jakarta组织开发的，Tomcat4的连接池也是DBCP。
connector.jar
JCA 规范，如果你在App Server上把Hibernate配置为Connector的话，就需要这个jar。不过实际上一般App Server肯定会带上这个包，所以实际上是多余的包。
dom4j.jar
解析XML文档。
参考文档：http://www.ibm.com/developerworks/cn/xml/x-dom4j.html
odmg.jar
ODMG是一个ORM的规范，Hibernate实现了ODMG规范，这是一个核心的库，必须使用的jar包。
jaas.jar
JAAS是用来进行权限验证的，已经包含在JDK1.4里面了。所以实际上是多余的包。
jcs.jar
如果你准备在Hibernate中使用JCS的话，那么必须包括它，否则就不用。
jdbc2_0-stdext.jar
JDBC2.0的扩展包，一般来说数据库连接池会用上它。不过App Server都会带上，所以也是多余的。
jta.jar
JTA规范，当Hibernate使用JTA的时候需要，不过App Server都会带上，所以也是多余的。
junit.jar
Junit包，当你运行Hibernate自带的测试代码的时候需要，否则就不用。
xalan.jar, xerces.jar, xml-apis.jar
Xerces是XML解析器，Xalan是格式化器，xml-apis实际上是JAXP。一般App Server都会带上，JDK1.4也包含了解析器，不过不是Xerces，是Crimson，效率比较差，不过Hibernate用XML只不过是读取配置文件，性能没什么紧要的，所以也是多余的。
final
final means, this value won’t be changed here after.
final is one of the most under-used features of Java. Whenever you compute a value and you know it will never be changed subsequently put a final on it. Why?
• final lets other programmers (or you reviewing your code years later) know they don’t have to worry about the value being changed anywhere else.
• final warns won’t let you or someone else inadvertently change the value somewhere else in the code, often by setting it to null. final helps prevent or flush out bugs. You can always remove it later.
• final helps the compiler generate faster code.
The term final is used in a number of contexts. static final variables are close to constants in other languages. final classes may not be subclassed. final methods may not be overridden. On methods private implies final, but on variables does not. Marking things final has two purposes: efficiency and safety. The compiler can perform various optimisations knowing the value cannot change. Hotspot and optimising compilers now do this anyway, whether or not you declare methods final, so using final purely for efficiency is no longer recommended. The compiler can also check to ensure you do not inadvertently attempt to change the value after computing its value once where it is defined.
A little known feature of Java is blank finals. You can declare member variables final, but not declare a value. This forces all constructors to initialise the blank final variables.
You can have both final instance and final static variables. final statics are more common. When you know the value of a constant at compile time you might as well make it static. It takes up less room, just one copy per class instead of one copy per object. It is also faster to access a static constant than an instance constant. However, if you don’t know the value of the constant until instantiation time, you have to make it an instance constant.
If you have a final reference to an object or array, it does not stop you from changing the fields in the object or elements of the array. It just stops you from pointing that variable to a different object or array. If you want to protect the object, you must make it immutable.
from:http://mindprod.com/jgloss/final.html
对final总结很全面的一片文章：http://renaud.waldura.com/doc/java/final-keyword.shtml
this是当前对象的引用，主要有如下四个作用：
1.用于返回类对象本身。
2.在构造方法内调用其他构造方法。
3.在方法内部调用类对象中的其他方法。
4.标识类成员变量。
http://mindprod.com/jgloss/this.html
super关键字有两个作用：
1、调用超类方法
2、调用超类的构造器
Accessing Superclass Members
If your method overrides one of its superclass’s methods, you can invoke the overridden method through the use of the keyword super. You can also use super to refer to a hidden field (although hiding fields is discouraged). Consider this class, Superclass:
public class Superclass {
public void printMethod() {
System.out.println(“Printed in Superclass.”);
}
}
Here is a subclass, called Subclass, that overrides printMethod():
public class Subclass extends Superclass {
public void printMethod() { //overrides printMethod in Superclass
super.printMethod();
System.out.println(“Printed in Subclass”);
}
public static void main(String[] args) {
Subclass s = new Subclass();
s.printMethod();
}
}
Within Subclass, the simple name printMethod() refers to the one declared in Subclass, which overrides the one in Superclass. So, to refer to printMethod() inherited from Superclass, Subclass must use a qualified name, using super as shown. Compiling and executing Subclass prints the following:
Printed in Superclass.
Printed in Subclass
Subclass Constructors
The following example illustrates how to use the super keyword to invoke a superclass’s constructor. Recall from the Bicycle example that MountainBike is a subclass of Bicycle. Here is the MountainBike (subclass) constructor that calls the superclass constructor and then adds initialization code of its own:
public MountainBike(int startHeight, int startCadence, int startSpeed, int startGear) {
super(startCadence, startSpeed, startGear);
seatHeight = startHeight;
}
Invocation of a superclass constructor must be the first line in the subclass constructor.
The syntax for calling a superclass constructor is
super();
–or–
super(parameter list);
With super(), the superclass no-argument constructor is called. With super(parameter list), the superclass constructor with a matching parameter list is called.
——————————————————————————–
Note: If a constructor does not explicitly invoke a superclass constructor, the Java compiler automatically inserts a call to the no-argument constructor of the superclass. If the super class does not have a no-argument constructor, you will get a compile-time error. Object does have such a constructor, so if Object is the only superclass, there is no problem.
——————————————————————————–
If a subclass constructor invokes a constructor of its superclass, either explicitly or implicitly, you might think that there will be a whole chain of constructors called, all the way back to the constructor of Object. In fact, this is the case. It is called constructor chaining, and you need to be aware of it when there is a long line of class descent.
from:http://java.sun.com/docs/books/tutorial/java/IandI/super.html
trim()
trim()会去掉前导空格和尾部空格。
subString(int beginIndex, int endIndex)
返回子串。
子串从指定的 beginIndex 处开始，一直到索引 endIndex – 1 处的字符。因此，该子字符串的长度为 endIndex-beginIndex。
示例：
“thoughtlab”.substring(0 ,7) returns “thought”
是截取从0索引到7-1 = 6 处的字符串。
getBytes()
使用平台默认的字符集将此 String 解码为字节序列，并将结果存储到一个新的字节数组中。
当此字符串不能在默认的字符集中解码时，该方法无指定的行为。
getBytes(String charsetName)
使用指定的字符集将此 String 解码为字节序列，并将结果存储到一个新的字节数组中。
当此字符串不能在给定的字符集中解码时，该方法无指定的行为。
String replaceFirst(String regex, String replacement)
使用给定的 replacement 字符串替换此字符串匹配给定的正则表达式的第一个子字符串。
参数regex是一个 regular-expression的匹配模式而不是一个简单的String，对一些特殊的字符需要进行转义处理才能正确使用（下同）。
String str1 = “aaa.bbb.ccc.ddd”;
String str2 = str1.replaceFirst(“\\.”,”+”);
System.out.println(str2);
String replaceAll(String regex, String replacement)
使用给定的 replacement 字符串替换此字符串匹配给定的正则表达式的每个子字符串。
String str1 = “aaa.bbb.ccc.ddd”;
String str2 = str1.replaceAll(“\\.”,”+”);
System.out.println(str2);
String[] split(String regex, int limit)
根据匹配给定的正则表达式来拆分此字符串。
此方法返回的数组包含由regex分割的子字符串，数组中的子字符串按它们在此字符串中的顺序排列。如果regex表达式不匹配字符串的任何部分，则结果数组只具有一个元素，即此字符串本身。
String str = “aaa.bbb.ccc.ddd”;
String[] strs = str.split(“\\.”,0);
for (int i = 0; i < strs.length; i++) {
System.out.println(strs[i]);
}
参数limit 参数控制模式应用的次数，因此影响结果数组的长度。
如果该限制 n 大于 0，则模式将被最多应用 n – 1 次，数组的长度将不会大于 n，而且数组的最后项将包含超出最后匹配的定界符的所有输入。
如果 n 为非正，则模式将被应用尽可能多的次数，而且数组可以是任意长度。
如果 n 为零，则模式将被应用尽可能多的次数，数组可有任何长度，并且结尾空字符串将被丢弃。
例如，字符串 “boo:and:foo” 使用这些参数可生成下列结果：
Regex Limit 结果
: 2 { “boo”, “and:foo” }
: 5 { “boo”, “and”, “foo” }
: -2 { “boo”, “and”, “foo” }
o 5 { “b”, “”, “:and:f”, “”, “” }
o -2 { “b”, “”, “:and:f”, “”, “” }
o 0 { “b”, “”, “:and:f” }
split(String regex)
根据给定的正则表达式的匹配来拆分此字符串。
该方法的作用就像是使用给定的表达式和限制参数 0 来调用两参数 split 方法。因此，结果数组中不包括结尾空字符串。
indexOf()
返回第一次出现的指定子字符串在此字符串中的索引。
使用替换和分割方法时，如果想在串中使用”\”字符，则也需要转义.首先要表达”aaaa\bbbb”这个串就应该用”aaaa\\bbbb”,如果要分隔就应该这样才能得到正确结果：
String[] aa = “aaa\\bbb\\bccc”.split(“\\\\”);
CHAR(size)
用于描述定长的字符型数据。
每一笔数据的长度都相同（不做长度的补满空白）。默认长度为一个字节，最大长度为2000字节。需要注意两个字节只能存储一个简体中文汉字。 More …
导航类
Ctrl+E
快速显示当前Editor的下拉列表(如果当前页面没有显示的用黑体表示)
Ctrl+Shift+E
显示管理当前打开的所有的View的管理器(可以选择关闭,激活等操作)
Alt+←
前一个编辑的页面
Alt+→
下一个编辑的页面
Ctrl+Q
定位到最后编辑的地方
Ctrl+L
定位在某行
F3
定位到声明或定义的地方
使用Ctrl+左键也能达到同样的效果。
Ctrl+Shift+P
定位到对应的匹配符：{}、（）
从前面定位后面时,光标要在匹配符里面,后面到前面,则反之
Ctrl+O
快速显示OutLine
Ctrl+T
快速显示当前类的继承结构
Ctrl+W
关闭当前Editor
Ctrl+Shift+F4
关闭所有打开的Editer
Ctrl+M
切换窗口的大小
Ctrl+/
(小键盘) 按默认要求折叠当前类中的所有代码
Ctrl+×
(小键盘) 展开当前类中的所有代码
编辑类
Ctrl+1
快速修复
Alt+/
代码助手完成一些代码的插入
Ctrl+D
删除当前行
Ctrl+/
在代码窗口中是这种//~注释。
Ctrl+Shift+/
在代码窗口中是这种/*~*/注释，在JSP文件窗口中是这种<%-- ~--%>。
Ctrl+Shift+M
(先把光标放在需导入包的类名上) 作用是加Import语句。
Ctrl+Shift+O
作用是缺少的Import语句被加入，多余的Import语句被删除。
Ctrl+Shift+F
格式化文件Format Document。
Ctrl+Alt+↓
复制当前行到下一行(复制增加)
Ctrl+Alt+↑
复制当前行到上一行(复制增加)
Alt+↓
当前行和下面一行交互位置(特别实用,可以省去先剪切,再粘贴了)
Alt+↑
当前行和上面一行交互位置(同上)
Shift+Enter
在当前行的下一行插入空行(这时鼠标可以在当前行的任一位置,不一定是最后)
Shift+Ctrl+Enter
在当前行插入空行(原理同上条)
Ctrl+Shift+X
把当前选中的文本全部变味小写
Ctrl+Shift+Y
把当前选中的文本全部变为小写
Ctrl+S
保存当前文件。
Ctrl+Shift+S
保存所有未保存的文件。
Alt+Enter
显示当前选择资源(工程,or 文件 or文件)的属性
查找类
Ctrl+F
当前编辑窗口查找
Ctrl+H
功能强悍的全文查找
Ctrl+K
参照选中的Word快速定位到下一个
Ctrl+J
正向增量查找(按下Ctrl+J后,你所输入的每个字母编辑器都提供快速匹配定位到某个单词,如果没有,则在status line中显示没有找到)
Ctrl+Shift+J
反向增量查找(和上条相同,只不过是从后往前查)
Alt+Shift+O
高亮显示与选中文本相同的字符串。
调试类
F5
单步调试进入函数内部。
F6
单步调试不进入函数内部。
F7
由函数内部返回到调用处。
F8
执行到下一个断点。
PS：
通过Help->Key Assist或者通过使用快捷键Ctrl+Shift+L可以查看所有快捷键信息。
问题
你可能想要将你的应用资源分解到多个文件中，以改善应用的组织和维护性，特别是在团队开发的环境中。
动作要领
创建单独的属性文件并且在struts-config.xml中为每一个文件声明一个message-resources元素。
动作变化
Struts 使用消息资源来提供对错误消息、字段标注、以及其他静态文本的存储机制。对于默认的Struts 实现，你可以将消息存储为属性文件（.properties文件）中的名称（关键字）/值对。消息资源集基本上相当于Java ResourceBundle（资源束）。
你可以将你的消息资源束性文件通过message-resources元素来配置。元素的parameter属性指示了属性文件的相对于 classpath的名称。你可以通过将文件路径中的分隔符替换为点号，以及删除文件名中的.properties扩展名来产生这个属性的值。比如，如果你的属性文件位于/WEB- INF/classes/com/oreilly/strutsckbk/MessageResources.properties，你可以将消息资源元素设置为：
在应用启动时， Struts将创建消息资源的运行时表达（一个对象实例），然后将其保存在servlet context中。
你并不限于只使用一个消息资源。然而，和使用多Struts配置文件不同，如果你使用多个消息资源文件，它们并不时合并成一个文件。相反，你需要定义消息资源的不同的集合。每一个集合使用一个key属性指定的唯一的值来标识。如果这个属性没被使用，那么该消息资源就会被设置为默认的消息集。只有一个默认消息集存在。同时，只有一个消息资源集对应于同一模块中的每一个唯一关键字。如果你使用同一关键字定义了多个消息资源束，则最后一个指定的将被使用。
key属性的值是作为servlet context 属性的名称，从属性文件创建的消息资源束就保存在它之下。key值被用在Struts标签之中，比如bean:message，来标识消息资源集，并引用到来自于属性文件的资源束。下面是你可以如何从labels消息资源来访问一个消息的方法：
bundle属性的值对应于struts-config.xml文件中的message-resources元素的key属性。bean: message标签也有一个key属性，但它和message-resources元素的key属性的含义完全不同。它指定一个特定的属性来访问消息资源中的消息。
不幸的是，这种在XML元素和JSP标签中使用同一个属性名的方法在Struts中很普遍。所以必须仔细研究和注意Struts taglib文档 (http://jakarta.apache.org/struts/userGuide/index.html) 以及Struts 的配置文档(http://jakarta.apache.org/struts/userGuide/configuration.html#struts-config) ，免得搞混淆了。
Struts 并不关心你如何分解你的消息资源属性文件。一种办法是按照消息类型分解。比如，你可以将你的消息资源分解为下面的几组：
* 错误消息
* 提示性消息
* 字段标注
* 表头单元个文本
虽然这样分解消息资源是合乎逻辑和合理的，但在团队环境中则倾向于按照功能进行分解。比如，考虑一个人力资源应用，它有薪酬、福利和管理功能区。你可以为每一个功能区创建一个消息资源属性文件。每一个属性文件都包含该功能区域所特定的错误消息、提示消息、字段标注和其他信息。如果你的开发团队是按照这些业务功能区进行分组的，按照相同的分组原则对消息资源进行分组则更加合理。相同的方法和原则也适用于Struts 配置文件的分解。
如果你熟悉Struts module，上述的每一个功能区都是一个很好的Struts module的候选。如果你使用module，那么你在struts-config文件中为某一个模块所定义的消息资源就仅适用于该模块。事实上，你可以在不同的模块中定义具有相同key属性的message-resource元素。回想一下， Struts 是使用key值将MessageResources保存在servlet context中。更准确地说，实际的值将用于模块名称（通常引用为模块的前缀），以及消息资源的key属性值的串联。
相关招式
第2.4式提供了关于分解应用组件的技术。Struts 用户指南提供了定义消息资源的文档，其地址为：http://jakarta.apache.org/struts/userGuide/configuration.html#resources_config.
Struts MessageResources的JavaDoc API可以在http://jakarta.apache.org/struts/api/org/apache/struts/util/MessageResources.html处找到。
Struts 文档中关于bean:message标签的文档可以在http://jakarta.apache.org/struts/userGuide/struts-bean.html#message处找到。
from：http://www.blogjava.net/SteelHand/archive/2005/05/17/4426.html
在Struts 1.0中，我们只能在web.xml中为ActionServlet指定一个配置文件，这对于我们这些网上的教学例子来说当然没什么问题，但是在实际的应用开发过程中，可能会有些麻烦。因为许多开发人员都可能同时需要修改配置文件，但是配置文件只能同时被一个人修改，这样肯定会造成一定程度上的资源争夺，势必会影响开发效率和引起开发人员的抱怨。
在Struts 1.1中，为了解决这个并行开发的问题，提出了两种解决方案：
- 多个配置文件的支持
- 模块的支持
支持多个配置文件，是指你能够为ActionServlet同时指定多个xml配置文件，文件之间以逗号分隔，比如Struts提供的MailReader演示例子中就采用该种方法。
/WEB-INF/struts-config-registration.xml
这种方法可以很好地解决修改冲突的问题，不同的开发人员可以在不同的配置文件中设置自己的Action、ActionForm等等（当然不是说每个开发人员都需要自己的配置文件，可以按照系统的功能模块进行划分）。但是，这里还是存在一个潜在的问题，就是可能不同的配置文件之间会产生冲突，因为在ActionServlet初始化的时候这几个文件最终还是需要合并到一起的。比如，在struts-config.xml中配置了一个名为success的
为了彻底解决这种冲突，Struts 1.1中引进了模块（Module）的概念。一个模块就是一个独立的子系统，你可以在其中进行任意所需的配置，同时又不必担心和其它的配置文件产生冲突。因为前面我们讲过，ActionServlet是将不同的模块信息保存在不同的ModuleConfig对象中的。要使用模块的功能，需要进行以下的准备工作：
1、为每个模块准备一个配置文件
2、配置web.xml文件，通知控制器
3、准备各个模块所需的ActionForm、Action和JSP等资源
决定采用多个模块以后，你需要将这些信息告诉控制器，这需要在web.xml文件进行配置。下面是一个典型的多模块配置：
要配置多个模块，你需要在原有的一个
但是要注意的是，模块的出现也同时带来了一个问题，即如何在不同模块间进行转发？有两种方法可以实现模块间的转发，一种就是在
下面就是一个全局的例子：
可以看出，只需要在原有的path属性前加上模块名，同时将contextRelative属性置为true即可。此外，你也可以在
如果你已经处在其他模块，需要转回到缺省模块，那应该类似下面这样定义，即模块名为空。
此外，你也可以使用org.apache.struts.actions.SwitchAction，例如：
参考文章：
http://www.ibm.com/developerworks/cn/java/l-struts1-1/
http://www.blogjava.net/SteelHand/archive/2005/05/13/4247.html
代码如下：
通过\r换行，innerText设置文本时也可以通过\r进行换行。