我们将使用如下的简单XML文档描述XPath语法：

XML文档可以看作是一个节点树（非常类似于计算机的树形文件夹）。

XPath使用模式表达式识别XML文档里的节点。一个XPath模式是一个以斜线分隔的子元素名列表，用于描述XML文档的一个路径。模式选择匹配该路径的元素。

下面的XPath表达式选择catalog元素的所有cd元素的所有price元素：

选择未知元素

通配符（*）用来选择未知XML元素。

选择分支

通过在XPath表达式中使用方括号可以进一步地指定一个元素。

选择多个路径

通过在XPath表达式中使用|操作符，可以选择多个路径。

下面的XPath表达式选择catalog元素的子元素cd元素下所有的title和artist元素：

选择属性

在XPath中，所有属性以前缀@指定。

下面的XPath表达式选择所有名为country的属性：

1, 完全备份

最常见和简单的备份就是直接使用拷贝命令，将版本库目录拷贝到备份目录上，就可以了。但是这样不是很安全的方式，因为如果在拷贝时版本库发生变化，将会造成备份的结果不够准确，失去备份的作用，为此Subversion提供了“svnadmin hotcopy”命令，可以防止这种问题。

还记得我们的版本库目录吗？

D:\SVNROOT
├─project1
│  ├─conf
│  ├─dav
│  ├─db
│  │  ├─revprops
│  │  ├─revs
│  │  └─transactions
│  ├─hooks
│  └─locks
└─project2
    ├─conf
    ├─dav
    ├─db
    │  ├─revprops
    │  ├─revs
    │  └─transactions
    ├─hooks
    └─locks
   

如果要把project1备份到d:\svnrootbak目录下，只需要运行：

svnadmin hotcopy d:\svnroot\project1 d:\svnrootbak\project1

但是我们作为配置管理员，必须想办法优化这个过程，如果我们这个目录下有许多版本库，需要为每个版本库写这样一条语句备份，为此我写了下面的脚本，实现备份一个目录下的所有版本库。我们在D:\SVNROOT下创建了两个文件，simpleBackup.bat：

@echo 正在备份版本库%1......
@%SVN_HOME%\bin\svnadmin hotcopy %1 %BACKUP_DIRECTORY%\%2
@echo 版本库%1成功备份到了%2！

这个文件仅仅是对“svnadmin hotcopy”的包装，然后是backup.bat：

echo off

rem Subversion的安装目录
set SVN_HOME="D:\Subversion"

rem 所有版本库的父目录
set SVN_ROOT=D:\svnroot

rem 备份的目录
set BACKUP_SVN_ROOT=D:\svnrootbak

set BACKUP_DIRECTORY=%BACKUP_SVN_ROOT%\%date:~0,10%
if exist %BACKUP_DIRECTORY% goto checkBack
echo 建立备份目录%BACKUP_DIRECTORY%>>%SVN_ROOT%/backup.log

mkdir %BACKUP_DIRECTORY%

rem 验证目录是否为版本库，如果是则取出名称备份
for /r %SVN_ROOT% %%I in (.) do @if exist "%%I\conf\svnserve.conf" %SVN_ROOT%\simpleBackup.bat "%%~fI" %%~nI
goto end

:checkBack
echo 备份目录%BACKUP_DIRECTORY%已经存在，请清空。
goto end

:end

你在使用的时候，只需要修改backup.bat开头的三个路径，将两个脚本拷贝到“SVN_ROOT”下就可以了。根据以上的配置，你只需要运行backup.bat，就可以把“SVN_ROOT”下的版本库都备份到“BACKUP_SVN_ROOT”里，并且存放在备份所在日的目录里，例如“D:\svnrootbak\2006-10-22”。

虽然这部分工作很简单，可是必须有人定时地去执行这个操作（例如每周一凌晨），为了避免发生遗忘的情况，我们可以将这个操作加入到系统的at任务当中去，例如还是上面的环境，为了安装at任务，我们运行：

at1:00/every:M D:\svnroot\backup.bat

这样在每周一凌晨1:00都会执行这个备份过程。当然备份在本机也是不安全的，你也许需要上传到别的机器，这个就要靠你自己去实现了。

2, 增量备份

尽管完全备份非常简单，但是也是有代价的，当版本库非常巨大时，经常进行完全备份是不现实的，也并不必要，但是一旦版本库在备份之间发生问题，该如何呢，这里我们就用到了增量备份。

增量备份通常要与完全备份结合使用，就像oracle数据库的归档日志，记录着每次Subversion提交的变化，然后在需要恢复时能够回到最新的可用状态。在我们这个例子中我们使用的是，svnadmin dump命令进行增量的备份，使用方法是：

svnadmin dump project1 --revision 15 --incremental > dumpfile2

上面的命令实现了对修订版本15进行增量的备份，其中的输出文件dumpfile2只保存了修订版本15更改的内容。

为了记录每次提交的结果，我们需要使用一项Subversion的特性--钩子（hook），看看我们的project1目录：

├─project1
│  ├─conf
│  ├─dav
│  ├─db
│  │  ├─revprops
│  │  ├─revs
│  │  └─transactions
│  ├─hooks
│  └─locks

其中的hooks目录里存放的就是钩子脚本，我们在此处只使用post-commit钩子，这个钩子会在每次提交之后执行，为了实现我们的备份功能，我们在hooks下建立一个文件post-commit.bat，内容如下：

echo off
set SVN_HOME="C:\Program Files\Subversion"
set SVN_ROOT=D:\svnroot
set UNIX_SVN_ROOT=D:/svnroot
set DELTA_BACKUP_SVN_ROOT=D:\svnrootbak\delta

set LOG_FILE=%1\backup.log
echo backup revision %2 >> %LOG_FILE%

for /r %SVN_ROOT% %%I in (.) do if D:/svnroot/%%~nI == %1 %SVN_ROOT%\%%~nI\hooks\deltaBackup.bat %%~nI %2
goto end

:end

通过这个脚本，可以实现D:\svnroot下的版本库提交时自动增量备份到D:\svnrootbak\delta（确定这个目录存在），其中使用的deltaBackup.bat其实可以放在任何地方，只是对脚本的svnadmin dump的包装，内容如下：

