红薯“http://www.oschina.net/question/12_8196”

有些时候，调试不得不用外网，比如说做支付宝的支付接口，服务器后台通 知就不得不用外网的ip。无奈，只能扔到服务器远程调试了。

网上讲关于远程调试tomcat的倒是蛮多，基本都是将改啥catalina.sh,startup.sh的，操作还是复杂点。下面这篇就只针对于 linux下的tomcat远程调试，不用改啥文件，简单而又没啥副作用。本人在tomcat6 的情况下远程调试成功。

相信很 多J2EE的开发者都是在Windows上面开发程序，然后把程序上传到Linux下运行的吧。可是有时候在自己机器上运行的好好的程序，放到服务器下就 出错了。单单看出错信息也推断不出是哪里的问题。这时候试试用Java的JPDA远程调试程序，一定可以让你很满意。

tomcat服务器已经内置了JPDA支持，只要用:

catalina.sh jpda start

这条命令启动tomcat，它就会监听8000端口，等待调试器的连接。要注意不能使用 startup.sh脚本。tomcat会使用 JPDA_ADDRESS这个环境变量的值。比如想监听8017端口：

export  JPDA_ADDRESS=8017
catalina.sh jpda start

接着，选一个自己喜欢的调试器，基本上现在主流的如Eclipse、NetBean都可以。我主要使用Eclipse，操作只要三步：

1.选择“Run”菜单里的“Open Debug Dialog”。

2.在对话框里找到“Remote Java Application”。 右键菜单选择“New”创建一个配置。

3.新创建的配置的Project选择服务器上的工程。Host和Port分别填写你服务器的IP和JPDA的端口，默认是8000，或 者$JPDA_ADDRESS。

现在就可以像本机调试一样， 设置断点和跟踪调试了。

--By oldjavaman

 http://blog.csdn.net/oldjavaman/archive/2009/07/10/4338315.aspx

1.   基于文件的session持久化技术

Seesion能够被跨服务器持久化， 包含我们的web应用的Class发生变化， 譬如在开发期间，使用基于文件的持久化Seesion技术是非常便捷的， 尤其是我们在开发时， 当Servlet会发生经常变化

在resin.conf中配置如下

<web-app xmlns="http://caucho.com/ns/resin">  <session-config>    <file-store>WEB-INF/sessions</file-store>  </session-config></web-app>

这样的配置是将Session写在一个在<file-store>中定义的文件目录中，当Session发生变化时，将会把session写入一个文件， 当web应用被加载时， resin会从文件里面加载session

但是，基于文件的session技术在做跨服务器的session传递时是没有作用的，有人提出使用NFS技术， 在多个服务器之间共享这个session持久文件， 但是NFS往往会从本地调用缓存， 这样一来， 实际存放session的文件发生变化时，不能及时在另一台服务器上得到体现

2.   分布式session
分布式session比文件持久session复杂得多， 文件持久session是一个简单的基于内存的session管理， 但是分布式session必须事先在多台服务器之间实现session变化的传递

多台机器的负载均衡， 使用的session技术不外乎sticky sessions （粘性session）或者symmetrical sessions（对称session）。前者关注的是负载均衡技术， 后者是关注JVM的技术。使用何种技术依赖于你有什么样的硬件，多少台机器，你要如何管理session.

2.1.      对称session
对称session技术多用于负载均衡，一个session可以从A机器中取出，存放在B机器里面，采用JDBC session技术的对称session ,需要描述resin.conf中的“always-load-session”属性。 每个请求都获得最新状态的session

对于对称的session来说， 一个完全一致的服务器环境是他可以工作的基础，所以较粘性session来说， 由于它每次web请求都需要更新session信息， 所以比较低效。

2.2.      粘性session
粘性的session依赖JVM来实现， 只要session开始工作，那么负载均衡将永远把相同的session存放于同一个机器上， 举个例子来说,有一个ID为aaaXXX的session永远放在A机器的JVM-A上， 而bbbXXX的session用于放在B机器的JVM-B上。

使用这种技术的是比较可靠的， 如果A机器宕机， 则可以从B机器上取得我们需要的session， 而使用者并无从查觉，另外使用粘性session是高效率的，只有session发生变更时才需要重写到服务器。

2.3.      always-load-session
正如上文提及的对称式的session技术需要使用<always-load-session>属性来标识是否每个请求都要从服务器更新session， 如果使用的是jdbc-session技术， 那么这个标识是一定要在配置文件中加上的， 但是如果是基于tcp-session技术的话， 可以不用标识， 因为tcp-session的技术更为老练一些。

always-save-session属性强制了客户的每次web请求需要从服务器的session存储中获得更新，默认情况，用户只有在创建session才从服务器持久层取得session，但是使用了多个服务器的话， 就需要标识来强制每个请求都从服务器持久层取得session来保证每个服务器的session是一致的。

2.4.      always-save-session
默认情况, 当session发生变化时Resin会将session写入到服务器， 如：你在程序中调用了setAttribute()方法，但是假设你仅仅是更新了session中的对象的一个属性， 譬如存放的是一个用户对象， 你改变了这个用户对象的年纪， 这个时候resin并不能侦测到session的变化，也不会保存这个变化。

使用<always-save-session >属性， 可以确保在客户么个请求结束后， 都会在服务器保存session的变化， 尽管低效， 但是非常可靠。

3.   基于数据库的session同步技术
基于数据库的session技术非常容易理解， resin把session写入到数据库中， 每次请求session从数据库中来获得。

