常用：

字符串类型：System.getProperty("user.dir");

综合：

package com.zcjl.test.base;
import java.io.File;
public class Test {
public static void main(String[] args) throws Exception {
System.out.println(
Thread.currentThread().getContextClassLoader().getResource(""));
System.out.println(Test.class.getClassLoader().getResource(""));
System.out.println(ClassLoader.getSystemResource(""));
System.out.println(Test.class.getResource(""));
System.out.println(Test.class.getResource("/"));
System.out.println(new File("").getAbsolutePath());
System.out.println(System.getProperty("user.dir"));
}
}

2.Web服务中

(1).Weblogic

WebApplication的系统文件根目录是你的weblogic安装所在根目录。
例如：如果你的weblogic安装在c:\bea\weblogic700.....
那么，你的文件根路径就是c:\.
所以，有两种方式能够让你访问你的服务器端的文件：
a.使用绝对路径：
比如将你的参数文件放在c:\yourconfig\yourconf.properties，
直接使用 new FileInputStream("yourconfig/yourconf.properties");
b.使用相对路径：
相对路径的根目录就是你的webapplication的根路径，即WEB-INF的上一级目录，将你的参数文件放在yourwebapp\yourconfig\yourconf.properties，
这样使用：
new FileInputStream("./yourconfig/yourconf.properties");
这两种方式均可，自己选择。

(2).Tomcat

在类中输出System.getProperty("user.dir");显示的是%Tomcat_Home%/bin

(3).Resin

不是你的JSP放的相对路径,是JSP引擎执行这个JSP编译成SERVLET
的路径为根.比如用新建文件法测试File f = new File("a.htm");
这个a.htm在resin的安装目录下

(4).如何读相对路径哪？

在Java文件中getResource或getResourceAsStream均可

例：getClass().getResourceAsStream(filePath);//filePath可以是"/filename",这里的/代表web发布根路径下WEB-INF/classes

(5).获得文件真实路径

string file_real_path=request.getRealPath("mypath/filename");

通常使用request.getRealPath("/");

3.文件操作的类

import java.io.*;
import java.net.*;
import java.util.*;
//import javax.swing.filechooser.*;
//import org.jr.swing.filter.*;

/**
* 此类中封装一些常用的文件操作。
* 所有方法都是静态方法，不需要生成此类的实例，
* 为避免生成此类的实例，构造方法被申明为private类型的。
* @since 0.1
*/

public class FileUtil {
/**
* 私有构造方法，防止类的实例化，因为工具类不需要实例化。
*/
private FileUtil() {

}

/**
* 修改文件的最后访问时间。
* 如果文件不存在则创建该文件。
* <b>目前这个方法的行为方式还不稳定，主要是方法有些信息输出，这些信息输出是否保留还在考

虑中。</b>
* @param file 需要修改最后访问时间的文件。
* @since 0.1
*/
public static void touch(File file) {
long currentTime = System.currentTimeMillis();
if (!file.exists()) {
System.err.println("file not found:" file.getName());
System.err.println("Create a new file:" file.getName());
try {
if (file.createNewFile()) {
// System.out.println("Succeeded!");
}
else {
// System.err.println("Create file failed!");
}
}
catch (IOException e) {
// System.err.println("Create file failed!");
e.printStackTrace();
}
}
boolean result = file.setLastModified(currentTime);
if (!result) {
// System.err.println("touch failed: " file.getName());
}
}

/**
* 修改文件的最后访问时间。
* 如果文件不存在则创建该文件。
* <b>目前这个方法的行为方式还不稳定，主要是方法有些信息输出，这些信息输出是否保留还在考

虑中。</b>
* @param fileName 需要修改最后访问时间的文件的文件名。
* @since 0.1
*/
public static void touch(String fileName) {
File file = new File(fileName);
touch(file);
}

/**
* 修改文件的最后访问时间。
* 如果文件不存在则创建该文件。
* <b>目前这个方法的行为方式还不稳定，主要是方法有些信息输出，这些信息输出是否保留还在考

虑中。</b>
* @param files 需要修改最后访问时间的文件数组。
* @since 0.1
*/
public static void touch(File[] files) {
for (int i = 0; i < files.length; i ) {
touch(files);
}
}

/**
* 修改文件的最后访问时间。
* 如果文件不存在则创建该文件。
* <b>目前这个方法的行为方式还不稳定，主要是方法有些信息输出，这些信息输出是否保留还在考

虑中。</b>
* @param fileNames 需要修改最后访问时间的文件名数组。
* @since 0.1
*/
public static void touch(String[] fileNames) {
File[] files = new File[fileNames.length];
for (int i = 0; i < fileNames.length; i ) {
files = new File(fileNames);
}
touch(files);
}

/**
* 判断指定的文件是否存在。
* @param fileName 要判断的文件的文件名
* @return 存在时返回true，否则返回false。
* @since 0.1
*/
public static boolean isFileExist(String fileName) {
return new File(fileName).isFile();
}

/**
* 创建指定的目录。
* 如果指定的目录的父目录不存在则创建其目录书上所有需要的父目录。
* <b>注意：可能会在返回false的时候创建部分父目录。</b>
* @param file 要创建的目录
* @return 完全创建成功时返回true，否则返回false。
* @since 0.1
*/
public static boolean makeDirectory(File file) {
File parent = file.getParentFile();
if (parent != null) {
return parent.mkdirs();
}
return false;
}

/**
* 创建指定的目录。
* 如果指定的目录的父目录不存在则创建其目录书上所有需要的父目录。
* <b>注意：可能会在返回false的时候创建部分父目录。</b>
* @param fileName 要创建的目录的目录名
* @return 完全创建成功时返回true，否则返回false。
* @since 0.1
*/
public static boolean makeDirectory(String fileName) {
File file = new File(fileName);
return makeDirectory(file);
}

/**
* 清空指定目录中的文件。
* 这个方法将尽可能删除所有的文件，但是只要有一个文件没有被删除都会返回false。
* 另外这个方法不会迭代删除，即不会删除子目录及其内容。
* @param directory 要清空的目录
* @return 目录下的所有文件都被成功删除时返回true，否则返回false.
* @since 0.1
*/
public static boolean emptyDirectory(File directory) {
boolean result = false;
File[] entries = directory.listFiles();
for (int i = 0; i < entries.length; i ) {
if (!entries.delete()) {
result = false;
}
}
return true;
}

/**
* 清空指定目录中的文件。
* 这个方法将尽可能删除所有的文件，但是只要有一个文件没有被删除都会返回false。
* 另外这个方法不会迭代删除，即不会删除子目录及其内容。
* @param directoryName 要清空的目录的目录名
* @return 目录下的所有文件都被成功删除时返回true，否则返回false。
* @since 0.1
*/
public static boolean emptyDirectory(String directoryName) {
File dir = new File(directoryName);
return emptyDirectory(dir);
}

/**
* 删除指定目录及其中的所有内容。
* @param dirName 要删除的目录的目录名
* @return 删除成功时返回true，否则返回false。
* @since 0.1
*/
public static boolean deleteDirectory(String dirName) {
return deleteDirectory(new File(dirName));
}

/**
* 删除指定目录及其中的所有内容。
* @param dir 要删除的目录
* @return 删除成功时返回true，否则返回false。
* @since 0.1
*/
public static boolean deleteDirectory(File dir) {
if ( (dir == null) || !dir.isDirectory()) {
throw new IllegalArgumentException("Argument " dir
" is not a directory. ");
}

File[] entries = dir.listFiles();
int sz = entries.length;

for (int i = 0; i < sz; i ) {
if (entries.isDirectory()) {
if (!deleteDirectory(entries)) {
return false;
}
}
else {
if (!entries.delete()) {
return false;
}
}
}

if (!dir.delete()) {
return false;
}
return true;
}

/**
* 返回文件的URL地址。
* @param file 文件
* @return 文件对应的的URL地址
* @throws MalformedURLException
* @since 0.4
* @deprecated 在实现的时候没有注意到File类本身带一个toURL方法将文件路径转换为URL。
* 请使用File.toURL方法。
*/
public static URL getURL(File file) throws MalformedURLException {
String fileURL = "file:/" file.getAbsolutePath();
URL url = new URL(fileURL);
return url;
}

/**
* 从文件路径得到文件名。
* @param filePath 文件的路径，可以是相对路径也可以是绝对路径
* @return 对应的文件名
* @since 0.4
*/
public static String getFileName(String filePath) {
File file = new File(filePath);
return file.getName();
}

/**
* 从文件名得到文件绝对路径。
* @param fileName 文件名
* @return 对应的文件路径
* @since 0.4
*/
public static String getFilePath(String fileName) {
File file = new File(fileName);
return file.getAbsolutePath();
}

/**
* 将DOS/Windows格式的路径转换为UNIX/Linux格式的路径。
* 其实就是将路径中的"\"全部换为"/"，因为在某些情况下我们转换为这种方式比较方便，
* 某中程度上说"/"比"\"更适合作为路径分隔符，而且DOS/Windows也将它当作路径分隔符。
* @param filePath 转换前的路径
* @return 转换后的路径
* @since 0.4
*/
public static String toUNIXpath(String filePath) {
return filePath.replace('\\', '/');
}

/**
* 从文件名得到UNIX风格的文件绝对路径。
* @param fileName 文件名
* @return 对应的UNIX风格的文件路径
* @since 0.4
* @see #toUNIXpath(String filePath) toUNIXpath
*/
public static String getUNIXfilePath(String fileName) {
File file = new File(fileName);
return toUNIXpath(file.getAbsolutePath());
}

/**
* 得到文件的类型。
* 实际上就是得到文件名中最后一个“.”后面的部分。
* @param fileName 文件名
* @return 文件名中的类型部分
* @since 0.5
*/
public static String getTypePart(String fileName) {
int point = fileName.lastIndexOf('.');
int length = fileName.length();
if (point == -1 || point == length - 1) {
return "";
}
else {
return fileName.substring(point 1, length);
}
}

/**
* 得到文件的类型。
* 实际上就是得到文件名中最后一个“.”后面的部分。
* @param file 文件
* @return 文件名中的类型部分
* @since 0.5
*/
public static String getFileType(File file) {
return getTypePart(file.getName());
}

/**
* 得到文件的名字部分。
* 实际上就是路径中的最后一个路径分隔符后的部分。
* @param fileName 文件名
* @return 文件名中的名字部分
* @since 0.5
*/
public static String getNamePart(String fileName) {
int point = getPathLsatIndex(fileName);
int length = fileName.length();
if (point == -1) {
return fileName;
}
else if (point == length - 1) {
int secondPoint = getPathLsatIndex(fileName, point - 1);
if (secondPoint == -1) {
if (length == 1) {
return fileName;
}
else {
return fileName.substring(0, point);
}
}
else {
return fileName.substring(secondPoint 1, point);
}
}
else {
return fileName.substring(point 1);
}
}

/**
* 得到文件名中的父路径部分。
* 对两种路径分隔符都有效。
* 不存在时返回""。
* 如果文件名是以路径分隔符结尾的则不考虑该分隔符，例如"/path/"返回""。
* @param fileName 文件名
* @return 父路径，不存在或者已经是父目录时返回""
* @since 0.5
*/
public static String getPathPart(String fileName) {
int point = getPathLsatIndex(fileName);
int length = fileName.length();
if (point == -1) {
return "";
}
else if (point == length - 1) {
int secondPoint = getPathLsatIndex(fileName, point - 1);
if (secondPoint == -1) {
return "";
}
else {
return fileName.substring(0, secondPoint);
}
}
else {
return fileName.substring(0, point);
}
}

/**
* 得到路径分隔符在文件路径中首次出现的位置。
* 对于DOS或者UNIX风格的分隔符都可以。
* @param fileName 文件路径
* @return 路径分隔符在路径中首次出现的位置，没有出现时返回-1。
* @since 0.5
*/
public static int getPathIndex(String fileName) {
int point = fileName.indexOf('/');
if (point == -1) {
point = fileName.indexOf('\\');
}
return point;
}

/**
* 得到路径分隔符在文件路径中指定位置后首次出现的位置。
* 对于DOS或者UNIX风格的分隔符都可以。
* @param fileName 文件路径
* @param fromIndex 开始查找的位置
* @return 路径分隔符在路径中指定位置后首次出现的位置，没有出现时返回-1。
* @since 0.5
*/
public static int getPathIndex(String fileName, int fromIndex) {
int point = fileName.indexOf('/', fromIndex);
if (point == -1) {
point = fileName.indexOf('\\', fromIndex);
}
return point;
}

/**
* 得到路径分隔符在文件路径中最后出现的位置。
* 对于DOS或者UNIX风格的分隔符都可以。
* @param fileName 文件路径
* @return 路径分隔符在路径中最后出现的位置，没有出现时返回-1。
* @since 0.5
*/
public static int getPathLsatIndex(String fileName) {
int point = fileName.lastIndexOf('/');
if (point == -1) {
point = fileName.lastIndexOf('\\');
}
return point;
}

/**
* 得到路径分隔符在文件路径中指定位置前最后出现的位置。
* 对于DOS或者UNIX风格的分隔符都可以。
* @param fileName 文件路径
* @param fromIndex 开始查找的位置
* @return 路径分隔符在路径中指定位置前最后出现的位置，没有出现时返回-1。
* @since 0.5
*/
public static int getPathLsatIndex(String fileName, int fromIndex) {
int point = fileName.lastIndexOf('/', fromIndex);
if (point == -1) {
point = fileName.lastIndexOf('\\', fromIndex);
}
return point;
}

/**
* 将文件名中的类型部分去掉。
* @param filename 文件名
* @return 去掉类型部分的结果
* @since 0.5
*/
public static String trimType(String filename) {
int index = filename.lastIndexOf(".");
if (index != -1) {
return filename.substring(0, index);
}
else {
return filename;
}
}
/**
* 得到相对路径。
* 文件名不是目录名的子节点时返回文件名。
* @param pathName 目录名
* @param fileName 文件名
* @return 得到文件名相对于目录名的相对路径，目录下不存在该文件时返回文件名
* @since 0.5
*/
public static String getSubpath(String pathName,String fileName) {
int index = fileName.indexOf(pathName);
if (index != -1) {
return fileName.substring(index pathName.length() 1);
}
else {
return fileName;
}
}

}
4.遗留问题