@echo 正在备份版本库%2......
%SVN_HOME%\bin\svnadmin dump %SVN_ROOT%\%1 --incremental --revision %2 >> %DELTA_BACKUP_SVN_ROOT%\%1.dump
@echo 版本库%2成功备份到了%3！

以上两个脚本可以直接拷贝到project2的hooks目录下，不需要修改就可以实现project2的自动备份。

以上的操作已经OK了，现在需要做的是将完全备份和增量备份结合起来，也就是在完全备份后清理增量备份的结果，使之只保存完全备份后的结果。

当果真出现版本库的故障，就要求我们实现版本库的恢复操作了，这是用要使用svnadmin load命令，同时也需要上次的完全备份例如要把上次完全备份backuprepo，和之后的增量备份dumpfile：

svnadmin load backuprepo < dumpfile

最后的结果，可以下载svnroot.rar，将之解压缩到d:\下，然后修改几个bat文件的SVN_HOME就可以使用了。

3, 版本库同步

Subversion 1.4增加了同步机制，可以实现一个版本库同另一个版本库的同步（但好像只是单向的），我们可以用来实现版本库的备份或镜像。

3.1. 对目标库初始化

svnsync init svn://localhost/project2 svn://localhost/project1 

其中project2是目标的版本库，而project1是源版本库。其中的目标版本库必须为空，而且必须允许修订版本属性的修改，也就是在目标的版本库的hooks目录里添加一个文件pre-revprop-change.bat，内容为空即可。

3.2. 同步project2到project1

svnsync sync svn://localhost/project2 

这时候你update一下你的project2的一个工作拷贝，就会发现有了project1的所有内容。如果project1又有提交，这时候project2的版本库无法看到最新的变化，还需要再运行一遍sync操作，这样才能将最新的变化同步。需要注意的是，目标版本库只能做成只读的，如果目标版本库发生了变更，则无法继续同步了。

3.3. 同步历史属性的修改

因为同步不会更新对历史属性的修改，所以svnsync还有子命令copy-revprops，可以同步某个版本的属性。

3.4. 钩子自动同步

希望在每次提交时同步，则需要在源版本库增加post-commit脚本，内容如下：

echooff
set SVN_HOME="D:\Subversion"%SVN_HOME%\bin\svnsync sync  --non-interactive svn://localhost/project2 

把以上内容存放为post-commit.bat，然后放到版本库project1下的hooks目录下，这样project1每次提交，都会引起project2的同步。

 <!-- Add user names and passwords that can edit the wiki -->
  <authenticator type="com.caucho.server.security.XmlAuthenticator">
    <init>
<!-- 可以加入多个 user, 格式: < user >用户名:密码:角色< / user > -->
      <user>adminuser:password:admin</user>
      <password-digest>none</password-digest>
    </init>
  </authenticator>
<!--指定验证方式为 basic, 就是浏览器弹出对话框的那种 -->
 <login-config auth-method='basic'/>
<!--被保护的页面地址及其响应的角色名 -->
  <security-constraint url-pattern='/Delete.jsp' role-name='admin'/>

这时候点击 Delete.jsp 后, 系统就会弹出窗口要求您进行身份验证. 是不是很简单呢?

先要压缩，然后一台机器一台机器的上传，接着还要停止服务器，解压缩，重新启动。。。。。。

如果只有两天台机器，那么还可以忍受；但是如果你有七八台机器要部署时，你的感觉一定是要疯掉了。更何况如工程比较大的话，压缩、上传都要花费很多的时间，我们宝贵的时间就这样溜走了。更可恶的是我们很多时候需要加班也是因为部署的效率太慢。

废话太多了，还是直接进入主题吧，让你和我们一起分享部署的乐趣吧！

首先说明几个主要的ant命令：

1. scp：一个optional task，用来上传文件到远程服务器上；
2. sshexec：ssh大家很熟悉吧？这个任务就是用来执行一个ssh脚本命令，可以执行远程服务器的命令；
3. fileset：这个大家应该也比较熟悉，用来设置一个文件的集合，关键的是它的一个子元素date可以用来设定文件的日期范围，比如<date datetime="2007.12.18 00:00:00" pattern="yyyy.MM.dd HH:mm:ss" when="after" />指定2007年12月18日以后的文件，具体的说明请参见http://ant.apache.org/manual/index.html；

主要就是这几个命令，很简单吧。

接着我们分析一下我们部署的一般流程吧。