为了效率的考虑， jvm所在机器必须保存session的缓存，只有当session发生变化时，这个机器才会向数据库重新查询，如果另一个jvm里面的代码改变了session，将会通知这个机器向数据库请求获得更新。

这样的数据库同步技术会导致向一个已经存在session的机器分发变更了的session数据，这样数据库可能会成为瓶颈， 为了解决这样的问题， 采用便捷轻巧的mysql来存储session，使用Oracle来存放业务数据是一个不错的主意。

使用数据库技术<database>属性是必须的， 加上这个属性，resin会自动在制定数据库上创建session存储的表

<resin xmlns="http://caucho.com/ns/resin"><server>  <http id='a' port='80'/>  <http id='b' port='80'/>   <database jndi-name="jdbc/session">    ...  </database>   <cluster>    <srun id='a' host='host-a' port='6802'/>    <srun id='b' host='host-b' port='6802'/>  </cluster>   <persistent-store type="jdbc">    <init>      <data-source>jdbc/session<data-source>    </init>  </persistent-store>  ...   <web-app-default>    <session-config>      <use-persistent-store/>    </session-config>  </web-app-default>
 

持久化的session必须在上文的<sever>中使用<persistent-store>来定义。而每一个web-app应用必须使用<use-persistent-store/>来表示需要分布式session技术

ata-source
 数据源
 
table-name
 存放session数据的表名
 
blob-type
  Blob类型
 
max-idle-time
  释放时间
 

CREATE TABLE persistent_session (

  id VARCHAR(64) NOT NULL,

  data BLOB,

  access_time int(11),

  expire_interval int(11),

  PRIMARY KEY(id)

)
 

下面是一个使用持久层session的web-app定义示例：

<web-app xmlns="http://caucho.com/ns/resin">  <session-config>    <use-persistent-store/>    <always-save-session/>  </session-config></web-app>

4.   基于集群session技术
基于集群的session技术应用在服务器集群领域， 在一些案例中采用数据库的session分布技术是高效的， 有些场合，采用集群的session是高效的。

在集群的session每一个服务器拥有一个jvm和一个备份jvm， session同时保存在自己的jvm和备份jvm里面。

同样地， 你必须修改<sever>中的<cluster>下面的<srun>属性来达到集群session的效果， 在web-app中使用<use-persistent-store>属性来标识这个应用采用session持久化技术

配置如下：

<resin xmlns="http://caucho.com/ns/resin">

  ...

<server>

  <cluster>

    <srun id="a" host="192.168.0.1" port="6802" index="1"/>

    <srun id="b" host="192.168.0.2" port="6802" index="2"/>

  </cluster>

  <persistent-store type="cluster">

    <init path="cluster"/>

  </persistent-store>

  ...
 

<web-app xmlns="http://caucho.com/ns/resin">  <session-config>    <use-persistent-store="true"/>  </session-config></web-app>
 

<srun>和<srun-backup>都被视为一个集群服务器， 当一个服务器上的session发生变化时， 它会自动寻找其他的备份服务器， 并把备份服务器上的session更新， 当这个服务器重新启动时， 他会向备份服务器请求session，并获得备份。

<resin xmlns="http://caucho.com/ns/resin"><server>  <http id='a' port='80'/>  <http id='b' port='80'/>   <cluster>    <srun id='a' host='host-a' port='6802'/>    <srun id='b' host='host-b' port='6802'/>  </cluster>   <persistent-store type="cluster">    <init path="cluster"/>  </persistent-store>   <host id=''>  <web-app id=''>   <session-config>    <use-persistent-store="true"/>  </session-config>   </web-app>  </host></server></resin>
 

 
 
5. 关于作者
OldJavaMan，长期致力于Java相关领域的技术工作， 主要参与J2EE相关程序的设计， 目前在南京的一家软件企业就职，他希望和广大的Java爱好者结交朋友。大家可以通过 mail 联系他 。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/oldjavaman/archive/2009/07/10/4338315.aspx

作者：darkblue

有两台服务器

主机名：web-srv

内网IP：10.199.55.1

外网IP：121.183.173.225

域名：web.xxxx.com

主机名：wap-srv

内网IP：10.199.55.3

外网IP：121.183.173.226

域名：wap.xxxx.com

防火墙：PIX525，服务器OS:RedHat ES4U2

需求：

web-srv和wap-srv均使用apache2+resin3.1.2提供http服务，监听端口都是80。

1、当两台主机都正常运作的时候，通过resin来实现负载均衡，web-srv的80端口提供web服务，wap-srv的80端口提供wap服务；

2、当web-srv宕机后，手工启用wap-srv上面的另一个apache进程，监听8080端口，提供web服务，这个时候两个公网IP同时指向一个私网IP10.199.55.3，结果是：80端口提供的是wap服务，8080端口提供的是web服务；

3、当wap-srv宕机后，手工启用web-srv上面的另一个apache进程，监听8080端口，提供wap服务，这个时候两个公网IP同时指向一个私网IP10.199.55.1，结果是：80端口提供的是web服务，8080端口提供的是wap服务；

配置：

一、DNS

增加两条纪录，分别是121.183.173.225 <---> web.xxxx.com，121.183.173.226 <---> wap.xxxx.com。

二、web-srv

2.1 安装apache2、resin-3.1.0

安装apache2略

安装resin-3.1.0

Wget “http://www.caucho.com/download/resin-3.1.0.tar.gz”

Cp resin-3.1.0.tar.gz /usr/local/

Tar –xzvf resin-3.1.0.tar.gz

cd resin-3.1.0

./ configure --with-apache=/usr/local/apache2

Make

Make install

2.2 准备配置文件和目录