目前new FileInputStream()只会使用绝对路径，相对没用过，因为要相对于web服务器地址，比较麻烦

还不如写个配置文件来的快哪

5.按Java文件类型分类读取配置文件

配 置文件是应用系统中不可缺少的，可以增加程序的灵活性。java.util.Properties是从jdk1.2就有的类，一直到现在都支持load ()方法，jdk1.4以后save(output,string) ->store(output,string)。如果只是单纯的读，根本不存在烦恼的问题。web层可以通过 Thread.currentThread().getContextClassLoader().
getResourceAsStream("xx.properties") 获取；Application可以通过new FileInputStream("xx.properties");直接在classes一级获取。关键是有时我们需要通过web修改配置文件，我们不 能将路径写死了。经过测试觉得有以下心得：

1.servlet中读写。如果运用Struts 或者Servlet可以直接在初始化参数中配置，调用时根据servlet的getRealPath("/")获取真实路径，再根据String file = this.servlet.getInitParameter("abc");获取相对的WEB-INF的相对路径。
例：
InputStream input = Thread.currentThread().getContextClassLoader().
getResourceAsStream("abc.properties");
Properties prop = new Properties();
prop.load(input);
input.close();
OutputStream out = new FileOutputStream(path);
prop.setProperty("abc", “test");
prop.store(out, “–test–");
out.close();

2.直接在jsp中操作，通过jsp内置对象获取可操作的绝对地址。
例：
// jsp页面
String path = pageContext.getServletContext().getRealPath("/");
String realPath = path "/WEB-INF/classes/abc.properties";

//java 程序
InputStream in = getClass().getClassLoader().getResourceAsStream("abc.properties"); // abc.properties放在webroot/WEB-INF/classes/目录下
prop.load(in);
in.close();

OutputStream out = new FileOutputStream(path); // path为通过页面传入的路径
prop.setProperty("abc", “abcccccc");
prop.store(out, “–test–");
out.close();

3.只通过Java程序操作资源文件
InputStream in = new FileInputStream("abc.properties"); // 放在classes同级

OutputStream out = new FileOutputStream("abc.properties");

/**
    * 获取一个类的class文件所在的绝对路径。 这个类可以是JDK自身的类，也可以是用户自定义的类，或者是第三方开发包里的类。
    * 只要是在本程序中可以被加载的类，都可以定位到它的class文件的绝对路径。
    *
    * @param cls
    *             一个对象的Class属性
    * @return 这个类的class文件位置的绝对路径。 如果没有这个类的定义，则返回null。
    */
   public String getPathFromClass(Class cls) throws IOException {
     String path = null;
     if (cls == null) {
       throw new NullPointerException();
     }
     URL url = getClassLocationURL(cls);
     if (url != null) {
       path = url.getPath();
       if ("jar".equalsIgnoreCase(url.getProtocol())) {
         try {
           path = new URL(path).getPath();
         }
         catch (MalformedURLException e) {
         }
         int location = path.indexOf("!/");
         if (location != -1) {
           path = path.substring(0, location);
         }
       }
       File file = new File(path);
       path = file.getCanonicalPath();
     }
     return path;
   }

   /**
* 获取类的class文件位置的URL。这个方法是本类最基础的方法，供其它方法调用。
*/
private URL getClassLocationURL(final Class cls) {
   if (cls == null) {
     throw new IllegalArgumentException("class that input is null");
   }
   URL result = null;
   final String clsAsResource = cls.getName().replace('.', '/').concat(".class");
   final ProtectionDomain pd = cls.getProtectionDomain();
   if (pd != null) {
     final CodeSource cs = pd.getCodeSource();
     if (cs != null) {
       result = cs.getLocation();

     }
     if (result != null) {
       if ("file".equals(result.getProtocol())) {
         try {
           if (result.toExternalForm().endsWith(".jar")
               || result.toExternalForm().endsWith(".zip")) {
             result = new URL("jar:".concat(
                 result.toExternalForm()).concat("!/")
                              .concat(clsAsResource));
           }
           else if (new File(result.getFile()).isDirectory()) {
             result = new URL(result, clsAsResource);
           }
         }
         catch (MalformedURLException ignore) {
         }
       }
     }
   }

   if (result == null) {
     final ClassLoader clsLoader = cls.getClassLoader();
     result = clsLoader != null ? clsLoader.getResource(clsAsResource)
         : ClassLoader.getSystemResource(clsAsResource);
   }
   return result;
}

·应用程序框架：提供浏览器的功能，但是常以包括窗口小部件抽象和另外的部件而出名，其功能主要围绕桌面GUI框架。

·基本结构框架：提供基本的管道和可移植的浏览器抽象，让开发者去创建内容。典型的功能：

* 针对XMLHttpRequest的包装器以封装浏览器-服务器的交互。(所有的框架都提供这一功能)。

* XML操作和查询。

* 根据来自XMLHttpRequest的应答执行DOM操作。

* 在一些情况中，与另外的浏览器端技术如Flash(和潜在的Java applets)集成在一起。

而服务器端框架通常以下面两种方式工作(尽管它们在这里根据语言的不同进行了分类)：

·HTML/JS生成：服务器提供完整的HTML/Javascript代码生成和浏览器-服务器协调，结果是只有浏览器端编码可以被定制。

·远程调用：Javascript调用直接被路由到服务器端功能(例如Java方法)并返回到Javascript回叫处理器；或者Javascript调用服务器以提取信息，例如会话细节，数据库查询等。

·纯Javascript：应用程序框架

1.1 Bindows(自从2003年)

网址是：http://www.bindows.net，Bindows是一个软件开发包(SDK)，它，通过强力联合DHTML，JavaScript，CSS和XML等技术，能生成高度交互的互联网应用程序-成为现代的桌面应用程序的强有力对手。Bindows应用程序不要求下载和也不需要在用户端安装-仅要求有一个浏览器(也不需要Java，Flash或者ActiveX)。Bindows有可能领导面向对象开发的AJAX应用程序的平台。
·它是商业化的，使用来自于MB的技术(总部位于GA USA，主要开发中心在瑞典，成立于2002年)。
Bindows框架提供给你：

·基于类的面向对象的API

·一套完整的窗口系统，提供宽范围的窗口小部件支持，包括菜单、表单、格子、滑动条、量程，甚至更多

·用于开发zero-footprint SOA客户端应用程序的领先的工具箱

·本机的XML，SOAP和XML-RPC支持

·单用户到企业级的支持

·内建的对AJAX的支持
Bindows开发环境：

·支持企业级规模的工程开发

·跨浏览器，跨平台支持

·服务器独立结构

·与新的和现有资源的互操作性

·一致性开发方法学
1.2 BackBase(自从2003年)

网址是：http://www.backbase.com，是一个全面的浏览器端框架，支持丰富的浏览器功能以及与.NET和Java的集成。

·商业化，来自于Backbase B.V(总部在Amsterdam，成立于2003年)。

1.3 DOJO(开发中;自从2004年9月)

网址是：http://dojotoolkit.org/，提供全面窗口小组件和浏览器-服务器消息支持。

·为创建定制的Javascript窗口小组件提供框架支持。

·预置的窗口小组件库。

·浏览器-服务器消息支持-XMLHttpRequest和另外的机制。

·支持浏览器中的URL操纵功能。

·开源许可(学术自由许可2.1(http://opensource.org/licenses/afl-2.1.php))，由JotSpot(http://www.jot.com/)的Alex Russell(http://alex.dojotoolkit.org/)所领导。

1.4 Open Rico(开发中;自从2005年5月;基于早期的私有框架)

网址是：http://openrico.org/demos.page，是一多用途框架，支持Ajax基础结构和用户交互。

·一个XMLHttpRequest应答能被路由到一个或者更多回叫操作，DOM对象，或者Javascript对象。

·容易鼠标拖动支持。

·Ajax动画，例如缩放和变换。

·"行为"-实质上是窗口小组件库。

·使用指南(http://www.mirimar.net/mailbrowser/)，由RussMirimar的Yonah所提供

·开源。源于Sabre航空公司解决方案，由Bill Scott(http://looksgoodworkswell.blogspot.com)，Darren James及另外一些人所支持。

1.5 qooxdoo(开发中;自从2005年5月)

网址是：http://qooxdoo.sourceforge.net/，是另一个雄心勃勃的框架，提供宽范围的UI支持和正在开发中的基础结构特性。

·基础结构：

* DOM和事件/焦点管理的可移植的抽象。

* 调试支持。

* 易于时间调度的Timer类。

* Getter/Setter支持。

·UI：

* 窗口小组件框架和预置的窗口小组件库。
* 布局管理器。

* 图像缓冲和可移植的PNG透明性。

·开源(LGPL)。来自多方面的贡献者。

1.6 Tibet(开发中;自从2005年6月)

网址是：http://www.technicalpursuit.com/，目的是提供高度可移植的和全面的Javascript. API，结果是，可能自动生成大量的客户端代码。自称是"企业级Ajax"。

·远程脚本运行在XMLHttpRequest包装之上-通过协调调用结果支持工作流管理，例如应答可以发生在只有当两个分离的调用返回时。

·URI支持。

·所有的HTTP方法-不仅是"GET"和"POST"。

·低级的协议-File://和WebDav以及HTTP。

·Web服务调用-SOAP，XML-RPC，等等。

·预置的针对Google API，Amazon API等等服务的支持。

·由高级Javascript对象组成一个巨大的库。

·许多XML操作。

·IDE和开发工具。

·开源许可(显然经过OSI认证，但是细节不多)。

2 纯Javascript：基础结构框架

2.1 AjaxCaller(Alpha版本;自从5月2005年)

网址是：http://ajaxify.com/run/testAjaxCaller/，是一基本的线程安全的XMLHttpRequest包装器，主要针对Ajax新手，仍处于原始的alpha开发阶段，目前仅与AjaxPatterns的在线搜索范例一起打包。

·实现对服务器的调用(GET/POST/PUT/DELETE)，用路由到一个回叫操作的plain-text或者XML完成。

·使用过的XMLHttpRequest对象的析构。

·Response缓冲(计划的)。

·针对Ajax新手-并非强调性能优化，该库主要用于实现易读的基础代码并将提供调试支持。

·开源许可。由Michael Mahemoff(http://softwareas.com)(具有John Wehr和Richard Schwartz的一些思想)维护。

2.2 Flash JavaScript集成包

网址是：http://www.osflash.org/doku.php?id=flashjs，允许JavaScript和Flash内容的集成：

·使JavaScript能够调用ActionScript功能和反过来的实现。

·所有主要的数据类型能在这两种环境之间传递。

·开源许可。由多个开源Flash贡献者提供支持。

2.3 Google AJAXSLT(发行于2005年6月)

网址是：http://goog-ajaxslt.sourceforge.net/，是一个Javascript框架，用来执行XSLT转换以及XPath查询。

·建立在Google地图工作基础之上。

·开源许可(BSD)。由一家创新搜索方案公司支持，自称为"Google"。

2.4 HTMLHttpRequest(Beta版；始于2005年)

HtmlHttpRequest(http://www.twinhelix.com/javascript/htmlhttprequest/)，它使用了XMLHttpRequest和Iframes以改进兼容性。

·测试过并能工作在:IE6/Win，IE5.5/Win，IE5/Win，IE4/Win，Mozilla/Win，Opera7/Win，Safari/Mac，IE5/Mac。

·未测试，可能能工作在：IE4/Mac，Mozilla/Mac，Opera/Other，Konqueror/Linux。你正在使用这些之一吗？作者正在请求兼容性信息。

·开源许可(LGPL)。由Twin Helix Designs(http://www.twinhelix.com/)的Angus Turnbull维护。

2.5 交互式网站框架(自从2005年5月)

交互式网站框架(http://sourceforge.net/projects/iwf/，是一个项目，目的是从浏览器端对Ajax基础结构的多方面予以支持。自描述为"使用javascript，css，xml，和html来创造高度交互网站的框架。包括一个定制的针对高度可读的javascript的xml分析器。实质上，是建立基于AJAX的网站的基础，还有另外一些通用脚本"。

·线程安全的XMLHttpRequest实现。

·针对XML文档的包装器，以便你能够创建更具可读性的代码：

var node = doc.groceries.frozen[0].pizza[0].size;</pre>

代替手工的导航：

var node = doc.documentElement.firstChild.firstChild.getAttribute("size");</pre>

·开源许可。由Weaver(http://circaware.com|Brock)维护。

2.6 LibXMLHttpRequest(发行于2003年6月)

libXmlRequest(http://www.whitefrost.com/servlet/connector?file=reference/2003/06/17/libXmlRequest.html)，是XMLHttpRequest的一个瘦包装器。

·getXML()和postXML()方法。

·XMLHttpRequest对象池支持。

·Response缓冲。

·可用源码(明显)，但是受标准版权的保护，由Stephen W.Coate(http://www.whitefrost.com/index.jsp)所维护。

2.7 RSLite(x)

网站是：http://www.ashleyit.com/rs/main.htm，是一个针对XMLHttpRequest的瘦包装器。

·一个简单的组件，作为Brent Ashley的更全面的远程脚本工作(参见Javascript远程脚本-JSRS在多语言服务器端)的一部分发行。

2.8 Sack(在开发中，自从2005年5月)

网站是：http://twilightuniverse.com/2005/05/sack-of-ajax/，是一个针对XMLHttpRequest的瘦包装器。

·调用者能指定回叫函数或者回叫DOM对象。借助于回叫DOM，应答文本直接被推入到DOM中

2.9 Sarissa(发行于2月，2003年)

网站是：http://sarissa.sf.net，是一种Javascript. API，它封装了在浏览器端可以独立调用XML的功能。

·可移植的XMLHttpRequest创建

·可移植的XPath查询

·可移植的DOM操作

·可移植的XSLT

·可移植的XML串行化

·开源(GPL2.0和LGPL2.1)。来自多方面贡献者。

2.10 XHConn(发行于自从4月，2005年)

网站是：http://xkr.us/code/javascript/XHConn/，是一个对XMLHttpRequest的瘦包装器。

·例如

new XHConn().connect("mypage.php"，"POST"，"foo=bar&baz=qux"，fnWhenDone);

·开源许可。由Brad Fults所维护。

3 服务器端：多种语言

3.1 跨平台异步的接口工具箱(5月2005年)

CPAINT：http://cpaint.sourceforge.net/，是一真正的支持PHP和ASP/Vbscript的Ajax实现和JSRS(JavaScript远程脚本)实现。CPAINT提供给你需求的代码在后台实现AJAX和JSRS，而返回的数据以JavaScript形式在前台操作，格式化和显示。这允许你创建能提供接近实时的反馈给用户的web应用程序。

·支持PHP&ASP

·针对所有函数的一致的JavaScript文件

·支持远程脚本和XML

·支持本地和远程函数

·单个或者多个XMLHTTP对象

·以文本或者JavaScript. XML/DOM文档对象方式返回后台数据

·能支持POST和GET请求

·后台代理函数来访问远程函数和数据

·在所有的主要浏览器上测试过

·在GNU GPL&LGPL保护下发行

3.2 SAJAX(可用，但是不是1.0版本;自从3月2005年)

网站是：http://www.modernmethod.com/sajax/，直接把调用从Javascript发送到你的服务器端语言并再次回返。例如，调用一个javascript方法x_calculateBudget()，将先到达服务器和调用一个Java calculateBudget()方法，然后以javascript方式把值返回到x_calculateBudget_cb()。

·便利从Javascript代理函数到后台操作的映射。

·能够代理对众多服务器端平台（ASP/ColdFusion/Io/Lua/Perl/PHP/Python/Ruby）的调用。

·开源许可。来自多方面贡献者。

3.3 Javascipt对象标志(JSON)和JSON-RPC

JSON(http://www.crockford.com/JSON/index.html)，是一个"胖的自由的XML选择"，而JSON-RPC(http://www.json-rpc.org/)是一种远程过程协议，类似于XML-RPC，强有力支持Javascript客户。

·实现多服务器端平台(http://www.json-rpc.org/impl.xhtml)：Java，Python，Ruby，Perl。

·针对每种平台有独立的打包和许可，如JSON-RPC-Java(http://oss.metaparadigm.com/jsonrpc/)。

3.4 Javascript远程脚本(JSRS)(自从2000年)

网址是：http://www.ashleyit.com/rs/jsrs/test.htm，直接把调用从Javascript发送到你的服务器端语言并再次回返。

·知名的浏览器：IE4+，NS4.x，NS6.x，Mozilla，Opera7和Galeon。

·服务器端支持：ASP，ColdFusion，PerlCGI，PHP,Python和JSP(servlet)。

·开源许可。由Brent Ashley(http://www.ashleyit.com/)提供支持。

4 服务器端：Java

注意：许多现有的框架最近正在添加Java支持(例如struts)，我将在后面指出。

4.1 WebORB for Java(自从2005年8月)

网址：http://www.themidnightcoders.com/weborb/aboutWeborb.htm，是一个平台，支持开发AJAX和基于Flash的胖客户端应用程序，并可以把它们与Java对象和XML Web服务相系起来。在线举例(http：//www.themidnightcoders.com/examples)

·WebORB包括一个称作丰富的客户系统(http://www.themidnightcoders.com/rcs/index.htm)的客户端库。该丰富的客户系统提供一简单的在线api来绑定到并调用任何Java对象，XML Web服务或者EJB上的方法。

·支持同步的和异步的方法调用。

·并不要求在服务器端代码上作任何修改，不需要定制方法属性，特别的签名或者参数类型。★不要求设计时生成代理。

·同步调用返回来自于该调用(不需要回叫)的数据。异步的调用依赖于一个回叫实现。

·任何服务器端方法能被同步地或者异步地调用。

·客户应用程序能向服务器对象请求指定的活动方式。结果，对象能被轻易地创建而不需任何特殊的编程。

·提供一个特定API来处理数据库查询结果-服务器代码能返回Data集合或者Data表，而客户端以一个特殊RecordSet JavaScript对象来显示这个结果。该对象提供一个方法以检索列名和行数据。

·支持数据分页技术。客户应用程序能检索页面中的数据。

·支持所有的服务器端参数类型并返回值-原型，字符串，复合类型，数组，本机.net集合，远程参考。

·共有两种版本可用：标准版(自由)和专业版(商业许可)

4.2 Echo 2(自从3月2005年)

网址是：http://www.nextapp.com/products/echo2/，允许你用纯Java代码编写Ajax应用软件(范例(http://demo.nextapp.com/InteractiveTest/ia))。

自动地生成HTML和Javascript。

·协调浏览器和服务器之间的消息。消息形式为XML。

·如果需要，可以手工编写定制的Javascript部件。

·开源许可(Mozilla公共许可或者GNU LGPL)。源于Next App,Inc.(http://www.nextapp.com/)。

4.3 Direct Web Remoting (DWR)(2005年)

网址是：http://www.getahead.ltd.uk/dwr/，是一个框架，用于直接从Javascript代码中调用Java方法。

·象SAJAX，能把Javascript中的调用传递到Java方法，并返回到Javascript回叫。

·能与任何web框架（Struts，Tapestry，等等）一起使用。

·开源许可(Apache(http://www.apache.org/LICENSE.txt))。由Joe Walker(http://www.getahead.ltd.uk/sg/space/joe/)所支持。被加入到WebWork(http://www.opensymphony.com/webwork/)版本。

4.4 SWATO(2005年)

网址是：http://swato.dev.java.net/，是一套可重用的和良好集成的Java/JavaScript库，它实现了一种更容易的方式来改变你的web应用程序的交互，它是通过AJAX方式实现。

·服务器端Java库能被容易地配置到所有的Servlet 2.3+匹配的容器中。

·客户端JavaScript库能工作在支持HttpXMLRequest的各种浏览器中。

·使用JSON来在服务器端编组你的POJO数据。这样你能存取在任何JavaScript环境(HTML，XUL，SVG)中的远程数据，这种存取可以容易地通过硬编码或者与某种成熟的JavaScript库集成来实现。

·提供一个简单的接口来使你的JavaScript代码可以与暴露在客户端的远程POJO交互(RPC等)。

·使用web.xml中的<servlet>和<filter>的容易且灵活的配置，并能(但不是依赖)与Spring集成到一起。

·提供了几个可帮助你快速开发web应用程序的组件(如自动完成的文本框，在线表单，在线列表，等等)。

5 服务器端：Lisp

5.1 CL-Ajax

网址：http://cliki.net/cl-ajax，实现Javascript直接调用服务器端Lisp函数。

·如下输出函数：

(export-函数 #’my-函数)

·可以产生带有参数的Javascript代理。

·能回叫Javascript函数或者DOM对象。

·可以被集成进SAJAX。

·开源(定制，非常灵活，许可)。由[Richard Newman](http://www.holygoat.co.uk/)所维护。

6 服务器端：.NET

6.1 WebORB for.NET(自从8月2005年)

网址：http://www.themidnightcoders.com/weborb/aboutWeborb.htm，是一个平台，用于开发AJAX和基于Flash的胖客户端应用程序，并能把它们连接到.NET对象和XML Web服务。(在线举例(http://www.themidnightcoders.com/examples))

·WebORB包括一个客户端库，名叫Rich Client System(http://www.themidnightcoders.com/rcs/index.htm)。Rich Client System提供一简单的在线api以绑定到和调用任何.NET对象或者XML Web服务上的任何方法。

·支持同步和异步的方法调用

·并不要求在服务器端代码上作任何修改，不需要定制方法属性，特别的签名或者参数类型。**不要求设计时代理生成。

·同步调用返回来自于该调用的数据(不需要回叫)。异步的调用依赖于一个回叫实现。

·任何服务器端方法能被同步地或者异步地调用。

·客户应用程序能向服务器对象请求指定的活动方式。结果，对象能被轻易地创建而不需任何特殊的编程。

·提供一个特定API来处理数据库查询结果-服务器代码能返回DataSet或者DataTable，而客户端以一个特殊RecordSet JavaScript对象来显示这个结果。该对象提供一个方法以检索列名和行数据

·支持数据页面技术。客户端应用程序能检索页面中的数据。

·支持所有的服务器端参数类型并返回值-原型，字符串，复合类型，数组，本机.net集合，远程参考

·共有两种版本可用的：标准版(自由)和专业版(商业许可)

6.2 Ajax.NET(自从3月2005年)

网址是：http://ajax.schwarz-interactive.de/，是一个库，实现从Javascript到服务器端.NET的存取。

·象SAJAX，能把Javascript中的调用传递到.NET方法，并返回到Javascript回叫。

·能存取来自于JavaScript的会话数据。

·缓存结果

·自由使用，可用的源码，未指定使用许可。由Michael Schwarz(http://weblogs.asp.net/mschwarz/)所维护。

·不允许改变源代码，用属性标记方法

·完整的类支持以返回客户端JavaScript值

·使用HtmlControls来进行输入和返回值

·可以返回数据表，数据集，数据视图，数组和集合

7 服务器端：PHP

7.1 AjaxAC(自从2005年4月)

网址是：http://ajax.zervaas.com.au/，用单个的PHP类封装了完整的应用程序。

·所有的应用程序代码是自包含在单个类中(附加另外一些JavaScript库)

·干净利索地调用PHP文件/HTML页面。只需创建应用程序类，然后参照应用程序JavaScript和依附任何需要的HTML元素到该应用程序。

·容易地处理JavaScript事件的内嵌功能

·创建子需要并处理它们的内嵌功能

·允许定制的配置值，因此某些单元能在运行时间设置

·无凌乱的JavaScript代码夹杂在调用HTML的代码中-所有的事件是被动态依附的

·由于以上两个原因容易和模板引擎集成到一起

·容易钩到（hook in to）已有的PHP类或者MySQL数据库以返回来自于子需求的数据

·能够容易地进一步生成JavaScript对象的可扩展的窗口小组件结构(但是还需要做一些工作)

背景：

·开源许可(Apache2.0)。由Zervaas Enterprises(http://ajax.zervaas.com.au/)支持

7.2 JPSpan

网址是：http://jpspan.sourceforge.net/wiki/doku.php，直接把Javascript调用传递到PHP函数。

·进行了严肃的单元测试。

·开源许可(PHP)。

7.3 XAJAX

网址是：http://xajax.sf.net，直接把Javascript调用传递到PHP函数。

·使用Javascript代理来调用PHP脚本。

·开源。由J.Max Wilson所创。

8 服务器端：Ruby

Ruby On Rails(http://www.rubyonrails.org/)是一个通常的强力支持Ajax的web框架：

·当Ajax出现的时候Rails还处于其发展的早期，因此Ajax可能逐渐成为Rails框架的核心。

·生成浏览器中大多数/全部的窗口小组件和动画的Javascript脚本。

·支持服务器端调用。

·调度支持。　

·开源许可。

       Dwr 通过用户配置文件 dwr.xml 将 java 类映射成一个 javascript 对象，从实现手法上看与 java 里的数据映射很相似。而 dwr 是将 JAVA 的对象映射到了 js 里，由客户端的 JS 提供给用户各类实现，而 java 代码完全在后台运行。

       DWR 函数调用里涉及到的 JS 代码： engine.js

       DWR 函数调用里涉及到的类有： AbstractDWRServlet 、 DefaultProcessor

用户在提交 request 以后的操作步骤请参见我 blog 里的：《 dwr 源码学习（一）》， JAVA 代码生成的映射 JS 代码其实只是一个 javascript 接口，它调用了 DWREngine._execute 这个函数，而这个函数大体只是执行了一些解析的工作，在它结尾处调用了 DWREngine.endBatch() ，然后又执行了 DWREngine._sendData(batch) ，这时我们会发现有这样一句： “ batch.req.open("GET", batch.path + "/exec/" + statsInfo + "?" + query, batch.async); ”很熟悉吧。

    下一步就到了真正的实现 js 调用 java 代码里方法的时候了，兴奋吧。其实实现也是很简单的。通过 servlet 这里实现了对各类型 request 参数的不同的匹配，还是看 AbstractDWRServlet .getPost() 这个方法：

也就只有这几种类型的请求，还记得 DWREngine._sendData 吗？里面有这么一句：“ batch.req.open("GET", batch.path + "/exec/" + statsInfo + "?" + query, batch.async); ”看到他的请求路径是 exec ，对应在 processor.handle(req, resp); 这个方法里就是 exec ，在刚才的 JAVA 代码里我们已经看到过了是括号内的代码（ else if (pathInfo.startsWith(HtmlConstants. PATH_EXEC )) ），而 exec 早已在 servlet 初始化的时候就已经设置为 DefaultExecProcessor ，它的函数 hadle() 就是具体对 js 调用 java 类方法的实现了。

DWR 是一个小型的 AJAX 框架，它的实现思路简单，其实有很多人在开发中一定也有过类似的想法。它之所以现在才出现我想大概还是要归功于异步 javascript 消息发送这样的技术成为现实。所以我又想 AJAX ，从技术上说只能是 javascript 有了一个飞跃性的进步，而 AJAX 的最终成功却要靠软件工程。

问题的分析

我首先想到在spring但是，我很快发现一个问题：当多用户同时并发访问数据库的时候会出现资源争用的问题。这都是“单例模式”惹的祸。众所周知，我们在使用spring通过以上的分析，解决多数据源访问问题的关键，就集中在sessionFactory(一)            采用Decorator设计模式

要解决这个问题，我的思路锁定在了这个dataSource什么是“

(二)            设计MultiDataSource类

现在回到我们的问题，我们需要对dataSource

对比原Decorator

客户在发出请求的时候，将dataSourceName放到request中，然后把request中的数据源名通过调用new MultiDataSource(dataSource)时可以告诉客户需要的数据源，就可以实现动态切换数据源了。但细心的朋友会发现这在单例的情况下就是问题的，因为在系统中只有一个对象，它的实例变量也只有一个，就如同一个静态变量一般。正因为如此，(三)            单例模式下的MultiDataSource

在单例模式下，由于我们在每次调用MultiDataSource

值得一提的是，我需要的数据源已经都在spring就是其对应的bean id="dataSource1"  

为了得到spring，并且实现方法：

如此这样，我就可以通过得到了。

example.rar
描述:	源码及示例	下载
文件名:	example.rar
文件大小:	32 KB
下载过的:	文件被下载或查看 521 次

再析在spring框架中解决多数据源的问题

关键字: Spring   Hibernate Decorator 设计模式    

如何在spring总结多数据源的问题，其实它需要分为以下三种情况：各个数据源的数据结构不同、各个数据源的数据结构相同、各个数据源的数据结构部分相同又有部分不同。对于第二种情况，各个数据源的数据结构相同，我们使用一个sessionFactory对于各个数据源的数据结构不同的情况，使用一个sessionFactory与MultiDataSource   在该方案中，SessionFactory接口，Decorator就是MultiSessionFactory，SessionFactory1和SessionFactory2往往是spring的。细心的朋友可能会注意，实际上并不是SessionFactory的时候其实并不是真正地得到了它，而是得到了一个SessionFactory重写了getObject()。在整个这个方案中，我们需要实现的只有MultiSessionFactory。MultiSessionFactoryclass MultiSessionFactory implements SessionFactory, ApplicationContextAware {        private static final long serialVersionUID = 2064557324203496378L;        private static final Log log = LogFactory.getLog(MultiSessionFactory.class);        private ApplicationContext applicationContext = null;        private SessionFactory sessionFactory = null;        public ApplicationContext getApplicationContext() {            return applicationContext;        }        public void setApplicationContext(ApplicationContext applicationContext) {           this.applicationContext = applicationContext;        }        public SessionFactory getSessionFactory(String sessionFactoryName) {           log.debug("sessionFactoryName:"+sessionFactoryName);           try{               if(sessionFactoryName==null||sessionFactoryName.equals("")){                  return sessionFactory;               }               return (SessionFactory)this.getApplicationContext().getBean(sessionFactoryName);           }catch(NoSuchBeanDefinitionException ex){               throw new DaoException("There is not the sessionFactory         }        }           public SessionFactory getSessionFactory() {           String sessionFactoryName = SpObserver.getSp();           return getSessionFactory(sessionFactoryName);        }           public void setSessionFactory(SessionFactory sessionFactory) {           this.sessionFactory = sessionFactory;        }           // SessionFactory接口需要实现的方法       ......       }   MultiSessionFactory的完整代码见我提供的附件。bean id="sessionFactory" class="com.htxx.service.dao.MultiSessionFactory">       <property name="sessionFactory"><ref bean="hostSessionFactory"/>property>  >   SpServer的写法与《如何在另外，在spring也许有些朋友对以上方案还不满意，因为在执行数据访问前毕竟还要多做一步指定sessionFactory另外，在这个方案中的核心是运用Decorator前面我已经给出了第一种和第二种情况的解决方案：各个数据源的数据结构不同的情况用MultiSessionFactory example.rar  描述:  示例文件 下载  文件名:  example.rar  文件大小:  16 KB  下载过的:  文件被下载或查看 180 次

建议到原作者博客查看原文,那里有很好的回复讨论~http://fangang.javaeye.com/blog/72486

org.

仔细查看和跟踪源码，我发现这个问题出在AbstractOutboundVariable

当dwr已经使用了某个对象以后，就会将它的置为，当再次装载这个对象的时候就会强制抛出异常。这在通常情况下是没有问题的，但在我们前面提到的例子中就有问题了。当转换员工值对象集合的时候，首先装载和转换了员工甲，他因为是“研发部”所以也装载了“研发部”这个部门值对象。然后开始装载和转换员工乙。由于员工乙也是“研发部”，因此又开始装载“研发部”这个值对象，但突然发现这个值对象已经装载过了，因而就抛出了以上错误。

如果我们希望整合、、到一起进行项目开发，以上这个问题是怎么也不能避免的，问题是如何解决。非常遗憾的是，官方似乎还没有要解决这个问题的意思，我思索再三以后决定，还是“自己动手丰衣足食”吧。解决的办法其实很简单，就是把行这个强制抛出异常注释掉，然后重新编译。这样修改以后就再也没有出现以上问题，同时至今也没有发现其它问题出现。这个问题我同样在《DWR帮助文档－dwr.xml文件的配置DWR帮助文档－dwr.xml文件的配置在使用dwrMissing java bean property to match javascript property:[属性名如果将log4jYou may be missing the correct setter: setXXX()

The property may be excluded using include or exclude rules.

其实你并没有在dwr在使用dwr

之所以说这个异常比较离谱，是因为它似乎就没有dwr3.2.0.rc4这个还是hibernate3CharScanner; panic: 遇到这个问题不要怕，其实解决的方法很简单，就是在springproperty name="hibernateProperties">  

然后写一个UserInfoUtil前面谈完了request首先，我们可能在不同的项目中会对为项目提供多种权限校验的机制，比如通过部门级次进行校验、通过分配给用户的功能进行校验、通过用户的特殊身份（总经理、局长等）进行校验等。这些校验机制并不是每个bus另外，我们还可能出现，一些特殊的功能需要单独为它设计一个权限校验机制，这个机制只作用与它自己。

还有一种情况是权限校验机制需要分不同的方法进行校验，如增删改一个校验机制，而查询是另一种校验机制。

然后，我们不希望在开发过程中加上权限校验机制，这无疑会为我们的调试增加许多的不便。

总结以上所有对权限校验的需求，使用filter我在前面的文章中提到，在页面端dwr最后我要提到的，就是dwr除此以外，与其它框架一样，我们在运用dwr

如何在struts+spring+hibernate的框架下构建低耦合高内聚的软件》。昨天和几个朋友讨论问题的时候，谈到通过DaoSupport

2

java 代码

1. package com.htxx.thps.psb.dao.imp;   
2.   
3. import com.htxx.service.dao.BasicDao;   
4. import com.htxx.service.dao.Condition;   
5. import com.htxx.service.dao.ResultSet;   
6. import com.htxx.thps.model.PsPsb;   
7. import com.htxx.thps.model.PsPsjcd;   
8. import com.htxx.thps.model.PsWtmx;   
9. import com.htxx.thps.psb.dao.PsbDao;   
10.   
11. /**  
12.  * @author FanGang  
13.  *  
14.  */  
15. public class PsbDaoImp extends BasicDao implements PsbDao {   
16.   
17.     /* (non-Javadoc)  
18.      * @see com.htxx.thps.psb.dao.PsbDao#getPsb(java.lang.String)  
19.      */  
20.     public PsPsb getPsb(String id) {   
21.         return (PsPsb)this.load(PsPsb.class, id);   
22.     }   
23.   
24.     /* (non-Javadoc)  
25.      * @see com.htxx.thps.psb.dao.PsbDao#updatePsb(com.htxx.thps.model.PsPsb)  
26.      */  
27.     public void updatePsb(PsPsb vo) {   
28.         this.update(vo);   
29.     }   
30.   
31.     /* (non-Javadoc)  
32.      * @see com.htxx.thps.psb.dao.PsbDao#getPsb(com.htxx.service.dao.Condition)  
33.      */  
34.     public ResultSet getPsb(Condition condition) {   
35.         return this.query("PsPsb", condition);   
36.     }   
37.   
38.     public PsPsjcd getPsjcd(String id) {   
39.         return (PsPsjcd)this.load(PsPsjcd.class, id);   
40.     }   
41.   
42.     public ResultSet getPsjcd(Condition condition) {   
43.         return this.query("PsPsjcd", condition);   
44.     }   
45.   
46.     public PsWtmx getWtmx(String id) {   
47.         return (PsWtmx)this.load(PsWtmx.class, id);   
48.     }   
49.   
50.     public ResultSet getWtmx(Condition condition) {   
51.         return this.query("PsWtmx", condition);   
52.     }   
53.   
54.     public void updatePsjcd(PsPsjcd vo) {   
55.         this.update(vo);   
56.     }   
57.   
58.     public void updateWtmx(PsWtmx vo) {   
59.         this.update(vo);   
60.     }   
61.   
62. }  

4 

 

如何在struts+spring+hibernate的框架下构建低耦合高内聚的软件》中已经给出了这个结构的一个实现，供大家参考。

我常常在思考一个问题，我们如何能设计出高水平、高质量的软件出来。怎样是高水平、高质量的软件？它应当是易于维护、易于适应变更、可重用性好的一个系统。如何做到这一点呢？答案当然是“低耦合、高内聚”了。低耦合就是软件在构造的时候，各个模块、各个功能、各个类都不会过度依赖于它周围的环境。只有这样，才能使我们的模块（功能、类）在周围发生变更时不受影响，做到易于维护和易于适应变更。正因为如此，也使它更易于重用到其它功能类似的环境中，提高了重用性。高内聚则使软件中的各个模块（功能、类）能够各尽其能而又充分合作，也就是对于软件问题空间中需求的各个功能，系统可以合理地把它分配给各个模块（功能、类）来共同完成，而不是一个或几个八面玲珑、包打天下的超级类一个人完成。而对于该系统中的某一个模块（功能、类），具有自己高度相关的职责，即该职责中的几个任务是高度相关的。每一个模块（功能、类）都决不去完成与自己无关职责的任务。

那么怎样能构造一个低耦合、高内聚的系统能，时下最流行的框架结构之一的struts+spring+hibernate然而我要说的是，即使我们使用了struts+spring+hibernate 

分析与决策

1.       编写DAO的时候不要直接去使用hibernate或spring对hibernate的支持。

现在我们在编写DAO以上问题，究其原因，是我们项目中的DAO

2.       编写Action的时候不要直接使用spring和spring的继承类

前面我说了应当避免DAO的继承类然后使用它的方法。如此的使用，我们的Action将依赖与spring。我们同样可以使用一个叫BasicAction的父类，然后用一个接口来隔离spring。由于ActionBasicAction中，提高系统的可维护性。

3.       当BUS需要获取别的模块的数据的时候，不要直接去使用该模块的DAO

我举一个简单的例子：我需要设计一个软件评审的管理软件，该软件分为评审组织者制订评审计划、评审者分别填写评审表后由评审组织者汇总评审表、评审组织者制作评审报告。这是一个非常简单的项目，分成了三个人来完成。但是项目进行快结束的时候却出现了问题。填写评审表需要获得评审计划中的一些数据，制作评审报告的数据来源于评审表。项目组在开始编程前先开了一次会，大家约定好了各个部分的数据格式及其规则，然后开始工作。然而数天后项目组把各个模块整合以后发现，系统根本跑不起来，为什么呢？设计评审计划的人发现，所有评审计划应当按照产品编号来进行管理而不是项目编号。由于这个变更，填写评审表模块在待评审列表中什么都无法显示；同样，设计评审表的人发现，在一个评审计划中评审表与评审者不是一对多的关系，而是一对一的关系，因而修改了这两个表的关联。因为这样，在制作评审报告时就不能正确得到评审表数据。其实一个软件项目在整个进行过程中总是不断变更。我们需要做的不是去抑制这些变更，而应当是通过软件的结构去适应这些变更，即是降低各模块间的依赖（耦合），提高内聚。

拿这个实例来说，当评审表需要调用评审计划的数据的时候，不应当是自己写一个DAO去调用评审计划的数据，而应当是调用评审计划的接口，将这个任务交给评审计划类来完成。当评审报告需要调用评审表的数据的时候，同样应当去调用评审表的接口，由评审表来实现。同时，这种调用应当是去调用BUS层的接口。为什么呢？比如在评审计划中的一个业务逻辑是只有在评审计划发布以后才能制作评审表，那么怎样才是已发布的评审计划呢？这个业务逻辑应当由谁来定义？当然是评审计划。在什么地方定义？当然是BUS而不是DAO，因为DAO仅仅是实现数据的持久化，而BUS才是实现业务逻辑的地方。既然如此，如果评审表去调用评审计划的DAO，那么已发布评审计划的业务逻辑必然包含在了评审表的业务逻辑里了。我们假设有一天，已发布评审计划的业务逻辑发生变更了（实际上这样的会在你毫不经意间就发生了），编写评审计划的人会很快就修改了评审计划的业务实现并且测试通过了。他不知道评审表里也包含了这样的业务逻辑，因而修改后的程序在运行到评审表的时候就很可能会出错。不幸的是，在实际工作中，同样一个业务逻辑可能包含在无数个你可能知道，但你也可能不知道的代码中。这样的结构就是一个不易于维护的差的结构。

总结：从技术升级和需求变更两方面适应变化

软件开发专家Alistair Cockburn相关链接：回复：《如何在struts+spring+hibernate的框架下构建低耦合高内聚的软件》。

Spring-Hibernate.rar
描述:		下载
文件名:	Spring-Hibernate.rar
文件大小:	9 KB
下载过的:	文件被下载或查看 511 次

一个dwr+spring+hibernate的示例

这是一个运用dwr+spring+hibernate这样一个框架编写的示例。它展示了一下内容： 1、在dwr中尝试编写的一些通用的代码，包括如何编写一个通用的列表显示框并实现分页、如何编写一个通用的单行编辑框、如何编辑一个通用的存盘和删除程序等等。 2、在dwr中如何与spring兼容，调用bus中的方法；在dwr中如何与hibernate兼容，在页面端操作值对象，以及处理值对象间的各种关系。 3、如何在spring中实现单dao，使这个单dao既可以与hibernate隔离，使其低耦合高内聚，提高可维护性，又能满足各个bus的业务需要，简化开发的过程。 不是美工，界面比较外行，见谅了：） 示例在MyEclipse中安装部署的步骤： 1、创建一个新的web项目并拷贝示例中的文件到项目中。注意web.xml文件应当是将原文件覆盖。 2、添加spring和hibernate。点击项目树中的项目名按Alt+Enter键，弹出项目属性对话框。选择“Java Build Path”中的“Libraries”标签，然后点击“Add Library”按钮，选择“MyEclipse Libraries”，点击“Next”，选择“Hibernate 3.0 Core Libraries”、“Spring 1.2 AOP Libraries”、“Spring 1.2 Core Libraries”、“Spring 1.2 ORM/DAO/Hibernate Libraries”、“Spring 1.2 Web Libraries”，点击“Finish”按钮。 3、点击“Add External JARs”按钮，添加dwr.jar、daosupport.jar、hxtg.jar、hibernate3(必须将hibernate3升级到3.2以上)以及其它数据库相关的jar包到项目中。添加完成以后记得重新部署应用服务器。 4、创建数据库实例，如果是oracle，在pl/sql中运行示例中的employee.sql创建数据库对象。 5、修改ApplicationContext-hibernate.xml中datasource的连接属性为你的数据库。部署完成！ 部署完成后运行可能会在部分功能中出错。这些问题的解决我会在《DWR帮助说明－dwr的bug及其解决方法》中详细讨论。 相关文档： 如何在struts+spring+hibernate的框架下构建低耦合高内聚的软件 DWR帮助文档－dwr.xml文件的配置 DWR帮助说明－如何编写通用的列表显示框 DWR帮助说明－如何编写通用的单行编辑框 DWR帮助说明－服务器端程序的编写 DWR帮助说明－dwr的bug及其解决方法

employee.rar
描述:		下载
文件名:	employee.rar
文件大小:	272 KB
下载过的:	文件被下载或查看 236 次

employee.rar
描述:	重新修订了一下	下载
文件名:	employee.rar
文件大小:	2 M
下载过的:	文件被下载或查看 397 次

1.架设基于Svnserve的服务器

2.让Svnserve在Windows启动时，自动启动  

一，下载TortoiseSVN和Subversion软件

二，新建仓库
    仓库是存放你的源代码文件等等的集散地。

三，架设Svnserver服务器
    Svnserver是Subversion自带的一个轻量级的服务器。
    1. 启动Svnserver服务

    2. 让Svnserver随Windows自动启动

    3. 控制Svnserver访问权限

第一、组织结构预览如下图：

 第二、功能说明：

当鼠标点击左边某组织时，会把该组织下的所有成员添加到右边（排重）；

当鼠标点击左边某成员时，会把该成员添加到右边（排重）；

当鼠标点击"全选"时，会把所有组织的成员添加到右边（排重）；

当鼠标点击"移除"时，会把右侧被选中的成员移除；

第三、java script代码实现如下：

//添加成员
    function addUser(id, name) {
        var oOption = document.createElement("OPTION");
        oOption.text = name;
        oOption.value = id;
        var oSelect = window.parent.document.getElementById("groupdest");
        if (!checkById(id, name)) {
            oSelect.add(oOption);
        } 
    }

//添加组织
    function addGroup(id, ids, names) {
        if (ids == "") {
            return;
        }
        var idArr = ids.split(",");
        var nameArr = names.split(",");
        var len = idArr.length;
        for (var i = 0; i < len - 1; i ++) {
            addUser(idArr[i], nameArr[i]);
        }
    }

//检查是否已经添加过
    function checkById(id, name) {
        var oSelect = window.parent.document.getElementById("groupdest");
        var bContains = false;
        for (var i = 0; i < oSelect.length; i++) {
            if (oSelect.options[i].value == id || oSelect.options[i].text == name) {
                bContains = true;
            }
        }
        return bContains;
    }

//移除用户

function removeUser() {
        var oSelect = document.getElementById("groupdest");
        for (var i = 0; i < oSelect.length; i++) {
            var option = oSelect.options[i];
            if (option.selected == true) {
                oSelect.remove(i);
                return;
            }
        }
    }

第四：树状组织结构图的MzTreeView-1.0动态实现的Table

/**
 *
 */
package com.daniel.lr.crbt.share.db;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Table;

import org.hibernate.validator.Pattern;

/**
 * @author Daniel Cao
 * @date   2007-4-27
 * @time   下午10:47:59
 *
 * 树状菜单(Menu)数据库定义.
 * 利用MzTreeView1.0生成.
 * 每个字段值中不可有冒号,不可以换行,
 * 引号酌情考虑应不与节点字符串的引号相冲突
 *
 */
@Entity
@Table(name="sys_menu")
public class Menu extends HibernateObject {
 private static final long serialVersionUID = 9135605811004668162L;
 //父节点ID,若已经是根节点则为0
 private Long   parentId;
 //节点显示文本,根节点可空，表示不显示
 private String text;
 //节点提示说明
 private String hint;
 //节点的图标,对应的名字在类里的icons和iconsExpand定义,这里表示图片的名称pic.gif;picopen.gif格式
 private String icon;
 //节点挂的数据,如param=value&param=value,url里?后的那串字符串格式
 private String data;
 //节点的链接,它为空或者为#时,这个节点的链接，点击将无反应
 private String url;
 //每个节点的链接允许在不同的target里打开,为空时取类里的默认值
 private String target;
 //点击该链接时所想触发的脚本语句
 private String method;
 
 @Column(name="menu_data")
 @Pattern(regex="[^:\n\r]+")
 public String getData() {
  return data;
 }
 public void setData(String data) {
  this.data = data;
 }
 @Column(name="menu_hint")
 @Pattern(regex="[^:\n\r]+")
 public String getHint() {
  return hint;
 }
 public void setHint(String hint) {
  this.hint = hint;
 }
 @Column(name="menu_icon")
 @Pattern(regex="[^:\n\r]+")
 public String getIcon() {
  return icon;
 }
 public void setIcon(String icon) {
  this.icon = icon;
 }
 @Column(name="menu_method")
 @Pattern(regex="[^:\n\r]+")
 public String getMethod() {
  return method;
 }
 public void setMethod(String method) {
  this.method = method;
 }
 @Column(name="menu_parent_id")
 @Pattern(regex="[^:\n\r]+")
 public Long getParentId() {
  return parentId;
 }
 public void setParentId(Long parentId) {
  this.parentId = parentId;
 }
 @Column(name="menu_target")
 @Pattern(regex="[^:\n\r]+")
 public String getTarget() {
  return target;
 }
 public void setTarget(String target) {
  this.target = target;
 }
 @Column(name="menu_text",nullable=false)
 @Pattern(regex="[^:\n\r]+")
 public String getText() {
  return text;
 }
 public void setText(String text) {
  this.text = text;
 }
 @Column(name="menu_url")
 @Pattern(regex="[^:\n\r]+")
 public String getUrl() {
  return url;
 }
 public void setUrl(String url) {
  this.url = url;
 }
}

/**
 *
 */
package com.daniel.lr.crbt.share.db;

import java.io.Serializable;
import java.util.Date;

import javax.persistence.Column;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.MappedSuperclass;

/**
 * @author Dianel Cao
 * @date   2007-4-18
 * @time   下午02:43:34
 *
 */
@MappedSuperclass
public abstract class HibernateObject implements Serializable {
 private Long   id;  //id主键值
 private String name;  //名称，备用字段
 private String status;  //status，备用字段
 private String memo;  //memo，备用字段
 private String createUser;  //创建者，备用字段
 private Date   createTime;  //创建日期，备用字段
 private Date   lastUpdateTime;  //更新日期，备用字段
 
 @Id@GeneratedValue(strategy=GenerationType.IDENTITY)
 public Long getId() {
  return id;
 }
 public void setId(Long id) {
  this.id = id;
 }
 @Column(name="name",length=60)
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 @Column(name="status",length=10)
 public String getStatus() {
  return status;
 }
 public void setStatus(String status) {
  this.status = status;
 }
 @Column(name="memo")
 public String getMemo() {
  return memo;
 }
 public void setMemo(String memo) {
  this.memo = memo;
 }
 @Column(updatable=true,name="createUser",nullable=true,length=60)
 public String getCreateUser() {
  return createUser;
 }
 public void setCreateUser(String createUser) {
  this.createUser = createUser;
 }
 @Column(updatable=false,name="createTime",nullable=false)
 public Date getCreateTime() {
  return createTime;
 }
 public void setCreateTime(Date createTime) {
  this.createTime = createTime;
 }
 @Column(name="lastUpdateTime")
 public Date getLastUpdateTime() {
  return lastUpdateTime;
 }
 public void setLastUpdateTime(Date lastUpdateTime) {
  this.lastUpdateTime = lastUpdateTime;
 }
}

第五、动态树状组织结构的Taglib实现：

/**
 *
 */
package com.daniel.lr.crbt.service.web.taglib;

import java.io.IOException;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.JspWriter;
import javax.servlet.jsp.tagext.Tag;
import javax.servlet.jsp.tagext.TagSupport;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import com.daniel.lr.crbt.share.db.Menu;

/**
 * @author Daniel Cao
 * @date 2007-4-27
 * @time 下午11:51:09
 *
 */
public class TreeMenuTag extends TagSupport {
 private static final long serialVersionUID = -4747559965295669957L;
 protected Log logger = LogFactory.getLog(TreeMenuTag.class);
 // 菜单数据
 private Collection<Menu> menuCollection;
 // 树节点的图标存放位置路径，可以是相对路径或绝对路径
 private String imagePath = "images/";
 // 点击节点时，默认跳转的Url
 private String defaultUrl = "#";
 // 点击节点时，打开的默认位置，可以是_top,_self,_parent,某一页面Name等
 private String defaultTegart = "_self";

 @Override
 public int doEndTag() throws JspException {
  try {
   JspWriter out = this.pageContext.getOut();
   out.write(buildTreeMenu(menuCollection));
  } catch (IOException ioe) {
   logger.error("输出自定义标签时错误.", ioe);
   throw new JspException("输出自定义标签时错误.");
  } catch (Exception e) {
   logger.error("创建自定义标签时错误.", e);
   throw new JspException("创建自定义标签时错误.");
  }
  return Tag.EVAL_PAGE;
 }

 @Override
 public int doStartTag() throws JspException {
  return Tag.SKIP_BODY;
 }

 @Override
 public void release() {
  menuCollection = null;
  super.release();
 }
 
 private String buildIcons(Collection<Menu> menuCollection) throws Exception{
  StringBuilder sb = new StringBuilder("");
  
  List<String> iconList = new ArrayList<String>();
  for (Menu menu : menuCollection) {
   String icon = menu.getIcon();
   if (icon == null || icon.trim().equals("") || icon.trim().equals(";")){
    continue;
   }
   if (icon.indexOf(";") == 0) {//只有打开图标不符合,用默认图标
    continue;
   }else if (icon.indexOf(";") == icon.length() - 1) {
    String iconname = icon.substring(0, icon.length() - 1);
    String iconname1 = iconname.split("file://.")[0/];
    if (!iconList.contains(iconname)) {
     sb.append("tree.icons[\"");
     sb.append(iconname1);
     sb.append("\"] = \"");
     sb.append(iconname);
     sb.append("\";\n");
     
     iconList.add(iconname1);
    }
   }else{
    String[] icons = icon.trim().split(";");
    String name0 = icons[0].split("file://.")[0/];
    if (!iconList.contains(name0)) {
     sb.append("tree.icons[\"");
     sb.append(name0);
     sb.append("\"] = \"");
     sb.append(icons[0]);
     sb.append("\";\n");
     sb.append("tree.iconsExpand[\"");
     sb.append(name0);
     sb.append("\"] = \"");
     sb.append(icons[1]);
     sb.append("\";\n");

     iconList.add(name0);
    }
   }
  }
  
  return sb.toString();
 }

 private String buildTreeMenu(Collection<Menu> menuCollection) throws Exception {
  StringBuilder sb = new StringBuilder("");
  sb.append("<script language=\"JavaScript\">\n");
  sb.append("var tree = new MzTreeView(\"tree\");\n");
  //以下三步不能换位置
  //1,创建自定义图标库
  sb.append(buildIcons(menuCollection));
  //2,设定图标库路径
  sb.append("tree.setIconPath(\"");
  sb.append(imagePath);
  sb.append("\"); \n");
  //3,设定节点属性
  for (Menu menu : menuCollection) {
   String nodeInfo = "";
   String text = menu.getText();
   if (text != null && !text.equals("")) {
    nodeInfo += "text:" + text + ";";
   }
   Long id = menu.getId();
   Long pId = menu.getParentId();
   String hint = menu.getHint();
   if (hint != null && !hint.equals("")) {
    nodeInfo += "hint:" + hint + ";";
   }
   String icon = menu.getIcon();
   if (icon != null && !icon.trim().equals("") && icon.trim().length() > 1) {
    if (icon.indexOf(";") == 0) {//只有打开图标不符合,用默认图标
     continue;
    } else if (icon.indexOf(";") == icon.length() - 1) {
     String iconname = icon.substring(0, icon.length() - 1);
     String iconname1 = iconname.split("file://.")[0/];
     nodeInfo += "icon:" + iconname1 + ";";
    } else {
     String[] icons = icon.trim().split(";");
     String name0 = icons[0].split("file://.")[0/];
     nodeInfo += "icon:" + name0 + ";";
    }
   }
   String data = menu.getData();
   if (data != null && !data.trim().equals("")){
    nodeInfo += "data:" + data + ";\n";
   }else{
    nodeInfo += "data:id=" + id + "&name=" + URLEncoder.encode(text,"utf-8") + ";";
   }
   String url = menu.getUrl();
   if (url != null && !url.trim().equals("")){
    nodeInfo += "url:" + url + ";";
   }
   String target = menu.getTarget();
   if (target != null && !target.trim().equals("")){
    nodeInfo += "target:" + target + ";";
   }
   String method = menu.getMethod();
   if (method !=null && !method.trim().equals("")){
    String methodName = method.split("file://(")[0/];
    if (methodName.indexOf("javascript:") == -1){
     methodName = "javascript:" + methodName;
    }
    if (method != null && !method.trim().equals("")){
     nodeInfo += "method:" + methodName + "(" + id + ",'" + text + "');";
    }
   }
   nodeInfo += "\";";
   
   sb.append("tree.nodes[\"");
   sb.append(pId);
   sb.append("_");
   sb.append(id);
   sb.append("\"] = \"");
   sb.append(nodeInfo);
   sb.append("\n");
  }
  sb.append("tree.setURL(\"");
  sb.append(defaultUrl);
  sb.append("\");\n");
  sb.append("tree.setTarget(\"");
  sb.append(defaultTegart);
  sb.append("\");\n");
  sb.append("document.write(tree.toString());\n");
  sb.append("</script>\n");

  return sb.toString();
 }

 public String getDefaultTegart() {
  return defaultTegart;
 }

 public void setDefaultTegart(String defaultTegart) {
  this.defaultTegart = defaultTegart;
 }

 public String getDefaultUrl() {
  return defaultUrl;
 }

 public void setDefaultUrl(String defaultUrl) {
  this.defaultUrl = defaultUrl;
 }

 public String getImagePath() {
  return imagePath;
 }

 public void setImagePath(String imagePath) {
  this.imagePath = imagePath;
 }

 public Collection<Menu> getMenuCollection() {
  return menuCollection;
 }

 public void setMenuCollection(Collection<Menu> menuCollection) {
  this.menuCollection = menuCollection;
 }
}

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1611914

 弄清楚struts-config.xml中各项元素的作用，对于我们构建web项目有莫大的好处。<struts-config>是struts的根元素，它主要有8个子元素，DTD定义如下：

<!ELEMENT struts-config
(data-sources?,form-beans?,global-exceptions?,global-forwards?,action-mappings?,controller?,message-resources*,plug-in*)
>
以上8个元素，下面一一描述：
1. date-sources元素
　　date-sources元素用来配置应用程序所需要的数据源。java语言提供了javax.sql.DateSource接口，所有数据源必须实现该接口。如下配置：
<data-sources>
　　<data-source type="org.apache.commons.dbcp.BasicDataSource">
　　　　………………
　　</data-source>
</data-sources>
在Action中访问方式如：
javax.sql.DataSource dataSource;
java.sql.Connection myConnection;
try
{
　　dataSource = getDataSource(request);
　　myConnection　＝　dataSource.getConnection();
}
…………
　　如果是多数据源，可用如下配置：
<data-sources>
　　<data-source key="a"  type="org.apache.commons.dbcp.BasicDataSource">
　　　　………………
　　</data-source>
　　<data-source key="b"   type="org.apache.commons.dbcp.BasicDataSource">
　　　　………………
　　</data-source>
</data-sources>
访问方式：dataSource = getDataSource(request,"a");

 2. form-beans元素
　　该元素主要用来配置表单验证的类。它包含如下属性：
　　1. classname：一般用得少，指定和form-bean无素对应的配置类，默认为org.apache.struts.config.FormBeanConfig，如果自定义，则必须扩展FormBeanConfig类。可有可无。
　　2. name：ActionForm Bean的惟一标识。必须。
　　3. type：ActionForm的完整类名。必须。
如下所示：
<form-beans>
　　<form-bean
　　　　　　name="Loign"
　　　　　　type="com.ha.login">
　　</form-bean>
</form-beans>
　　如果是动态Action FormBean，还必须配置form-bean元素的form-property子元素。它包含四个属性，上面三个，还有一个initial 元素：以字符串的形式设置表单字段的初始值，如果没有设置该属性，则是基本类型为0，如果是对象则为null。可有可无。如下所示：
<form-beans>
　　<form-bean
　　　　　　name="Loign"
　　　　　　type="com.ha.login">
　　　　　<form-property name="ok"  type="java.lang.String"/>
　　　　　<form-property name="oks"  type="java.lang.String"/>
　　　　　<form-property name="okss"  type="java.lang.Integer" initial="20"/>
　　</form-bean>
</form-beans>

 3. global-exceptions元素
　　该元素主要配置异常处理，它的exception子元素代表全局的异常配置。struts采取配置的方式来处理异常。它用来设置java异常和异常处理类org.apache.struts.action.ExceptionHandler之间的映射。它有七个属性，如下所示：
　　1. className：指定和exception元素对应的配置类，默认为：org.apache.struts.config.ExceptionConfig。可有可无。
　　2. Handler：指定异常得理类，默认为：org.apache.struts.action.ExceptionHandler。可有可无
　　3. key：指定在Resource Bundle中描述该异常的消息key
　　4. path：指定当异常发生时的转发路径。
　　5. scope：指定ActionMessages实例的存放范围，可选值包括：request和session，默认为request。可有可无。
　　6. type：指定所需处理异常类的名字，必须。
　　7. bundle：指定Resource Bundle
如下所示：
<global-exceptions>
　　<exception
　　　　　　key="global.error.invalidlogin"
　　　　　　path="/error.jsp"
　　　　　　scope="request"
　　　　　　type="com.hn.tree"
　　/>
</global-exceptions>

 4. global-forwards元素
　　该元素主要用来声明全局的转发关系，它具有以下四个属性：
　　1. className：和forward元素对应的配置类，默认为：org.apache.struts.action.ActionForward。可有可无。
　　2. contextRelative：此项为true时，表时path属性以＂/＂开头，相对于当前上下文的URL，默认为false．可有可无。　
　　3. name：转发路径的逻辑名．必填。
　　4. path：转发或重定向的URL，当contextRelative=false时，URL路径相对于当前应用（application），当为ture时，表示URL路径相对于当前上下文（context）。
　　5.  redirect：当此项为ture时，表示执行重定向操作。当此项为false时表示转向操作。默认为false。
如下所示：
<global-forwards>
　　<forward  name="forms1"  path="/a.do"/>
　　<forward  name="forms2"  path="/nb.jsp"/>
<global-forwards>

 5. action-mappings元素
　　描述从特定的请求路径到相应的Action类的映射。它具有以下几个属性：
　　1. attribute：设置和Action关联的ActionForm Bean在request和session范围内的key。如：Form Bean存在于request范围内，此项设为“myBenas”，则在request.getAttribute("myBenas")就可以返回该Bean的实例。
　　2. classsName：和action元素对应的配置元素，默认为：org.apache.struts.action.ActionMapping.
　　3. forward：转发的URL路径。
　　4. include：指定包含的URL路径。
　　5. input：输入表单的URL路径，当表单验证失败时，将把请求转发到该URL。
　　6. name：指定和Action关联的Action FormBean的名字，该名字必须在Form-Bean定义过。
　　7. path：指定访问Action的路径，以“/”开头，无扩展名。
　　8. parameter：指定Actgion的配置参数，在Action类的execute()方法中，可以调用ActionMapping对象的getParameter()方法来读取该配置参数。
　　9. roles：指定允许调用该Action的安全角色，多个角色之间用，隔开，在处理请求时，RequestProcessor会根据该配置项来决定用户是否有权限调用Action权限。
　　10. scope：指定ActionForm Bean的存在范围，可选取为request和session，默认为session。
　　11. type：指定Action类的完整类名。
　　12. unknown：如果此项为true，表示可以处理用户发出的所有无效的Action URL，默认为false；
　　13. validate：指定是否要调用Action FormBean的validate方法，默认值为ture.
注：forward、include、type属性只能选中其中一项。
如下：
<action path="/search"
　　　　type="zxj.okBean"
　　　　name="a1"
　　　　scope="request"
　　　　validate="true"
　　　　input="/b.jsp">
　　<forward name="tig" path="/aa.jsp"/>
</action>
注：此中的forward是指局部的转发路径。global-forwards表示全局的转发路径。

 6. controller元素
　　该元素用于配置ActionServlet。它具有以下属性。
　　1. bufferSize：指定上载文件的输入缓冲大小，可选，默认为4096
　　2. className：指定和controller元素对应的配置类，默认为org.apache.struts.config.ControllerConfig
　　3. conentType：字符编码，如果在Action和JSP网页中设置了，则覆盖该设置。
　　4. locale：指定是否把Locale对象保存到当前用户的session中，默认值为false.
　　5. processorClass：指定负责请求的java类完整路径。
　　6. tempDir：指定处理文件的临时工作目录，如果此项没有设置，将采用Servlet容器为web应用分配的临时工作目录。
　　7. nochache：如果为true：在响应结果中将加入特定的头参数：Pragma,Cache-Control和Expise，防止页面被保存在客户端的浏览器中，默认为false
如下：
<controller
　　contentType="text/html;charset="UTF-8""
　　locale="true"
　　processorClass="con.ok"/>

 7. message-resources元素
　　主要配置本地化消息文本，它具有以下属性。
　　1. className：和message-resources元素对应的配置类，默认为org.apache.struts.config.MessageResourcesConfig。
　　2. factory：指定消息资源的工厂类，默认为：org.apache.struts.util.PropertyMessageResourcesFactory类
　　3. key：指定Resource Bundle存放的ServletContext对象中时采用的属性Key，默认由Globals.MESSAGES_KEY定义的字符串常量，只允许一个Resource Bundle采用默认的属性Key。
　　4. null：指定MessageSources类如何处理未知消息的key，如果为true，则返回空字符串，如果为false，则返回相关字串，默认为false
　　5. prameter：指定MessageSources的资源文件名，如果为：a.b.ApplicationResources，则实际对应的文件路径为：WEB-INF/classes/a/b/ApplicationResources.properties.
如：
<message-resources null="false" parameter="defaultResource"/>
<message-resources key="num1" null="false" parameter="test"/>
访问为：
<bean:message  key="zxj"/>
<bean:message  key="zxj"  bundle="num1"/>
其中，zxj表法，messagesource资源文件中的一个字符串。

 8. plugin-in元素
　　配置Struts的插件，属性如下：
　　1. className：指定的Struts插件类，必须实现org.apache.struts.action.PlugiIn接口。如：
<plug-in
　　className="a.b.c.">
　　<set-property property="xxx" value="/WEB-INF/aa.xml"  />
</plug-in>

 后记，多模块的配置，可以供多个应用应用不同的struts-config.xml

(转载于：http://blog.csdn.net/zxjcool/archive/2006/06/18/810305.aspx)