1. 我们要先把本地的文件压缩到一个压缩文件中，实现增量部署的关键也是在这里（感谢付成睿的帮助）。最好的方式是每次只压缩最近修改的内容，而那些没有修改的内容没有必要再次上传。压缩一个时间点以后的文件可以通过date来实现，不过我们需要自动的记录上一次部署的时间。现在有两种方式可以做这件事，一种是付成睿的，比较简单，但会修改配置文件；另外一种就是我的方式，也就是将日期保存到一个文件中，如果没有文件就认为是全部部署，并创建文件。
   具体的代码如下：
    <target name="appZipModified">
     <!-- 判断文件是否存在 -->
     <condition property="local.app.timestamp.present">
      <available file="${app.zip.timestamp.file}" type="file" />
     </condition>
     <!-- 如果文件不存在则创建文件 -->
     <antcall target="mkStampFile">
      <param name="zipFilePresent" value="${local.app.timestamp.present}" />
      <param name="newZipFile" value="${app.zip.timestamp.file}" />
     </antcall>
     <!-- 从文件中获取上次部署的时间 -->
     <echo>Load the old timestamp from the disk file</echo>
     <loadfile property="old.zip.timestamp" srcFile="${app.zip.timestamp.file}" />
     <!-- 获取当前时间 -->
     <tstamp>
      <format property="this.zip.timestamp" pattern="${ts.pattern}" />
     </tstamp>
     <echo>zip the new modified files &amp; folders that after ${old.zip.timestamp} to ${appzip} </echo>
     <!-- 先删除上次的zip文件，这样保证上次的压缩的文件不会再次上传 -->
     <delete file="${appzip}" />
     <!-- 执行压缩操作 -->
     <zip destfile="${appzip}">
      <fileset dir="../WebRoot">
       <include name="**/*" />
       <!-- 这个语句是关键，只压缩old.zip.timestamp以后修改的文件 -->
       <date datetime="${old.zip.timestamp}" pattern="${ts.pattern}" when="after" />
      </fileset>
     </zip>
     <echo>Replace the old timestamp with the new timestamp</echo>
     <!-- 最后将当前的时间更新到文件中 -->
     <replace file="${app.zip.timestamp.file}" token="${old.zip.timestamp}" value="${this.zip.timestamp}" />
    </target>
    <!-- 创建文件的操作，unless的含义是zipFilePresent为false时才执行，与之对应的是if -->
    <target name="mkStampFile" unless="zipFilePresent">
     <echo>Create txt file to store timestamp</echo>
     <!-- 创建一个文件 -->
     <touch file="${newZipFile}" datetime="12/19/2007 21:20 pm" />
     <!-- 应用正则表达式的replace命令，写入一个很早的时间（正则真是太神奇了！） -->
     <replaceregexp file="${newZipFile}" match=".*" replace="2000.01.01 00:00:00" byline="true" />
    </target>
   
   这种方式还是比较复杂的，使用付成睿的方法则更简单。只是需要在properties文件中增加last.zip.timestamp的设置。
    <target name="zipModified">
     <echo>zip modified files</echo>
     <echo>get current time stamp</echo>
     <tstamp>
      <format property="this.zip.timestamp" pattern="${ts.pattern}" />
     </tstamp>
     <echo>current time stamp: ${this.zip.timestamp}</echo>
     <echo>zip modified files aflter ${last.zip.timestamp}</echo>
     <zip destfile="${local.testZip}">
      <fileset dir="./test">
       <date datetime="${last.zip.timestamp}" pattern="${ts.pattern}" when="after" />
      </fileset>
     </zip>
     <echo>save this zip time stamp</echo>
     <replace file="build.properties" token="${last.zip.timestamp}" value="${this.zip.timestamp}" />
    </target>
   
2. 有了zip文件后下面就需要把文件上传到服务器上，方法如下：
    <!-- 上传zip压缩文件 -->
    <target name="uploadZipApp" description="upload ziped app file to remote server">
     <echo>upload ziped app file to remote server</echo>
     <scp file="${appzip}" todir="user@${host}:/path/test.zip" password="${pass}" trust="yes" />
    </target>
   很简单吧？
3. 上传完后就是在服务器的操作了（例子用的是unix），包括解压缩、停止服务器、重新启动等，主要还是如何远程调用服务器命令。
   下面的例子是将文件解压缩，最关键的是sshexec命令的用法。
     <!-- 解压缩备份文件 -->
    <target name="unZipBackupResource" description="decompress the backup tar file back to the file system">
     <echo>decompress the backup tar file back to the file system</echo>
     <sshexec host="${host}" username="user" command="tar xvf test.tar" password="${pass}" trust="yes" />
    </target>
   做其他的操作只要把上面例子中的黑体字部分去掉就可以了。
4. 最后最好将一个完整的部署流程封装到一个target中，这样部署一台服务器只要输入相应的密码就可以了。
5. 而现在部署时你要做的操作只是在outline模式下在一个部署的target上点击右键，然后run就可以了。

这就是完整的流程。

如果部署的是jsp文件或者静态文件，那就更简单了，直接上传解压缩就可以了。

其他tz有什么更好的方法也一起分享啊，我在这算是抛砖引玉了。。。。。。

    <Context path="/articlesystem" docBase="articlesystem" debug="5" reloadable="true" crossContext="true">
       <Resource name="jdbc/StrutsArticle" auth="Container" type="javax.sql.DataSource"
          maxActive="100" maxIdle="30" maxWait="10000"
          username="root" password="root" driverClassName="com.mysql.jdbc.Driver"
          url="jdbc:mysql://localhost:3306/strutsaritclecharacterEncoding=GBK&amp;useUnicode=TRUE&amp;autoReconnect=true"/>
    </Context>

另. Context元素代表一个web应用，运行在某个特定的虚拟主机上。你可以在一个Host元素中嵌套任意多的Context元素。每个Context的路径必须是惟一的，由path属性定义。

所有Context的实现支持如下属性：

属性	描述
backgroundProcessorDelay	这个值代表在context及其子容器（包括所有的wrappers）上调用backgroundProcess方法的延时，以秒为单位。如果延时值非负，子容器不会被调用，也就是说子容器使用自己的处理线程。如果该值为正，会创建一个新的线程。在等待指定的时间以后，该线程在主机及其 子容器上调用backgroundProcess方法。context利用后台处理session过期，监测类的变化用于重新载入。如果没有指定，该属性的缺省值是－1，说明context依赖其所属的Host的后台处理。
className	实现的Java类名。该类必须实现org.apache.catalina.Context接口。如果没有指定，使用标准实现（在下面定义）。
cookies	如果想利用cookies来传递session identifier（需要客户端支持cookies），设为ture。否则为false，这种情况下只能依靠URL Rewriting传递session identifier。
crossContext	如果想在应用内调用ServletContext.getContext()来返回在该虚拟主机上运行的其他web application的request dispatcher,设为true。在安全性很重要的环境中，设为false，使得getContext()总是返回null。缺省值为false。
docBase	该web应用的文档基准目录（Document Base，也称为Context Root），或者是WAR文件的路径。可以使用绝对路径，也可以使用相对于context所属的Host的appBase路径。
override	如果想利用该Context元素中的设置覆盖DefaultContext中相应的设置，设为true。缺省情况下使用DefaultContext中的设置。
privileged	设为true，允许context使用container servlets，比如manager servlet。
path	web应用的context路径。catalina将每个URL的起始和context path进行比较，选择合适的web应用处理该请求。特定Host下的context path必须是惟一的。如果context path为空字符串（""），这个context是所属Host的缺省web应用,用来处理不能匹配任何context path的请求。
reloadable	如果希望Catalina监视/WEB-INF/classes/和/WEB-INF/lib下面的类是否发生变化，在发生变化的时候自动重载web application，设为true。这个特征在开发阶段很有用，但也大大增加了服务器的开销。因此，在发布以后，不推荐使用。但是，你可以使用Manager应用在必要的时候触发应用的重载。
wrapperClass	org.apache.catalina.Wrapper实现类的名称，用于该Context管理的servlets。如果没有指定，使用标准的缺省值。

 java代码得到连接:

 Context initCtx = new InitialContext();
         Context ctx = (Context)initCtx.lookup("java:comp/env");
         Object obj = (Object) ctx.lookup("jdbc/sqlserver");
         javax.sql.DataSource ds = (javax.sql.DataSource)obj;
         conn = ds.getConnection();