copy /usr/local/apache2/conf/httpd.conf httpdweb.conf

copy /usr/local/apache2/conf/httpd.conf httpdwap.conf

mkdir /usr/local/apache2/htdocs/web

mkdir /usr/local/apache2/htdocs/wap

cp -r /usr/local/resin-3.1.0 /usr/local/resin-web

cp -r /usr/local/resin-3.1.0 /usr/local/resin-wap

2.3 修改httpdweb.conf的监听端口(80)和web的路径

file: /usr/local/apache2/conf/httpdweb.conf

ResinConfigServer 10.199.55.3 6802

ResinConfigServer 10.199.55.1 6802

CauchoConfigCacheDirectory /tmp

CauchoStatus yes

2.4 修改httpdwap.conf的监听端口(8080)和wap的路径

file: /usr/local/apache2/conf/httpdweb.conf

ResinConfigServer 10.199.55.3 6803

ResinConfigServer 10.199.55.1 6803

CauchoConfigCacheDirectory /tmp

CauchoStatus yes

2.5 修改resin3.1.2的集群和相关的java配置

file: /usr/local/resin-web/conf/resin.conf

<cluster>

  <server id="10.199.55.1" address="10.199.55.1" port="6802">

 ………………

</cluster>

file: /usr/local/resin-wap/conf/resin.conf

<cluster>

  <server id="10.199.55.1" address="10.199.55.1" port="6803">

 ………………

</cluster>

2.6 启动apache和resin

apache2

/usr/local/apache2/bin/httpd -f ./conf/httpdweb.conf

/usr/local/apache2/bin/httpd -f ./conf/httpdwap.conf

resin

/usr/local/resin-web/bin/httpd.sh -server 10.199.55.1 start

/usr/local/resin-wap/bin/httpd.sh -server 10.199.55.1 start

三、wap-srv

3.1 安装apache2、resin-3.1.0

安装apache2略

安装resin-3.1.0

Wget “http://www.caucho.com/download/resin-3.1.0.tar.gz”

Cp resin-3.1.0.tar.gz /usr/local/

Tar –xzvf resin-3.1.0.tar.gz

cd resin-3.1.0

./ configure --with-apache=/usr/local/apache2

Make

Make install

3.2 准备配置文件和目录

copy /usr/local/apache2/conf/httpd.conf httpdweb.conf

copy /usr/local/apache2/conf/httpd.conf httpdwap.conf

mkdir /usr/local/apache2/htdocs/web

mkdir /usr/local/apache2/htdocs/wap

cp -r /usr/local/resin-3.1.0 /usr/local/resin-web

cp -r /usr/local/resin-3.1.0 /usr/local/resin-wap

3.3 修改httpdweb.conf的监听端口(8080)和web的路径

file: /usr/local/apache2/conf/httpdweb.conf

端口和目录略

ResinConfigServer 10.199.55.3 6802

ResinConfigServer 10.199.55.1 6802

CauchoConfigCacheDirectory /tmp

CauchoStatus yes

3.4 修改httpdwap.conf的监听端口(80)和wap的路径

file: /usr/local/apache2/conf/httpdweb.conf

端口和目录略

ResinConfigServer 10.199.55.3 6803

ResinConfigServer 10.199.55.1 6803

CauchoConfigCacheDirectory /tmp

CauchoStatus yes

3.5 修改resin3.1.2的集群和相关的java配置

file: /usr/local/resin-web/conf/resin.conf

<cluster>

  <server id="10.199.55.3" address="10.199.55.3" port="6802">

 ………………

</cluster>

file: /usr/local/resin-wap/conf/resin.conf

<cluster>

  <server id="10.199.55.3" address="10.199.55.3" port="6803">

 ………………

</cluster>

3.6 启动apache和resin

apache2

/usr/local/apache2/bin/httpd -f ./conf/httpdweb.conf

/usr/local/apache2/bin/httpd -f ./conf/httpdwap.conf

resin

/usr/local/resin-web/bin/httpd.sh -server 10.199.55.3 start

/usr/local/resin-wap/bin/httpd.sh -server 10.199.55.3 start

四、防火墙的配置

因为web-srv和wap-srv只提供www服务，所以只需要对这两个内外网的IP地址对做端口映射。

static (dmz,outside) tcp 121.183.173.225 www 10.199.55.1 www netmask 255.255.255.255

static (dmz,outside) tcp 121.183.173.226 www 10.199.55.3 www netmask 255.255.255.255

五、冷备的实现

5.1 当web-srv宕机后：

5.1.1 修改防火墙配置

no static (dmz,outside) tcp 121.183.173.225 www 10.199.55.1 www netmask 255.255.255.255

static (dmz,outside) tcp 121.183.173.225 www 10.199.55.3 8080 netmask 255.255.255.255

5.1.2 启动wap-srv的第二个apache进程，监听8080端口，提供web服务

/usr/local/apache2/bin/httpd -f ./conf/httpdweb.conf

用户访问http://web.xxxx.com将指向10.199.55.3:8080

5.2 当wap-srv宕机后：

5.2.1 修改防火墙配置

no static (dmz,outside) tcp 121.183.173.226 www 10.199.55.3 www netmask 255.255.255.255

static (dmz,outside) tcp 121.183.173.226 www 10.199.55.1 8080 netmask 255.255.255.255

5.2.2 启动web-srv的第二个apache进程，监听8080端口，提供wap服务

/usr/local/apache2/bin/httpd -f ./conf/httpdwap.conf

用户访问http://wap.xxxx.com将指向10.199.55.1:8080

1 演示环境

2 安装Apache

