摘要: Why is RUNSTATS important?
Almost every major database today uses some method of updating catalog statistics to provide the best information possi...
阅读全文
posted @
2006-06-23 15:40 MyJavaWorld 阅读(437) |
评论 (0) |
编辑 收藏
|
| When you update table statistics using the RUNSTATS command, it requires that you run the command against each table, one by one. REORGCHK gives you the capability to update the statistics of a group of tables or all the tables in the database, with only one command. |
|
.
|
|
_
|
DB2 UDB uses the statistics information in the catalog table to derive the best access plan. The DBA should regularly run the RUNSTATS command to keep the database statistics updated. This procedure will ensure the best performance on queries.
If you want to update statistics on all the tables or a group of tables in the database, you can use the REORGCHK command with the UPDATE STATISTICS option. This would be run instead of running the RUNSTATS command against each table. The UPDATE STATISTICS option will first call the RUNSTATS routine to update the table statistic. You can then use these new statistics to determine if a reorg is needed.
The REORGCHK command allows you to update statistics on a group of tables with one command.
To update all the user and system tables use:
REORGCHK UPDATE STATISTICS ON TABLE ALL
To update all the tables of a particular schema use:
REORGCHK UPDATE STATISTICS on SCHEMA schema_name
To update all the tables of a particular table system use:
REORGCHK UPDATE STATISTICS on TABLE SYSTEM
|
|
|
|
|
posted @
2006-06-23 15:19 MyJavaWorld 阅读(469) |
评论 (0) |
编辑 收藏
<html:radio idName=" idName " value="value" name=" name" property=" property " />
表示在输出时，html:radio输出为input type="radio"；name输出为name="name"；对
于value的输出，当不指定idName时，value="value"，当指定idName时，输出是由bean
名为" idName "，属性名为"value"的属性值；当bean名为" name "，属性名为" property "的属性值等于上述value的输出值时，输出checked="checked"。
我的例子：
<logic:iterate id = "answer" name = "answerList" scope = "page">
<html:radio idName = "answer" value = "answerItem" name = "question" property = "rightAnswer" ></html:radio>
</logic:iterate>
如果从bean answer的answerItem属性中取出的值等于从bean question的rightAnswer
属性中取出的值相等，那么该radio将被选中
|
|
|
posted @
2006-06-21 16:54 MyJavaWorld 阅读(1414) |
评论 (0) |
编辑 收藏
|
1. 一个表如果建有大量索引会影响 INSERT、UPDATE 和 DELETE 语句的性能，因为在表中的数据更改时，所有索引都须进行适当的调整。另一方面，对于不需要修改数据的查询（SELECT 语句），大量索引有助于提高性能，因为数据库有更多的索引可供选择，以便确定以最快速度访问数据的最佳方法。
2. 组合索引：组合索引即多列索引，指一个索引含有多个列。一个组合索引相当于多个单列索引，如索引(ColA, ColB, ColC)至少相当于(ColA)、(ColA, ColB)、(ColA, ColB, ColC)三个索引。
2. 覆盖的查询可以提高性能。覆盖的查询是指查询中所有指定的列都包含在同一个索引(组合索引)中。例如，如果在一个表的 a、b 和 c 列上创建了组合索引，则从该表中检索 a 和 b 列的查询被视为覆盖的查询。创建覆盖一个查询的索引可以提高性能，因为该查询的所有数据都包含在索引自身当中；检索数据时只需引用表的索引页，不必引用数据页，因而减少了 I/O 总量。尽管给索引添加列以覆盖查询可以提高性能，但在索引中额外维护更多的列会产生更新和存储成本。
3. 对小型表进行索引可能不会产生优化效果，因为数据库在遍历索引以搜索数据时，花费的时间可能会比简单的表扫描还长。
4. 应使用 SQL 事件探查器和索引优化向导帮助分析查询，确定要创建的索引。为数据库及其工作负荷选择正确的索引是非常复杂的，需要在查询速度和更新成本之间取得平衡。窄索引（搜索关键字中只有很少的列的索引）需要的磁盘空间和维护开销都更少。而另一方面，宽索引可以覆盖更多的查询。确定正确的索引集没有简便的规则。经验丰富的数据库管理员常常能够设计出很好的索引集，但是，即使对于不特别复杂的数据库和工作负荷来说，这项任务也十分复杂、费时和易于出错。可以使用索引优化向导使这项任务自动化。有关更多信息，请参见索引优化向导。
5. 可以在视图上指定索引。
6. 可以在计算列上指定索引。
7. 避免在索引列上使用IS NULL和IS NOT NULL。避免在索引中使用任何可以为空的列，数据库将无法使用该索引。对于单列索引，如果列包含空值，索引中将不存在此记录；对于复合索引，如果每个列都为空，索引中同样不存在此记录. 如果至少有一个列不为空，则记录存在于索引中。
8. 如果经常检索包含大量数据的表中的少于15%的行则需要创建索引。
9. 衡量索引效率的 95/5 规则：如果查询的结果返回的行数少于表中所有行的5%，则索引是检索数据的最快方法，如果查询的结果超过5%，那么通常使用索引就不是最快的方式。
10.主关键字和唯一关键字所在的列自动具有索引，但外部关键字没有自动索引。
二、索引的特征
在确定某一索引适合某一查询之后，可以自定义最适合具体情况的索引类型。索引特征包括：
●聚集还是非聚集
●唯一还是不唯一
●单列还是多列
●索引中的列顺序为升序还是降序(索引缺省为升序，但目前多数大型数据库已经能够支持反向索引)
●覆盖还是非覆盖
●还可以自定义索引的初始存储特征，通过设置填充因子优化其维护，并使用文件和文件组自定义其位置以优化性能。
●位映射索引(bitmap)
|
|
|
posted @
2006-06-21 16:50 MyJavaWorld 阅读(2270) |
评论 (0) |
编辑 收藏
|
基础
要使用 sql 获得当前的日期、时间及时间戳记，请参考适当的 db2 寄存器：
select current date from sysibm.sysdummy1
select current time from sysibm.sysdummy1
select current timestamp from sysibm.sysdummy1
|
sysibm.sysdummy1表是一个特殊的内存中的表，用它可以发现如上面演示的 db2 寄存器的值。您也可以使用关键字 values 来对寄存器或表达式求值。例如，在 db2 命令行处理器（command line processor，clp）上，以下 sql 语句揭示了类似信息：
values current date
values current time
values current timestamp
|
在余下的示例中，我将只提供函数或表达式，而不再重复 select ... from sysibm.sysdummy1 或使用 values 子句。
要使当前时间或当前时间戳记调整到 gmt/cut，则把当前的时间或时间戳记减去当前时区寄存器：
current time - current timezone
current timestamp - current timezone
|
给定了日期、时间或时间戳记，则使用适当的函数可以单独抽取出（如果适用的话）年、月、日、时、分、秒及微秒各部分：
year (current timestamp)
month (current timestamp)
day (current timestamp)
hour (current timestamp)
minute (current timestamp)
second (current timestamp)
microsecond (current timestamp)
|
从时间戳记单独抽取出日期和时间也非常简单：
date (current timestamp)
time (current timestamp)
|
因为没有更好的术语，所以您还可以使用英语来执行日期和时间计算：
current date + 1 year
current date + 3 years + 2 months + 15 days
current time + 5 hours - 3 minutes + 10 seconds
|
要计算两个日期之间的天数，您可以对日期作减法，如下所示：
days (current date) - days (date(''1999-10-22''))
|
而以下示例描述了如何获得微秒部分归零的当前时间戳记：
current timestamp - microsecond (current timestamp) microseconds
|
如果想将日期或时间值与其它文本相衔接，那么需要先将该值转换成字符串。为此，只要使用 char() 函数：
char(current date)
char(current time)
char(current date + 12 hours)
|
要将字符串转换成日期或时间值，可以使用：
timestamp (''2002-10-20-12.00.00.000000'')
timestamp (''2002-10-20 12:00:00'')
date (''2002-10-20'')
date (''10/20/2002'')
time (''12:00:00'')
time (''12.00.00'')
|
timestamp()、date() 和 time() 函数接受更多种格式。上面几种格式只是示例，我将把它作为一个练习，让读者自己去发现其它格式。
|
警告:
摘自 db2 udb v8.1 sql cookbook，作者 graeme birchall(see http://ourworld.compuserve.com/homepages/graeme_birchall).
如果你在日期函数中偶然地遗漏了引号，那将如何呢？结论是函数会工作，但结果会出错：
select date(2001-09-22) from sysibm.sysdummy1;
|
结果:
为什么会产生将近 2000 年的差距呢？当 date 函数得到了一个字符串作为输入参数的时候，它会假定这是一个有效的 db2 日期的表示，并对其进行适当地转换。相反，当输入参数是数字类型时，函数会假定该参数值减 1 等于距离公元第一天（0001-01-01）的天数。在上面的例子中，我们的输入是 2001-09-22，被理解为 (2001-9)-22, 等于 1970 天，于是该函数被理解为 date(1970)。
|
日期函数
有时，您需要知道两个时间戳记之间的时差。为此，db2 提供了一个名为 timestampdiff() 的内置函数。但该函数返回的是近似值，因为它不考虑闰年，而且假设每个月只有 30 天。以下示例描述了如何得到两个日期的近似时差：
timestampdiff (<n>, char(
timestamp(''2002-11-30-00.00.00'')-
timestamp(''2002-11-08-00.00.00'')))
|
对于 <n>，可以使用以下各值来替代，以指出结果的时间单位：
- 1 = 秒的小数部分
- 2 = 秒
- 4 = 分
- 8 = 时
- 16 = 天
- 32 = 周
- 64 = 月
- 128 = 季度
- 256 = 年
当日期很接近时使用 timestampdiff() 比日期相差很大时精确。如果需要进行更精确的计算，可以使用以下方法来确定时差（按秒计）：
(days(t1) - days(t2)) * 86400 +
(midnight_seconds(t1) - midnight_seconds(t2))
|
为方便起见，还可以对上面的方法创建 sql 用户定义的函数：
create function secondsdiff(t1 timestamp, t2 timestamp)
returns int
return (
(days(t1) - days(t2)) * 86400 +
(midnight_seconds(t1) - midnight_seconds(t2))
)
@
|
如果需要确定给定年份是否是闰年，以下是一个很有用的 sql 函数，您可以创建它来确定给定年份的天数：
create function daysinyear(yr int)
returns int
return (case (mod(yr, 400)) when 0 then 366 else
case (mod(yr, 4)) when 0 then
case (mod(yr, 100)) when 0 then 365 else 366 end
else 365 end
end)@
|
最后，以下是一张用于日期操作的内置函数表。它旨在帮助您快速确定可能满足您要求的函数，但未提供完整的参考。有关这些函数的更多信息，请参考 sql 参考大全。
| sql 日期和时间函数 |
| dayname |
返回一个大小写混合的字符串，对于参数的日部分，用星期表示这一天的名称（例如，friday）。 |
| dayofweek |
返回参数中的星期几，用范围在 1-7 的整数值表示，其中 1 代表星期日。 |
| dayofweek_iso |
返回参数中的星期几，用范围在 1-7 的整数值表示，其中 1 代表星期一。 |
| dayofyear |
返回参数中一年中的第几天，用范围在 1-366 的整数值表示。 |
| days |
返回日期的整数表示。 |
| julian_day |
返回从公元前 4712 年 1 月 1 日（儒略日历的开始日期）到参数中指定日期值之间的天数，用整数值表示。 |
| midnight_seconds |
返回午夜和参数中指定的时间值之间的秒数，用范围在 0 到 86400 之间的整数值表示。 |
| monthname |
对于参数的月部分的月份，返回一个大小写混合的字符串（例如，january）。 |
| timestamp_iso |
根据日期、时间或时间戳记参数而返回一个时间戳记值。 |
| timestamp_format |
从已使用字符模板解释的字符串返回时间戳记。 |
| timestampdiff |
根据两个时间戳记之间的时差，返回由第一个参数定义的类型表示的估计时差。 |
| to_char |
返回已用字符模板进行格式化的时间戳记的字符表示。to_char 是 varchar_format 的同义词。 |
| to_date |
从已使用字符模板解释过的字符串返回时间戳记。to_date 是 timestamp_format 的同义词。 |
| week |
返回参数中一年的第几周，用范围在 1-54 的整数值表示。以星期日作为一周的开始。 |
| week_iso |
返回参数中一年的第几周，用范围在 1-53 的整数值表示。 |
改变日期格式
在日期的表示方面，这也是我经常碰到的一个问题。用于日期的缺省格式由数据库的地区代码决定，该代码在数据库创建的时候被指定。例如，我在创建数据库时使用 territory=us 来定义地区代码，则日期的格式就会像下面的样子：
values current date
1
----------
05/30/2003
1 record(s) selected.
|
也就是说，日期的格式是 mm/dd/yyyy. 如果想要改变这种格式，你可以通过绑定特定的 db2 工具包来实现. 其他被支持的日期格式包括:
| def |
使用与地区代码相匹配的日期和时间格式。 |
| eur |
使用欧洲日期和时间的 ibm 标准格式。 |
| iso |
使用国际标准组织（iso）制订的日期和时间格式。 |
| jis |
使用日本工业标准的日期和时间格式。 |
| loc |
使用与数据库地区代码相匹配的本地日期和时间格式。 |
| usa |
使用美国日期和时间的 ibm 标准格式。 |
在 windows 环境下，要将缺省的日期和时间格式转化成 iso 格式（yyyy-mm-dd），执行下列操作：
- 在命令行中，改变当前目录为
sqllib\bnd 。
例如:
在 windows 环境:c:\program files\ibm\sqllib\bnd
在 unix 环境:/home/db2inst1/sqllib/bnd
- 从操作系统的命令行界面中用具有 sysadm 权限的用户连接到数据库:
db2 connect to dbname
db2 bind @db2ubind.lst datetime iso blocking all grant public
|
(在你的实际环境中， 用你的数据库名称和想使用的日期格式分别来替换 dbname and iso。)
现在，你可以看到你的数据库已经使用 iso 作为日期格式了：
values current date
1
----------
2003-05-30
1 record(s) selected.
|
定制日期/时间格式
在上面的例子中，我们展示了如何将 db2 当前的日期格式转化成系统支持的特定格式。但是，如果你想将当前日期格式转化成定制的格式（比如‘yyyymmdd’），那又该如何去做呢？按照我的经验，最好的办法就是编写一个自己定制的格式化函数。
下面是这个 udf 的代码:
create function ts_fmt(ts timestamp, fmt varchar(20))
returns varchar(50)
return
with tmp (dd,mm,yyyy,hh,mi,ss,nnnnnn) as
(
select
substr( digits (day(ts)),9),
substr( digits (month(ts)),9) ,
rtrim(char(year(ts))) ,
substr( digits (hour(ts)),9),
substr( digits (minute(ts)),9),
substr( digits (second(ts)),9),
rtrim(char(microsecond(ts)))
from sysibm.sysdummy1
)
select
case fmt
when ''yyyymmdd''
then yyyy || mm || dd
when ''mm/dd/yyyy''
then mm || ''/'' || dd || ''/'' || yyyy
when ''yyyy/dd/mm hh:mi:ss''
then yyyy || ''/'' || mm || ''/'' || dd || '' '' ||
hh || '':'' || mi || '':'' || ss
when ''nnnnnn''
then nnnnnn
else
''date format '' || coalesce(fmt,'' <null> '') ||
'' not recognized.''
end
from tmp
|
乍一看，函数的代码可能显得很复杂，但是在仔细研究之后，你会发现这段代码其实非常简单而且很优雅。最开始，我们使用了一个公共表表达式（cte）来将一个时间戳记（第一个输入参数）分别剥离为单独的时间元素。然后，我们检查提供的定制格式（第二个输入参数）并将前面剥离出的元素按照该定制格式的要求加以组合。
这个函数还非常灵活。如果要增加另外一种模式，可以很容易地再添加一个 when 子句来处理。在使用过程中，如果用户提供的格式不符合任何在 when 子句中定义的任何一种模式时，函数会返回一个错误信息。
使用方法示例：
values ts_fmt(current timestamp,''yyyymmdd'')
''20030818''
values ts_fmt(current timestamp,''asa'')
''date format asa not recognized.''
|
|
|
|
posted @
2006-06-13 11:29 MyJavaWorld 阅读(359) |
评论 (0) |
编辑 收藏
tomcat5.5的管理功能非常强,只要你配置好了tomcat-user.xml.
主要是增加一个具有系统管理权限的用户,比如增加一个用户名和密码都是suxiaoyong的用户,只需要在在最后一行增加
| 代码 | | <user username="suxiaoyong" password="suxiaoyong" roles="admin,manager"/> |
其他的用户都可以删掉了
然后,我们可以进入http://localhost:8080/manager/status 来查看服务器的各种状态.
也可以通过url来直接对应用进行监控
命令格式
| 代码 | | http://{ host }:{ port }/manager/{ command }?{ parameters } |
部署一个应用
列出已经部署的应用
| 代码 | | http://localhost:8080/manager/list |
重新加载一个应用
比如你更新了class或者lib的话，需要重新加载系统
| 代码 | | http://localhost:8080/manager/reload?path=/examples |
查看jvm和系统信息
| 代码 | | http://localhost:8080/manager/serverinfo |
查看可用的安全角色
| 代码 | | http://localhost:8080/manager/roles |
查看某个应用默认的session超时时间和当前活跃的session数
| 代码 | | http://localhost:8080/manager/sessions?path=/examples |
启动一个应用
比如有时候重新启动数据库后可能需要重新启动应用
| 代码 | | http://localhost:8080/manager/start?path=/examples |
关闭一个应用
关闭后，任何发往该应用的请求都将转向404错误的页面
| 代码 | | http://localhost:8080/manager/stop?path=/examples |
undeploy
慎用，将删除应用的目录及其war文件
ant脚本，更多的详见tomcat5.5的文档
| 代码 | <project name="My Application" default="compile" basedir=".">
<!-- Configure the directory into which the web application is built -->
<property name="build" value="${ basedir }/build"/>
<!-- Configure the context path for this application -->
<property name="path" value="/myapp"/>
<!-- Configure properties to access the Manager application -->
<property name="url" value="http://localhost:8080/manager"/>
<property name="username" value="myusername"/>
<property name="password" value="mypassword"/>
<!-- Configure the custom Ant tasks for the Manager application -->
<taskdef name="deploy" classname="org.apache.catalina.ant.DeployTask"/>
<taskdef name="list" classname="org.apache.catalina.ant.ListTask"/>
<taskdef name="reload" classname="org.apache.catalina.ant.ReloadTask"/>
<taskdef name="resources" classname="org.apache.catalina.ant.ResourcesTask"/>
<taskdef name="roles" classname="org.apache.catalina.ant.RolesTask"/>
<taskdef name="start" classname="org.apache.catalina.ant.StartTask"/>
<taskdef name="stop" classname="org.apache.catalina.ant.StopTask"/>
<taskdef name="undeploy" classname="org.apache.catalina.ant.UndeployTask"/>
<!-- Executable Targets -->
<target name="compile" description="Compile web application">
<!-- ... construct web application in ${ build } subdirectory, and
generated a ${ path }.war ... -->
</target>
<target name="deploy" description="Install web application"
depends="compile">
<deploy url="${ url }" username="${ username }" password="${ password }"
path="${ path }" war="${ build }${ path }.war"/>
</target>
<target name="reload" description="Reload web application"
depends="compile">
<reload url="${ url }" username="${ username }" password="${ password }"
path="${ path }"/>
</target>
<target name="undeploy" description="Remove web application">
<undeploy url="${ url }" username="${ username }" password="${ password }"
path="${ path }"/>
</target>
</project> |
|
|
|
|
posted @
2006-06-12 10:28 MyJavaWorld 阅读(455) |
评论 (0) |
编辑 收藏
1． 配置系统管理（Admin Web Application）
大多数商业化的J2EE服务器都提供一个功能强大的管理界面，且大都采用易于理解的Web应用界面。Tomcat按照自己的方式，同样提供一个成熟的管理工具，并且丝毫不逊于那些商业化的竞争对手。Tomcat的Admin Web Application最初在4.1版本时出现，当时的功能包括管理context、data source、user和group等。当然也可以管理像初始化参数，user、group、role的多种数据库管理等。在后续的版本中，这些功能将得到很大的扩展，但现有的功能已经非常实用了。
Admin Web Application被定义在自动部署文件：CATALINA_BASE/webapps/admin.xml 。
（译者注：CATALINA_BASE即tomcat安装目录下的server目录）
你必须编辑这个文件，以确定Context中的docBase参数是绝对路径。也就是说，CATALINA_BASE/webapps/admin.xml 的路径是绝对路径。作为另外一种选择，你也可以删除这个自动部署文件，而在server.xml文件中建立一个Admin Web Application的context，效果是一样的。你不能管理Admin Web Application这个应用，换而言之，除了删除CATALINA_BASE/webapps/admin.xml ，你可能什么都做不了。
如果你使用UserDatabaseRealm（默认），你将需要添加一个user以及一个role到CATALINA_BASE/conf/tomcat-users.xml 文件中。你编辑这个文件，添加一个名叫“admin”的role 到该文件中，如下：
<role name="admin"/>
你同样需要有一个用户，并且这个用户的角色是“admin”。象存在的用户那样，添加一个用户（改变密码使其更加安全）：
<user name="admin" password="deep_dark_secret" roles="admin"/>
当你完成这些步骤后，请重新启动Tomcat，访问http://localhost:8080/admin，你将看到一个登录界面。Admin Web Application采用基于容器管理的安全机制，并采用了Jakarta Struts框架。一旦你作为“admin”角色的用户登录管理界面，你将能够使用这个管理界面配置Tomcat。
2．配置应用管理（Manager Web Application）
Manager Web Application让你通过一个比Admin Web Application更为简单的用户界面，执行一些简单的Web应用任务。
Manager Web Application被被定义在一个自动部署文件中：
CATALINA_BASE/webapps/manager.xml 。
你必须编辑这个文件，以确保context的docBase参数是绝对路径，也就是说CATALINA_HOME/server/webapps/manager的绝对路径。
（译者注：CATALINA_HOME即tomcat安装目录）
如果你使用的是UserDatabaseRealm，那么你需要添加一个角色和一个用户到CATALINA_BASE/conf/tomcat-users.xml文件中。接下来，编辑这个文件，添加一个名为“manager”的角色到该文件中：
<role name=”manager”>
你同样需要有一个角色为“manager”的用户。像已经存在的用户那样，添加一个新用户（改变密码使其更加安全）：
<user name="manager" password="deep_dark_secret" roles="manager"/>
然后重新启动Tomcat，访问http://localhost/manager/list，将看到一个很朴素的文本型管理界面，或者访问http://localhost/manager/html/list，将看到一个HMTL的管理界面。不管是哪种方式都说明你的Manager Web Application现在已经启动了。
Manager application让你可以在没有系统管理特权的基础上，安装新的Web应用，以用于测试。如果我们有一个新的web应用位于/home/user/hello下在，并且想把它安装到 /hello下，为了测试这个应用，我们可以这么做，在第一个文件框中输入“/hello”（作为访问时的path），在第二个文本框中输入“file:/home/user/hello”（作为Config URL）。
Manager application还允许你停止、重新启动、移除以及重新部署一个web应用。停止一个应用使其无法被访问，当有用户尝试访问这个被停止的应用时，将看到一个503的错误——“503 - This application is not currently available”。
移除一个web应用，只是指从Tomcat的运行拷贝中删除了该应用，如果你重新启动Tomcat，被删除的应用将再次出现（也就是说，移除并不是指从硬盘上删除）。
3．部署一个web应用
有两个办法可以在系统中部署web服务。
1> 拷贝你的WAR文件或者你的web应用文件夹（包括该web的所有内容）到$CATALINA_BASE/webapps目录下。
2> 为你的web服务建立一个只包括context内容的XML片断文件，并把该文件放到$CATALINA_BASE/webapps目录下。这个web应用本身可以存储在硬盘上的任何地方。
如果你有一个WAR文件，你若想部署它，则只需要把该文件简单的拷贝到CATALINA_BASE/webapps目录下即可，文件必须以“.war”作为扩展名。一旦Tomcat监听到这个文件，它将（缺省的）解开该文件包作为一个子目录，并以WAR文件的文件名作为子目录的名字。接下来，Tomcat将在内存中建立一个context，就好象你在server.xml文件里建立一样。当然，其他必需的内容，将从server.xml中的DefaultContext获得。
部署web应用的另一种方式是写一个Context XML片断文件，然后把该文件拷贝到CATALINA_BASE/webapps目录下。一个Context片断并非一个完整的XML文件，而只是一个context元素，以及对该应用的相应描述。这种片断文件就像是从server.xml中切取出来的context元素一样，所以这种片断被命名为“context片断”。
举个例子，如果我们想部署一个名叫MyWebApp.war的应用，该应用使用realm作为访问控制方式，我们可以使用下面这个片断：
<!--
Context fragment for deploying MyWebApp.war
-->
<Context path="/demo" docBase="webapps/MyWebApp.war"
debug="0" privileged="true">
<Realm className="org.apache.catalina.realm.UserDatabaseRealm"
resourceName="UserDatabase"/>
</Context>
把该片断命名为“MyWebApp.xml”，然后拷贝到CATALINA_BASE/webapps目录下。
这种context片断提供了一种便利的方法来部署web应用，你不需要编辑server.xml，除非你想改变缺省的部署特性，安装一个新的web应用时不需要重启动Tomcat。
4．配置虚拟主机（Virtual Hosts）
关于server.xml中“Host”这个元素，只有在你设置虚拟主机的才需要修改。虚拟主机是一种在一个web服务器上服务多个域名的机制，对每个域名而言，都好象独享了整个主机。实际上，大多数的小型商务网站都是采用虚拟主机实现的，这主要是因为虚拟主机能直接连接到Internet并提供相应的带宽，以保障合理的访问响应速度，另外虚拟主机还能提供一个稳定的固定IP。
基于名字的虚拟主机可以被建立在任何web服务器上，建立的方法就是通过在域名服务器（DNS）上建立IP地址的别名，并且告诉web服务器把去往不同域名的请求分发到相应的网页目录。因为这篇文章主要是讲Tomcat，我们不准备介绍在各种操作系统上设置DNS的方法，如果你在这方面需要帮助，请参考《DNS and Bind》一书，作者是Paul Albitz and Cricket Liu (O'Reilly)。为了示范方便，我将使用一个静态的主机文件，因为这是测试别名最简单的方法。
在Tomcat中使用虚拟主机，你需要设置DNS或主机数据。为了测试，为本地IP设置一个IP别名就足够了，接下来，你需要在server.xml中添加几行内容，如下：
<Server port="8005" shutdown="SHUTDOWN" debug="0">
<Service name="Tomcat-Standalone">
<Connector className="org.apache.coyote.tomcat4.CoyoteConnector"
port="8080" minProcessors="5" maxProcessors="75"
enableLookups="true" redirectPort="8443"/>
<Connector className="org.apache.coyote.tomcat4.CoyoteConnector"
port="8443" minProcessors="5" maxProcessors="75"
acceptCount="10" debug="0" scheme="https" secure="true"/>
<Factory className="org.apache.coyote.tomcat4.CoyoteServerSocketFactory"
clientAuth="false" protocol="TLS" />
</Connector>
<Engine name="Standalone" defaultHost="localhost" debug="0">
<!-- This Host is the default Host -->
<Host name="localhost" debug="0" appBase="webapps"
unpackWARs="true" autoDeploy="true">
<Context path="" docBase="ROOT" debug="0"/>
<Context path="/orders" docBase="/home/ian/orders" debug="0"
reloadable="true" crossContext="true">
</Context>
</Host>
<!-- This Host is the first "Virtual Host": www.example.com -->
<Host name="www.example.com" appBase="/home/example/webapp">
<Context path="" docBase="."/>
</Host>
</Engine>
</Service>
</Server>
Tomcat的server.xml文件，在初始状态下，只包括一个虚拟主机，但是它容易被扩充到支持多个虚拟主机。在前面的例子中展示的是一个简单的server.xml版本，其中粗体部分就是用于添加一个虚拟主机。每一个Host元素必须包括一个或多个context元素，所包含的context元素中必须有一个是默认的context，这个默认的context的显示路径应该为空（例如，path=””）。
5．配置基础验证（Basic Authentication）
容器管理验证方法控制着当用户访问受保护的web应用资源时，如何进行用户的身份鉴别。当一个web应用使用了Basic Authentication（BASIC参数在web.xml文件中auto-method元素中设置），而有用户访问受保护的web应用时，Tomcat将通过HTTP Basic Authentication方式，弹出一个对话框，要求用户输入用户名和密码。在这种验证方法中，所有密码将被以64位的编码方式在网络上传输。
注意：使用Basic Authentication通过被认为是不安全的，因为它没有强健的加密方法，除非在客户端和服务器端都使用HTTPS或者其他密码加密码方式（比如，在一个虚拟私人网络中）。若没有额外的加密方法，网络管理员将能够截获（或滥用）用户的密码。但是，如果你是刚开始使用Tomcat，或者你想在你的web应用中测试一下基于容器的安全管理，Basic Authentication还是非常易于设置和使用的。只需要添加<security-constraint>和<login-config>两个元素到你的web应用的web.xml文件中，并且在CATALINA_BASE/conf/tomcat-users.xml 文件中添加适当的<role>和<user>即可，然后重新启动Tomcat。
下面例子中的web.xml摘自一个俱乐部会员网站系统，该系统中只有member目录被保护起来，并使用Basic Authentication进行身份验证。请注意，这种方式将有效的代替Apache web服务器中的.htaccess文件。
<!--
Define the Members-only area, by defining
a "Security Constraint" on this Application, and
mapping it to the subdirectory (URL) that we want
to restrict.
-->
<security-constraint>
<web-resource-collection>
<web-resource-name>
Entire Application
</web-resource-name>
<url-pattern>/members/*</url-pattern>
</web-resource-collection>
<auth-constraint>
<role-name>member</role-name>
</auth-constraint>
</security-constraint>
<!-- Define the Login Configuration for this Application -->
<login-config>
<auth-method>BASIC</auth-method>
<realm-name>My Club Members-only Area</realm-name>
</login-config>
6．配置单点登录（Single Sign-On）
一旦你设置了realm和验证的方法，你就需要进行实际的用户登录处理。一般说来，对用户而言登录系统是一件很麻烦的事情，你必须尽量减少用户登录验证的次数。作为缺省的情况，当用户第一次请求受保护的资源时，每一个web应用都会要求用户登录。如果你运行了多个web应用，并且每个应用都需要进行单独的用户验证，那这看起来就有点像你在与你的用户搏斗。用户们不知道怎样才能把多个分离的应用整合成一个单独的系统，所有他们也就不知道他们需要访问多少个不同的应用，只是很迷惑，为什么总要不停的登录。
Tomcat 4的“single sign-on”特性允许用户在访问同一虚拟主机下所有web应用时，只需登录一次。为了使用这个功能，你只需要在Host上添加一个SingleSignOn Valve元素即可，如下所示：
<Valve className="org.apache.catalina.authenticator.SingleSignOn"
debug="0"/>
在Tomcat初始安装后，server.xml的注释里面包括SingleSignOn Valve配置的例子，你只需要去掉注释，即可使用。那么，任何用户只要登录过一个应用，则对于同一虚拟主机下的所有应用同样有效。
使用single sign-on valve有一些重要的限制：
1> value必须被配置和嵌套在相同的Host元素里，并且所有需要进行单点验证的web应用（必须通过context元素定义）都位于该Host下。
2> 包括共享用户信息的realm必须被设置在同一级Host中或者嵌套之外。
3> 不能被context中的realm覆盖。
4> 使用单点登录的web应用最好使用一个Tomcat的内置的验证方式（被定义在web.xml中的<auth-method>中），这比自定义的验证方式强，Tomcat内置的的验证方式包括basic、digest、form和client-cert。
5> 如果你使用单点登录，还希望集成一个第三方的web应用到你的网站中来，并且这个新的web应用使用它自己的验证方式，而不使用容器管理安全，那你基本上就没招了。你的用户每次登录原来所有应用时需要登录一次，并且在请求新的第三方应用时还得再登录一次。当然，如果你拥有这个第三方web应用的源码，而你又是一个程序员，你可以修改它，但那恐怕也不容易做。
6> 单点登录需要使用cookies。
7．配置用户定制目录（Customized User Directores）
一些站点允许个别用户在服务器上发布网页。例如，一所大学的学院可能想给每一位学生一个公共区域，或者是一个ISP希望给一些web空间给他的客户，但这又不是虚拟主机。在这种情况下，一个典型的方法就是在用户名前面加一个特殊字符（~），作为每位用户的网站，比如：
http://www.cs.myuniversity.edu/~username
http://members.mybigisp.com/~username
Tomcat提供两种方法在主机上映射这些个人网站，主要使用一对特殊的Listener元素。Listener的className属性应该是org.apache.catalina.startup.UserConfig，userClass属性应该是几个映射类之一。如果你的系统是Unix，它将有一个标准的/etc/passwd文件，该文件中的帐号能够被运行中的Tomcat很容易的读取，该文件指定了用户的主目录，使用PasswdUserDatabase 映射类。
<Listener className="org.apache.catalina.startup.UserConfig"
directoryName="public_html"
userClass="org.apache.catalina.startup.PasswdUserDatabase"/>
web文件需要放置在像/home/users/ian/public_html 或者 /users/jbrittain/public_html一样的目录下面。当然你也可以改变public_html 到其他任何子目录下。
实际上，这个用户目录根本不一定需要位于用户主目录下里面。如果你没有一个密码文件，但你又想把一个用户名映射到公共的像/home一样目录的子目录里面，则可以使用HomesUserDatabase类。
<Listener className="org.apache.catalina.startup.UserConfig"
directoryName="public_html" homeBase="/home"
userClass="org.apache.catalina.startup.HomesUserDatabase"/>
这样一来，web文件就可以位于像/home/ian/public_html 或者 /home/jasonb/public_html一样的目录下。这种形式对Windows而言更加有利，你可以使用一个像c:\home这样的目录。
这些Listener元素，如果出现，则必须在Host元素里面，而不能在context元素里面，因为它们都用应用于Host本身。
8．在Tomcat中使用CGI脚本
Tomcat主要是作为Servlet/JSP容器，但它也有许多传统web服务器的性能。支持通用网关接口（Common Gateway Interface，即CGI）就是其中之一，CGI提供一组方法在响应浏览器请求时运行一些扩展程序。CGI之所以被称为通用，是因为它能在大多数程序或脚本中被调用，包括：Perl，Python，awk，Unix shell scripting等，甚至包括Java。当然，你大概不会把一个Java应用程序当作CGI来运行，毕竟这样太过原始。一般而言，开发Servlet总要比CGI具有更好的效率，因为当用户点击一个链接或一个按钮时，你不需要从操作系统层开始进行处理。
Tomcat包括一个可选的CGI Servlet，允许你运行遗留下来的CGI脚本。
为了使Tomcat能够运行CGI，你必须做如下几件事：
1. 把servlets-cgi.renametojar （在CATALINA_HOME/server/lib/目录下）改名为servlets-cgi.jar。处理CGI的servlet应该位于Tomcat的CLASSPATH下。
2. 在Tomcat的CATALINA_BASE/conf/web.xml 文件中，把关于<servlet-name> CGI的那段的注释去掉（默认情况下，该段位于第241行）。
3. 同样，在Tomcat的CATALINA_BASE/conf/web.xml文件中，把关于对CGI进行映射的那段的注释去掉（默认情况下，该段位于第299行）。注意，这段内容指定了HTML链接到CGI脚本的访问方式。
4. 你可以把CGI脚本放置在WEB-INF/cgi 目录下（注意，WEB-INF是一个安全的地方，你可以把一些不想被用户看见或基于安全考虑不想暴露的文件放在此处），或者你也可以把CGI脚本放置在context下的其他目录下，并为CGI Servlet调整cgiPathPrefix初始化参数。这就指定的CGI Servlet的实际位置，且不能与上一步指定的URL重名。
5. 重新启动Tomcat，你的CGI就可以运行了。
在Tomcat中，CGI程序缺省放置在WEB-INF/cgi目录下，正如前面所提示的那样，WEB-INF目录受保护的，通过客户端的浏览器无法窥探到其中内容，所以对于放置含有密码或其他敏感信息的CGI脚本而言，这是一个非常好的地方。为了兼容其他服务器，尽管你也可以把CGI脚本保存在传统的/cgi-bin目录，但要知道，在这些目录中的文件有可能被网上好奇的冲浪者看到。另外，在Unix中，请确定运行Tomcat的用户有执行CGI脚本的权限。
9．改变Tomcat中的JSP编译器（JSP Compiler）
在Tomcat 4.1（或更高版本，大概），JSP的编译由包含在Tomcat里面的Ant程序控制器直接执行。这听起来有一点点奇怪，但这正是Ant有意为之的一部分，有一个API文档指导开发者在没有启动一个新的JVM的情况下，使用Ant。这是使用Ant进行Java开发的一大优势。另外，这也意味着你现在能够在Ant中使用任何javac支持的编译方式，这里有一个关于Apache Ant使用手册的javac page列表。使用起来是容易的，因为你只需要在<init-param> 元素中定义一个名字叫“compiler”，并且在value中有一个支持编译的编译器名字，示例如下：
<servlet>
<servlet-name>jsp</servlet-name>
<servlet-class>
org.apache.jasper.servlet.JspServlet
</servlet-class>
<init-param>
<param-name>logVerbosityLevel</param-name>
<param-value>WARNING</param-value>
</init-param>
<init-param>
<param-name>compiler</param-name>
<param-value>jikes</param-value>
</init-param>
<load-on-startup>3</load-on-startup>
</servlet>
当然，给出的编译器必须已经安装在你的系统中，并且CLASSPATH可能需要设置，那处决于你选择的是何种编译器。
10．限制特定主机访问（Restricting Access to Specific Hosts）
有时，你可能想限制对Tomcat web应用的访问，比如，你希望只有你指定的主机或IP地址可以访问你的应用。这样一来，就只有那些指定的的客户端可以访问服务的内容了。为了实现这种效果，Tomcat提供了两个参数供你配置：RemoteHostValve 和RemoteAddrValve。
通过配置这两个参数，可以让你过滤来自请求的主机或IP地址，并允许或拒绝哪些主机/IP。与之类似的，在Apache的httpd文件里有对每个目录的允许/拒绝指定。
例如你可以把Admin Web application设置成只允许本地访问，设置如下：
<Context path="/path/to/secret_files" ...>
<Valve className="org.apache.catalina.valves.RemoteAddrValve"
allow="127.0.0.1" deny=""/>
</Context>
如果没有给出允许主机的指定，那么与拒绝主机匹配的主机就会被拒绝，除此之外的都是允许的。与之类似，如果没有给出拒绝主机的指定，那么与允许主机匹配的主机就会被允许，除此之外的都是拒绝的。
--------------------------------------
posted @
2006-06-09 17:32 MyJavaWorld 阅读(198) |
评论 (0) |
编辑 收藏
JSP视窗组件所使用的struts标记库由四类标记组成：
2. Bean标记：用来在JSP页中管理bean
3. 逻辑标记：用来在JSP页中控制流程
4. HTML标记：用来生成HTML标记，在表单中显示数据，使用会话ID对URL进行编程
5. 模板标记：使用动态模板构造普通格式的页
2.1 Bean标记
这个标记库中包含用于定义新bean、访问bean及其属性的标记。Struts框架提供了多种自定义标记用来在JSP页中处理JavaBean。这些标记被封装在一个普通的标记库中，在文件struts-bean.tld中定义了它的标记库描述器。Bean标记库将标记定义在四个子类别中：
创建和复制bean的标记
脚本变量定义标记
bean翻译标记
消息国际化标记
2.1.1 Bean复制标记
可定义新bean，可复制现有bean，还可从现有bean复制属性。
<bean:define>标记用来：
定义新字符串常数
将现有的bean复制到新定义的bean对象
复制现有bean的属性来创建新的bean
<bean:define>标记属性：
属性描述Id 新定义的bean脚本变量名称，必须设置Type 定义引入脚本变量的类Value 为id属性定义的脚本变量分配一个新的对象Name 目标bean的名称。若value属性没有设置，这个属性就必须设置property Name属性定义的bean的属性名称，用来定义新的bean
13
Scope 源bean的作用域。若没有设置，搜索范围是从页作用域到应用程序作用域toScope 目标bean的作用域。若没有设置，默认值是页作用域
例如：定义一个bean:
<bean:define id=”test” value=”this is a test”/>
源bean在页作用域中被拷贝大哦请求作用域中的另一个bean:
<bean:define id=”targetBean” name=”sourceBean”
scope=”page” toScope=”request”/>
2.1.2 定义脚本变量的标记
从多种资源中定义和生成脚本变量，这些资源包括cookie,请求参数，HTTP标头等等。属性如下：
属性描述Id 脚本变量和要定义的页作用域属性的名称Name cookie/标头/参数的名称multiple 如果这个属性设置了任意一个数值，所有匹配的cookie都会被积累并存储到一个Cookie[](一个数组)类型的bean里。若无设置，指定cookie的第一个值将作为Cookie类型的值Value 如果没有匹配的cookie或数值，就返回这个属性指定的默认值
例如：
<bean:cookie id=”myCookie” name=”userName”/>
脚本变量名称是myCookie，用来创建这个属性的cookie的名称是userName。
<bean:header id=”myHeader” name=”Accept-Language”/>
脚本变量名称是myHeader,请求标头的名称是Accept-Language.
<bean:parameter id=”myParameter” name=”myParameter”>
脚本变量名称是myPatameter,它保存的请求参数的名称也是myParameter.
<bean:include>标记将对一个资源的响应进行检索，并引入一个脚本变量和字符串类型的页作用域属性。这个资源可以是一个页，一个ActionForward或一个外部URL。与<jsp:include>的不同是资源的响应被存储到一个页作用域的bean中，而不是写入到输出流。属性如下：
属性描述Id 脚本变量和要定义的页作用域属性的名称Page 一个内部资源forward 一个ActionForward Href 要包含的资源的完整URL
例如：
<bean:include id=”myInclude” page=”MyJsp?x=1”/>
脚本变量的名称是myInclude，要检索的响应来自资源MyJsp?x=1。
<bean:resource>标记将检索web应用中的资源，并引入一个脚本变量和InputStream或字符串类型的页作用域属性。如果在检索资源时发生问题，就会产生一个请求时间异常。属性如下：
属性描述
14
Id 脚本变量和要定义的页作用域属性的名称Name 资源的相对路径Input 如果这个属性不存在，资源的类型就是字符串
例如：
<bean:resource id=”myResource” name=”/WEB-INF/images/myResource.xml”/>
脚本变量的名称是myResource，要检索的资源的名称是myResource.xml。
2.1.3 显示Bean属性
标记库中定义了<bean:write>标记，用来将bean的属性输送到封装的JSP页写入器。这个标记与<jsp:getProperty>类似，属性如下：
属性描述Name 要进行属性显示的bean的名称property 要显示的属性的名称。如果这个属性类有java.beans.PropertyEditor,getAsText()或toString 方法会被调用Scope Bean的作用域，若没有设置，搜索范围是从页到应用程序作用域Filter 如果设置true,属性中的所有特殊HTML字符都将被转化为相应的实体引用Ignore 如果设置false，当发现属性时会产生一个请求时间异常，否则返回null
例如：
<bean:write name=”myBean” property=”myProperty” scope=”request”
filter=”true”/>
myBean的属性myProperty将会被显示，作用域为请求，如果发现任何HTML特殊字符都将被转化为相应的实体引用。
2.1.4 消息标记和国际化
strtus框架支持国际化和本地化。用户在他们的计算机中定义自己所在的区域，当web应用程序需要输出一条消息时，它将引用一个资源文件，在这个文件中所有的消息都使用了适当的语言。一个应用程序可能提供了很多资源文件，每个文件提供了用不同语言编写的消息。如果没有找到所选语言的资源文件，就将使用默认的资源文件。
struts框架对国际化的支持是使用<bean:message>标记，以及使用java.util数据包中定义的Locale和ResourceBundle类来实现Java2平台对这些任务的支持。Java.text.MessageFormat类定义的技术可以支持消息的格式。利用此功能，开发人员不需了解这些类的细节就可进行国际化和设置消息的格式。
用strtus实现国际化和本地化：
第一步要定义资源文件的名称，这个文件会包含用默认语言编写的在程序中会出现的所有消息。这些消息以“关键字-值”的形式存储，如下：
error.validation.location = The entered location is invalid
这个文件需要存储在类的路径下，而且它的路径要作为初始化参数传送给ActionServlet作为参数进行传递时，路径的格式要符合完整Java类的标准命名规范。比如，如果资源文件存储在WEB-INFclasses目录中，文件名是
15
ApplicationResources.properties，那么需要传递的参数值是ApplicationResources。如果文件在WEB-INFclassescomtest中，那么参数值就应该是com.test. ApplicationResources.
为了实现国际化，所有的资源文件必须都存储在基本资源文件所在的目录中。基本资源文件包含的是用默认地区语言-本地语言编写的消息。如果基本资源文件的名称是ApplicationResources.properties，那么用其他特定语言编写的资源文件的名称就应该是ApplicationResources_xx.properties(xx为ISO编码，如英语是en)。因此这些文件应包含相同的关键字，但关键字的值是用特定语言编写的。
ActionServlet的区域初始化参数必须与一个true值一起传送，这样ActionServlet就会在用户会话中的Action.LOCALE_KEY关键字下存储一个特定用户计算机的区域对象。现在可以运行一个国际化的web站点，它可以根据用户计算机上的设置的区域自动以相应的语言显示。
我们还可以使用特定的字符串来替换部分消息，就象用java.text.MessageFormat的方法一样：
error.invalid.number = The number {0} is valid
我们可以把字符串{0}替换成任何我们需要的数字。<bean:message>标签属性如下：
属性描述Key 资源文件中定义消息关键字Locale 用户会话中存储的区域对象的属性名称。若没有设置，默认值是Action.LOCALE_KEY Bundle 在应用程序上下文中，存储资源对象的属性的名称。如果没有设置这个属性，默认值是Action.MESSAGE_KEY arg0 第一个替换参数值arg1 第二个替换参数值arg2 第三个替换参数值arg3 第四个替换参数值
例如：资源文件中定义了一个消息：
info.myKey = The numbers entered are {0},{1},{2},{3}
我们可使用下面的消息标记：
<bean:message key=”info.myKey” arg0=”5” arg1=”6” arg2=”7” arg3=”8”/>
这个信息标记输出到JSP页会显示为：The numbers entered are 5,6,7,8
2.2 逻辑标记
逻辑库的标记能够用来处理外观逻辑而不需要使用scriptlet。Struts逻辑标签库包含的标记能够有条件地产生输出文本，在对象集合中循环从而重复地产生输出文本，以及应用程序流程控制。它也提供了一组在JSP页中处理流程控制的标记。这些标记封装在文件名为struts-logic.tld的标记包中。逻辑标记库定义的标记能够执行下列三个功能：
条件逻辑
重复
转发/重定向响应
16
2.2.1 条件逻辑
struts有三类条件逻辑。第一类可以比较下列实体与一个常数的大小：
cookie
请求参数
bean或bean的参数
请求标头
以下列出了这一类标记：
标记功能<equal> 如果常数与被定义的实体相等，返回true <notEqual> 如果常数与被定义的实体不相等，返回true <greaterEqual> 如果常数大于等于被定义的实体，返回true <lessEqual> 如果常数小于等于被定义的实体，返回true <lessThan> 如果常数小于被定义的实体，返回true <greaterThan> 如果常数大于被定义的实体，返回true
这一类的所有标记有相同的属性
属性描述Value 要进行比较的常数值Cookie 要进行比较的HTTP cookie的名称Header 要进行比较的HTTP请求标头的名称parameter 要进行比较的HTTP请求参数的名称Name 如果要进行比较的是bean或bean的属性，则这个属性代表bean的名称property 要进行比较的bean属性的名称Scope Bean的作用域，如果没有指定作用域，则它的搜索范围是从页到应用程序
例如：
<logic:equal parameter=”name” value=”SomeName”>
The entered name is SomeName
</logic:equal>
判断名为”name”的请求参数的值是否是”SomeName”。
<logic:greaterThan name=”bean” property=”prop” scope=”page” value=”7”>
The value of bean.Prop is greater than 7
</logic:greaterThan>
判断在页的作用域中是否有一个名为”bean”的bean，它有一个prop属性，这个属性的值是否大于7。如果这个属性能够转化为数值，就进行数值比较，否则就进行字符串比较。
第二类条件标记定义了两个标记：
<logic:present>
<logic:notPresent>
它们的功能是在计算标记体之前判断特定的项目是否存在。标记的属性和属性值决定了要进行检查的项目。
属性描述
17
Cookie 由这个属性指定的cookie将被检查是否存在Header 由这个属性指定的请求标头将被检查是否存在parameter 由这个属性指定的请求参数将被检查是否存在Name 如果没有设置property属性，那么有这个属性指定的bean将被检查是否存在。如果设置了，那么bean和bean属性都将被检查是否存在。property 检查有name属性指定的bean中是否存在指定的属性Scope 如果指定了bean的名称，这就是bean的作用域。如果没有指定作用域，搜索的范围从页到应用程序作用域。Role 检查当前已经确认的用户是否属于特殊的角色User 检查当前已经确认的用户是否有特定的名称
例如：
<logic:notPresent name=”bean” property=”prop” scope=”page”>
The bean property bean.prop is present
</logic:notPresent>
标记判断在页作用域中是否存在一个名为”bean”的bean，这个bean有一个prop属性。
第三类条件标记比较复杂，这些标记根据模板匹配的结果检查标记体的内容。换句话说，这些标记判断一个指定项目的值是否是一个特定常数的子字符串：
<logic:match>
<logic:notMatch>
这些标记允许JSP引擎在发现了匹配或是没有发现时计算标记主体。属性如下：
属性描述Cookie 要进行比较的HTTP cookie的名称Header 要进行比较的的HTTP标头的名称parameter 要进行比较的的HTTP请求参数的名称Name 若要对bean或bean的属性进行比较，这个属性是用户指定bean的名称location 如果设置了这个属性的值，将会在这个指定的位置(索引值)进行匹配scope 如果对bean进行比较，这个属性指定了bean的作用域。如果没有设置这个参数，搜索范围是从页到应用程序作用域property 要进行比较的bean的属性名称value 要进行比较的常数值
例如：
<logic:match parameter=”name” value=”xyz” location=”1”>
The parameter name is a sub-string of the string xyz from index 1
</logic:match>
标记检查名为”name”的请求参数是否是”xyz”的子字符串，但是子字符串必须从”xyz”的索引位置1开始（也就是说子字符串必须是”y”或”yz”）。
2.2.2 重复标记
在逻辑标记库中定义了<logic:iterate>标记，它能够根据特定集合中元素的数目对标记体的内容进行重复的检查。集合的类型可以是java.util.Iterator,java.util.Collection
18
,java.util.Map或是一个数组。有三种方法可以定义这个集合：
使用运行时间表达式来返回一个属性集合的集合
将集合定义为bean，并且使用name属性指定存储属性的名称。
使用name属性定义一个bean，并且使用property属性定义一个返回集合的bean属性。
当前元素的集合会被定义为一个页作用域的bean。属性如下，所有这些属性都能使用运行时表达式。
属性描述collection 如果没有设置name属性，它就指定了要进行重复的集合Id 页作用域bean和脚本变量的名称，它保存着集合中当前元素的句柄indexed 页作用域JSP bean的名称，它包含着每次重复完成后集合的当前索引Length 重复的最大次数Name 作为集合的bean的名称，或是一个bean名称，它由property属性定义的属性，是个集合Offset 重复开始位置的索引property 作为集合的Bean属性的名称Scope 如果指定了bean名称，这个属性设置bean的作用域。若没有设置，搜索范围从页到应用程序作用域Type 为当前定义的页作用域bean的类型
例如：
<logic:iterate id=”currentInt”
collection=”<% =myList %>”
type=”java.lang.Integer”
offset=”1”
length=”2”>
<% =currentint %>
</logic:iterate>
代码将从列表中的第一个元素开始重复两个元素并且能够让当前元素作为页作用域和java.lang.Integer类型的脚本变量来使用。也就是说，如果myList包含元素1，2，3，4等，代码将会打印1和2。
2.2.3 转发和重定向标记
转发标记
<logic:forward>标记能够将响应转发给重定向到特定的全局ActionForward上。ActionForward的类型决定了是使用PageContext转发响应，还是使用sendRedirect将响应进行重定向。此标记只有一个”name”属性，用来指定全局ActionForward的名称，例如：
<logic:forward name=”myGlobalForward”/>
重定向标记
<logic:redirect>标记是一个能够执行HTTP重定向的强大工具。根据指定的不同属性，它能够通过不同的方式实现重定向。它还允许开发人员指定重定向URL的查询参数。属性如下：
19
属性描述Forward 映射了资源相对路径的ActionForward Href 资源的完整URL Page 资源的相对路径Name Map类型的页名称，请求，会话或程序属性的名称，其中包含要附加大哦重定向URL（如果没有设置property属性）上的“名称-值”参数。或是具有Map类型属性的bean名称，其中包含相同的信息（没有设置property属性） Property Map类型的bean属性的名称。Bean的名称由name属性指定。Scope 如果指定了bean的名称，这个属性指定搜索bean的范围。如果没有设置，搜索范围从页到应用程序作用域ParamID 定义特定查询参数的名称ParamName 字符串类型的bean的名称，其中包含查询参数的值(如果没有设置paramProperty属性)；或是一个bean的名称，它的属性(在paramProperty属性中指定)包含了查询参数值paramProperty 字符串bean属性的名称，其中包含着查询参数的值ParamScope ParamName定义的bean的搜索范围
使用这个标记时至少要指定forward,href或page中的一个属性，以便标明将响应重定向到哪个资源。
2.3 HTML标记
Struts HTML标记可以大致地分为以下几个功能：
显示表单元素和输入控件
显示错误信息
显示其他HTML元素
2.3.1 显示表单元素和输入控件
struts将HTML表单与为表单操作而定义的ActionForm bean紧密联系在一起。表单输入字段的名称与ActionForm bean里定义的属性名称是对应的。当第一次显示表单时，表单的输入字段是从ActionForm bean中移植过来的，当表单被提交时，请求参数将移植到ActionForm bean实例。
所有可以在<form>标记中使用的用来显示HTML输入控件的内嵌标记都使用下列属性来定义JavaScript事件处理器。
属性描述Onblur 字段失去了焦点Onchange 字段失去了焦点并且数值被更改了Onclick 字段被鼠标点击Ondblclick 字段被鼠标双击Onfocus 字段接收到输入焦点Onkeydown 字段拥有焦点并且有键按下
20
onkeypress 字段拥有焦点并且有键按下并释放Onkeyup 字段拥有焦点并且有键被释放onmousedown 鼠标指针指向字段并且点击onmousemove 鼠标指针指向字段并且在字段内移动onmouseout 鼠标指针指向控件，但是指针在元素外围移动onmouseover 鼠标指针没有指向字段，但是指针在元素内部移动Onmouseup 鼠标指针指向字段，并且释放了鼠标按键
<form>元素中能够被定义的其他一般属性有：
属性描述Accesskey 定义访问输入字段的快捷键Style 定义输入字段的样式styleClass 定义输入字段的样式表类Tabindex 输入字段的tab顺序
a) 表单标记
<html:form>标记用来显示HTML标记，可以指定AcitonForm bean的名称和它的类名。如果没有设置这些属性，就需要有配置文件来指定ActionMapping以表明当前输入的是哪个JSP页，以及从映射中检索的bean名和类。如果在ActionMapping指定的作用域中没有找到指定的名称，就会创建并存储一个新的bean，否则将使用找到的bean。
<form>标记能够包含与各种HTML输入字段相对应的子标记。
<html:form>标记属性如下：
属性描述Action 与表单相关的操作。在配置中，这个操作也用来标识与表单相关的ActionForm bean Enctype 表单HTTP方法的编码类型Focus 表单中需要初始化焦点的字段Method 表单使用的HTTP方法Name 与表单相关的ActionForm bean的名称。如果没有设置这个属性，bean的名称将会从配置信息中获得Onreset 表单复位时的JavaScript事件句柄Onsubmit 表单提交时的JavaScript事件句柄Scope 搜索ActionForm bean的范围。如果没有设置，将从配置文件中获取Style 使用的格式styleClass 这个元素的格式表类Type ActionForm bean的完整名称。如果没有设置，将从配置文件获得
例如：
<html:form action=”validateEmploee.do” method=”post”>
</html:form>
与表单相关的操作路径是validateEmployee,而表单数据是通过POST传递的。对于这个表单来说，ActionForm bean的其他信息，如bean名称类型，作用域，都是从表单指定操作的ActionMapping中检索得到的：
21
<form-beans>
<form-bean name=”empForm” type=”com.example.EmployeeForm”/>
</form-beans>
<action-mappings>
<action path=”/validateEmployee”
type=”com.example.ValidateExampleAction”
name=”empForm”
scope=”request”
input=”/employeeInput.jsp”>
<forward name=”success” path=”/employeeOutput.jsp”>
</action>
</action-mapping>
如果配置文件中包含上述信息，并且请求URI的*.do被映射到ActionServlet，与表单相关的ActionForm bean的名称，类型和作用域分别是empForm,com.example.EmployeeForm和request.这些属性也可以使用<html:form>标记属性进行显示的定义。
以下标记必须嵌套在<html:form>标记里
b) 按钮和取消标记
<html:button>标记显示一个按钮控件；<html:cancel>标记显示一个取消按钮。属性如下：
属性描述Property 定义在表单被提交时返回到服务器的请求参数的名称Value 按钮上的标记
c) 复位和提交标记
<html:reset>和<html:submit>标记分别能够显示HTML复位按钮和提交按钮。
d) 文本和文本区标记
<html:text>和<html:textarea>标记分别HTML文本框和文本区，属性如下：
属性描述Property 定义当表单被提交时送回到服务器的请求参数的名称，或用来确定文本元素当前值的bean的属性名称Name 属性被查询的bean的名称，它决定了文本框和文本区的值。如果没有设置，将使用与这个内嵌表单相关的ActionForm的名称
<html:text>标记还有以下属性：
属性描述Maxlength 能够输入的最大字符数
22
Size 文本框的大小（字符数）
<html:textarea>标记特有的属性如下：
属性描述Rows 文本区的行数Cols 文本区的列数
e) 检查框和复选框标记
<html:checkbox>标记能够显示检查框控件。<html:multibox>标记能够显示HTML复选框控件，请求对象在传递检查框名称时使用的getParameterValues()调用将返回一个字符串数组。属性如下：
属性描述Name Bean的名称，其属性会被用来确定检查是否以选中的状态显示。如果没有设置，将使用与这个内嵌表单相关的ActionFrom bean的名称。Property 检查框的名称，也是决定检查框是否以选中的状态显示的bean属性名称。在复选框的情况下，这个属性必须是一个数组。Value 当检查框被选中时返回到服务器的请求参数的值
例如：
<html:checkbox property=”married” value=”Y”/>
一个名为married的检查框，在表单提交时会返回一个”Y”.
f) 文件标记
<html:file>标记可以显示HTML文件控件。属性如下：
属性描述Name Bean的名称，它的属性将确定文件控件中显示的内容。如果没设置，将使用与内嵌表单相关的ActionForm bean的名称property 这个属性定义了当表单被提交时送回到服务器的请求参数的名称，以及用来确定文件控件中显示内容的bean属性名称Accept 服务器能够处理的内容类型集。它也将对客户浏览器对话框中的可选文件类型进行过滤Value 按钮上的标记，这个按钮能够在本地文件系统中浏览文件
g) 单选钮标记
<html:radio>标记用来显示HTML单选钮控件，属性如下：
属性描述Name Bean的名称，其属性会被用来确定单选钮是否以选中的状态显示。如果没有设置，将使用与这个内嵌表单相关的ActionFrom bean的名称。property 当表单被提交时送回到服务器的请求参数的名称，以及用来确定单选钮是否以被选中状态进行显示的bean属性的名称
23
Value 当单选钮被选中时返回到服务器的值
h) 隐藏标记
<html:hidden>标记能够显示HTML隐藏输入元素，属性如下：
属性描述Name Bean的名称，其属性会被用来确定隐藏元素的当前值。如果没有设置，将使用与这个内嵌表单相关的ActionFrom bean的名称。property 定义了当表单被提交时送回到服务器的请求参数的名称，以及用来确定隐藏元素当前值的bean属性的名称Value 用来初始化隐藏输入元素的值
i) 密码标记
<html:password>标记能够显示HTML密码控件，属性如下：
属性描述maxlength 能够输入的最大字符数Name Bean的名称，它的属性将用来确定密码元素的当前值。如果没有设置，将使用与这个内嵌表单相关的ActionFrom bean的名称。property 定义了当表单被提交时送回到服务器的请求参数的名称，以及用来确定密码元素当前值的bean属性的名称redisplay 在显示这个字段时，如果相应的bean属性已经被设置了数据，这个属性决定了是否显示密码的内容Size 字段的大小
j) 选择标记
<html:select>标记能够显示HTML选择控件，属性如下：
属性描述multiple 表明这个选择控件是否允许进行多选Name Bean的名称，它的属性确定了哪个。如果没有设置，将使用与这个内嵌表单相关的ActionFrom bean的名称。property 定义了当表单被提交时送回到服务器的请求参数的名称，以及用来确定哪个选项需要被选中的bean属性的名称Size 能够同时显示的选项数目Value 用来表明需要被选中的选项
k) 选项标记(这个元素需要嵌套在<html:select>标记里)
<html:option>标记用来显示HTML选项元素集合，属性如下：
24
属性描述collection Bean集合的名称，这个集合存储在某个作用域的属性中。选项的数目与集合中元素的数目相同。Property属性能够定义选项值所使用的bean属性，而labelProperty属性定义选项标记所使用的bean的属性labelName 用来指定存储于某个作用域的bean，这个bean是一个字符串的集合，能够定义<html:option>元素的标记(如果标志与值不相同) labelProperty 与collection属性共同使用时，用来定义了存储于某个作用域的bean，这个bean将返回一个字符串集合，能够用来写入<html:option>元素的value属性Name 如果这是唯一被指定的属性，它就定义了存储于某个作用域的bean，这个bean将返回一个字符串集合，能够用来写入<html:option>元素的value属性property 这个属性在与collection属性共同使用时，定义了每个要显示选项值的独立bean的name属性。如果不是与collection属性共同使用，这个属性定义了由name属性指定的bean的属性名称(如果有name属性)，或是定义了一个ActionForm bean，这个bean将返回一个集合来写入选项的值
我们看一下这个标记的一些例子：
<html:option collection=”optionCollection” property=”optionValue”
labelProperty=”optionLabel”/>
标记假设在某个作用域中有一个名为optionCollection的集合，它包含了一些具有optionValue属性的独立的bean，每个属性将作为一个选项的值。每个选项的标志由bean的optionLabel属性属性进行定义。
<html:option name=”optionValues” labelName=”optionLabels”/>
标记中optionValues代表一个存储在某个作用域中的bean，它是一个字符串集合，能够用来写入选项的值，而optionLabels代表一个存储在某个作用域中的bean，它也是一个字符串集合，能够用来写入选项的标志。
2.3.2.显示错误信息的标记
<html:errors>标记能够与ActionErrors结合在一起来显示错误信息。这个标记首先要从当前区域的资源文件中读取消息关键字errors.header，然后显示消息的文本。接下去它会在ActionErrors对象(通常作为请求参数而存储在Action.ERROR_KEY关键字下)中循环，读取单个ActionError对象的消息关键字，从当前区域的资源文件中读取并格式化相应的消息，并且显示它们。然后它读取与errors.footer关键字相对应的消息并且显示出来。
通过定义property属性能够过滤要显示的消息，这个属性的值应该与ActionErrors对象中存储ActionError对象的关键字对应。属性如下：
属性描述Bundle 表示应用程序作用域属性的名称，它包含着消息资源，其默认值Acion.MESSAGE_KEY Locale 表示会话作用域属性的名称，它存储着用户当前登录的区域信息。其默认值是Action.ERROR_KEY
25
Name 表示请求属性的名称，它存储着ActionErrors对象。其默认值是Action.ERROR_KEY property 这个属性指定了ActionErrors对象中存储每个独立ActionError对象的关键字，它可以过滤消息
例子：
<html:errors/>
显示集合中所有的错误。
<html:errors property=”missing.name”/>
显示存储在missing.name关键字的错误。
2.3.3.其他HTML标记
struts HTML标记还定义了下列标记来显示其他HTML元素：
<html:html> : 显示HTML元素
<html:img> : 显示图象标记
<html:link> : 显示HTML链接或锚点
<html:rewrite> : 创建没有锚点标记的URI
这些标记的详细内容请参照struts文档。
2.4. 模板标记
动态模板是模块化WEB页布局设计的强大手段。Struts模板标记库定义了自定义标记来实现动态模板。
2.4.1.插入标记
<template:insert>标记能够在应用程序的JSP页中插入动态模板。这个标记只有一个template属性，用来定义模板JSP页。要插入到模板的页是有多个<template:put>标记来指定的，而这些标记被定义为<template:insert>标记的主体内容。
2.4.2.放置标记
<template:put>标记是<template:insert>标记内部使用的，用来指定插入到模板的资源。属性如下：
属性描述content 定义要插入的内容，比如一个JSP文件或一个HTML文件direct 如果这个设置为true，由content属性指定的内容将直接显示在JSP上而不是作为包含文件Name 要插入的内容的名称Role 如果设置了这个属性，只有在当前合法用户具有特定角色时才能进行内容的插入。
26
2.4.3.获得标记
在模板JSP页中使用<template:get>标记能够检索由<template:put>标记插入到JSP页的资源。属性如下：
属性描述Name 由<template:put>标记插入的内容的名称Role 如果设置了这个属性，只有在当前合法用户具有特定角色时才能进行内容的检索
2.4.4.使用模板标记
首先编写一个模板JSP页，它将被所有的web页使用：
<html>
<%@ taglib uri=”/template” prefix=”template” %>
<head>
<title></title>
</head>
<body>
<table width=”100%” height=”100%” >
<tr height=”10%”>
<td>
<template:get name=”header”/>
</td>
</tr>
<tr height=”80%”>
<td>
<template:get name=”content”/>
</td>
</tr>
<tr height=”10%”>
<td>
<template:get name=”footer”/>
</td>
</tr>
</table>
</body>
</html>
我们将这个文件命名为template.jsp。这个文件使用<template:get>标记来获得由JSP页使用<template:put>标记提供的内容，并且将内容在一个HTML表格中显示出来。这三个内容是标题，内容和页脚。典型的内容JSP会是这样：
<%@ taglib uri=”/template” prefix=”/template” %>
<template:insert template=”template.jsp”>
<template:put name=”header” content=”header.html”/>
27
<template:put name=”content” content=”employeeList.jsp”/>
<template:put name=”footer” content=”footer.html”/>
</template:insert>
这个应用程序JSP页使用<template:insert标记来定义模板，然后使用<template:put>标记将特定内容名称指定的资源放到模板JSP页中。如果我们有上百个布局相同的页，但突然想改变这个模板，我们只需要改变template.jsp文件。 |
|
|
posted @
2006-06-08 13:00 MyJavaWorld 阅读(261) |
评论 (0) |
编辑 收藏
|
指令名称：sudo
使用权限：在 /etc/sudoers 中有出现的使用者
使用方式：sudo -V
sudo -h
sudo -l
sudo -v
sudo -k
sudo -s
sudo -H
sudo [ -b ] [ -p prompt ] [ -u username/#uid] -s
sudo command
说明：以系统管理者的身份执行指令，也就是说，经由 sudo 所执行的指令就好像是 root 亲自执行
参数：
-V 显示版本编号
-h 会显示版本编号及指令的使用方式说明
-l 显示出自己（执行 sudo 的使用者）的权限
-v 因为 sudo 在第一次执行时或是在 N 分钟内没有执行（N 预设为五）会问密码，这个参数是重新做一次确认，如果超过 N 分钟，也会问密码
-k 将会强迫使用者在下一次执行 sudo 时问密码（不论有没有超过 N 分钟）
-b 将要执行的指令放在背景执行
-p prompt 可以更改问密码的提示语，其中 ％u 会代换为使用者的帐号名称， ％h 会显示主机名称
-u username/#uid 不加此参数，代表要以 root 的身份执行指令，而加了此参数，可以以 username 的身份执行指令（#uid 为该 username 的使用者号码）
-s 执行环境变数中的 SHELL 所指定的 shell ，或是 /etc/passwd 里所指定的 shell
-H 将环境变数中的 HOME （家目录）指定为要变更身份的使用者家目录（如不加 -u 参数就是系统管理者 root ）
command 要以系统管理者身份（或以 -u 更改为其他人）执行的指令
范例：
sudo -l 列出目前的权限
sudo -V 列出 sudo 的版本资讯
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
以root身份执行指令 名称
sudo - 以超级使用者 (superuser; root) 的身分执行指令
visudo - 编辑 sudoers 档案
语法
sudo command
描述
Sudo 允许经过同意的使用者以超级使用者的身分执行指令。 Sudo 参考/etc/sudoers 这个档案来判定谁是被授权的使用者。Sudo 将会提示使用者输入密码来启始一段 N 分钟的允许时间（其中 N 是在安装的时候定义的且预设值为 5 分钟）。
Sudoers 这个档案是由一个选择性的主机别名 (host alias) 节区，一个选择性的指令别名 (command alias) 节区以及使用者说明 (user specification)节区所组成的。所有的指令别名或主机别名必须需以他们自己的关键字作为开始 (Host_Alias/Cmnd_Alias)。注意，只有第一次使用者（在使用者说明节区里有记录的使用者）使用时会有说明。
使用者说明节区格式：
使用者 接取群组 [: 接取群组 ] ...
接取群组 ::= 主机象徵 = [op]指令象徵 [,[op]指令象徵] ...
主机象徵 ::= 一个小写的主机名称或主机别名。
指令象徵 ::= 一个指令或指令别名。
op ::= 逻辑的 ! 否定运算元。
主机别名节区格式：
Host_Alias 主机别名 = 主机列表
Host_Alias ::= 这是一个关键字。
主机别名 ::= 一个大写的别名。
主机列表 ::= 以逗号间隔的一些主机名称。
指令别名节区格式：
Cmnd_Alias 指令别名 = 指令列表
Cmnd_Alias ::= 这是一个关键字。
指令别名 ::= 一个大写的别名。
指令列表 ::= 以逗号间隔的一些指令。
所有在 # 符号後面的文字都会被当作是注解。
太长的行可以使用倒斜线 字元来分成新的行。
保留的别名 ALL 在 {Host,Cmnd}_Alias 里都可以使用。
不要用 ALL 来定义一个别名，这个别名无效。
注意到 ALL 暗示全部的主机跟指令。
你可以使用这个语法从整个范围中减掉一些项目：
user host=ALL,!ALIAS1,!/etc/halt...
范例
# Host alias specification
Host_Alias HUB=houdini.rootgroup.com:
REMOTE=merlin,kodiakthorn,spirit
Host_Alias MACHINES=kalkan,alpo,milkbones
Host_Alias SERVERS=houdini,merlin,kodiakthorn,spirit
# Command alias specification
Cmnd_Alias LPCS=/usr/etc/lpc,/usr/ucb/lprm
Cmnd_Alias SHELLS=/bin/sh,/bin/csh,/bin/tcsh
Cmnd_Alias MISC=/bin/rm,/bin/cat:
SHUTDOWN=/etc/halt,/etc/shutdown
# User specification
britt REMOTE=SHUTDOWN:ALL=LPCS
robh ALL=ALL,!SHELLS
nieusma SERVERS=SHUTDOWN,/etc/reboot:
HUB=ALL,!SHELLS
jill houdini.rootgroup.com=/etc/shutdown,MISC
markm HUB=ALL,!MISC,!/etc/shutdown,!/etc/halt
billp ALL=/usr/local/bin/top:MACHINES=SHELLS
davehieb merlin=ALL:SERVERS=/etc/halt:
kodiakthorn=ALL
上面的 sudoers 说明档案是由 4 个主机别名说明，4 个指令别名说明以及 7 个使用者说明所组成的。Britt 被允许在远端机器 (merlin, kodiakthorn, 还有 spirit) 上执行 /etc/halt, /etc/shutdown, /usr/etc/lpc 以及/usr/ucb/lprm 。Rohn 被允许在任何机器上执行除了 SHELL 指令群以外的任何指令。Jill 被允许在 houdini 上执行 /etc/shotdown, /bin/rm, 以及/bin/cat 。Davehieb 可以在 merlin 以及 kodiakthorn 上执行任何指令并且可以 halt SERVERS 。
Sudoers 档案应该用 visudo 指令编辑，它会锁住该档并且做文法检查。这提供了一个可以避免愚蠢文法错误的机制。
Sudo 被设计成经由 4.3 BSD syslogging 来记录，但是如果真的想要的话还是可以记录到一个档案来取代。
如果一个没有被授权的使用者执行了 sudo 的话，将会有一封 mail 从该使用者寄送到当地的授权者处（在安装的时候定义的）。
所有的设定都是在安装的时后定义的，从 sudo.h 含入档及 Makefile 取得。
未来加强
允许巢状的主机以及指令别名。
允许在 sudoers 档案中使用 host specifier
以便使用全区符号 (user ALL,!SERVERS, ... = commands) 。
允许在 sudores 档案里的使用者别名（就如同主机／指令别名一样）。
使 visudo 对 sudoers 档案做更广泛的检查。
档案
/etc/sudoers 经授权的使用者档案。
/etc/stmp visudo 的 lock file 。
/usr/local/bin/sudo sudo 的执行档。
/usr/local/etc/visudo 修改 sudoers 档案的工具。
|
|
|
posted @
2006-06-08 12:57 MyJavaWorld 阅读(307) |
评论 (0) |
编辑 收藏Struts的Token（令牌）机制能够很好的解决表单重复提交的问题，基本原理是：服务器端在处理到达的请求之前，会将请求中包含的令牌值与保存在当前用户会话中的令牌值进行比较，看是否匹配。在处理完该请求后，且在答复发送给客户端之前，将会产生一个新的令牌，该令牌除传给客户端以外，也会将用户会话中保存的旧的令牌进行替换。这样如果用户回退到刚才的提交页面并再次提交的话，客户端传过来的令牌就和服务器端的令牌不一致，从而有效地防止了重复提交的发生。
这时其实也就是两点，第一：你需要在请求中有这个令牌值，请求中的令牌值如何保存，其实就和我们平时在页面中保存一些信息是一样的，通过隐藏字段来保存，保存的形式如： 〈input type="hidden" name="org.apache.struts.taglib.html.TOKEN" value="6aa35341f25184fd996c4c918255c3ae"〉，这个value是TokenProcessor类中的generateToken()获得的，是根据当前用户的session id和当前时间的long值来计算的。第二：在客户端提交后，我们要根据判断在请求中包含的值是否和服务器的令牌一致，因为服务器每次提交都会生成新的Token，所以，如果是重复提交，客户端的Token值和服务器端的Token值就会不一致。下面就以在数据库中插入一条数据来说明如何防止重复提交。
在Action中的add方法中，我们需要将Token值明确的要求保存在页面中，只需增加一条语句：saveToken(request);，如下所示：
public ActionForward add(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response)
//前面的处理省略
saveToken(request);
return mapping.findForward("add");
}在Action的insert方法中，我们根据表单中的Token值与服务器端的Token值比较，如下所示：
public ActionForward insert(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response)
if (isTokenValid(request, true)) {
// 表单不是重复提交
//这里是保存数据的代码
} else {
//表单重复提交
saveToken(request);
//其它的处理代码
}
}
222222222222222222222222222222222222222222222222222222222222222222222
1。重复提交、重复刷新的场景
重复提交、重复刷新都是来解决系统重复记录的问题。也就是说某个人在多次的提交某条记录（为什么？也许是闲了没有事情干的;最有可能是用户根本就不知道自己的提交结果是否已经执行了？！）。
但出现了这样的问题并不见得就必须处理，要看你所开发的系统的类别而定。比如你接手的是某个资源管理系统，系统本身从需求的角度根本就不允许出现"重复"的记录，在这样需求的约束条件下，去执行重复的提交动作只会引发“业务级异常”的产生，根本就不可能执行成功也就无所谓避免不避免的问题了。
2。防止后退的场景
了解了重复刷新、重复提交的场景，我们来了解一下"防止后退"操作的原因是什么？比如你在开发某个投票系统，它有很多的步骤，并且这些步骤之间是有联系的，比如第一步会将某些信息发送给第二步，第二步缓存了这些信息，同时将自身的信息发送给了第三步。。。。。等等，如果此时用户处在第三步骤下，我们想象一下某个淘气用户的用户点击了后退按钮，此时屏幕出现了第二步骤的页面，他再次的修改或者再次的提交，进入到下一个步骤（也就是第三步骤），错误就会在此产生？！什么错误呢？最为典型的就是这样的操作直接导致了对于第一个步骤信息的丢失！（如果这样的信息是依靠Request存放的话，当然你可以存放在Session或者更大的上下文环境中，但这不是个好主意！关于信息存放的问题，下次在就这个问题详细的讨论）
三。如何处理的问题
当然很多的系统（比如订票系统从需求上本身是允许个人重复订票的）是必须要避免重复刷新、重复提交、以及防止后退的问题的，但即使是这样的问题，也要区分如何处理以及在哪里处理的（网上只是告诉你如何处理，但很少去区分在哪里处理的），显然处理的方式无非是客户端或者服务器端两种，而面对不同的位置处理的方式也是不同的，但有一点要事先声明：任何客户端（尤其是B/S端）的处理都是不可信任的，最好的也是最应该的是服务器端的处理方法。
客户端处理：
面对客户端我们可以使用Javascript脚本来解决，如下
1。重复刷新、重复提交
Ways One：设置一个变量，只允许提交一次。
<script language="javascript">
var checkSubmit*** = false;
function checkSubmit() {
if (checkSubmit*** == true) {
return false;
}
checkSubmit*** = true;
return true;
}
document.ondblclick = function docondblclick() {
window.event.returnValue = false;
}
document.onclick = function doconclick() {
if (checkSubmit***) {
window.event.returnValue = false;
}
}
</script>
<html:form action="myAction.do" method="post" onsubmit="return checkSubmit();">
Way Two : 将提交按钮或者image置为disable
<html:form action="myAction.do" method="post"
onsubmit="getElById('submitInput').disabled = true; return true;">
<html:image styleId="submitInput" src="images/ok_b.gif" border="0" />
</html:form>
2。防止用户后退
这里的方法是千姿百态，有的是更改浏览器的历史纪录的，比如使用window.history.forward()方法;有的是“用新页面的URL替换当前的历史纪录，这样浏览历史记录中就只有一个页面，后退按钮永远不会变为可用。”比如使用javascript:location.replace(this.href); event.returnValue=false;
2.服务器端的处理（这里只说Struts框架的处理）
利用同步令牌（Token）机制来解决Web应用中重复提交的问题，Struts也给出了一个参考实现。
基本原理：
服务器端在处理到达的请求之前，会将请求中包含的令牌值与保存在当前用户会话中的令牌值进行比较，
看是否匹配。在处理完该请求后，且在答复发送给客户端之前，将会产生一个新的令牌，该令牌除传给
客户端以外，也会将用户会话中保存的旧的令牌进行替换。这样如果用户回退到刚才的提交页面并再次
提交的话，客户端传过来的令牌就和服务器端的令牌不一致，从而有效地防止了重复提交的发生。
if (isTokenValid(request, true)) {
// your code here
return mapping.findForward("success");
} else {
saveToken(request);
return mapping.findForward("submitagain");
}
Struts根据用户会话ID和当前系统时间来生成一个唯一（对于每个会话）令牌的，具体实现可以参考
TokenProcessor类中的generateToken()方法。
1. //验证事务控制令牌,<html:form >会自动根据session中标识生成一个隐含input代表令牌，防止两次提交
2. 在action中：
//<input type="hidden" name="org.apache.struts.taglib.html.TOKEN"
// value="6aa35341f25184fd996c4c918255c3ae">
if (!isTokenValid(request))
errors.add(ActionErrors.GLOBAL_ERROR,
new ActionError("error.transaction.token"));
resetToken(request); //删除session中的令牌
3. action有这样的一个方法生成令牌
protected String generateToken(HttpServletRequest request) {
HttpSession session = request.getSession();
try {
byte id[] = session.getId().getBytes();
byte now[] =
new Long(System.currentTimeMillis()).toString().getBytes();
MessageDigest md = MessageDigest.getInstance("MD5");
md.update(id);
md.update(now);
return (toHex(md.digest()));
} catch (IllegalStateException e) {
return (null);
} catch (NoSuchAlgorithmException e) {
return (null);
}
}
总结
对于重复提交、重复刷新、防止后退等等都是属于系统为避免重复记录而需要解决的问题，在客户端去处理需要针对每一种的可能提出相应的解决方案，然而在服务器端看来只不过是对于数据真实性的检验问题，基于令牌的处理就是一劳永逸的方法。
同时我们也看到，从不同的角度去看待问题，其解决的方法也是不同的。客户端更追求的是用户的操作，而服务端则将注意力放在了数据的处理上，所以在某个对于服务器端看似容易的问题上，用客户端来解决却麻烦了很多！反之依然。所以在某些问题的处理上我们需要综合考虑和平衡，是用客户端来解决？还是用服务器端来处理
posted @
2006-06-02 18:15 MyJavaWorld 阅读(3248) |
评论 (4) |
编辑 收藏