<property name="connection.datasource">java:comp/env/jdbc/sqlserver</property>

<bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
               <property name="jndiName"><value>java:comp/env/jdbc/dermis</value></property>
 </bean>

 如果你用的是jboss服务器:
           把java:comp/env 改成java:就足够了

           如果你用的是apache的dbcp包:
           1.type="org.apache.commons.dbcp.BasicDataSouce"
           2.driverClassName="net.sourceforge.jtds.jdbc.Driver"
           3.url="jdbc:jtds:sqlserver://127.0.0.1:1433/dataBasename"

 如果你用的是MySQL:
            1.driverClassName="com.mysql.jdbc.Driver"
            2.url="jdbc:mysql://127.0.0.1:3306/dbname"
 如果是Oracle:
    
            1.driverClassName="oracel.jdbc.driver.OracleDriver"
            2.url="jdbc:oracle:thin://127.0.0.1:1521/dbname" 

Tomcat 5.5

首先编辑Server.xml，添加数据源代码

<Context path="/StudentManager" docbase="StudentManager" debug="5" reload="true" crossContext="true">
         <Resource name="jdbc/StudentManager" auth="Container" type="javax.sql.DataSource"/>
            <ResourceParams name="jdbc/StudentManager">
                <parameter>
                  <name>factory</name>
                  <values>org.apache.commons.dbcp.BasicDataSourceFactory</values> 
                </parameter>
                <parameter>
                  <name>url</name>
                  <values>jdbc:mysql://localhost:3306/studentmanager</values>
                </parameter>
                <parameter>
                  <name>driverclassname</name>
                  <values>com.mysql.jdbc.Driver</values>
                </parameter> 
                <parameter>
                  <name>username</name>
                  <values>root</values> 
                </parameter>
                <parameter>
                  <name>password</name>
                  <values>root</values>
                </parameter>
                <parameter>
                  <name>maxWait</name>
                  <values>3000</values>
                </parameter>
                <parameter>
                  <name>maxIdle</name>
                  <values>10</values>
                </parameter>
                <parameter>
                  <name>maxActive</name>
                  <values>100</values>
                </parameter>

            </ResourceParams>                    
      </Context>

在Web.xml中加入对jndi的引用

<resource-ref>   
      <description>SqlServer   Datasource   example</description>   
      <res-ref-name>jdbc/StudentManager</res-ref-name>   
      <res-type>javax.sql.DataSource</res-type>   
      <res-auth>Container</res-auth>   
  </resource-ref>

 

测试代码：

 

<%
    String jndi="java:comp/env/jdbc/StudentManager";
    DataSource ds=null; 
     try{  
          
          Context initCtx=new InitialContext();   //初始化上下文，可以读配置文件如：web.xml   
          if(initCtx==null)   
                  throw new Exception("Initial   Failed!");       
          Context ctx=(Context)initCtx.lookup("java:comp/env");   
          if(ctx!=null)   
               ds=(DataSource)ctx.lookup("jdbc/StudentManager"); 
          if(ds==null)   
                  throw new Exception("Look   up   DataSource   Failed!");   
  }   
  catch(Exception e){   
          System.out.println(e.getMessage());   
  }
    System.out.println(ds);
 %>

 

经常，我们在启动应用的时候发现系统需要的端口被别的程序占用，如何知道谁占有了我们需要的端口，很多人都比较头疼，下面就介绍一种非常简单的方法，希望对大家有用

假如我们需要确定谁占用了我们的9050端口

1、Windows平台
在windows命令行窗口下执行：

C:\>netstat -aon|findstr "9050" 

TCP    127.0.0.1:9050         0.0.0.0:0              LISTENING       2016 

C:\>tasklist|findstr "2016" 

一. 编译安装apache
1) 从apache官网上下载apache最新的 release版本2.2.6
unix版本取httpd-2.2.6.tar.gz
2) 解开包
gunzip httpd-2.2.6.tar.gz
tar xvf httpd-2.2.6.tar
3) 编译安装
进入解压后的目录httpd-2.2.6，依次执行
./configure --prefix=/*要安装apache的目录*/ --enable-so
make
make install
成功后apache就安装到前面指定的目录了

二) 启动apache
进入apache安装目录
1) 修改apache/conf/httpd.conf
Listen 80 修改80为需要的端口如 11280
2) 启动
进入apache/bin/执行： ./apachectl start
3) 打开浏览起访问
http://ip: 11280

三) 编译安装resin

./configure --prefix=/data/aoxj/artest/resin --with-apxs=/data/aoxj/artest/apache/bin/apxs --with-apache=/data/aoxj/artest/apache
make
make install
上述操作除了编译安装resin外（其实不做这些操作，resin本身也是可以跑起来的），还会修改apache，包括：
1. copy mod_caucho.so到apache目录（就是前面指定的--with-apache=/data/aoxj/artest/apache）的modules
2. 修改apache的配置文件conf/httpd.conf，自动增加以下内容
LoadModule caucho_module ***/modules/mod_caucho.so
ResinConfigServer localhost 6802
CauchoConfigCacheDirectory /tmp
CauchoStatus yes

四）配置resin
需要修改resin.conf文件

<cluster>
<srun server-id="a" host="192.168.0.1" port="6802"/>
<srun server-id="a" host="192.168.0.1" port="6802"/>
</cluster>

五）启动resin
运行resin/bin/httpd.sh
注意一定要加-server，否则resin启动后是监听80/8080这样的端口，而不是上面cluster设置里面的6802
./httpd.sh -server a start
这样resin才会监听6802，建议手工telnet确认一下。如果resin启动不正确，后面apache启动后访问resin就会失败，然后在页面报503错误。
以后stop/restart 时也需要加-server