3 安装Resin

3  配置Resin

3.1 配置默认的负责均衡

4 配置Apache

4.1 修改监听接口

4.2 修改DocumentRoot

4.3 Directory

4.4 修改DirectoryIndex

4.5  修改Rensin相关配置

5 访问测试

5.1. 编写测试页面

5.2 发布项目

5.3. 启动服务

5.4. 验证a.jsp

    <!-- define the servers in the cluster -->
<server id="a" address="127.0.0.1" port="6800"/>
<server id="b" address="127.0.0.1" port="6801"/>

1

            

> D:\resin-pro-3.1.3\httpd.exe -conf conf/resin-web.conf -server web-a
            

1

            

<%System.out.println("aaaaaaaaaaaa");%>
            

1 、安装

1）安装好JDK

2）把resin-3.0.x.zip解压缩

3）运行resin-3.0.x/httpd.exe

4）打开http://localhost:8080查看测试页面

如果正确打开，窗口会显示如下信息：

C:"win32> resin-3.0.0"bin"httpd

Resin 3.0.0-beta (built Thu Feb 13 18:21:13 PST 2003)

Copyright(c) 1998-2002 Caucho Technology. All rights reserved.

Starting Resin on Sat， 01 Mar 2003 19:11:52 -0500 (EST)

[19:11:56.479] ServletServer[] starting

[19:11:57.000] Host[] starting

[19:11:58.312] Application[http://localhost:8080/doc] starting

[19:12:11.872] Application[http://localhost:8080/quercus] starting

...

[19:12:12.803]http listening to *:8080

[19:12:12.933]hmux listening to *:6802

2、配置

部署为Windows下的服务：

The Resin Web Server can be installed as an Windows service.

Resin服务器可以被安装成为Windows的服务

要安装为Windows的服务，可以用下面的命令

C:"> resin-3.0.x"bin"httpd -install -conf conf/myconf.conf

这样Resin就会作为服务随着机器的启动而自动开启。

要想移除此服务

C:"> resin-3.0.x"bin"httpd -remove

你也可以用如下命令开启和关闭Resin的服务：

C:"> net start resin

...

C:"> net stop resin

多服务起配置：

使用参数 -install-as foo来指定一个特定的服务名

C:"> resin-3.0.x"bin"httpd -install-as ResinA -conf conf/myconf.conf

-server a

C:"> net start ResinA

注意：

有一些JDK存在这样的Bug，当管理员帐户注销以后服务也会随着关闭，解决办法是在安装的时候使用参数–Xrs:

C:"> resin3.0.0/httpd.exe -install –Xrs

二、Linux下resin的安装以及配置：

1、安装

1） 安装 JDK 1.4

2） 确定环境变量JAVA_HOME设置正确

3） 安装

单独运行：

# tar zxvf resin-3.0.4.tar.gz

# mv resin03.0.6 /usr/local/resin

#cd /usr/local/resin

# ./configure

# make

# make install

#cd bin

#./httpd.sh start

自动启动：

在/etc/rc.d/rc.local中加入如下语句：

/usr/local/resin/bin/httpd.sh start

和Apache整合：

1）Apache安装
# tar zxvf httpd-2.49.tar.gz
# cd httpd-2.49
# ./configure --prefix=/usr/local/httpd --enable-modules=so --enable-so 
--prefix
--enable-modules用来指定系统允许使用的功能扩展模块的类型，这里指定为so类型。
--enabel-so 用来指定允许使用DSO（Dynamic Share Object动态共享对象）。
# make
# make install
设置apache自动启动：
将Apache的启动文件apachectl写入rc.local中
/usr/local/httpd/bin/apachectl start

2）Resin安装

# tar zxvf resin-3.0.4.tar.gz
# cd resin-3.0.4
# ./configure --prefix=/usr/local/resin --with-apache=/usr/local/httpd
# make
# make install
此时已经生成Resin连接Apache2的.so文件了，其存在与$APACHE_HOMEe/modules/mod_caucho.so

conf/httpd.conf中就会多出以下语句：

LoadModule caucho_modules modules/mod_caucho.so    
 ResinConfigServer localhost 6802    

分别先后启动Resin和Apache
访问http://hostname/caucho-status 可以看到Resin的状态页面

2 、配置

1）linux下使用resin的单服务器配置

使用单服务器方案，只要安装完毕，配置一下Resin的resin.conf文件和app_default.xml文件就可以了，resin.conf文件中需要配置两处，一是端口号，另一处是Web程序存放目录，app_default.xml内可配置默认首页的搜索顺序。由于原网站使用多个端口配置，所以单服务器只能用于做单个站点的测试使用。

2）linux下使用resin的多服务器配置以及多实例开机自动运行的配置

       有时候需要运行多个服务器以在同一个ＩＰ上监听多个端口，这时候就需要使用单独的Resin服务器运行多个实例，以监听多个端口来部署多个Web站点。

可以有如下两种配置方法：

第一种方法：

这种方法为多次使用httpd.sh的参数指定配置文件和运行时的pid文件，实现多个实例的运行。

使用的命令行如下所示：

$RESIN_HOME/bin/httpd.sh -conf conf/resin1.conf -pid resin1.pid start

解释：

       -conf 选项为选择此服务器实例所用的配置文件，在这个文件里面配置不同的端口和主目录。

-pid 进程id及所用pid文件。

       start启动。

用以上命令，在建立多个服务器配置文件以后就可以手工打开多个服务器实例。

把这些语句加到/etc/rc.d/rc.local中就可以实现开机自动启动了。

 

第二种方法：

这种方法使用Chkconfig命令设置多服务器自动启动，运行于不同系统运行级别的后台方式。并使他们成为可在图形界面下管理的服务。

设置好JAVA_HOME环境变量后将RESIN解包到/home/resin下，执行编译脚本

#tar zxf resin-version.tar.gz

#mv resin-version /home/resin

#cd /home/resin/

#./configure

#make

#make install

 

将make install生成的$RESIN_HOME/contrib/init.resin复制到/etc/rc.d/init.d/目录下改名为resinx

修改resin文件的内容（三处）

（1）JAVA环境设置

       找到以下代码段

       JAVA_HOME=/usr/java

RESIN_HOME=/usr/local/resin

并修改他们为相应的目录，第一个为JDK安装主目录，第二个为Resin安转主目录。

（2）PID=$RESIN_HOME/resin.pid

修改为

PID=$RESIN_HOME/resin1.pid（很清楚，要不一样的pid）

（3）、找到程序段

start)

       echo -n "Starting resin: "

       if test -n "$USER"; then

       su $USER -c "$EXE -pid $PID start $ARGS"

       else

       $EXE -pid $PID start $ARGS

        fi

       echo

       ;;

修改为

start)

       echo -n "Starting resin: "

       if test -n "$USER"; then

       su $USER -c "$EXE -conf $RESIN_HOME/conf/resin1.conf -pid $PID start $ARGS"

       else

       $EXE -conf $RESIN_HOME/conf/resin1.conf -pid $PID start $ARGS

        fi

       echo

       ;;

