sdlyi的博客dfgfdgdfgd

test feedburner

Wed, 24 Jan 2007 22:33:10 +0800

dsfsadfsdfsdf 汉字节     788787687686786788

test2

Tue, 12 Dec 2006 22:04:21 +0800

fsdfsdfsdfsdfsdfsdfsdfsdfsdffsdf

test

Tue, 12 Dec 2006 19:16:13 +0800

sdfdsfsdfsdfsdf

测试PING BOOSO

Tue, 18 Jul 2006 02:37:26 +0800

AF-Ⅲ双网络报警控制器

简介

随着我国经济的高速发展，人民生活水平的不断提高，公共及个人财产不断增加，对于安防报警系统得需求力度也不断加大。为此，我公司自主研发了基于GSM网络平台和电话传输平台的自动报警系统，本系统结合世界上多种先进报警系统得优点，采用了国际先进的微处理技术、传感技术等，形成了一套针对室内场所防盗、求助、燃气泄漏及烟雾火灾等险情报警系统。本系统突出的优点是结合无线、有线两种告警传输方式，直观、可靠的将报警地点的情况反映到当地的110指挥中心的系统操作平台和用户手机屏幕上，接警中心据此可在最短时间内立即通知就近警员前往报警地点处理警情。

AF-Ⅲ双网络报警控制器集政府机关、办公室、商店、家庭安全、紧急呼救等智能家居为一体，真正实现了超远距离方便、灵活的智能无线报警，成功解决了固定电话和无线短信为一体的高安全、高性能的新一代报警系统。

AF-Ⅲ双网络报警控制器可广泛应用于公安、市政、小区物业、银行、电信、医疗、电力、交通、石油、煤炭、铁道、国防等部门行业的安防设备、数据检测以及远程监控。该系统是新一代高质量、高性能的职能报警系统。

AF-Ⅲ双网络报警控制器已通过国家3C认证，并且有中国人保财险每户20万元的保险。确保发生警情后的损失尽量减少到最低。

test Trackback

samba conf

Tue, 11 Jul 2006 01:25:13 +0800

samba conf

SAMBA安装配置

1. SAMBA安装配置

1.1. 软件下载

samba下载地址

1.2. 安装流程

tar xzvf samba-3.0.22.tar.gz
cd samba-3.0.22
cd source/
./autogen.sh
./configure
make;make install
cd ../packaging/
cp -r . /usr/local/samba/
cd /usr/local/samba/setup
cp smb.conf ../lib/

1.3. 配置启动

1.3.1. 修改配置文件./lib/smb.conf

[smb]
   comment = Mary's and Fred's stuff
   path = /opt
   valid users = root admin
   public = yes
   writable = yes
   printable = no
   create mask = 0765

1.3.2. 创建帐户

useradd admin
passwd admin
smbpasswd  -a admin

1.3.3. 启动SAMBA

/usr/local/samba/sbin/smbd -D
/usr/local/samba/sbin/nmbd -D

1.3.4. 测试启动

shell#smbclient -U% -L localhost
params.c:OpenConfFile() - Unable to open configuration file &quot;/usr/local/lib/smb.conf&quot;:
        No such file or directory
smbclient: Can't load /usr/local/lib/smb.conf - run testparm to debug it
Domain=[MYGROUP] OS=[Unix] Server=[Samba 3.0.22]

        Sharename       Type      Comment
        ---------       ----      -------
        IPC$            IPC       IPC Service (Samba Server)
        smb             Disk      Mary's and Fred's stuff
        ADMIN$          IPC       IPC Service (Samba Server)
Domain=[MYGROUP] OS=[Unix] Server=[Samba 3.0.22]

        Server               Comment
        ---------            -------
        LOCALHOST            Samba Server

        Workgroup            Master
        ---------            -------
        BOKEE-INC            SPS
        CHINALABS            LAB1
        CONTACTUS            MAIL
        HOME                 WINIX
        MYGROUP              LOCALHOST

1.3.5. 远程连接

smbclient  //192.168.27.25/smb -U admin   //连接成功

apache mod rewrite

Tue, 11 Jul 2006 01:24:12 +0800

suijf/apache mod rewrite

apache mod_rewirte相关文档

1. apache mod_rewirte相关文档

1.1. 安装篇

编译apache 包含mod_rewrite模块

./configure --prefix=/usr/local/apache2 --enable-cache --enable-disk-cache --enable-file-cache --enable-so --enable-rewrite=shared --enable-proxy --with-mpm=worker --with-threads=yes
make
make install

apache动态编译mod_rewrite模块

/usr/local/apache2/bin/apxs -ci /usr/local/src/httpd-2.0.52/modules/mappers/mod_rewrite.c

1.2. 配置篇

我们的目标是把http://www.bulknews.cn/show.php?id=1014700通过rewrite的url重写，使可以直接http://www.bulknews.cn/1014700.html访问

1.2.1. 首先配置apache的httpd.conf，目的是使.htaccess文件生效

&lt;VirtualHost a.b.c.d&gt;
    ServerAdmin a@b.com
    DocumentRoot /var/www/bulknews
    ServerName www.bulknews.cn
&lt;Directory /&gt;
      Options FollowSymLinks
      AllowOverride All
&lt;/Directory&gt;
ErrorLog  &quot;|/usr/local/sbin/cronolog /var/log/www/wapya/www.bulknews.cn_error_log.%Y%m%d&quot;
CustomLog &quot;|/usr/local/sbin/cronolog /var/log/www/wapya/www.bulknews.cn_access_log.%Y%m%d&quot; combined
&lt;/VirtualHost&gt;

注意，这里必须是FollowSymLinks，AllowOverride是All，否则rewrite引擎根本不起作用，另外如果你的apache默认根目录是/var/www 的话，在/var/www的配置字段也要设置 Options FollowSymLinks

AllowOverride All

我的就因为这个，只是在虚拟主机设置，导致一直不能实现静态页面的转化。

1.2.2. 在/var/www/bulknews下设置.htaccess文件

RewriteEngine   on
RewriteBase     /
RewriteRule     (.+)\.html$ show.php?id=$1 [L]

OK，重启web服务，这时候你就可以正常访问http://www.bulknews.cn/1014700.html

1.2.3. 一个配置文件

&lt;IfModule mod_rewrite.c&gt;
ProxyVia on
RewriteEngine On
#RewriteCond     %{REQUEST_URI}          ^.*
RewriteCond     %{REQUEST_URI}          ^.*
#RewriteCond     %{HTTP_HOST}           ^[a-zA-Z]+.*\.feeds
#RewriteBase    /
#RewriteRule
#RewriteRule     ^/$            doUser.php?domain=$1&amp;uri=%{REQUEST_URI} [P]
#RewriteRule     ^/([a-z]+)             doUser.php?domain=$1&amp;uri=%{REQUEST_URI} [P,L]
#RewriteRule     ^/user/([a-zA-Z]+)             doUser.php?domain=$1 [R]
RewriteRule     !^/doUser.php$                  - [C]
RewriteRule     ^/([a-zA-Z]+)/?.*$              doUser.php?domain=$1&amp;uri=%{REQUEST_URI} [R,L]
#RewriteRule     ^/([a-zA-Z]+.*$)               doUser.php?domain=$1&amp;uri=%{HTTP_HOST} [R]
#RewriteRule     ^/([a-zA-Z]+./?$)              doUser.php?domain=$1&amp;uri=%{HTTP_HOST} [R]
#RewriteRule     ^/self                   http://localhost:8080/keyLink/showKey.k [P]
#RewriteRule     ^/copy/([0-9]+)          http://localhost:8080/keyLink/copyKey.k?linkID=$1 [P]
#RewriteRule     ^/add                    http://localhost:8080/keyLink/createKey.k [P]
#RewriteRule     ^/link/([0-9]+)          http://localhost:8080/keyLink/showLink.k?linkID=$1 [P]
#RewriteRule     ^/t/WSSE/                http://localhost:8080/t/WSSE/  [P]
#RewriteRule     ^/showTags                http://localhost:8080/homePage.k?method=showTags  [P]
#RewriteRule     ^/shownews/([0-9]+)          http://localhost:8080/homePage.k?method=showNews&amp;newsID=$1  [P]

#RewriteRule     ^/xml-rpc              http://localhost:8080/xml-rpc [P]
#RewriteRule     ^/index.html           /usr/local/flyer/key/index.html  [L]
#RewriteRule     ^/download.html       /usr/local/flyer/key/download.html  [L]
#RewriteRule     ^/download.html       http://localhost:8080/download.html [P]

RewriteLogLevel 0
RewriteLog   /usr/local/apache2/logs/rewrite.log
&lt;/IfModule&gt;

1.3. 解析配置文件字段

1.3.1. RewriteEngine 指令

RewriteEngine指令打开或关闭运行时刻的重写引擎。如果设置为off，则mod_rewrite模块不执行任何运行时刻的重写操作，甚至也不更新SCRIPT_URx环境变量。

使用该指令可以使mod_rewrite模块无效，而无须注释所有的RewriteRule指令!

注意：默认情况下，重写配置是不可继承的，即，必须在每个需要的虚拟主机中设置一个RewriteEngine on指令。

1.3.2. RewriteLock 指令

此指令设置mod_rewrite为了和RewriteMap 程序通讯而使用的一个同步加锁文件的名称。在需要使用重写映射表程序时，它必须是一个本地路径(而不能是一个NFS挂接设备)；对其他类型的重写映射表，则无此要求。

1.3.3. RewriteLog 指令

RewriteLog指令设置用于记录所有重写操作的文件的名称。如果此文件名不是以斜杠('/')开头，则它是相对于Server Root的。此指令应该仅仅出现在服务器级配置中。

如果要关闭对重写操作的记录，不推荐把Filename设置为/dev/null，因为，虽然重写引擎不能输出记录了，但仍会内部地建立这个日志文件，它会使服务器速度降低，而且对管理员毫无益处! 要关闭日志，可以删除或注解RewriteLog指令，或者使用RewriteLogLevel 0! 安全参见Apache Security Tips，其中讲述了，为什么如果存放日志的目录对除了启动服务器以外的用户是可写的会带来安全隐患。举例 RewriteLog "/usr/local/var/apache/logs/rewrite.log"

1.3.4. RewriteLogLevel 指令

RewriteLogLevel指令设置重写引擎日志的详细程度的级别。默认级别0意味着不记录，而9或更大的值意味着记录所有的操作。

要关闭重写引擎日志，可以简单地设此值为0，关闭所有的重写操作记录。

使用较高的Level值会使Apache服务器速度急剧下降! 重写日志使用大于2的Level值只用于调试! 举例 RewriteLogLevel 3

1.3.5. RewriteMap 指令

RewriteMap定义一个映射表，由映射函数用于查找关键词来插入/替换字段。此查找操作的源可以是多种类型。

MapName是映射表的名称，指定了一个映射函数，用于重写规则的字符串替换，它可以是下列形式之一：

${ MapName : LookupKey }
${ MapName : LookupKey | DefaultValue }

如果使用了这样的形式，则会在MapName中查找关键词LookupKey。如果找到了，则被替换成SubstValue；如果没有找到，则被替换成DefaultValue，如果没有指定DefaultValue，则被替换成空字符串。

可以使用下列MapType和MapSource的组合:

标准纯文本 MapType: txt, MapSource: 有效的Unix文件系统文件名这是重写映射表的标准形式，即， MapSource是一个纯文本文件，包含空行、注释行(以字符'#'打头)，以及每行一个的替换对，如下。

MatchingKey SubstValue

Example
##
## map.txt -- rewriting map
##

Ralf.S.Engelschall rse # Bastard Operator From Hell
Mr.Joe.Average joe # Mr. Average

RewriteMap real-to-user txt:/path/to/file/map.txt

随机纯文本 MapType: rnd, MapSource: 有效的Unix文件系统文件名这个与上述的标准纯文本很相似，但它有一个特殊的后处理特性：查找完毕后，会解析其中包含的含义为or和|符号。也就是说，会随机地选择其中之一作为实际的返回值。虽然这看似毫无意义，但它的设计意图是，在一个查找值是服务器名称的反向代理环境中，实现负载平衡。如：