六) 配置apache
确认conf/httpd.conf文件中的以下内容
1) LoadModule caucho_module ***/modules/mod_caucho.so
检查mod_caucho.so是否存在
2) ResinConfigServer localhost 6802
这个ResinConfigServer只能出现一行,如果resin有多台,请在这里指定的那台resin配置文件中的<cluster>中配置其他机器的ip/port
3) CauchoConfigCacheDirectory /tmp
4)CauchoStatus yes

最后修改的配置为:

LoadModule caucho_module "/data/aoxj/artest/apache/modules/mod_caucho.so"
ResinConfigServer 192.168.0.1 6802
AddHandler caucho-request .action
CauchoConfigCacheDirectory /tmp
CauchoStatus yes

八）web访问
启动apache
用浏览器访问apache的端口，注意不是访问resin的端口

http://www.blogjava.net/flyffa/archive/2006/11/06/79356.aspx

    在网上找了一些文档，还是觉得不是很清楚，自己走了些弯路，才把这个配置好，还是写下来吧，以备后查。

1.   目标

使用 apache 和 tomcat 配置一个可以应用的 web 网站，要达到以下要求：

1、 Apache 做为 HttpServer ，后面连接多个 tomcat 应用实例，并进行负载均衡。

2、 为系统设定 Session 超时时间，包括 Apache 和 tomcat

3、 为系统屏蔽文件列表，包括 Apache 和 tomcat

2.   安装 tomcat

2.1. 下载，解压 tomcat

不要下载安装版 , 下载地址

http://tomcat.apache.org

2.2. 配置 tomcat

2.2.1.     配置 server 的关闭口

我们需要在一台机器上跑 2 个不同的 tomcat ，需要修改不同的 tomcat 的关闭口，避免出现端口被占用的情况。在 server.xml 中找到 server, 将：

<Server port="8005" shutdown="SHUTDOWN">

改为

<Server port="XXXX" shutdown="SHUTDOWN">

XXXX 在这里表示不同的端口：我的两个 tomcat 分别使用 8035 ， 8045

注意：这里之所以要配置不同的 tomcat 关闭口，只是因为我们使用了多个 tomcat ，其实用一个 server 多个实例也可以。

2.2.2.     配置 service

我们需要对不同的 tomcat 的 service 取不同的名字，在 server.xml 中找到：

<Service name="Catalina">

改为：

<Service name="XXXX">

两个 service 分别为 tomcat6 和 tomcat5

2.2.3.     配置 Connector

这个部分主要是要改两个 Connector ，当然前提是你的 tomcat 只有两个 Connector 。

修改 ajp1.3 的端口：

找到： <Connector port="8009" protocol="AJP/1.3" redirectPort="8443" />

改为： <Connector port="XXXX" protocol="AJP/1.3" redirectPort="8443" />

两个 Service 的 ajp/1.3 的端口分别为： 8019 ， 8029

修改 http 的端口：

找到：

<Connector port="8080" protocol="HTTP/1.1"

               maxThreads="150" connectionTimeout="20000"

               redirectPort="8443" />

改为：

<Connector port="XXXX" protocol="HTTP/1.1"

               maxThreads="150" connectionTimeout="20000"

               redirectPort="8443" />

两个 Service 的 ajp/1.3 的端口分别为： 8060 ， 8070

2.2.4.     配置 Engine

Engine 主要是配置 jvmRoute 属性，找到：

<Engine name="Catalina" defaultHost="localhost">

改为：

<Engine jvmRoute="XXXX" name="Catalina" defaultHost="localhost">

两个实例分别为： tomcat6 和 tomcat5.

2.2.5.     配置公用性 Context

如果有 Context 是多个系统公用的，比如图片等的存放地，可以做个配置：

在 Host 中增加：

<Context path="/image" docBase="D:"webRoot"image" debug="0" reloadable="false" crossContext="true">

</Context>

2.2.6.     屏蔽文件列表

打开 tomcat 目录下的 conf/web.xml ，

找到：

<servlet>

        <servlet-name>default</servlet-name>

        <servlet-class>org.apache.catalina.servlets.DefaultServlet</servlet-class>

        <init-param>

            <param-name>debug</param-name>

            <param-value>0</param-value>

        </init-param>

        <init-param>

            <param-name>listings</param-name>

            <param-value>true</param-value>

        </init-param>

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

    </servlet>

将 listings 参数改为 false;

2.3. 配置应用 (web.xml)

对系统应用做些控制。

配置 session 过期时间，大多数网站用户都只是做些浏览性的操作，为了减轻服务器负载压力，我们将 session 超时时间从默认的 30 分钟变为 5 分钟。

在 web 应用程序的 web.xml 中 servlet-mapping 之后增加如下一段：

<session-config>

    <session-timeout>5</session-timeout>

</session-config>

3.   安装 Apache

3.1. 下载、安装 Apache

下载地址 http://httpd.apache.org/download.cgi

下载后点击安装 msi 文件。

安装的时候没有什么特别需要注意的地方，按照默认就行了。是否安装为 service 看具体情况而定。

3.2. 下载、安装 Apache 、 tomcat 的 Connector

http://tomcat.apache.org/download-connectors.cgi

注意，很多网站上都介绍是 JK2 ，可能是觉得 JK2 比 JK 要新吧，其实 JK2 已经停止研发了，建议使用 jk1.2 。

下载压缩包，之后将 module 目录中的 mod_jk-apache****.so 文件放入 /module/ 目录下。

3.3. 配置 Apache （ httpd.conf ）

3.3.1.     配置端口：

找到

Listen 80

改为

Listen **

当然如果不需要改的话，就不用改了。正常情况无须更改。

3.3.2.     配置 DocumentRoot

找到 DocumentRoot 段，将其改为：

DocumentRoot "E:/MyWebsite"

这里的 "E:/MyWebsite" 指的是你的 web 程序的根路径，视具体应用而定。

3.3.3.     配置 serverName

找到 serverName 这个段，将其配置为你的 ServerName