其实上面的程序和第一部分是一样的，只是用脚本来运行了。

最后chmod +x resin1

 

用上面的方法拷贝出resin2，resin3.....

chmod +x resin1

chmod +x resin2

......

命令为：

cp contrib/init.resin /etc/rc.d/init.d/resin1

vi /etc/rc.d/init.d/resin1

i

:wq

chmod +x /etc/rc.d/init.d/resin1

 

如此你想运行几个服务器实例创建几个这样的文件(resinx)

 

修改resin中的一些设置：JAVA_HOME RESIN_HOME USER等，

 

将resin服务在不同的启动级中设置成自启动:

#/sbin/chkconfig resin1 reset

#/sbin/chkconfig resin2 reset

......

 

创建不同的配置文件

注意每一个配置文件必须保持三处不同：

(1)srun（负载平衡配置）部分端口号必须不同，用不同的ip地址也可以。

在原文件的如下部分：

<cluster>

      <srun server-id="" host="127.0.0.1" port="6802"/>

</cluster>

(2)默认主文件目录要设为不同，不然就失去了多个实例的意义，不然的话还不如用负载平衡来提高性能

<web-app id="/" document-directory="webapps/ROOT"/>

(3)服务器的端口号必须不同。

<http server-id="" host="*" port="8080"/>

 

这样系统启动的时候，resin就会在后台运行多个实例了，效果和第一步一样。

都市淘沙者 2007-11-22 16:10 发表评论

]]>