##
## map.txt -- rewriting map
##

static www1|www2|www3|www4
dynamic www5|www6

RewriteMap servers rnd:/path/to/file/map.txt

散列文件 MapType: dbm[=type], MapSource: 有效的Unix文件系统文件名这里的源是一个二进制格式的DBM文件，包含了与纯文本相同的内容，但是因为它有优化的特殊表现形式，使它的查找速度明显快得多。此类型可以是sdbm, gdbm, ndbm或db，由compile-time settings所决定。如果省略type，则使用编译时选择的缺省设置。你可以使用任何DBM工具或者下列Perl脚本来建立这个文件，但必须保证 DBM的类型正确。建立NDBM文件的例子：

#!/path/to/bin/perl
##
## txt2dbm -- convert txt map to dbm format
##

use NDBM_File;
use Fcntl;

($txtmap, $dbmmap) = @ARGV;

open(TXT, &quot;&lt;$txtmap&quot;) or die &quot;Couldn't open $txtmap!\n&quot;;
tie (%DB, 'NDBM_File', $dbmmap,O_RDWR|O_TRUNC|O_CREAT, 0644)
or die &quot;Couldn't create $dbmmap!\n&quot;;

while (&lt;TXT&gt;) {
next if (/^\s*#/ or /^\s*$/);
$DB{$1} = $2 if (/^\s*(\S+)\s+(\S+)/);
}

untie %DB;
close(TXT);

$ txt2dbm map.txt map.db

内部函数 MapType: int, MapSource: 内部的Apache函数这里的源是一个内部的Apache函数。目前，还不能由你自己建立，只能使用下列已经存在的函数：

toupper: 转换查找关键词为大写. tolower: 转换查找关键词为小写. escape: 转换查找关键词中的特殊字符为十六进制编码. unescape: 转换查找关键词中的十六进制编码为特殊字符. 外部的重写程序 MapType: prg, MapSource: 有效的Unix文件系统文件名这里的源是一个程序，而不是一个映射表文件。程序的编制语言可以随意选择，但最终结果必须是可执行的 (即, 或者是目标代码，或者是首行为'#!/path/to/interpreter'的脚本).

此程序仅在Apache服务器启动时启动一次，随后通过stdin和stdout文件句柄与重写引擎交互。对每个映射函数的查找操作，它从stdin接收以回车结束的查找关键词，然后把查找结果以回车结束反馈到stdout，如果查找失败，则返回四个字符的NULL (即, 对给定的关键词没有对应的值)。此程序的最简单形式是一个1:1的映射(即,key == value)，如:

#!/usr/bin/perl
$| = 1;
while (&lt;STDIN&gt;) {
# ...put here any transformations or lookups...
print $_;
}

但是必须注意:

即使它看来简单而愚蠢，只要正确，就保持原样(Keep it simple, stupid) (KISS), 因为，在规则起作用时，此程序的崩溃会直接导致Apache服务器的崩溃。避免犯一个常见的错误: 绝不要对stdout做缓冲I/O! 它会导致死循环! 所以上述例子中才会有$|=1... 使用RewriteLock指令定义一个加锁文件，用于同步mod_rewrite和此程序之间的通讯。缺省时是没有同步操作的。 RewriteMap指令允许多次出现。对每个映射函数都可以使用一个RewriteMap指令来定义其重写映射表。虽然不能在目录的上下文中定义映射表，但是，完全可以在其中使用映射表。

注意对于纯文本和DBM格式的文件，已经查找过的关键词会被缓存在内核中，直到映射表的mtime改变了或者服务器重启了。这样，你可以把每个请求都会用到的映射函数放在规则中，这是没有问题的，因为外部查找只进行一次!

1.3.6. RewriteOptions 指令

RewriteOptions指令为当前服务器级和目录级的配置设置一些选项。 Option可以是下列值之一：

inherit 此值强制当前配置可以继承其父配置。在虚拟主机级配置中，它意味着主服务器的映射表、条件和规则可以被继承。在目录级配置中，它意味着其父目录的.htaccess中的条件和规则可以被继承。 MaxRedirects=number 为了避免目录级RewriteRule的无休止的内部重定向，在此类重定向和500内部服务器错误次数达到一个最大值的时候， mod_rewrite会停止对此请求的处理。如果你确实需要对每个请求允许大于10次的内部重定向，可以增大这个值。

1.3.7. RewriteRule 指令

RewriteRule指令是重写引擎的根本。此指令可以多次使用。每个指令定义一个简单的重写规则。这些规则的定义顺序尤为重要, 因为，在运行时刻，规则是按这个顺序逐一生效的.

Pattern是一个作用于当前URL的兼容perl的正则表达式. 这里的当前是指该规则生效时的URL的值。它可能与被请求的URL不同，因为其他规则可能在此之前已经发生匹配并对它做了改动。

1.3.8. 正则表达式的一些用法

Text:
. Any single character
[chars] Character class: One of chars
[^chars] Character class: None of chars
text1|text2 Alternative: text1 or text2

Quantifiers:
? 0 or 1 of the preceding text
* 0 or N of the preceding text (N &gt; 0)
+ 1 or N of the preceding text (N &gt; 1)

Grouping:
(text) Grouping of text
(either to set the borders of an alternative or
for making backreferences where the Nth group can
be used on the RHS of a RewriteRule with $N)

Anchors:
^ Start of line anchor
$ End of line anchor

Escaping:
\char escape that particular char
(for instance to specify the chars &quot;.[]()&quot; etc.)

更多有关正则表达式的资料请参见perl正则表达式手册页("perldoc perlre"). 如果你对正则表达式的更详细的资料及其变种(POSIX regex 等.)感兴趣，请参见以下专著:

Mastering Regular Expressions Jeffrey E.F. Friedl Nutshell Handbook Series O'Reilly & Associates, Inc. 1997 ISBN 1-56592-257-3

另外，在mod_rewrite中，还可以使用否字符('!')的pattern前缀，以实现pattern的反转。比如：如果当前URL不与pattern相匹配. 它用于使用否pattern较容易描述的需要排除的某些情况，或者作为最后一条规则。

注意使用否字符以反转pattern时，pattern中不能使用分组的通配成分。由于pattern不匹配而使分组的内容是空的，所以它是不可能实现的。因此，如果使用了否pattern，那么后继的字符串中就不能使用$N! 重写规则中的Substitution是，当原始URL与Pattern相匹配时，用以替代(或替换)的字符串。除了纯文本，还可以使用

$N 反向引用RewriteRule的pattern %N 反向引用最后匹配的RewriteCond pattern 规则条件测试字符串中(%{VARNAME})的服务器变量映射函数调用(${mapname:key|default}) 反向引用的$N (N=0..9) 是指用Pattern所匹配的第N组的内容去替换URL。服务器变量与RewriteCond指令的TestString相同。映射函数由RewriteMap指令所决定，其说明也参见该指令。这三种类型变量按上面列表中的顺序被扩展。

如上所述，所有的重写规则都是(按配置文件中的定义顺序)作用于Substitution的。 URL被Substitution完全地替换，并继续处理直到所有规则处理完毕，除非用L标记显式地终结 - 见下文。

'-'是一个特殊的替换串，意思是不要替换! 似乎很愚蠢吧? 不, 它可以用于仅仅匹配某些URL而无须替换的情况下，即，在发生替换前，允许以C (chain)标记连接的多个pattern同时起作用。

还有，你甚至可以在替换字符串中新建包含请求串的URL。在替换串中使用问号，以标明其后继的成分应该被重新注入到QUERY_STRING中。要删除一个已有的请求串，可以用问号来终结替换字符串。

注意一个特殊功能: 在用[url] http://thishost[/url][:thisport]作为替换字段的前缀时， mod_rewrite会把它自动剥离出去。在配合生成主机名的映射函数使用的时候，这个对隐含的外部重定向URL的精简化操作是有用的而且是重要的。下面例子一节中的第一个例子有助于理解这点。谨记由于此功能的存在，以[url] http://thishost[/url]为前缀的无条件外部重定向在你自己的服务器上是无效的。要做这样一个自身的重定向，必须使用R标记 (见下文). 此外，Substitution还可以追加特殊标记

1.3.9. flags(要点)

作为RewriteRule指令的第三个参数。 Flags是一个包含以逗号分隔的下列标记的列表:

1.3.9.1. redirect|R [=code]

(强制重定向 redirect)

以[url]http://thishost[/url][:thisport]/(使新的URL成为一个URI) 为前缀的Substitution可以强制性执行一个外部重定向。 如果code没有指定，则产生一个HTTP响应代码302(临时性移动)。如果需要使用在300-400范围内的其他响应代码，只需在此指定这个数值即可， 另外，还可以使用下列符号名称之一: temp (默认的), permanent, seeother. 用它可以把规范化的URL反馈给客户端，如, 重写``/~''为 ``/u/''，或对/u/user加上斜杠，等等。

注意: 在使用这个标记时，必须确保该替换字段是一个有效的URL! 否则，它会指向一个无效的位置! 并且要记住，此标记本身只是对URL加上 [url]http://thishost[/url][:thisport]/的前缀，重写操作仍然会继续。通常，你会希望停止重写操作而立即重定向，则还需要使用'L'标记.

1.3.9.2. forbidden|F

(强制URL为被禁止的 forbidden)

强制当前URL为被禁止的，即，立即反馈一个HTTP响应代码403(被禁止的)。使用这个标记，可以链接若干RewriteConds以有条件地阻塞某些URL。

1.3.9.3. gone|G

(强制URL为已废弃的 gone)

强制当前URL为已废弃的，即，立即反馈一个HTTP响应代码410(已废弃的)。使用这个标记，可以标明页面已经被废弃而不存在了.

1.3.9.4. proxy|P

(强制为代理 proxy)

此标记使替换成分被内部地强制为代理请求，并立即(即，重写规则处理立即中断)把处理移交给代理模块。你必须确保此替换串是一个有效的(比如常见的以 [url]http://hostname[/url]开头的)能够为Apache代理模块所处理的URI。使用这个标记，可以把某些远程成分映射到本地服务器名称空间，从而增强了ProxyPass指令的功能。注意: 要使用这个功能，代理模块必须编译在Apache服务器中。如果你不能确定，可以检查httpd -l的输出中是否有mod_proxy.c。如果有，则mod_rewrite可以使用这个功能；如果没有，则必须启用mod_proxy并重新编译httpd程序。

1.3.9.5. last|L

(最后一个规则 last)

立即停止重写操作，并不再应用其他重写规则。它对应于Perl中的last命令或C语言中的break命令。这个标记可以阻止当前已被重写的URL为其后继的规则所重写。举例，使用它可以重写根路径的URL('/')为实际存在的URL, 比如, '/e/www/'. 'next|N' (重新执行 next round) 重新执行重写操作(从第一个规则重新开始). 这时再次进行处理的URL已经不是原始的URL了，而是经最后一个重写规则处理的URL。它对应于Perl中的next命令或C语言中的continue命令。此标记可以重新开始重写操作，即, 立即回到循环的头部。但是要小心，不要制造死循环!

1.3.9.6. chain|C

(与下一个规则相链接 chained)

此标记使当前规则与下一个(其本身又可以与其后继规则相链接的，并可以如此反复的)规则相链接。它产生这样一个效果: 如果一个规则被匹配，通常会继续处理其后继规则，即，这个标记不起作用；如果规则不能被匹配，则其后继的链接的规则会被忽略。比如，在执行一个外部重定向时，对一个目录级规则集，你可能需要删除.www (此处不应该出现.www的)。

1.3.9.7. type|T=MIME-type

(强制MIME类型 type)

强制目标文件的MIME类型为MIME-type。比如，它可以用于模拟mod_alias中的ScriptAlias指令，以内部地强制被映射目录中的所有文件的MIME类型为application/x-httpd-cgi.

1.3.9.8. nosubreq|NS

(仅用于不对内部子请求进行处理 no internal sub-request)

在当前请求是一个内部子请求时，此标记强制重写引擎跳过该重写规则。比如，在mod_include试图搜索可能的目录默认文件 (index.xxx)时， Apache会内部地产生子请求。对子请求，它不一定有用的，而且如果整个规则集都起作用，它甚至可能会引发错误。所以，可以用这个标记来排除某些规则。

根据你的需要遵循以下原则: 如果你使用了有CGI脚本的URL前缀，以强制它们由CGI脚本处理，而对子请求处理的出错率(或者开销)很高，在这种情况下，可以使用这个标记。

1.3.9.9. nocase|NC

(忽略大小写 no case)

它使Pattern忽略大小写，即, 在Pattern与当前URL匹配时，'A-Z' 和'a-z'没有区别。 'qsappend|QSA' (追加请求串 query string append) 此标记强制重写引擎在已有的替换串中追加一个请求串，而不是简单的替换。如果需要通过重写规则在请求串中增加信息，就可以使用这个标记。

1.3.9.10. noescape|NE

(在输出中不对URI作转义 no URI escaping)

此标记阻止mod_rewrite对重写结果应用常规的URI转义规则。一般情况下，特殊字符(如'%', '$', ';'等)会被转义为等值的十六进制编码。此标记可以阻止这样的转义，以允许百分号等符号出现在输出中，如：

RewriteRule /foo/(.*) /bar?arg=P1\%3d$1 [R,NE]

可以使'/foo/zed'转向到一个安全的请求'/bar?arg=P1=zed'.

1.3.9.11. passthrough|PT

(移交给下一个处理器 pass through)

此标记强制重写引擎将内部结构request_rec中的uri字段设置为 filename字段的值，它只是一个小修改，使之能对来自其他URI到文件名翻译器的 Alias，ScriptAlias, Redirect 等指令的输出进行后续处理。举一个能说明其含义的例子：如果要通过mod_rewrite的重写引擎重写/abc为/def，然后通过mod_alias使/def转变为/ghi，可以这样:

RewriteRule ^/abc(.*) /def$1 [PT]
Alias /def /ghi

如果省略了PT标记，虽然mod_rewrite运作正常，即, 作为一个使用API的URI到文件名翻译器，它可以重写uri=/abc/...为filename=/def/...，但是，后续的mod_alias在试图作URI到文件名的翻译时，则会失效。注意: 如果需要混合使用不同的包含URI到文件名翻译器的模块时，就必须使用这个标记。。混合使用mod_alias和mod_rewrite就是个典型的例子。

For Apache hackers 如果当前Apache API除了URI到文件名hook之外，还有一个文件名到文件名的hook，就不需要这个标记了! 但是，如果没有这样一个hook，则此标记是唯一的解决方案。 Apache Group讨论过这个问题，并在Apache 2.0 版本中会增加这样一个hook。 'skip|S=num' (跳过后继的规则 skip) 此标记强制重写引擎跳过当前匹配规则后继的num个规则。它可以实现一个伪if-then-else的构造: 最后一个规则是then从句，而被跳过的skip=N个规则是else从句. (它和'chain|C'标记是不同的!) 'env|E=VAL' (设置环境变量 environment variable) 此标记使环境变量VAR的值为VAL, VAL可以包含可扩展的反向引用的正则表达式$N和%N。此标记可以多次使用以设置多个变量。这些变量可以在其后许多情况下被间接引用，但通常是在XSSI (via ) or CGI (如 $ENV{'VAR'})中，也可以在后继的RewriteCond指令的pattern中通过%{VAR}作引用。使用它可以从URL中剥离并记住一些信息。

1.3.9.12. cookie|CO=NAME:VAL:domain[:lifetime[:path]]

(设置cookie)

它在客户端浏览器上设置一个cookie。 cookie的名称是NAME，其值是VAL。 domain字段是该cookie的域，比如'.apache.org', 可选的lifetime是cookie生命期的分钟数，可选的path是cookie的路径。注意绝不要忘记，在服务器级配置文件中，Pattern是作用于整个URL的。但是在目录级配置文件中， (一般总是和特定目录名称相同的)目录前缀会在pattern匹配时被自动删除，而又在替换完毕后自动被加上。此特性对很多种重写是必须的，因为，如果没有这个剥离前缀的动作，就必须与其父目录去匹配，而这并不总是可行的。但是有一个例外: 如果替换串以 http://开头，则不会附加目录前缀，而是强制产生一个外部重定向，或者(如果使用了P标记)是一个代理操作!

注意为了对目录级配置启用重写引擎，你必须在这些文件中设置RewriteEngine On，并且打开Options FollowSymLinks'。如果管理员对用户目录禁用了FollowSymLinks，则无法使用重写引擎。这个限制是为了安全而设置的。以下是所有可能的替换组合及其含义:

在服务器级配置中(httpd.conf) ，对这样一个请求 GET /somepath/pathinfo:

Given Rule Resulting Substitution
---------------------------------------------- ----------------------------------
^/somepath(.*) otherpath$1 not supported, because invalid!

^/somepath(.*) otherpath$1 [R] not supported, because invalid!

^/somepath(.*) otherpath$1 [P] not supported, because invalid!
---------------------------------------------- ----------------------------------
^/somepath(.*) /otherpath$1 /otherpath/pathinfo

^/somepath(.*) /otherpath$1 [R] [url]http://thishost/otherpath/pathinfo[/url]
via external redirection

^/somepath(.*) /otherpath$1 [P] not supported, because silly!
---------------------------------------------- ----------------------------------
^/somepath(.*) [url]http://thishost/otherpath$1[/url] /otherpath/pathinfo

^/somepath(.*) [url]http://thishost/otherpath$1[/url] [R] [url]http://thishost/otherpath/pathinfo[/url]
via external redirection

^/somepath(.*) [url]http://thishost/otherpath$1[/url] [P] not supported, because silly!
---------------------------------------------- ----------------------------------
^/somepath(.*) [url]http://otherhost/otherpath$1[/url] [url]http://otherhost/otherpath/pathinfo[/url]
via external redirection

^/somepath(.*) [url]http://otherhost/otherpath$1[/url] [R] [url]http://otherhost/otherpath/pathinfo[/url]
via external redirection
(the [R] flag is redundant)

^/somepath(.*) [url]http://otherhost/otherpath$1[/url] [P] [url]http://otherhost/otherpath/pathinfo[/url]
via internal proxy

在/somepath的目录级配置中 (即, 目录/physical/path/to/somepath的.htaccess文件中包含 RewriteBase /somepath) 对这样一个请求GET /somepath/localpath/pathinfo:

Given Rule Resulting Substitution
---------------------------------------------- ----------------------------------
^localpath(.*) otherpath$1 /somepath/otherpath/pathinfo

^localpath(.*) otherpath$1 [R] [url]http://thishost/somepath/otherpath/pathinfo[/url]
via external redirection

^localpath(.*) otherpath$1 [P] not supported, because silly!
---------------------------------------------- ----------------------------------
^localpath(.*) /otherpath$1 /otherpath/pathinfo

^localpath(.*) /otherpath$1 [R] [url]http://thishost/otherpath/pathinfo[/url]
via external redirection

^localpath(.*) /otherpath$1 [P] not supported, because silly!
---------------------------------------------- ----------------------------------
^localpath(.*) [url]http://thishost/otherpath$1[/url] /otherpath/pathinfo

^localpath(.*) [url]http://thishost/otherpath$1[/url] [R] [url]http://thishost/otherpath/pathinfo[/url]
via external redirection

^localpath(.*) [url]http://thishost/otherpath$1[/url] [P] not supported, because silly!
---------------------------------------------- ----------------------------------
^localpath(.*) [url]http://otherhost/otherpath$1[/url] [url]http://otherhost/otherpath/pathinfo[/url]
via external redirection

^localpath(.*) [url]http://otherhost/otherpath$1[/url] [R] [url]http://otherhost/otherpath/pathinfo[/url]
via external redirection
(the [R] flag is redundant)

^localpath(.*) [url]http://otherhost/otherpath$1[/url] [P] [url]http://otherhost/otherpath/pathinfo[/url]
via internal proxy

举例:

要重写这种形式的URL

/ Language /~ Realname /.../ File

为

/u/ Username /.../ File . Language

可以把这样的对应关系保存在/path/to/file/map.txt映射文件中，此后，只要在Apache服务器配置文件中增加下列行，即可：

RewriteLog /path/to/file/rewrite.log
RewriteMap real-to-user txt:/path/to/file/map.txt
RewriteRule ^/([^/]+)/~([^/]+)/(.*)$ /u/${real-to-user:$2|nobody}/$3.$1

rewriterule  ^/photoblog.*$ http://localhost:8080/%{REQUEST_URI} [P]
rewriterule  !^/top/?$ - [C]
rewriterule  !^/groups/?$ - [C]
rewriterule  ^/([a-zA-Z0-9]+)/?$ http://localhost:8080/photoblog/YourHomeCtrl?domain=$1  [P,L]

mod jk 安装

Tue, 11 Jul 2006 01:23:23 +0800

mod jk

1. 安装流程

1.1. 下载包文件

wget http://archive.apache.org/dist/jakarta/tomcat-connectors/jk2/jakarta-tomcat-connectors-jk2-src-current.tar.gz

1.2. 解压

tar xzvf jakarta-tomcat-connectors-jk2-src-current.tar.gz

1.3. 切换路径

/usr/local/httpd-2.0.55/jakarta-tomcat-connectors-jk2-2.0.4-src/jk/native2

1.4. 安装前配置

./configure --with-apxs2=/usr/local/apache2/bin/apxs --with-java-home=/usr/java/j2sdk1.4.2_04/

1.5. 安装

make jk2-build-apxs

1.6. 切换路径

cd server/apache2/

1.7. 生成mod_jk

make -f Makefile.apxs install

1.8. 修改apache配置文件

LoadModule jk2_module modules/mod_jk2.so

安装完成！

2. 配置流程

设置虚拟主机比如，我现在有虚拟主机 vhosts.vicp.net 希望把jsp和servlet都转到tomcat去，而其他的文件比如html页面，图片等等仍然用apache解析。 Tomcat设置：修改 tomcat/conf/server.xml，在 <Engine></Engine>里面再增加一个<host/>，

&lt;Host name=&quot;vhosts.vicp.net&quot; debug=&quot;0&quot; 
appBase=&quot;/opt/jakarta-tomcat-4.1.12-LE-jdk14/webapps/struts-example&quot;
unpackWARs=&quot;true&quot; autoDeploy=&quot;true&quot;&gt;
&lt;Alias&gt;localhost&lt;/Alias&gt;
&lt;Alias&gt;www&lt;/Alias&gt;
&lt;Alias&gt;10.0.0.10&lt;/Alias&gt;
&lt;Context path=&quot;&quot; docBase=&quot;&quot; debug=&quot;1&quot;/&gt;
&lt;Valve className=&quot;org.apache.catalina.valves.AccessLogValve&quot;
directory=&quot;logs&quot; prefix=&quot;vhost.vicp.net_access_log.&quot; suffix=&quot;.txt&quot;
pattern=&quot;common&quot; resolveHosts=&quot;false&quot;/&gt;
&lt;Logger className=&quot;org.apache.catalina.logger.FileLogger&quot;
directory=&quot;logs&quot; prefix=&quot;home_log_&quot; suffix=&quot;_app_log.txt&quot;
timestamp=&quot;true&quot;/&gt;
&lt;/Host&gt;

调整里面的参数和设置使之适合你的环境，当然，如果你还有其他的<host/>添加在后面。

2.1. 设置虚拟主机

在httpd.conf里面配置：

把下面这段放到VirtualHost之前，可以从全局避免用户用apache访问WEB-INF目录。

&lt;Directory ~ &quot;/WEB-INF/&quot;&gt;
Order allow,deny
Deny from all
&lt;/Directory&gt;

典型的VirtualHost配置样本

&lt;VirtualHost _default_:80&gt;
ServerName vhost.vicp.net
DocumentRoot /home/webapp/public_html/
DirectoryIndex index.htm index.html default.htm index.php index.jsp
&lt;Location ~ &quot;/*.jsp|/*/servlet/*&quot;&gt;
JkUriSet worker ajp13:localhost:8009
&lt;/Location&gt;
ErrorLog logs/vhosts.vicp.net-err_log
CustomLog logs/vhosts.vicp.net-acc_log common
&lt;/VirtualHost&gt;

这样就可以为每个不同的虚拟主机分别指定使用或者不使用jsp功能。

好了，可以开始开发和使用你的web应用了！

2006-03-30 02:09:56由jenves编辑

测试

Mon, 16 Jan 2006 18:46:03 +0800

测试所用

Using the WebLogic XML Streaming API

Wed, 28 Dec 2005 02:39:50 +0800

  Using the WebLogic XML Streaming API

Parsing an XML Document: Typical Steps

The following procedure describes the typical steps for using the WebLogic XML Streaming API to parse and manipulate an XML document.

The first two steps are required. The next steps you take depend on how you want to process the XML file.

Import the weblogic.xml.stream.* classes.
Get an XML stream of events from an XML file, a DOM tree, or a set of SAX events. You can also filter the XML stream to get only certain types of events, names of specific elements, and so on. See "Getting an XML Input Stream" on page 4-7.
Iterate over the stream, returning generic XMLEvent types. See "Iterating Over the Stream" on page 4-10.
For each generic XMLEvent type, determine the specific event type. Event types include the start of an XML document, the end of an element, an entity reference, and so on. See "Determining the Specific XMLEvent Type" on page 4-11.
Get the attributes of an element. See "Getting the Attributes of an Element" on page 4-15.
Position the stream by skipping over event, skipping to a particular event, and so on. See "Positioning the Stream" on page 4-16.
Get the children of an element. See "Getting a Substream" on page 4-17.
Close the stream. See "Closing the Input Stream" on page 4-19.

Example of Parsing an XML Document

The following program shows an example of using the XML Streaming API to parse an XML document.

The program takes a single parameter, an XML file, that it converts into an XML input stream. It then iterates over the stream, determining the type of each event, such as the start of an XML element, the end of the XML document, and so on. The program prints out information for three types of events: start elements, end elements, and the character data that forms the body of an element. The program does nothing when it encounters the other types of events, such as comments or start of the XML document.

Note: The code in bold font is described in detail in the sections following the example.

package examples.xml.stream;

import weblogic.xml.stream.Attribute;
import weblogic.xml.stream.AttributeIterator;
import weblogic.xml.stream.ChangePrefixMapping;
import weblogic.xml.stream.CharacterData;
import weblogic.xml.stream.Comment;
import weblogic.xml.stream.XMLEvent;
import weblogic.xml.stream.EndDocument;
import weblogic.xml.stream.EndElement;
import weblogic.xml.stream.EntityReference;
import weblogic.xml.stream.ProcessingInstruction;
import weblogic.xml.stream.Space;
import weblogic.xml.stream.StartDocument;
import weblogic.xml.stream.StartPrefixMapping;
import weblogic.xml.stream.StartElement;
import weblogic.xml.stream.EndPrefixMapping;
import weblogic.xml.stream.XMLInputStream;
import weblogic.xml.stream.XMLInputStreamFactory;
import weblogic.xml.stream.XMLName;
import weblogic.xml.stream.XMLStreamException;

import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class ComplexParse {

  /**
   * Helper method to get a handle on a stream.
   * Takes in a name and returns a stream.  This
   * method usese the InputStreamFactory to create an
   * instance of an XMLInputStream
   * @param name The file to parse
   * @return XMLInputStream the stream to parse
   */
  public XMLInputStream getStream(String name)
    throws XMLStreamException, FileNotFoundException
  {
    XMLInputStreamFactory factory = XMLInputStreamFactory.newInstance();
    XMLInputStream stream = factory.newInputStream(new FileInputStream(name));
    return stream;
  }

  /**
   *  Determines the type of event, such as the start
   *  of an element, end of a document, and so on.  If the
   *  event is of type START_ELEMENT, END_ELEMENT, or
   *  CHARACTER_DATA, the method prints out appropriate info;
   *  otherwise, it does nothing.
   *  @param event The XML event that has been parsed
   */
  public void parse(XMLEvent event)
    throws XMLStreamException
  {
    switch(event.getType()) {
    case XMLEvent.START_ELEMENT:
      StartElement startElement = (StartElement) event;
      System.out.print(&quot;&lt;&quot; + startElement.getName().getQualifiedName() );
      AttributeIterator attributes = startElement.getAttributesAndNamespaces();
      while(attributes.hasNext()){
        Attribute attribute = attributes.next();
        System.out.print(&quot; &quot; + attribute.getName().getQualifiedName() + 
                          &quot;='&quot; + attribute.getValue() + &quot;'&quot;);
      }
      System.out.print(&quot;&gt;&quot;);
      break;
    case XMLEvent.END_ELEMENT:
      System.out.print(&quot;&lt;/&quot; + event.getName().getQualifiedName() +&quot;&gt;&quot;);
      break;
    case XMLEvent.SPACE:
    case XMLEvent.CHARACTER_DATA:
      CharacterData characterData = (CharacterData) event;
      System.out.print(characterData.getContent());
      break;
    case XMLEvent.COMMENT:
      // Print comment
      break;
    case XMLEvent.PROCESSING_INSTRUCTION:
      // Print ProcessingInstruction
      break;
    case XMLEvent.START_DOCUMENT:
      // Print StartDocument
      break;
    case XMLEvent.END_DOCUMENT:
      // Print EndDocument
      break;
    case XMLEvent.START_PREFIX_MAPPING:
      // Print StartPrefixMapping
      break;
    case XMLEvent.END_PREFIX_MAPPING:
      // Print EndPrefixMapping
      break;
    case XMLEvent.CHANGE_PREFIX_MAPPING:
      // Print ChangePrefixMapping
      break;
    case XMLEvent.ENTITY_REFERENCE:
      // Print EntityReference
      break;
    case XMLEvent.NULL_ELEMENT:
      throw new XMLStreamException(&quot;Attempt to write a null event.&quot;);
    default:
      throw new XMLStreamException(&quot;Attempt to write unknown event
                                    [&quot;+event.getType()+&quot;]&quot;);
    }
  }
  /**
   * Helper method to iterate over a stream
   * @param name The file to parse
   */
  public void parse(XMLInputStream stream)
    throws XMLStreamException
  {
    while(stream.hasNext()) {
      XMLEvent event = stream.next();
      parse(event);
    }
    stream.close();
  }

  /** Main method.   Takes a single argument: an XML file
   *  that will be converted into an XML input stream.
   */
  public static void main(String args[])
    throws Exception
  {
    ComplexParse complexParse= new ComplexParse();
    complexParse.parse(complexParse.getStream(args[0]));
  }
}

Getting an XML Input Stream

You can use the XML Streaming API to convert a variety of objects, such as XML files, DOM trees, or SAX events, into a stream of events.

The following example shows how to create a stream of events from an XML file:

XMLInputStreamFactory factory = XMLInputStreamFactory.newInstance();
XMLInputStream stream = factory.newInputStream(new FileInputStream(name));

First you create a new instance of the XMLInputStreamFactory, then use the factory to create a new XMLInputStream from the XML file referred to in the name variable.

The following example shows how to create a stream from a DOM tree:

DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
dbf.setValidating(false);
dbf.setNamespaceAware(true);
DocumentBuilder db = dbf.newDocumentBuilder();
Document doc = db.parse(new java.io.File(file));
XMLInputStream stream = XMLInputStreamFactory.newInstance().newInputStream(doc);

Getting a Buffered XML Input Stream

After you finish iterating over an XMLInputStream object, you cannot access the stream again. If, however, you need to process the stream again, such as send it to another application or iterate over it again in some other way, use a BufferedXMLInputStream object rather than a plain XMlInputStream object.

Use the newBufferedInputStream() method of the XMLInputStreamFactory class to create a buffered XMlL input stream, as shown in the following example:

XMLInputStreamFactory factory = XMLInputStreamFactory.newInstance();
BufferedXMLInputStream bufstream =
    factory.newBufferedInputStream(factory.newInputStream(new 
    FileInputStream(name)));

You can use the mark() and reset() methods of the BufferedXMLInputStream object to mark a particular spot in the stream, continue processing the stream, then reset the stream back to the marked spot. See Marking and Resetting a Buffered XML Input Stream for more information.

Filtering the XML Stream

Filtering an XML stream refers to creating a stream that contains only specified types of events. For example, you can create a stream that contains only start elements, end elements, and the character data that make up the body of an XML element. Another example is filtering an XML stream so that only elements with a specified name appear in the stream.

To filter an XML stream, you specify a filter class as the second parameter to the XMLInputStreamFactory.newInputStream() method. You specify the events that you want in the XML stream as parameters to the filter class. The following example shows how to use the TypeFilter class to specify that you want only start and end XML elements and character data in the resulting XML stream:

import weblogic.xml.stream.util.TypeFilter;

XMLInputStreamFactory factory = XMLInputStreamFactory.newInstance();
XMLInputStream stream = factory.newInputStream(new FileInputStream(name), 
                        new TypeFilter(XMLEvent.START_ELEMENT |
                                       XMLEvent.END_ELEMENT |
                                       XMLEvent.CHARACTER_DATA));

The following table describes the filters provided by the WebLogic XML Streaming API. They are part of the weblogic.xml.stream.util package.

Table 4-2

Name of Filter	Description	Sample Usage
TypeFilter	Filter an XML stream based on specified event types, such as XMLEvent.START_ELEMENT, XMLEvent.END_ELEMENT, and so on. See "Determining the Specific XMLEvent Type" on page 4-11 for a full list of event types. TypeFilter takes an integer bitmask as input; you OR the values to create this bitmask, as shown in the sample.	new TypeFilter (XMLEvent.START_ELEMENT \| XMLEvent.END_ELEMENT \| XMLEvent.CHARACTER_DATA)
NameFilter	Filter an XML stream based on the name of an element in the XML document.	new NameFilter ("Book")
NameSpaceFilter	Filter an XML stream based on the specified namespace URI.	new NameSpaceFilter ("http://namespace.org")
NamespaceTypeFilter	Filter an XML stream based on specified event types and namespace URI. This filter combines the functionality of TypeFilter and NameSpaceFilter.	new NamespaceFilter ("http://namespace.org", XMLEvent.START_ELEMENT) The example returns a stream where all start elements have the specified namespace.

Creating a Custom Filter

You can also create your own filter if the ones included in the API do not meet your needs.

Create a class that implements the ElementFilter interface and contains a method called accept(XMLEvent). This method tells the XMLInputStreamFactory.newInputStream() method whether to add a particular event to the stream or not, as shown in the following example:

package my.filters;

import weblogic.xml.stream.XMLName;
import weblogic.xml.stream.ElementFilter;
import weblogic.xml.stream.events.NullEvent;

public class SuperDooperFilter implements ElementFilter {

  protected String name;

  public SuperDooperFilter(String name)
  {
    this.name = name;
  }

  public boolean accept(XMLEvent e) {
    if (name.equals(e.getName().getLocalName()))
      return true;
    return false;
  }
}

In your XML application, be sure to import the new filter class:
```
import my.filters.SuperDooperFilter
```
Specify the filter as the second parameter to the newInputStream() method, passing to the filter class the types of events you want to appear in the XML stream in whatever format required by your filter class:

XMLInputStreamFactory factory = XMLInputStreamFactory.newInstance();
XMLInputStream stream = factory.newInputStream(new FileInputStream(name), 
                        new SuperDooperFilter(param));

Iterating Over the Stream

Once you have a stream of events, the next step is to methodically step through it using the XMLInputStream.next() and XMLInputStream.hasNext() methods, as shown in the following example:

    while(stream.hasNext()) {
      XMLEvent event = stream.next();
      System.out.print(event);
    }

Determining the Specific XMLEvent Type

The XMLInputStream.next() method returns an object of type XMLEvent. XMLEvent has subinterfaces that further classify what this event might be, such as the start of the XML document, the end of an element, an entity reference, and so on. The XMLEvent interface also contains corresponding fields, or constants, as well as a set of methods that you can use to identify the actual event. The following diagram shows the hierarchy of the XMLEvent interface and its subinterfaces:

The following table lists the subclasses and fields of the XMLEvent class that you can use to identify a particular event while parsing the XML stream.

Table 4-3 Subclasses and Fields of the XMLEvent Class

XMLEvent Subclass	Field of the XMLEvent Class used to Identify Subclass	Method used to Identify Subclass	Description of the Subclass Event
ChangePrefixMapping	CHANGE_PREFIX_MAPPING	isChangePrefixMapping	Signals that a prefix mapping has changed from an old namespace to a new namespace.
CharacterData	CHARACTER_DATA	isCharacterData	Signals that the returned XMLEvent object contains the character data from the body of the element.
Comment	COMMENT	isComment	Signals that the returned XMLEvent object contains an XML comment.
EndDocument	END_DOCUMENT	isEndDocument	Signals the end of the XML document.
EndElement	END_ELEMENT	isEndElement	Signals the end of an element in the XML document.
EndPrefixMapping	END_PREFIX_MAPPING	isEndPrefixMapping	Signals that a prefix mapping has gone out of scope.
EntityReference	ENTITY_REFERENCE	isEntityReference	Signals that the returned XMLEvent object contains an entity reference.
ProcessingInstruction	PROCESSING_INSTRUCTION	isProcessingInstruction	Signals that the returned XMLEvent object contains a processing instruction.
Space	SPACE	isSpace	Signals that the returned XMLEvent object contains whitespace.
StartDocument	START_DOCUMENT	isStartDocument	Signals the start of an XML document.
StartElement	START_ELEMENT	isStartElement	Signals the start of a element in the XML document.
StartPrefixMapping	START_PREFIX_MAPPING	isStartPrefixMapping	Signals that a prefix mapping has started its scope.

The following example shows how to use the Java case statement to determine the particular type of event that was returned by the XMLInputStream.next() method. For simplicity, the example simply prints that an event has been found; later sections show further processing of the event.

    switch(event.getType()) {
    case XMLEvent.START_ELEMENT:
      // Start of an element
      System.out.println (&quot;Start Element\n&quot;);
      break;

    case XMLEvent.END_ELEMENT:
      // End of an element
      System.out.println (&quot;End Element\n&quot;);
      break;

    case XMLEvent.PROCESSING_INSTRUCTION:
      // Processing Instruction
      System.out.println (&quot;Processing instruction\n&quot;);
      break;

    case XMLEvent.SPACE:
      // Whitespace
      System.out.println (&quot;White space\n&quot;);
      break;

    case XMLEvent.CHARACTER_DATA:
      // Character data
      System.out.println (&quot;Character data\n&quot;);
      break;

    case XMLEvent.COMMENT:
      // Comment
      System.out.println (&quot;Comment\n&quot;);
      break;

    case XMLEvent.START_DOCUMENT:
      // Start of the XML document
      System.out.println (&quot;Start Document\n&quot;);
      break;

    case XMLEvent.END_DOCUMENT:
      // End of the XML Document
      System.out.println (&quot;End Document\n&quot;);
      break;

    case XMLEvent.START_PREFIX_MAPPING:
      // The start of a prefix mapping scope
      System.out.println (&quot;Start prefix mapping\n&quot;);
      break;

    case XMLEvent.END_PREFIX_MAPPING:
      // The end of a prefix mapping scope
      System.out.println (&quot;End prefix mapping\n&quot;);
      break;

    case XMLEvent.CHANGE_PREFIX_MAPPING:
      // Prefix mapping has changed namespaces
      System.out.println (&quot;Change prefix mapping\n&quot;);
      break;

    case XMLEvent.ENTITY_REFERENCE:
      // An entity reference
      System.out.println (&quot;Entity reference\n&quot;);
      break;
    default:

      throw new XMLStreamException(&quot;Attempt to parse unknown event 
                                    [&quot; + event.getType() + &quot;]&quot;);
    }

Getting the Attributes of an Element

To get the attributes of an element in an XML document, you must first cast the XMLEvent object that was returned by the XMLInputStream.next() method to a StartElement object.

Because you do not know how many attributes an element might have, you must first create an AttributeIterator object to contain the entire list of attributes, and then iterate over the list until there are no more attributes. The following example describes how to do this as part of the START_ELEMENT case of the switch statement shown in "Iterating Over the Stream" on page 4-10:

case XMLEvent.START_ELEMENT:

    StartElement startElement = (StartElement) event;
    System.out.print(&quot;&lt;&quot; + startElement.getName().getQualifiedName() );
    AttributeIterator attributes = startElement.getAttributesAndNamespaces();
    while(attributes.hasNext()){
      Attribute attribute = attributes.next();
      System.out.print(&quot; &quot; + attribute.getName().getQualifiedName() + 
                        &quot;='&quot; + attribute.getValue() + &quot;'&quot;);
    }
    System.out.print(&quot;&gt;&quot;);
    break;

The example first creates a StartElement object by casting the returned XMLEvent to StartElement. It then creates an AttributeIterator object using the method StartElement.getAttributesAndNamespaces(), and iterates over the attributes using the AttributeIterator.hasNext() method. For each Attribute, it uses the Attributes.getName().getQualifiedName() and Attribute.getValue() methods to return the name and value of the attribute.

You can also use the getNamespace() and getAttributes() methods to return just the namespaces or attributes on their own.

Positioning the Stream

The following table describes the methods of the XMLInputStream interface that you can use to skip ahead to specific locations in the stream.

Table 4-4 Methods Used to Position the Input Stream

Method of XMLInputStream	Description
skip()	Positions the input stream to the next stream event. Note: The next event might not necessarily be an actual element in the XML file; for example, it could be a comment or white space.
skip(int)	Positions the input stream to the next event of this type. Examples of event types are XMLEvent.START_ELEMENT and XMLEvent.END_DOCUMENT. Refer to Table 4-3 for the full list of event types.
skip(XMLName)	Positions the input stream to the next event of this name.
skip(XMLName, int)	Positions the input stream to the next event of this name and type.
skipElement()	Skips to the next element (does not skip to the sub-elements of the current element).
peek()	Checks the next event without actually reading it from the stream.

The following example shows how you can modify the basic code for iterating over an input stream to skip over the character data in the body of an XML element:

    while(stream.hasNext()) {
      XMLEvent peek = stream.peek();
      if (peek.getType() == XMLEvent.CHARACTER_DATA ) {
        stream.skip();
        continue;
      }
      XMLEvent event = stream.next();
      parse(event);
    }

The example shows how to use the XMLInputStream.peek() method to determine the next event on the stream. If the type of event is XMLEvent.CHARACTER_DATA, then skip the event and go to the next one.

Getting a Substream

Use the XMLInputStream.getSubStream() method to get a copy of the next element, including all its subelements. The getSubstream() method returns an XMLInputStream object. Your position in the parent stream (or the stream from which you called getSubStream()) does not move. In the parent stream, if you want to skip the element you just got with getSubStream(), use the skipElement() method.

The getSubStream() method keeps a count of the START_ELEMENT and END_ELEMENT events it encounters, and as soon as the number is equal (or in other words, as soon as it finds the complete next element) it stops and returns the resulting substream as an XMLInputStream object.

For example, assume that you are using the XML Streaming API to parse the following XML document, but you are only interested in the substream delineated by the <content> and </content> tags:

&lt;book&gt;
  &lt;title&gt;The History of the World&lt;/title&gt;
  &lt;author&gt;Juliet Shackell&lt;/author&gt;
  &lt;publisher&gt;CrazyDays Publishing&lt;/publisher&gt;
  &lt;content&gt;
      &lt;chapter title='Just a Speck of Dust'&gt;
        &lt;synopsis&gt;The world as a speck of dust&lt;/synopsis&gt;
        &lt;para&gt;Once the world was just a speck of dust...&lt;/para&gt;
      &lt;/chapter&gt;
      &lt;chapter title='Life Appears'&gt;
        &lt;synopsis&gt;Move over dust, here comes life.&lt;/synopsis&gt;
        &lt;para&gt;Happily, the dust got a companion: life...&lt;/para&gt;
      &lt;/chapter&gt;
   &lt;/content&gt;
&lt;/book&gt;

The following code fragment shows how you can skip to the <content> start element tag, get the substream, and parse it using a separate ComplexParse object:

     if (stream.skip( ElementFactory.createXMLName(&quot;content&quot;)))
       {
          ComplexParse complexParse = new ComplexParse();
          complexParse.parse(stream.getSubStream());
       }

When you call this method on the previous XML document, you get the following output:

&lt;content&gt;
      &lt;chapter title='Just a Speck of Dust'&gt;
        &lt;synopsis&gt;The world as a speck of dust&lt;/synopsis&gt;
        &lt;para&gt;Once the world was just a speck of dust...&lt;/para&gt;
      &lt;/chapter&gt;
      &lt;chapter title='Life Appears'&gt;
        &lt;synopsis&gt;Move over dust, here comes life.&lt;/synopsis&gt;
        &lt;para&gt;Happily, the dust got a companion: life...&lt;/para&gt;
      &lt;/chapter&gt;
&lt;/content&gt;

Marking and Resetting a Buffered XML Input Stream

If you are using a BufferedXMLInputStream object, you can use the mark() and reset() methods to mark the stream at a particular spot, process the stream, and then subsequently reset the stream back to the marked spot. These methods are useful if you want to further manipulate the stream after initially iterating over it.

Note: If you read a buffered stream without marking it, you cannot access what you've just read. In other words, just because the stream is buffered, it does not automatically mean you can reread it. You must mark it first.

The following example shows a typical use of the BufferedXMLInputStream object:

    XMLInputStreamFactory factory = XMLInputStreamFactory.newInstance();
    BufferedXMLInputStream bufstream =
    factory.newBufferedInputStream(factory.newInputStream(new 
                FileInputStream(name)));

    // mark the start of the stream
    bufstream.mark();

    // process it locally
    bufferedParse.parse(bufstream);

    // reset the stream to the mark
    bufstream.reset();

    // send stream off to another application
    ComplexParse complexParse =  new ComplexParse();
    complexParse.parse(bufstream);

Closing the Input Stream

It is good programming practice to explicitly close the XML input stream when you are finished with it. To close an input stream, use the XMLInputStream.close() method, as shown in the following example:

// close the input stream
input.close();

Generating a New XML Document: Typical Steps

The following procedure describes the typical steps for using the WebLogic XML Streaming API to generate a new XML document.

The first two steps are required. The next steps you take depend on how you want to generate the XML file.

Import the weblogic.xml.stream.* classes.
Create an XML output stream to which to write the XML document. See "Creating an XML Output Stream" on page 4-22.
Add events to the XML output stream. See "Adding Elements to the Output Stream" on page 4-23.
Add attributes to the XML output stream. See "Adding Attributes to an Element on the Output Stream" on page 4-24.
Add an input stream to the output stream. See "Adding an Input Stream to an Output Stream" on page 4-25.
Print the output stream. See "Printing an Output Stream" on page 4-26.
Close the output stream. See "Closing the Output Stream" on page 4-26.

Example of Generating an XML Document

The following program shows an example of using the XML Streaming API to generate an XML document.

The program first creates an output stream based on a PrintWriter object, then adds elements to the output stream to create a simple XML purchase order, described in the comments of the program. The program also shows how to add an input stream based on a separate XML file to the output stream.

Note: The topics following the example describe it in more detail.

package examples.xml.stream;

import weblogic.xml.stream.XMLInputStream;
import weblogic.xml.stream.XMLOutputStream;
import weblogic.xml.stream.XMLInputStreamFactory;
import weblogic.xml.stream.XMLName;
import weblogic.xml.stream.XMLEvent;
import weblogic.xml.stream.StartElement;
import weblogic.xml.stream.EndElement;
import weblogic.xml.stream.Attribute;
import weblogic.xml.stream.ElementFactory;
import weblogic.xml.stream.XMLStreamException;
import weblogic.xml.stream.XMLOutputStreamFactory;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.PrintWriter;

/**
 * Program that prints out a very simple purchase order that looks
 * like the following:
 *
 * &lt;purchase_order&gt;
 *  &lt;name&gt;Juliet Shackell&lt;/name&gt;
 *  &lt;item id=&quot;1234&quot; quantity=&quot;2&quot;&gt;Fabulous Chair&lt;/item&gt;
 *  &lt;!-- this is a comment--&gt;
 *  &lt;another_file&gt;
 *    This comes from another file called &quot;another_file.xml&quot;
 *  &lt;/another_file&gt;
 * &lt;/purchase_order&gt;
 *
 * In the preceding XML file, the &lt;another_file&gt; element is actually another
 * XML file that is passed as an argument to the program, converted into an
 * XMLInputStream, then added to the output stream.
 */
public class PrintPurchaseOrder {

  /**
   * Helper method to get a handle on a stream.
   * Takes in a name and returns a stream.  This
   * method uses the InputStreamFactory to create an
   * instance of an XMLInputStream
   * @param name The file to parse
   * @return XMLInputStream the stream to parse
   */
  public XMLInputStream getInputStream(String name)
    throws XMLStreamException, FileNotFoundException
  {
    XMLInputStreamFactory factory = XMLInputStreamFactory.newInstance();
    XMLInputStream stream = factory.newInputStream(new FileInputStream(name));
    return stream;
  }
  public static void main(String args[])
    throws Exception
  {
    PrintPurchaseOrder printer = new PrintPurchaseOrder();
    //
    // Create an output stream.
    //
    XMLOutputStreamFactory factory = XMLOutputStreamFactory.newInstance();
    XMLOutputStream output = factory.newOutputStream(new           
                                        PrintWriter(System.out,true));

   // add the &lt;purchase_order&gt; root element
   output.add(ElementFactory.createStartElement(&quot;purchase_order&quot;));
   output.add(ElementFactory.createCharacterData(&quot;\n&quot;));

   // add the &lt;name&gt; element
   output.add(ElementFactory.createStartElement(&quot;name&quot;));
   output.add(ElementFactory.createCharacterData(&quot;Juliet Shackell&quot;));
   output.add(ElementFactory.createEndElement(&quot;name&quot;));
   output.add(ElementFactory.createCharacterData(&quot;\n&quot;));

   // add the &lt;item&gt; element along with the id and quantity attributes
   output.add(ElementFactory.createStartElement(&quot;item&quot;));
   output.add(ElementFactory.createAttribute(&quot;id&quot;,&quot;1234&quot;));
   output.add(ElementFactory.createAttribute(&quot;quantity&quot;,&quot;2&quot;));
   output.add(ElementFactory.createCharacterData(&quot;Fabulous Chair&quot;));
   output.add(ElementFactory.createEndElement(&quot;item&quot;));
   output.add(ElementFactory.createCharacterData(&quot;\n&quot;));

    // add a comment
   output.add(&quot;&lt;!-- this is a comment--&gt;&quot;);
   output.add(ElementFactory.createCharacterData(&quot;\n&quot;));

   // create an input stream from each XML file argument then add it to the output
   for (int i=0; i &lt; args.length; i++)
   //
   // Get an input stream and add it to the output stream
   //
   output.add(printer.getInputStream(args[i]));

    // Finally, end the root &quot;purchase_order&quot; element
   output.add(ElementFactory.createEndElement(&quot;purchase_order&quot;));
   output.add(ElementFactory.createCharacterData(&quot;\n&quot;));

    //
    // Print the results to the screen
    //
    output.flush();

   // Close the output streams
   output.close();
  }
}

The preceding program produces the following output:

&lt;purchase_order&gt;
  &lt;name&gt;Juliet Shackell&lt;/name&gt;
  &lt;item id=&quot;1234&quot; quantity=&quot;2&quot;&gt;Fabulous Chair&lt;/item&gt;
  &lt;!-- this is a comment--&gt;
  &lt;another_file&gt;
     This is from another file.
  &lt;/another_file&gt;
&lt;/purchase_order&gt;

Creating an XML Output Stream

One of the first steps in generating an XML document using the Weblogic XML Streaming API is to create an output stream which holds the document as it is being built. Creating an XML output stream is similar to creating an input stream: you first create an instance of the XMLOutputStreamFactory and then create an output stream with the XMLOutputStreamFactory.newOutputStream() method, as shown in the following example:

	    XMLOutputStreamFactory factory = XMLOutputStreamFactory.newInstance();
    XMLOutputStream output = factory.newOutputStream(new
                              PrintWriter(System.out,true));

The following example shows how to create an XMLOutputStream based on a DOM tree:

    DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
    dbf.setValidating(false);
    dbf.setNamespaceAware(true);
    Document doc = dbf.newDocumentBuilder().newDocument();
    XMLOutputStream out =
         XMLOutputStreamFactory.newInstance().newOutputStream(doc);

You can use the XMLOutputStreamFactory.newOutputStream() method to create an output stream based on the following four Java objects, depending on what the final form of the XML document will be (such as a file on the operating system, a DOM tree, and so on):

java.io.OutputStream
java.io.Writer
org.xml.sax.ContentHandler
org.w3c.dom.Document

Adding Elements to the Output Stream

Use the XMLOutputStream.add(XMLEvent) method to add elements to the output stream. Use the ElementFactory to create the particular element.

The ElementFactory interface includes methods to create each type of element; the general format is ElementFactory.createXXX() where XXX refers to the particular element, such as createStartElement(), createCharacterData(), and so on. You can create most elements by passing the name as a String or as an XMLName.

Warning: The XMLOutputStream does not validate your XML.

Note: Each time you create a start element, you must explicitly also create an end element at some point. The same rule applies to creating a start document.

For example, assume you want to create the following snippet of XML:

&lt;name&gt;Georgina Shackell Green&lt;/name&gt;

The Java code to add this element to an output stream is as follows:

   output.add(ElementFactory.createStartElement(&quot;name&quot;));
   output.add(ElementFactory.createCharacterData(&quot;Georgina Shackell Green&quot;));
   output.add(ElementFactory.createEndElement(&quot;name&quot;));
   output.add(ElementFactory.createCharacterData(&quot;\n&quot;));

The final createCharacterData() method adds a newline character to the output stream. This is optional, but useful if you want to create human-readable XML.

Adding Attributes to an Element on the Output Stream

Use the XMLOutputStream.add(Attribute) to add attributes to an element you have just created. Use the ElementFactory.createAttribute() method to create a particular attribute.

For example, assume you want to create the following snippet of XML:

&lt;item id=&quot;1234&quot; quantity=&quot;2&quot;&gt;Fabulous Chair&lt;/item&gt;

The Java code to add this element to an output stream is as follows:

   output.add(ElementFactory.createStartElement(&quot;item&quot;));
   output.add(ElementFactory.createAttribute(&quot;id&quot;,&quot;1234&quot;));
   output.add(ElementFactory.createAttribute(&quot;quantity&quot;,&quot;2&quot;));
   output.add(ElementFactory.createCharacterData(&quot;Fabulous Chair&quot;));
   output.add(ElementFactory.createEndElement(&quot;item&quot;));
   output.add(ElementFactory.createCharacterData(&quot;\n&quot;));

Note: Be sure you add attributes to an element after you create the start element but before you create the corresponding end element. Otherwise, although your code will compile successfully, you will get a runtime error when you try to run the program. For example, the following code returns an error because the attributes are added to the <item> element after the element has been explicitly ended:

   output.add(ElementFactory.createStartElement(&quot;item&quot;));
   output.add(ElementFactory.createEndElement(&quot;item&quot;));
   output.add(ElementFactory.createAttribute(&quot;id&quot;,&quot;1234&quot;));
   output.add(ElementFactory.createAttribute(&quot;quantity&quot;,&quot;2&quot;));
   output.add(ElementFactory.createCharacterData(&quot;Fabulous Chair&quot;));
   output.add(ElementFactory.createCharacterData(&quot;\n&quot;));

Adding an Input Stream to an Output Stream

When creating an XML output stream, you might want to add an existing XML document, such as an XML file or a DOM tree, to the output stream. To do this, you must first convert the XML document to an XML input stream, then use XMLOutputStream.add(XMLInputStream) method to add the input stream to the output stream.

The following example first shows a method called getInputStream() that creates an XML input stream from an XML file and then how to use the method to add the created input stream to an output stream:

  /**
   * Helper method to get a handle on a stream.
   * Takes in a name and returns a stream.  This
   * method uses the InputStreamFactory to create an
   * instance of an XMLInputStream
   * @param name The file to parse
   * @return XMLInputStream the stream to parse
   */

  public XMLInputStream getInputStream(String name)
    throws XMLStreamException, FileNotFoundException
  {
    XMLInputStreamFactory factory = XMLInputStreamFactory.newInstance();
    XMLInputStream stream = factory.newInputStream(new FileInputStream(name));
    return stream;
  }

....

   // create an input stream from each XML file argument then add it to the output

   for (int i=0; i &lt; args.length; i++)
   //
   // Get an input stream and add it to the output stream
   //
   output.add(printer.getInputStream(args[i]));

Printing an Output Stream

Use the XMLOutputStream.flush() method to print out the XML output stream to whatever object you created it from. For example, if you created an XML output stream from a PrintWriter object, then the flush() method prints the stream to the standard output.

Note: If you are writing to an XMLOutputStream based on a DOM tree, you must execute the flush() method before you can manipulate the DOM.

The following example shows how to print an output stream:

    //
    // Print the results to the screen
    //
    output.flush();

Closing the Output Stream

It is good programming practice to explicitly close the XML output stream when you are finished with it. To close an output stream, use the XMLOutputStream.close() method, as shown in the following example:

// close the output stream
output.close();

Parsing an XML Document with XML Streaming API

Wed, 28 Dec 2005 00:08:20 +0800

Parsing an XML Document: Typical Steps

The following procedure describes the typical steps for using the WebLogic XML Streaming API to parse and manipulate an XML document.

The first two steps are required. The next steps you take depend on how you want to process the XML file.

Import the weblogic.xml.stream.* classes.
Get an XML stream of events from an XML file, a DOM tree, or a set of SAX events. You can also filter the XML stream to get only certain types of events, names of specific elements, and so on. See "Getting an XML Input Stream" on page 4-7.
Iterate over the stream, returning generic XMLEvent types. See "Iterating Over the Stream" on page 4-10.
For each generic XMLEvent type, determine the specific event type. Event types include the start of an XML document, the end of an element, an entity reference, and so on. See "Determining the Specific XMLEvent Type" on page 4-11.
Get the attributes of an element. See "Getting the Attributes of an Element" on page 4-15.
Position the stream by skipping over event, skipping to a particular event, and so on. See "Positioning the Stream" on page 4-16.
Get the children of an element. See "Getting a Substream" on page 4-17.
Close the stream. See "Closing the Input Stream" on page 4-19.

Example of Parsing an XML Document

The following program shows an example of using the XML Streaming API to parse an XML document.

Note: The code in bold font is described in detail in the sections following the example.

package examples.xml.stream;

import weblogic.xml.stream.Attribute;
import weblogic.xml.stream.AttributeIterator;
import weblogic.xml.stream.ChangePrefixMapping;
import weblogic.xml.stream.CharacterData;
import weblogic.xml.stream.Comment;
import weblogic.xml.stream.XMLEvent;
import weblogic.xml.stream.EndDocument;
import weblogic.xml.stream.EndElement;
import weblogic.xml.stream.EntityReference;
import weblogic.xml.stream.ProcessingInstruction;
import weblogic.xml.stream.Space;
import weblogic.xml.stream.StartDocument;
import weblogic.xml.stream.StartPrefixMapping;
import weblogic.xml.stream.StartElement;
import weblogic.xml.stream.EndPrefixMapping;
import weblogic.xml.stream.XMLInputStream;
import weblogic.xml.stream.XMLInputStreamFactory;
import weblogic.xml.stream.XMLName;
import weblogic.xml.stream.XMLStreamException;

import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class ComplexParse {

 /**
 * Helper method to get a handle on a stream.
 * Takes in a name and returns a stream. This
 * method usese the InputStreamFactory to create an
 * instance of an XMLInputStream
 * @param name The file to parse
 * @return XMLInputStream the stream to parse
 */
 public XMLInputStream getStream(String name)
 throws XMLStreamException, FileNotFoundException
 {
 XMLInputStreamFactory factory = XMLInputStreamFactory.newInstance();
 XMLInputStream stream = factory.newInputStream(new FileInputStream(name));
 return stream;
 }

 /**
 * Determines the type of event, such as the start
 * of an element, end of a document, and so on. If the
 * event is of type START_ELEMENT, END_ELEMENT, or
 * CHARACTER_DATA, the method prints out appropriate info;
 * otherwise, it does nothing.
 * @param event The XML event that has been parsed
 */
 public void parse(XMLEvent event)
 throws XMLStreamException
 {
 switch(event.getType()) {
 case XMLEvent.START_ELEMENT:
 StartElement startElement = (StartElement) event;
 System.out.print("&lt;" + startElement.getName().getQualifiedName() );
 AttributeIterator attributes = startElement.getAttributesAndNamespaces();
 while(attributes.hasNext()){
 Attribute attribute = attributes.next();
 System.out.print(" " + attribute.getName().getQualifiedName() + 
 "=&apos;" + attribute.getValue() + "&apos;");
 }
 System.out.print("&gt;");
 break;
 case XMLEvent.END_ELEMENT:
 System.out.print("&lt;/" + event.getName().getQualifiedName() +"&gt;");
 break;
 case XMLEvent.SPACE:
 case XMLEvent.CHARACTER_DATA:
 CharacterData characterData = (CharacterData) event;
 System.out.print(characterData.getContent());
 break;
 case XMLEvent.COMMENT:
 // Print comment
 break;
 case XMLEvent.PROCESSING_INSTRUCTION:
 // Print ProcessingInstruction
 break;
 case XMLEvent.START_DOCUMENT:
 // Print StartDocument
 break;
 case XMLEvent.END_DOCUMENT:
 // Print EndDocument
 break;
 case XMLEvent.START_PREFIX_MAPPING:
 // Print StartPrefixMapping
 break;
 case XMLEvent.END_PREFIX_MAPPING:
 // Print EndPrefixMapping
 break;
 case XMLEvent.CHANGE_PREFIX_MAPPING:
 // Print ChangePrefixMapping
 break;
 case XMLEvent.ENTITY_REFERENCE:
 // Print EntityReference
 break;
 case XMLEvent.NULL_ELEMENT:
 throw new XMLStreamException("Attempt to write a null event.");
 default:
 throw new XMLStreamException("Attempt to write unknown event
 ["+event.getType()+"]");
 }
 }
 /**
 * Helper method to iterate over a stream
 * @param name The file to parse
 */
 public void parse(XMLInputStream stream)
 throws XMLStreamException
 {
 while(stream.hasNext()) {
 XMLEvent event = stream.next();
 parse(event);
 }
 stream.close();
 }

 /** Main method. Takes a single argument: an XML file
 * that will be converted into an XML input stream.
 */
 public static void main(String args[])
 throws Exception
 {
 ComplexParse complexParse= new ComplexParse();
 complexParse.parse(complexParse.getStream(args[0]));
 }
}

Getting an XML Input Stream

You can use the XML Streaming API to convert a variety of objects, such as XML files, DOM trees, or SAX events, into a stream of events.

The following example shows how to create a stream of events from an XML file:

XMLInputStreamFactory factory = XMLInputStreamFactory.newInstance();
XMLInputStream stream = factory.newInputStream(new FileInputStream(name));

First you create a new instance of the XMLInputStreamFactory, then use the factory to create a new XMLInputStream from the XML file referred to in the name variable.

The following example shows how to create a stream from a DOM tree:

DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
dbf.setValidating(false);
dbf.setNamespaceAware(true);
DocumentBuilder db = dbf.newDocumentBuilder();
Document doc = db.parse(new java.io.File(file));
XMLInputStream stream = XMLInputStreamFactory.newInstance().newInputStream(doc);

Getting a Buffered XML Input Stream

Use the newBufferedInputStream() method of the XMLInputStreamFactory class to create a buffered XMlL input stream, as shown in the following example:

XMLInputStreamFactory factory = XMLInputStreamFactory.newInstance();
BufferedXMLInputStream bufstream =
 factory.newBufferedInputStream(factory.newInputStream(new 
 FileInputStream(name)));

Filtering the XML Stream

import weblogic.xml.stream.util.TypeFilter;

XMLInputStreamFactory factory = XMLInputStreamFactory.newInstance();
XMLInputStream stream = factory.newInputStream(new FileInputStream(name), 
 new TypeFilter(XMLEvent.START_ELEMENT |
 XMLEvent.END_ELEMENT |
 XMLEvent.CHARACTER_DATA));

The following table describes the filters provided by the WebLogic XML Streaming API. They are part of the weblogic.xml.stream.util package.

Table 4-2

Name of Filter	Description	Sample Usage
TypeFilter	Filter an XML stream based on specified event types, such as XMLEvent.START_ELEMENT, XMLEvent.END_ELEMENT, and so on. See "Determining the Specific XMLEvent Type" on page 4-11 for a full list of event types. TypeFilter takes an integer bitmask as input; you OR the values to create this bitmask, as shown in the sample.	new TypeFilter (XMLEvent.START_ELEMENT \| XMLEvent.END_ELEMENT \| XMLEvent.CHARACTER_DATA)
NameFilter	Filter an XML stream based on the name of an element in the XML document.	new NameFilter ("Book")
NameSpaceFilter	Filter an XML stream based on the specified namespace URI.	new NameSpaceFilter ("http://namespace.org")
NamespaceTypeFilter	Filter an XML stream based on specified event types and namespace URI. This filter combines the functionality of TypeFilter and NameSpaceFilter.	new NamespaceFilter ("http://namespace.org", XMLEvent.START_ELEMENT) The example returns a stream where all start elements have the specified namespace.

Creating a Custom Filter

You can also create your own filter if the ones included in the API do not meet your needs.

package my.filters;

import weblogic.xml.stream.XMLName;
import weblogic.xml.stream.ElementFilter;
import weblogic.xml.stream.events.NullEvent;

public class SuperDooperFilter implements ElementFilter {

 protected String name;

 public SuperDooperFilter(String name)
 {
 this.name = name;
 }

 public boolean accept(XMLEvent e) {
 if (name.equals(e.getName().getLocalName()))
 return true;
 return false;
 }
}

In your XML application, be sure to import the new filter class:
```
import my.filters.SuperDooperFilter
```
Specify the filter as the second parameter to the newInputStream() method, passing to the filter class the types of events you want to appear in the XML stream in whatever format required by your filter class:

XMLInputStreamFactory factory = XMLInputStreamFactory.newInstance();
XMLInputStream stream = factory.newInputStream(new FileInputStream(name), 
 new SuperDooperFilter(param));

Iterating Over the Stream

Once you have a stream of events, the next step is to methodically step through it using the XMLInputStream.next() and XMLInputStream.hasNext() methods, as shown in the following example:

 while(stream.hasNext()) {
 XMLEvent event = stream.next();
 System.out.print(event);
 }

Determining the Specific XMLEvent Type

The following table lists the subclasses and fields of the XMLEvent class that you can use to identify a particular event while parsing the XML stream.

Table 4-3 Subclasses and Fields of the XMLEvent Class

XMLEvent Subclass	Field of the XMLEvent Class used to Identify Subclass	Method used to Identify Subclass	Description of the Subclass Event
ChangePrefixMapping	CHANGE_PREFIX_MAPPING	isChangePrefixMapping	Signals that a prefix mapping has changed from an old namespace to a new namespace.
CharacterData	CHARACTER_DATA	isCharacterData	Signals that the returned XMLEvent object contains the character data from the body of the element.
Comment	COMMENT	isComment	Signals that the returned XMLEvent object contains an XML comment.
EndDocument	END_DOCUMENT	isEndDocument	Signals the end of the XML document.
EndElement	END_ELEMENT	isEndElement	Signals the end of an element in the XML document.
EndPrefixMapping	END_PREFIX_MAPPING	isEndPrefixMapping	Signals that a prefix mapping has gone out of scope.
EntityReference	ENTITY_REFERENCE	isEntityReference	Signals that the returned XMLEvent object contains an entity reference.
ProcessingInstruction	PROCESSING_INSTRUCTION	isProcessingInstruction	Signals that the returned XMLEvent object contains a processing instruction.
Space	SPACE	isSpace	Signals that the returned XMLEvent object contains whitespace.
StartDocument	START_DOCUMENT	isStartDocument	Signals the start of an XML document.
StartElement	START_ELEMENT	isStartElement	Signals the start of a element in the XML document.
StartPrefixMapping	START_PREFIX_MAPPING	isStartPrefixMapping	Signals that a prefix mapping has started its scope.

 switch(event.getType()) {
 case XMLEvent.START_ELEMENT:
 // Start of an element
 System.out.println ("Start Element\n");
 break;

 case XMLEvent.END_ELEMENT:
 // End of an element
 System.out.println ("End Element\n");
 break;

 case XMLEvent.PROCESSING_INSTRUCTION:
 // Processing Instruction
 System.out.println ("Processing instruction\n");
 break;

 case XMLEvent.SPACE:
 // Whitespace
 System.out.println ("White space\n");
 break;

 case XMLEvent.CHARACTER_DATA:
 // Character data
 System.out.println ("Character data\n");
 break;

 case XMLEvent.COMMENT:
 // Comment
 System.out.println ("Comment\n");
 break;

 case XMLEvent.START_DOCUMENT:
 // Start of the XML document
 System.out.println ("Start Document\n");
 break;

 case XMLEvent.END_DOCUMENT:
 // End of the XML Document
 System.out.println ("End Document\n");
 break;

 case XMLEvent.START_PREFIX_MAPPING:
 // The start of a prefix mapping scope
 System.out.println ("Start prefix mapping\n");
 break;

 case XMLEvent.END_PREFIX_MAPPING:
 // The end of a prefix mapping scope
 System.out.println ("End prefix mapping\n");
 break;

 case XMLEvent.CHANGE_PREFIX_MAPPING:
 // Prefix mapping has changed namespaces
 System.out.println ("Change prefix mapping\n");
 break;

 case XMLEvent.ENTITY_REFERENCE:
 // An entity reference
 System.out.println ("Entity reference\n");
 break;
 default:

 throw new XMLStreamException("Attempt to parse unknown event 
 [" + event.getType() + "]");
 }

Getting the Attributes of an Element

To get the attributes of an element in an XML document, you must first cast the XMLEvent object that was returned by the XMLInputStream.next() method to a StartElement object.

case XMLEvent.START_ELEMENT:

 StartElement startElement = (StartElement) event;
 System.out.print("&lt;" + startElement.getName().getQualifiedName() );
 AttributeIterator attributes = startElement.getAttributesAndNamespaces();
 while(attributes.hasNext()){
 Attribute attribute = attributes.next();
 System.out.print(" " + attribute.getName().getQualifiedName() + 
 "=&apos;" + attribute.getValue() + "&apos;");
 }
 System.out.print("&gt;");
 break;

You can also use the getNamespace() and getAttributes() methods to return just the namespaces or attributes on their own.

Positioning the Stream

The following table describes the methods of the XMLInputStream interface that you can use to skip ahead to specific locations in the stream.

Table 4-4 Methods Used to Position the Input Stream

Method of XMLInputStream	Description
skip()	Positions the input stream to the next stream event. Note: The next event might not necessarily be an actual element in the XML file; for example, it could be a comment or white space.
skip(int)	Positions the input stream to the next event of this type. Examples of event types are XMLEvent.START_ELEMENT and XMLEvent.END_DOCUMENT. Refer to Table 4-3 for the full list of event types.
skip(XMLName)	Positions the input stream to the next event of this name.
skip(XMLName, int)	Positions the input stream to the next event of this name and type.
skipElement()	Skips to the next element (does not skip to the sub-elements of the current element).
peek()	Checks the next event without actually reading it from the stream.

The following example shows how you can modify the basic code for iterating over an input stream to skip over the character data in the body of an XML element:

 while(stream.hasNext()) {
 XMLEvent peek = stream.peek();
 if (peek.getType() == XMLEvent.CHARACTER_DATA ) {
 stream.skip();
 continue;
 }
 XMLEvent event = stream.next();
 parse(event);
 }

The example shows how to use the XMLInputStream.peek() method to determine the next event on the stream. If the type of event is XMLEvent.CHARACTER_DATA, then skip the event and go to the next one.

Getting a Substream

For example, assume that you are using the XML Streaming API to parse the following XML document, but you are only interested in the substream delineated by the <content> and </content> tags:

&lt;book&gt;
 &lt;title&gt;The History of the World&lt;/title&gt;
 &lt;author&gt;Juliet Shackell&lt;/author&gt;
 &lt;publisher&gt;CrazyDays Publishing&lt;/publisher&gt;
 &lt;content&gt;
 &lt;chapter title=&apos;Just a Speck of Dust&apos;&gt;
 &lt;synopsis&gt;The world as a speck of dust&lt;/synopsis&gt;
 &lt;para&gt;Once the world was just a speck of dust...&lt;/para&gt;
 &lt;/chapter&gt;
 &lt;chapter title=&apos;Life Appears&apos;&gt;
 &lt;synopsis&gt;Move over dust, here comes life.&lt;/synopsis&gt;
 &lt;para&gt;Happily, the dust got a companion: life...&lt;/para&gt;
 &lt;/chapter&gt;
 &lt;/content&gt;
&lt;/book&gt;

The following code fragment shows how you can skip to the <content> start element tag, get the substream, and parse it using a separate ComplexParse object:

 if (stream.skip( ElementFactory.createXMLName("content")))
 {
 ComplexParse complexParse = new ComplexParse();
 complexParse.parse(stream.getSubStream());
 }

When you call this method on the previous XML document, you get the following output:

&lt;content&gt;
 &lt;chapter title=&apos;Just a Speck of Dust&apos;&gt;
 &lt;synopsis&gt;The world as a speck of dust&lt;/synopsis&gt;
 &lt;para&gt;Once the world was just a speck of dust...&lt;/para&gt;
 &lt;/chapter&gt;
 &lt;chapter title=&apos;Life Appears&apos;&gt;
 &lt;synopsis&gt;Move over dust, here comes life.&lt;/synopsis&gt;
 &lt;para&gt;Happily, the dust got a companion: life...&lt;/para&gt;
 &lt;/chapter&gt;
&lt;/content&gt;

Marking and Resetting a Buffered XML Input Stream

The following example shows a typical use of the BufferedXMLInputStream object:

 XMLInputStreamFactory factory = XMLInputStreamFactory.newInstance();
 BufferedXMLInputStream bufstream =
 factory.newBufferedInputStream(factory.newInputStream(new 
 FileInputStream(name)));

 // mark the start of the stream
 bufstream.mark();

 // process it locally
 bufferedParse.parse(bufstream);

 // reset the stream to the mark
 bufstream.reset();

 // send stream off to another application
 ComplexParse complexParse = new ComplexParse();
 complexParse.parse(bufstream);

Closing the Input Stream

// close the input stream
input.close();

Generating a New XML Document: Typical Steps

The following procedure describes the typical steps for using the WebLogic XML Streaming API to generate a new XML document.

The first two steps are required. The next steps you take depend on how you want to generate the XML file.

Import the weblogic.xml.stream.* classes.
Create an XML output stream to which to write the XML document. See "Creating an XML Output Stream" on page 4-22.
Add events to the XML output stream. See "Adding Elements to the Output Stream" on page 4-23.
Add attributes to the XML output stream. See "Adding Attributes to an Element on the Output Stream" on page 4-24.
Add an input stream to the output stream. See "Adding an Input Stream to an Output Stream" on page 4-25.
Print the output stream. See "Printing an Output Stream" on page 4-26.
Close the output stream. See "Closing the Output Stream" on page 4-26.

Example of Generating an XML Document

The following program shows an example of using the XML Streaming API to generate an XML document.

Note: The topics following the example describe it in more detail.

package examples.xml.stream;

import weblogic.xml.stream.XMLInputStream;
import weblogic.xml.stream.XMLOutputStream;
import weblogic.xml.stream.XMLInputStreamFactory;
import weblogic.xml.stream.XMLName;
import weblogic.xml.stream.XMLEvent;
import weblogic.xml.stream.StartElement;
import weblogic.xml.stream.EndElement;
import weblogic.xml.stream.Attribute;
import weblogic.xml.stream.ElementFactory;
import weblogic.xml.stream.XMLStreamException;
import weblogic.xml.stream.XMLOutputStreamFactory;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.PrintWriter;

/**
 * Program that prints out a very simple purchase order that looks
 * like the following:
 *
 * &lt;purchase_order&gt;
 * &lt;name&gt;Juliet Shackell&lt;/name&gt;
 * &lt;item id="1234" quantity="2"&gt;Fabulous Chair&lt;/item&gt;
 * &lt;!-- this is a comment--&gt;
 * &lt;another_file&gt;
 * This comes from another file called "another_file.xml"
 * &lt;/another_file&gt;
 * &lt;/purchase_order&gt;
 *
 * In the preceding XML file, the &lt;another_file&gt; element is actually another
 * XML file that is passed as an argument to the program, converted into an
 * XMLInputStream, then added to the output stream.
 */
public class PrintPurchaseOrder {

 /**
 * Helper method to get a handle on a stream.
 * Takes in a name and returns a stream. This
 * method uses the InputStreamFactory to create an
 * instance of an XMLInputStream
 * @param name The file to parse
 * @return XMLInputStream the stream to parse
 */
 public XMLInputStream getInputStream(String name)
 throws XMLStreamException, FileNotFoundException
 {
 XMLInputStreamFactory factory = XMLInputStreamFactory.newInstance();
 XMLInputStream stream = factory.newInputStream(new FileInputStream(name));
 return stream;
 }
 public static void main(String args[])
 throws Exception
 {
 PrintPurchaseOrder printer = new PrintPurchaseOrder();
 //
 // Create an output stream.
 //
 XMLOutputStreamFactory factory = XMLOutputStreamFactory.newInstance();
 XMLOutputStream output = factory.newOutputStream(new 
 PrintWriter(System.out,true));

 // add the &lt;purchase_order&gt; root element
 output.add(ElementFactory.createStartElement("purchase_order"));
 output.add(ElementFactory.createCharacterData("\n"));

 // add the &lt;name&gt; element
 output.add(ElementFactory.createStartElement("name"));
 output.add(ElementFactory.createCharacterData("Juliet Shackell"));
 output.add(ElementFactory.createEndElement("name"));
 output.add(ElementFactory.createCharacterData("\n"));

 // add the &lt;item&gt; element along with the id and quantity attributes
 output.add(ElementFactory.createStartElement("item"));
 output.add(ElementFactory.createAttribute("id","1234"));
 output.add(ElementFactory.createAttribute("quantity","2"));
 output.add(ElementFactory.createCharacterData("Fabulous Chair"));
 output.add(ElementFactory.createEndElement("item"));
 output.add(ElementFactory.createCharacterData("\n"));

 // add a comment
 output.add("&lt;!-- this is a comment--&gt;");
 output.add(ElementFactory.createCharacterData("\n"));

 // create an input stream from each XML file argument then add it to the output
 for (int i=0; i &lt; args.length; i++)
 //
 // Get an input stream and add it to the output stream
 //
 output.add(printer.getInputStream(args[i]));

 // Finally, end the root "purchase_order" element
 output.add(ElementFactory.createEndElement("purchase_order"));
 output.add(ElementFactory.createCharacterData("\n"));

 //
 // Print the results to the screen
 //
 output.flush();

 // Close the output streams
 output.close();
 }
}

The preceding program produces the following output:

&lt;purchase_order&gt;
 &lt;name&gt;Juliet Shackell&lt;/name&gt;
 &lt;item id="1234" quantity="2"&gt;Fabulous Chair&lt;/item&gt;
 &lt;!-- this is a comment--&gt;
 &lt;another_file&gt;
 This is from another file.
 &lt;/another_file&gt;
&lt;/purchase_order&gt;

Creating an XML Output Stream

 XMLOutputStreamFactory factory = XMLOutputStreamFactory.newInstance();
 XMLOutputStream output = factory.newOutputStream(new
 PrintWriter(System.out,true));

The following example shows how to create an XMLOutputStream based on a DOM tree:

 DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
 dbf.setValidating(false);
 dbf.setNamespaceAware(true);
 Document doc = dbf.newDocumentBuilder().newDocument();
 XMLOutputStream out =
 XMLOutputStreamFactory.newInstance().newOutputStream(doc);

java.io.OutputStream
java.io.Writer
org.xml.sax.ContentHandler
org.w3c.dom.Document

Adding Elements to the Output Stream

Use the XMLOutputStream.add(XMLEvent) method to add elements to the output stream. Use the ElementFactory to create the particular element.

Warning: The XMLOutputStream does not validate your XML.

Note: Each time you create a start element, you must explicitly also create an end element at some point. The same rule applies to creating a start document.

For example, assume you want to create the following snippet of XML:

&lt;name&gt;Georgina Shackell Green&lt;/name&gt;

The Java code to add this element to an output stream is as follows:

 output.add(ElementFactory.createStartElement("name"));
 output.add(ElementFactory.createCharacterData("Georgina Shackell Green"));
 output.add(ElementFactory.createEndElement("name"));
 output.add(ElementFactory.createCharacterData("\n"));

The final createCharacterData() method adds a newline character to the output stream. This is optional, but useful if you want to create human-readable XML.

Adding Attributes to an Element on the Output Stream

Use the XMLOutputStream.add(Attribute) to add attributes to an element you have just created. Use the ElementFactory.createAttribute() method to create a particular attribute.

For example, assume you want to create the following snippet of XML:

&lt;item id="1234" quantity="2"&gt;Fabulous Chair&lt;/item&gt;

The Java code to add this element to an output stream is as follows:

 output.add(ElementFactory.createStartElement("item"));
 output.add(ElementFactory.createAttribute("id","1234"));
 output.add(ElementFactory.createAttribute("quantity","2"));
 output.add(ElementFactory.createCharacterData("Fabulous Chair"));
 output.add(ElementFactory.createEndElement("item"));
 output.add(ElementFactory.createCharacterData("\n"));

 output.add(ElementFactory.createStartElement("item"));
 output.add(ElementFactory.createEndElement("item"));
 output.add(ElementFactory.createAttribute("id","1234"));
 output.add(ElementFactory.createAttribute("quantity","2"));
 output.add(ElementFactory.createCharacterData("Fabulous Chair"));
 output.add(ElementFactory.createCharacterData("\n"));

Adding an Input Stream to an Output Stream

 /**
 * Helper method to get a handle on a stream.
 * Takes in a name and returns a stream. This
 * method uses the InputStreamFactory to create an
 * instance of an XMLInputStream
 * @param name The file to parse
 * @return XMLInputStream the stream to parse
 */

 public XMLInputStream getInputStream(String name)
 throws XMLStreamException, FileNotFoundException
 {
 XMLInputStreamFactory factory = XMLInputStreamFactory.newInstance();
 XMLInputStream stream = factory.newInputStream(new FileInputStream(name));
 return stream;
 }

....

 // create an input stream from each XML file argument then add it to the output

 for (int i=0; i &lt; args.length; i++)
 //
 // Get an input stream and add it to the output stream
 //
 output.add(printer.getInputStream(args[i]));

Printing an Output Stream

Note: If you are writing to an XMLOutputStream based on a DOM tree, you must execute the flush() method before you can manipulate the DOM.

The following example shows how to print an output stream:

 //
 // Print the results to the screen
 //
 output.flush();

Closing the Output Stream

// close the output stream
output.close();