如果没有配置为域名，配为 IP 也可以，此处还不是很清楚，多虚拟主机的情况的配置。

3.3.4.     配置虚拟主机

<VirtualHost *:80>

    ServerAdmin flyffa@gmail.com

    DocumentRoot       E:/MyWebsite

    ServerName localhost

    DirectoryIndex index.html index.htm index.jsp

    ErrorLog logs/error_log

    CustomLog logs/access_log common

    ErrorDocument 404 /sys/logon.jsp

</VirtualHost>

3.4. 配置 JK 方式的负载均衡

3.4.1.     配置 module

我们需要与 tomcat 做连接，所以要把 tomcat 的 connector 的模块配置进去。

在 LoadModule 部分加入：

LoadModule jk_module modules/mod_jk-apache-2.0.55.so －加载模块

这个 so 是我下载的版本，个人可以根据自己下载的文件名加以配置

JkWorkersFile conf/workers.properties －指定 connector 的配置文件名称

JkLogFile logs/mod_jk.log －指定 connector 的日志文件名称

JkLogLevel info －指定 connector 的日志等级

3.4.2.     配置 worker 列表 (conf/workers.properties)

定义列表

worker.list=tomcat6,tomcat5,loadbalancer

定义一个名为 “loadbalancer” 的 worker

其作为对多个 Tomcat 进程的负载平衡使用：

worker.loadbalancer.type=lb

worker.loadbalancer.balanced_workers=tomcat5, tomcat6

（ 负载平衡类型的 worker 并不与 Tomcat worker 通讯，它负责管理这些 Tomcat worker 。 ）

定义多个 worker 列表

# Set properties for tomcat6 (ajp13)

worker.tomcat6.type=ajp13

worker.tomcat6.host=localhost

worker.tomcat6.port=8019

worker.tomcat6.lbfactor=50

worker.tomcat6.cachesize=10

worker.tomcat6.cache_timeout=600

worker.tomcat6.socket_keepalive=1

worker.tomcat6.reclycle_timeout=300

# Set properties for tomcat5 (ajp13)

worker.tomcat5.type=ajp13

worker.tomcat5.host=localhost

worker.tomcat5.port=8029

worker.tomcat5.lbfactor=50

worker.tomcat5.cachesize=10

worker.tomcat5.cache_timeout=600

worker.tomcat5.socket_keepalive=1

worker.tomcat5.reclycle_timeout=300

注意： lbfactor= 50 （ 当此 Tomcat worker 被用于一个负载平衡 worker 使用时，此属性将被使用。它定义了此 worker 的负载平衡权值。 ）

cachesize= 10 （ 当在多线程的 web server （例如 apache2.0 、 IIS 、 Netscape ）中使用 JK 时，此属性是有效的。如果将 cachesize 的值设置为较高的值，这些支持多线程的 web server 将获得很好的处理能力。如果此属性不被设置，则连接 cache 特性将失效。 ）

3.4.3.     配置 Apache 到 tomcat 的桥接

在 DocumnetRoot 片段下加入