<!--备份每日日志，并且压缩为.gz格式文件减少占用容量，如果一周备份一次则需要将“1D”改为“1W”-->
<log name="" level="info" path="log/stdout.log" timestamp="[%H:%M:%S.%s] "
     archive-format="stdout.log.%Y-%m-%d.gz"
     rollover-period="1D"/>

  <!--
     - For production sites, change dependency-check-interval to something
     - like 600s, so it only checks for updates every 10 minutes.
    -->
  <dependency-check-interval>2s</dependency-check-interval>

  <!--
     - You can change the compiler to "javac" or jikes.
     - The default is "internal" only because it's the most
     - likely to be available.
    -->
  <javac compiler="internal" args=""/>

  <!-- Security providers.
     - <security-provider>
     -    com.sun.net.ssl.internal.ssl.Provider
     - </security-provider>
    -->

  <!--
     - If starting bin/resin as root on Unix, specify the user name
     - and group name for the web server user.
     -
     - <user-name>resin</user-name>
     - <group-name>resin</group-name>
    -->

  <!--
     - Configures threads shared among all HTTP and SRUN ports.
    -->
  <thread-pool>
    <!-- Maximum number of threads. -->
    <thread-max>1024</thread-max>

    <!-- Minimum number of spare connection threads. -->
    <spare-thread-min>25</spare-thread-min>
  </thread-pool>

  <!--
     - Configures the minimum free memory allowed before Resin
     - will force a restart.
    -->
  <min-free-memory>1M</min-free-memory>

  <server>
    <!-- adds all .jar files under the resin/lib directory -->
    <class-loader>
      <tree-loader path="${resin.home}/lib"/>
      <tree-loader path="${server.root}/lib"/>
    </class-loader>

    <!-- Configures the keepalive -->
    <keepalive-max>500</keepalive-max>
    <keepalive-timeout>120s</keepalive-timeout>

    <resin:if test="${resin.isProfessional()}">
      <select-manager enable="true"/>
    </resin:if>

    <!-- listen to the http ports only after the server has started. -->
    <bind-ports-after-start/>

    <!-- The http port -->
    <http server-id="" host="*" port="6060"/>

    <!--
       - SSL port configuration:
       -
       - <http port="8443">
       -   <openssl>
       -     <certificate-file>keys/gryffindor.crt</certificate-file>
       -     <certificate-key-file>keys/gryffindor.key</certificate-key-file>
       -     <password>test123</password>
       -   </openssl>
       - </http>
      -->

    <!--
       - The local cluster, used for load balancing and distributed
       - backup.
      -->
    <!--cluster>
      <srun server-id="" host="127.0.0.1" port="6806"/>
    </cluster-->

    <!--
       - Configures the persistent store for single-server or clustered
       - in Resin professional.
      -->
    <resin:if test="${resin.isProfessional()}">
      <persistent-store type="cluster">
        <init path="session"/>
      </persistent-store>
    </resin:if>

    <!--
       - Enables/disables exceptions when the browser closes a connection.
      -->
    <ignore-client-disconnect>true</ignore-client-disconnect>

    <!--
       - For security, use a different cookie for SSL sessions.
       - <ssl-session-cookie>SSL_JSESSIONID</ssl-session-cookie>
      -->

    <!--
       - Enables the cache (available in Resin Professional)
      -->
    <resin:if test="${isResinProfessional}">
      <cache path="cache" memory-size="8M"/>
    </resin:if>

    <!--
       - Enables periodic checking of the server status.
       -
       - With JDK 1.5, this will ask the JDK to check for deadlocks.
       - All servers can add <url>s to be checked.
      -->
    <resin:if test="${isResinProfessional}">
      <ping>
        <!-- <url>http://localhost:8080/test-ping.jsp</url> -->
      </ping>
    </resin:if>

    <!--
       - Defaults applied to each web-app.
      -->
    <web-app-default>
      <!--
         - Extension library for common jar files.  The ext is safe
         - even for non-classloader aware jars.  The loaded classes
         - will be loaded separately for each web-app, i.e. the class
         - itself will be distinct.
        -->
      <class-loader>
        <tree-loader path="${server.root}/ext-webapp"/>
      </class-loader>

      <!--
         - Sets timeout values for cacheable pages, e.g. static pages.
        -->
      <cache-mapping url-pattern="/" expires="5s"/>
      <cache-mapping url-pattern="*.gif" expires="60s"/>
      <cache-mapping url-pattern="*.jpg" expires="60s"/>

      <!--
         - Servlet to use for directory display.
        -->
      <servlet servlet-name="directory"
              servlet-class="com.caucho.servlets.DirectoryServlet"/>

      <!--
         - Enable EL expressions in Servlet and Filter init-param
        -->
      <allow-servlet-el/>

      <!--
         - for security, disable session URLs by default.
        -->
      <session-config>
        <enable-url-rewriting>true</enable-url-rewriting>
        <save-only-on-shutdown>true</save-only-on-shutdown>
        <file-store>${resin.home}/webapps</file-store>
        <ignore-serialization-errors>true</ignore-serialization-errors>
      </session-config>

      <!--
         - For security, set the HttpOnly flag in cookies.
         - <cookie-http-only/>
        -->
    </web-app-default>

    <!--
       - Sample database pool configuration
       -
       - The JDBC name is java:comp/env/jdbc/test
         <database>
           <jndi-name>jdbc/mysql</jndi-name>
           <driver type="org.gjt.mm.mysql.Driver">
             <url>jdbc:mysql://localhost:3306/test</url>
             <user></user>
             <password></password>
            </driver>
            <prepared-statement-cache-size>8</prepared-statement-cache-size>
            <max-connections>20</max-connections>
            <max-idle-time>30s</max-idle-time>
          </database>
      -->

    <!--
       - Default host configuration applied to all virtual hosts.
      -->
    <host-default>
      <class-loader>
        <compiling-loader path="webapps-/WEB-INF/classes"/>
        <library-loader path="webapps-/WEB-INF/lib"/>
      </class-loader>

      <!--
         - With another web server, like Apache, this can be commented out
         - because the web server will log this information.
        -->
  <!--查看上面红色字体的说明
-->
      <access-log path="logs/access.log" 
             archive-format="stdout.log.%Y-%m-%d.gz"
            rollover-period="1D"/> 

      <!-- creates the webapps directory for .war expansion -->
      <web-app-deploy path="webapps-"/>

      <!-- creates the deploy directory for .ear expansion -->
      <ear-deploy path="deploy">
        <ear-default>
          <!-- Configure this for the ejb server
             -
             - <ejb-server>
             -   <config-directory>WEB-INF</config-directory>
             -   <data-source>jdbc/test</data-source>
             - </ejb-server>
            -->
        </ear-default>
      </ear-deploy>

      <!-- creates the deploy directory for .rar expansion -->
      <resource-deploy path="deploy"/>

      <!-- creates a second deploy directory for .war expansion -->
      <web-app-deploy path="deploy"/>
    </host-default>

    <!-- includes the web-app-default for default web-app behavior -->
    <resin:import path="${resin.home}/conf/app-default.xml"/>

    <!-- configures a deployment directory for virtual hosts -->
    <host-deploy path="hosts">
      <host-default>
        <resin:import path="host.xml" optional="true"/>
      </host-default>
    </host-deploy>

    <!-- configures the default host, matching any host name -->
    <host id="" root-directory=".">
      <!--
         - configures an explicit root web-app matching the
         - webapp's ROOT
        -->
      <!--web-app id="/" document-directory="webapps/ROOT"/-->

      <!--
         - Administration application /resin-admin
         -
         - password is the md5 hash of the password.
         - localhost is true to limit access to the localhost
        -->
      <resin:set var="resin_admin_password"  default=""/>
      <resin:set var="resin_admin_localhost" default="true"/>

      <!--web-app id="/resin-admin" document-directory="${resin.home}/php/admin"/-->
       <web-app id="/" document-directory="webapps/job">

 
      </web-app>

      <!--web-app id="resin-doc" document-directory="webapps/resin-doc"/-->
    
    </host>
  </server>
</resin>