JkMount /*.jsp tomcat6

JkMount /*.do tomcat6

JkMount /*Servlet tomcat6

这里只是简单的将 apache 的请求转到其中的一个 tomcat 中，形成桥接，至于负载均衡的时候，就无须进行这步操作，直接启动负载均衡。启动负载均衡见下一节。

3.4.4.     启动负载均衡

在 DocumnetRoot 片段下加入

JkMount /*.jsp loadbalancer

JkMount /*.do loadbalancer

JkMount /*Servlet loadbalancer

－指定对所有的请求启动负载均衡，这里的 loadbalancer 是定义的 worker 的名字

这里我在配置的时候犯了两个错误：

第一是没有配置 JkWorkersFile conf/workers.properties ，以为 Apache 会自动认识（其实 apache 是自动产生了一个叫做 ajp13 的 worker ，指向本机的 8009 端口）。

第二是以为 JkMount 语句中出现 loadbalancer,ajp13 之类的是系统设定的东西，其实都是在 workers.properties 文件中定义的，结果出现名字不匹配的情况。后来配置了 JkLogFile logs/mod_jk.log 之后看到错误日志才明白。

3.5. 配置 Proxy 方式的负载均衡

使用 Apache2.1 以上的版本，就可以用 mod_proxy_ajp 来完成负载均衡的配置，不过到目前为止，没有看到如何让 Apache 负责静态部分， tomcat 负责动态部分的配置方式，只能用 path 进行区分分发请求。如：在虚拟主机的配置中增加：

ProxyPass / ajp://localhost:8019/

ProxyPassReverse / ajp://localhost:8019/

而形如：

ProxyPass /*.jsp ajp://localhost:8019/

ProxyPassReverse /*.jsp ajp://localhost:8019/

这样的配置是不能通过的。

<context-param>
           <param-name>context/param</param-name>
           <param-value>avalible during application</param-value>
  </context-param>

(2)servlet范围内的参数，只能在servlet的init()方法中取得，在web.xml中配置如下：

<servlet>
    <servlet-name>MainServlet</servlet-name>
    <servlet-class>com.wes.controller.MainServlet</servlet-class>
    <init-param>
       <param-name>param1</param-name>
       <param-value>avalible in servlet init()</param-value>
    </init-param>
    <load-on-startup>0</load-on-startup>
</servlet>

在servlet中可以通过代码分别取用：

package com.wes.controller;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;

public class MainServlet extends HttpServlet ...{

    public MainServlet() ...{
        super();
     }
    public void init() throws ServletException ...{
         System.out.println("下面的两个参数param1是在servlet中存放的");
         System.out.println(this.getInitParameter("param1"));
         System.out.println("下面的参数是存放在servletcontext中的");
         System.out.println(getServletContext().getInitParameter("context/param"));
      }
}

第一种参数在servlet里面可以通过getServletContext().getInitParameter("context/param")得到
第二种参数只能在servlet的init()方法中通过this.getInitParameter("param1")取得

BTW: 原文还介绍了一些其他内容，对于ANT初学者有较好的参考价值，建议看看。

利用 Ant 提供的 filter 任务替换属性值

现在根据不同环境的需要，对某些配置文件的值做一些替换。在 Ant 中，提供了 filter 任务，使得替换值很方便。当然也可以使用下面介绍的正则表达式来替换属性值。filter 主要用来在同一行内容中的替换，而正则表达式一下子可以替换多行内容。filter 的使用例子：

  <filter token=" log4j.logger" value="INFO"/>

  <copy todir="${dest.dir}" filtering="true">

    <fileset dir="${src.dir}"/>

  </copy>

这段脚本的意思就是在 src.dir 目录下的所有文件中，如果有预先定义好的"@log4j.logger@"占位符的话，在拷贝到 dest.dir 目录后，所有的占位符都被替换成了"INFO"。

你也可以将所有被替换的值放到某个属性文件中，filter 任务将属性文件中的每一个条目读出来并且设置成一个 Filter。如下所示：

 <filter filtersfile="deploy_env.properties"/>

  <copy todir="${dest.dir}" filtering="true">

    <fileset dir="${src.dir}"/>

  </copy>

上面的脚本表示所有在 deploy_env 中出现的条目将被作为一个 filter，在拷贝到 dest.dir 目录后，所有 src.dir 目录中存在的占位符将被替换成 deploy_env 中的值。具体的例子可以参见随本文附带的 deploy.xml， deploy_env.properties 和 Test.properties。

其中 deploy.xml 是 ant 脚本，deploy_env.properties 中包含所有要替换的值，在 Test.properties 中是包含有占位符的资源文件。

利用正则表达式替换属性值

Ant 中支持多种正则表达式，在运行 Ant 的时候用哪种正则表达式可以通过设置 ant.regexp.regexpimpl 的值来切换，Ant 支持的的正则表达式有：

• java.util.regex package of JDK 1.4
• jakarta-regexp
• installation dependencies

正则表达式的例子：

<replaceregexp byline="true">

<regexp pattern="正则表达式"/>

<substitution expression="将要替换的值"/>

<fileset dir="${unpack.war.dir}/WEB-INF" includes="web.xml"/>

</replaceregexp>

byline 属性用来确认被替换的时候是一次替换一行还是多行；pattern 属性用来指明正则表达式；substitution expression 中是替换的值，替换的值都定义在相对应的配置文件中；fileset 属性中的 dir 用来指定被替换文件所在的目录，includes 用来指定要替换哪个文件。需要注意的是，如果在正则表达式或者替换的值中出现"<"的话，需要用转义符"<"。

在 Eclipse3.1 中已经内置了对正则表达式的支持；但是如果你在命令行中运行需要正则表达式支持的脚本的话，则需要自己将正则表达式的包下载下来加到 classpath 中。在随文章的 deploy.xml 中提供了一个简单的替换属性文件的值的例子。正则表达式的例子可以在本文所带的 deploy.xml 中找到。

dbunit: DbUnit is a JUnit extension (also usable with Ant) targeted for database-driven projects

official site, 好久没更新了, 最新版本2.1还是2004年5月的

1. use ant task

<taskdef classpathref="project.classpath" classname="org.dbunit.ant.DbUnitTask" name="dbunit" />

 导出数据

<target name="export">
<dbunit password="${database.password}" userid="${database.userid}" 
   url="${database.url}" driver="${database.driver}" supportbatchstatement="true">
<export format="xml" dest="data/export-data.xml">
      <query name="FOO" sql="SELECT COL1, COL2 FROM FOO WHERE COL1=4"/>
      <table name="BAR"/> 
</export>
</dbunit>
</target>

tip: 不指定query、table， 导出所有的table

导入数据

<target name="clean_insert">
<dbunit password="${database.password}" userid="${database.userid}" 
   url="${database.url}" driver="${database.driver}">
   <operation format="xml" src="data/init-data.xml" type="CLEAN_INSERT" />
</dbunit>
</target>

tip:
type: UPDATE, INSERT, DELETE, DELETE_ALL, REFRESH,
      MSSQL_INSERT, MSSQL_REFRESH, MSSQL_CLEAN_INSERT.

比较数据

<target name="compare">
<dbunit password="${database.password}" userid="${database.userid}" 
   url="${database.url}" driver="${database.driver}">
   <compare format="xml" src="data/init-data.xml" />
</dbunit>
</target>

2. use code

导出数据

IDatabaseConnection conn = new DatabaseConnection(jdbcConnection, schema); // oracle指定schema
IDataSet dataSet = conn.createDataSet();
XmlDataSet.write(dataSet, new FileOutputStream("export-data.xml")); // xml file
FlatXmlDataSet.write(dataSet,new FileOutputStream("export-data.xml")); // flat xml file
XlsDataSet.write(dataSet,new FileOutputStream("export-data.xls")); // xls file
FlatDtdDataSet.write(dataSet,new FileOutputStream("export-data.dtd")); // dtd file
CsvDataSetWriter.write(dataSet, new File("export-data-csv")); // csv file

使用DatabaseSequenceFilter, 解决违反外键约束的问题

IDatabaseConnection conn = new DatabaseConnection(jdbcConnection);
ITableFilter filter = new DatabaseSequenceFilter(conn);
// ITableFilter filter = new DatabaseSequenceFilter(conn, tableNames);
IDataSet dataset = new FilteredDataSet(filter, conn.createDataSet());
XmlDataSet.write(dataset, new FileOutputStream("export-data.xml"));

导入数据

DatabaseOperation.REFRESH.execute(conn, dataSet);
DatabaseOperation.INSERT.execute(conn, dataSet);

删除数据

DatabaseOperation.DELETE.execute(conn, dataSet);

比较数据

IDatabaseConnection conn = new DatabaseConnection(jdbcConnection);
Compare compare = new Compare();
compare.setFormat("xml");
compare.setSrc(new File("export-data.xml"));
compare.execute(conn);

tip: 使用assert进行比较, 作用不大
code: Assertion.assertEquals(expectedTable, actualTable);

3. QueryDataSet: use sql

QueryDataSet queryDataSet = new QueryDataSet(conn);
queryDataSet.addTable("orders", ordersQuerySQL);

posted on 2005-08-20 03:17 water ye 阅读(956) 评论(0)  编辑  收藏 所属分类: Other 、Java Basic

把属性的设置都放一个XML文件中

props.xml文件

<propertyname="build.dir"value="build"/>

然后在 build.xml文件中加入如下

<!DOCTYPE project [<!ENTITY properties SYSTEM "file:props.xml">]>

二，将多个目录的源文件编译到一个地方

<javacdestdir="build/classes">

    <srcpath="src1"/>

    <srcpath="src2"/>

</javac>

三，保存构建时的信息

<projectdefault="init">

    <targetname="init"></target>

    <propertyenvironment="env"/>

    <propertyname="env.COMPUTERNAME"value="${env.HOSTNAME}"/>

    <propertyfilecomment="Build Information"file="./buildinfo.properties">

        <entrykey="build.host"value="${env.COMPUTERNAME}"/>

        <entrykey="build.user.name"value="${user.name}"/>

        <entrykey="build.os.name"value="${os.name}"/>

    </propertyfile>

</project>

四，去除属性文件的注释

属性文件：

# 这里是注释，会给过滤掉

build.dir = build

build文件：

<copyfile="props.properties"todir="sample">

    <filterchain>

        <striplinecomments>

            <commentvalue="#"/>

        </striplinecomments>

    </filterchain>

</copy>

五，两个花俏的功能

1.声音提示

<projectname="Sound"default="all">

    <propertyfile="build.properties"/>

    <targetname="init">

        <sound>

            <successsource="${sound.dir}/success.wav"duration="500"/>

            <failsource="${sound.dir}/fail.wav"loops="2"/>

        </sound>

    </target>

    <targetname="fail"depends="init">

        <fail/>

    </target>

    <targetname="success"depends="init"/>

    <targetname="all"depends="success"/>

</project>

2.进度条提示

<projectname="splash"default="init">

    <targetname="init">

        <splashimageurl="http://java.chinaitlab.com/UploadFiles_8734/200610/20061021103415601.gif"showduration="5000"/>

        <sleepseconds="1"/>

        <sleepseconds="1"/>

        <sleepseconds="1"/>

        <sleepseconds="1"/>

        <sleepseconds="1"/>

        <sleepseconds="1"/>

    </target>

</project>

　　第一步，创建一个空白目录，如F:/SVNRepositorys/sample/sampleRepository

　　第二步，右键点击该目录，在右键菜单中选择TortoiseSVN->Create repository here...。如下图所示

　　我原先为自己一些文件的版本管理做过很多的麻烦事，比如搭建CVSNT啊，学习SVN Server的配置啊。但是没有想到可以这么简单的就可以达到自己的目的了。这件事情给了我一个启发：熟练掌握你手里已有的工具，你会发现你其实已经拥有很多。

package pub.capart;

import java.io.*;
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;

public class GrindServlet extends HttpServlet {
   protected void doGet(HttpServletRequest req, HttpServletResponse res)
         throws ServletException, IOException {
      Grinderv1 grinder = Grinderv1.getGrinder();
      long t1 = System.currentTimeMillis();
      grinder.grindCPU(13);
      long t2 = System.currentTimeMillis();

      PrintWriter pw = res.getWriter();
      pw.print("<html>\n< body> \n");
      pw.print("Grind Time = "+(t2-t1));
      pw.print("< body> \n< /html> \n");
   }
}

package pub.capart;

/**
* This is a simple class designed to simulate an application consuming
* CPU, memory, and contending for a synchronization lock.
*/
public class Grinderv1 {
   private static Grinderv1 singleton = new Grinderv1();
   private static final String randstr =
      "this is just a random string that I'm going to add up many many times";