负载平衡方案如下：
一台机器（操作系统2003）安装apache，作为负载服务器，并安装tomcat作为一个worker；一个单独安装tomcat，作为第二个worker；剩下的一台单独作为数据库服务器。
Apache和tomcat的负载平衡采用JK1.2.14（没有采用2.0，主要是2.0不再维护了）。
集群方案：
采用Tomcat本身的集群方案。在server.xml配置。
压力测试问题：
压力测试后，发现了一些问题，现一一列出来：
（1） 采用Tocmat集群后，速度变得很慢。因为集群后，要进行session复制，导致速度较慢。Tomcatd的复制，目前不支持application复制。复制的作用，主要用来容错的，即一台机器有故障后，apache可以把请求自动转发到另外一个机器。在容错和速度的考虑上，我们最终选择速度，去掉了Tomcat集群。
（2） 操作系统最大并发用户的限制：
为了采用网站的压力，我们开始的时候，仅测试Tomcat的最大负载数。Tomcat服务器安装的操作系统是windows2000 Professional。当我们用压力测试工具，并发测试时，发现只要超过15个并发用户，会经常出现无法连接服务器的情况。经过研究，发现是操作系统的问题：windows2000 Professional 支持的并发访问用户有限，默认的好像是15个。于是我们把操作系统全部采用windows2003 server版本。
（3） 数据库连接池的问题：
测试数据库连接性能时，发现数据库连接速度很慢。每增加一些用户，连接性能就差了很多。我们采用的数据库连接池是DBCP，默认的初始化为50个，应该不会很慢吧。查询数据库的连接数，发现初始化，只初始化一个连接。并发增加一个用户时，程序就会重新创建一个连接，导致连接很慢。原因就在这里了。如何解决呢？偶尔在JDK1.4下的Tomcat5.0.30下执行数据库连接压力测试，发现速度很快，程序创建数据库连接的速度也是很快的。看来JDK1.5的JDBC驱动程序有问题。于是我们修改 JDK的版本为1.4.

（4） C3P0和DBCP
C3P0是Hibernate3.0默认的自带数据库连接池，DBCP是Apache开发的数据库连接池。我们对这两种连接池进行压力测试对比，发现在并发300个用户以下时，DBCP比C3P0平均时间快1秒左右。但在并发400个用户时，两者差不多。

速度上虽然DBCP比C3P0快些，但是有BUG：当DBCP建立的数据库连接，因为某种原因断掉后，DBCP将不会再重新创建新的连接，导致必须重新启动Tomcat才能解决问题。DBCP的BUG使我们决定采用C3P0作为数据库连接池。
调整后的方案：
操作系统Windows2003 server版本
JDK1.4
Tomcat 5.0.30
数据库连接池C3P0
仅采用负载平衡，不采用集群。
软件的配置：
Apache配置：主要配置httpd.conf和新增加的文件workers.properties
Httpd.conf：
#一个连接的最大请求数量
MaxKeepAliveRequests 10000
#NT环境，只能配置这个参数来提供性能
<IfModule mpm_winnt.c>
#每个进程的线程数，最大1920。NT只启动父子两个进程，不能设置启动多个进程
ThreadsPerChild 1900
每个子进程能够处理的最大请求数
MaxRequestsPerChild 10000
</IfModule>

# 加载mod_jk
#
LoadModule jk_module modules/mod_jk.so
#
# 配置mod_jk
#
JkWorkersFile conf/workers.properties
JkLogFile logs/mod_jk.log
JkLogLevel info
#请求分发，对jsp文件，.do等动态请求交由tomcat处理
DocumentRoot "C:/Apache/htdocs"
JkMount /*.jsp loadbalancer
JkMount /*.do loadbalancer
JkMount /servlet/* loadbalancer
#关掉主机Lookup，如果为on，很影响性能，可以有10多秒钟的延迟。
HostnameLookups Off
#缓存配置
LoadModule cache_module modules/mod_cache.so
LoadModule disk_cache_module modules/mod_disk_cache.so
LoadModule mem_cache_module modules/mod_mem_cache.so

<IfModule mod_cache.c>
CacheForceCompletion 100
CacheDefaultExpire 3600
CacheMaxExpire 86400
CacheLastModifiedFactor 0.1

<IfModule mod_disk_cache.c>
CacheEnable disk /
CacheRoot c:/cacheroot
CacheSize 327680
CacheDirLength 4
CacheDirLevels 5
CacheGcInterval 4
</IfModule>
<IfModule mod_mem_cache.c>
CacheEnable mem /
MCacheSize 8192
MCacheMaxObjectCount 10000
MCacheMinObjectSize 1
MCacheMaxObjectSize 51200
</IfModule>
</IfModule>
worker. Properties文件
#
# workers.properties ，可以参考
http://jakarta.apache.org/tomcat/connectors-doc/config/workers.html
# In Unix, we use forward slashes:
ps=

# list the workers by name

worker.list=tomcat1, tomcat2, loadbalancer

# ------------------------
# First tomcat server
# ------------------------
worker.tomcat1.port=8009
worker.tomcat1.host=localhost
worker.tomcat1.type=ajp13

# Specify the size of the open connection cache.
#worker.tomcat1.cachesize

#
# Specifies the load balance factor when used with
# a load balancing worker.
# Note:
# ----> lbfactor must be > 0
# ----> Low lbfactor means less work done by the worker.
worker.tomcat1.lbfactor=900

# ------------------------
# Second tomcat server
# ------------------------
worker.tomcat1.port=8009
worker.tomcat1.host=202.88.8.101
worker.tomcat1.type=ajp13

# Specify the size of the open connection cache.
#worker.tomcat1.cachesize

#
# Specifies the load balance factor when used with
# a load balancing worker.
# Note:
# ----> lbfactor must be > 0
# ----> Low lbfactor means less work done by the worker.
worker.tomcat1.lbfactor=2000

# ------------------------
# Load Balancer worker
# ------------------------

#
# The loadbalancer (type lb) worker performs weighted round-robin
# load balancing with sticky sessions.
# Note:
# ----> If a worker dies, the load balancer will check its state
# once in a while. Until then all work is redirected to peer
# worker.
worker.loadbalancer.type=lb
worker.loadbalancer.balanced_workers=tomcat1,tomcat2

#
# END workers.properties
#

Tomcat1配置:
<!--配置server.xml
去掉8080端口，即注释掉如下代码：-->
<Connector
port="8080" maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
enableLookups="false" redirectPort="8443" acceptCount="100"
debug="0" connectionTimeout="20000"
disableUploadTimeout="true" />

<!--配置8009端口如下：-->
<Connector port="8009"
maxThreads="500" minSpareThreads="400" maxSpareThreads="450"
enableLookups="false" redirectPort="8443" debug="0"
protocol="AJP/1.3" />
<!--配置引擎-->
<Engine name="Catalina" defaultHost="localhost" debug="0" jvmRoute="tomcat1">

启动内存配置,开发configure tomcat程序即可配置：
Initial memory pool: 200 M
Maxinum memory pool:300M
Tomcat2配置：
配置和tomcat1差不多，需要改动的地方如下：
<!--配置引擎-->
<Engine name="Catalina" defaultHost="localhost" debug="0" jvmRoute="tomcat2">

启动内存配置,开发configure tomcat程序即可配置：
Initial memory pool: 512 M
Maxinum memory pool:768M
Mysql配置：
Server类型：Dedicated MySQL Server Machine
Database usage:Transational Database Only
并发连接数量：Online Transaction Processing(OLTP)
字符集：UTF8
数据库连接池的配置：
我们采用的是spring 框架，配置如下：
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
<prop key="hibernate.connection.driver_class">com.mysql.jdbc.Driver</prop>
<prop key="hibernate.connection.url">jdbc:mysql://202.88.1.103/db</prop>
<prop key="hibernate.connection.username">sa</prop>
<prop key="hibernate.connection.password"></prop>

<prop key="hibernate.show_sql">false</prop>
<prop key="hibernate.use_sql_comments">false</prop>

<prop key="hibernate.cglib.use_reflection_optimizer">true</prop>
<prop key="hibernate.max_fetch_depth">2</prop>

<prop key="hibernate.c3p0.max_size">200</prop>
<prop key="hibernate.c3p0.min_size">5</prop>
<prop key="hibernate.c3p0.timeout">12000</prop>
<prop key="hibernate.c3p0.max_statements">50</prop>
<prop key="hibernate.c3p0.acquire_increment">1</prop>
</props>
</property>
其他的没有额外配置。
LoadRunner 常见问题：
（1）sofeware caused connction：这种情况，一般是脚本有问题，或者loadrunner有问题。解决方法：重新启动机器，或者重新录制脚本，估计是loadrunner的bug。
（2）cannot connect to server:无法连接到服务器。这种情况是服务器的配置有问题，服务器无法承受过多的并发连接了。需要优化服务器的配置，
如操作系统采用windows 2003 server，
优化tomcat配置：maxThreads="500" minSpareThreads="400" maxSpareThreads="450"。但是tomcat 最多支持500个并发访问
优化apache配置：
ThreadsPerChild 1900
MaxRequestsPerChild 10000
其他的错误如：
Action.c(10): Error -27791: Server has shut down the connection prematurely
HTTP Status-Code=503 (Service Temporarily Unavailable)
一般都是由于服务器配置不够好引起的，按照问题（2）处理，如果仍旧不行，需要优化硬件和调整程序了。
Apache问题：
（1） File does not exist: C:/Apache/htdocs/favicon.ico：
这个问题是apache，htdocs目录没有favicon.ico文件引起的，该文件是网站的图标，仅在firefox,myIE等浏览器出现。
（2） 图片无法显示：
配置apache后，却无法显示图片。
解决方法：把程序的图片，按照程序结构copy到apache的htdocs目录下。
（3） 无法处理请求：
当我们输入 ***.do 命令后，apache确返回错误信息，而连接tomcat却没有问题。原因是没有把.do命令转发给tomcat处理。解决方法如下：
在apache配置文件中配置如下内容：
DocumentRoot "C:/Apache/htdocs"
JkMount /*.jsp loadbalancer
JkMount /*.do loadbalancer

总结：
网站的压力测试，涉及的知识面挺广的，不仅要熟悉压力测试工具，还要知道如何配置和优化应用服务器和数据库，并且需要知道如何优化网络、操作系统、硬件系统。
测试中不仅要善于发现问题，要知道如何解决。最重要的一点，要有良好的测试方法。刚开始测试时，可以从最简单的测试脚本入手，不需要太复杂的脚本，这样便于发现问题。如我们刚开始时，就从一个简单的下载登陆界面的脚本入手，测试一个tomcat的压力负载。一个简单的获取登陆的脚本，帮助我们优化了tomcat的配置；后来再测试数据库连接，也是一个简单的数据库连接脚本，帮助我们优化了数据库连接池；然后利用这些简单的脚本，测试apache的负载平衡，优化了apache配置。最后运行复杂的脚本，模拟多种角色的用户在不同时间下的处理，以测试网站压力负载。