   public static Grinderv1 getGrinder() {
      return singleton;
   }
   public synchronized void grindCPU(int level) {
      StringBuffer sb = new StringBuffer();
      String s = randstr;
      for (int i=0;i<level;++i) {
         sb.append(s);
         s = getReverse(sb.toString());
      }
   }
   public String getReverse(String s) {
      StringBuffer sb = new StringBuffer(s);
      sb = sb.reverse();
      return sb.toString();
   }
} 

package pub.capart;

/**
* This is a simple class designed to simulate an application consuming
* CPU, memory, and contending for a synchronization lock.
*/
public class Grinderv2 {
   private static Grinderv2 singleton = new Grinderv2();
   private static final String randstr =
      "this is just a random string that I'm going to add up many many times";
   private StringBuffer sbuf = new StringBuffer();
   private StringBuffer sbufrev = new StringBuffer();

   public static Grinderv2 getGrinder() {
      return singleton;
   }
   public synchronized void grindCPU(int level) {
      sbufrev.setLength(0);
      sbufrev.append(randstr);
      sbuf.setLength(0);
      for (int i=0;i<level;++i) {
         sbuf.append(sbufrev);
         reverse();
      }
      return sbuf.toString();
   }

   public String getReverse(String s) {
      StringBuffer sb = new StringBuffer(s);
      sb = sb.reverse();
      return sb.toString();
   }
} 

package pub.capart;

/**

* This is just a dummy class designed to simulate a process consuming
* CPU, memory, and contending for a synchronization lock.
*/
public class Grinderv3 {
   private static Grinderv3 grinders[];
   private static int grinderRoundRobin = 0;
   private static final String randstr =
      "this is just a random string that I'm going to add up many many times";
   private StringBuffer sbuf = new StringBuffer();
   private StringBuffer sbufrev = new StringBuffer();

   static {
      grinders = new Grinderv3[10];
      for (int i=0;i<grinders.length;++i) {
         grinders[i] = new Grinderv3();
      }
   }
   public synchronized static Grinderv3 getGrinder() {
      Grinderv3 g = grinders[grinderRoundRobin];
      grinderRoundRobin = (grinderRoundRobin +1) % grinders.length;
      return g;
   }
   public synchronized void grindCPU(int level) {
      sbufrev.setLength(0);
      sbufrev.append(randstr);
      sbuf.setLength(0);
      for (int i=0;i<level;++i) {
         sbuf.append(sbufrev);
         reverse();
      }
      return sbuf.toString();
   }
   public String getReverse(String s) {
      StringBuffer sb = new StringBuffer(s);
      sb = sb.reverse();
      return sb.toString();
   }
} 
  

DefaultContext组件