﻿<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:trackback="http://madskills.com/public/xml/rss/module/trackback/" xmlns:wfw="http://wellformedweb.org/CommentAPI/" xmlns:slash="http://purl.org/rss/1.0/modules/slash/"><channel><title>BlogJava-WOLF--执着-文章分类-tomcat集群</title><link>http://www.blogjava.net/sutao/category/24290.html</link><description>用文字记录学习的体验！</description><language>zh-cn</language><lastBuildDate>Fri, 23 Nov 2007 09:09:37 GMT</lastBuildDate><pubDate>Fri, 23 Nov 2007 09:09:37 GMT</pubDate><ttl>60</ttl><item><title>Tomcat性能调整</title><link>http://www.blogjava.net/sutao/articles/162665.html</link><dc:creator>苏醄</dc:creator><author>苏醄</author><pubDate>Fri, 23 Nov 2007 08:27:00 GMT</pubDate><guid>http://www.blogjava.net/sutao/articles/162665.html</guid><wfw:comment>http://www.blogjava.net/sutao/comments/162665.html</wfw:comment><comments>http://www.blogjava.net/sutao/articles/162665.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/sutao/comments/commentRss/162665.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/sutao/services/trackbacks/162665.html</trackback:ping><description><![CDATA[<div class="postTitle"><a href="http://blog.csdn.net/avery_leo/archive/2007/11/16/1889227.aspx"><span style="color: #0000ff">Tomcat性能调整 </span></a><span style="color: #0000ff">&nbsp;&nbsp; <script src="http://blog.csdn.net/count.aspx?ID=1889227&amp;Type=Rank"></script><img title="文章指数:0" alt="文章指数:0" src="http://blog.csdn.net/images/star_0.gif" border="0" />&nbsp;&nbsp;<img title="CSDN Blog推出文章指数概念，文章指数是对Blog文章综合评分后推算出的，综合评分项分别是该文章的点击量，回复次数，被网摘收录数量，文章长度和文章类型；满分100，每月更新一次。" alt="CSDN Blog推出文章指数概念，文章指数是对Blog文章综合评分后推算出的，综合评分项分别是该文章的点击量，回复次数，被网摘收录数量，文章长度和文章类型；满分100，每月更新一次。" src="http://blog.csdn.net/images/ask.gif" border="0" /> </span></div>
<div class="postText">
<p><br />
<span style="color: #0000ff">一. 引言<br />
性能测试与分析是软件开发过程中介于架构和调整的一个广泛并比较不容易理解的领域，更是一项较为复杂的活动。就像下棋游戏一样，有效的性能测试和分析只能在一个良好的计划策略和具备了对不可预料事件的处理能力的条件下顺利地完成。一个下棋高手赢得比赛靠的不仅仅是对游戏规则的认识，更是靠他的自己的能力和不断地专注于分析自己对手的实力来更加有效地利用和发挥规则的作用。同样一个优秀的性能测试和分析人员将要面对的是来自一个全新的应用程序和环境下带来的整个项目的挑战。本文中作者结合自己的使用经验和参考文档，对Tomcat性能方面的调整做一简要的介绍，并给出Tomcat性能的测试、分析和调整优化的一些方法。</span></p>
<p><span style="color: #0000ff">二. 测量Web服务器的性能<br />
测量web服务器的性能是一项让人感到畏缩的任务，但是我们在这里将给出一些需要注意的地方并且指点你了解其中更多的细节性的内容。它不像一些简单的任务，如测量CPU的速率或者是测量程序占用CPU的比例，web服务器的性能优化中包括许调整许多变量来达到目标。许多的测量策略中都包含了一个看似简单的浏览实际上是在向服务器发送大量的请求，我们称之为客户端的程序，来测量响应时间。客户端和服务器端是在同一台机器上吗？服务器在测试的时候还运行着其它的什么程序吗？客户端和服务器端的通讯是通过局域网，100baseT，10baseT还是使用调制解调器？客户端是否一直重复请求相同的页面，还是随机地访问不同的页面？（这些影响到了服务缓存的性能）客户端发送请求的有规律的还是突发的？你是在最终的配置环境下运行服务的还是在调试的配置环境下运行服务的？客户端请求中包含图片还是只有HTML页面？是否有请求是通过servlets和 JSP的，CGI程序，服务端包含（Server-Side Includes ，SSI是一个可以让你使用动态HTML文件的技术）？所有这些都将是我们要关心的，并且几乎我们不可能精确地把所有的问题都清楚地列出来。</span></p>
<p><span style="color: #0000ff">1.压力测试工具</span></p>
<p><span style="color: #0000ff">&#8220;工欲善其事，必先利其器&#8221;，压力测试只有借助于一些工具才可得以实施。</span></p>
<p><span style="color: #0000ff">大多数web压力测试工具的实现原理都是通过重复的大量的页面请求来模拟多用户对被测系统的并发访问，以此达到产生压力的目的。产生压力的手段都是通过录制或者是编写压力脚本，这些脚本以多个进程或者线程的形式在客户端运行，这样通过人为制造各种类型的压力，我们可以观察被测系统在各种压力状况下的表现，从而定位系统瓶颈，作为系统调优的基础。目前已经存在的性能测试工具林林总总，数量不下一百种，从单一的开放源码的免费小工具如 Aapache 自带的 web 性能测试工具 Apache Benchmark、开源的Jmeter 到大而全的商业性能测试软件如 Mercury 的 LoadRunner 等等。任何性能测试工具都有其优缺点，我们可以根据实际情况挑选用最合适的工具。您可以在这里找到一些web压力测试工具</span><a href="http://www.softwareqatest.com/qatweb1.html#LOAD"><span style="color: #0000ff">http://www.softwareqatest.com/qatweb1.html#LOAD</span></a></p>
<p><span style="color: #0000ff">这里我们所使用的工具要支持web应用服务认证才可以，要支持接收发送cookies，不仅如此Tomcat支持多种认证方式，比如基本认证、基于表单的认证、相互认证和客户端认证，而一些工具仅仅支持HTTP基本认证。真实地模拟用户认证是性能测试工具的一个重要的部分，因为认证机制将对一个web站点的性能特征产生重要的影响。基于你在产品中使用的不同的认证方式，你需要从上面的工具列表中选择使用这种特性的测试工具。</span></p>
<p><span style="color: #0000ff">Apache Benchmark和http_load是命令行形式的工具，非常易于使用。Apache Benchmark可以模仿单独的URL请求并且重复地执行，可以使用不同的命令行参数来控制执行迭代的次数，并发用户数等等。它的一个特点是可以周期性地打印出处理过程的信息，而其它工具只能给出一个全局的报告。</span></p>
<p><span style="color: #0000ff">2.压力测试工具介绍</span></p>
<p><span style="color: #0000ff">三. 外部环境的调整<br />
在Tomcat 和应用程序进行了压力测试后，如果您对应用程序的性能结果不太满意，就可以采取一些性能调整措施了，当然了前提是应用程序没有问题，我们这里只讲 Tomcat的调整。由于Tomcat的运行依赖于JVM，所以在这里我们把Tomcat的调整可以分为两类来详细描述：</span></p>
<p><span style="color: #0000ff">　　外部环境调整 </span></p>
<p><span style="color: #0000ff">　　调整非Tomcat组件，例如Tomcat运行的操作系统和运行Tomcat的java虚拟机。</span></p>
<p><span style="color: #0000ff">　　自身调整 </span></p>
<p><span style="color: #0000ff">　　修改Tomcat自身的参数，调整Tomcat配置文件中的参数。</span></p>
<p><span style="color: #0000ff">　　下面我们将详细讲解外部环境调整的有关内容，Tomcat自身调整的内容将在第2部分中阐述。1.JAVA虚拟机性能优化</span></p>
<p><span style="color: #0000ff">　　Tomcat本身不能直接在计算机上运行，需要依赖于硬件基础之上的操作系统和一个java虚拟机。您可以选择自己的需要选择不同的操作系统和对应的 JDK的版本（只要是符合Sun发布的Java规范的），但我们推荐您使用Sun公司发布的JDK。确保您所使用的版本是最新的，因为Sun公司和其它一些公司一直在为提高性能而对java虚拟机做一些升级改进。一些报告显示JDK1.4在性能上比JDK1.3提高了将近10%到20%。</span></p>
<p><span style="color: #0000ff">　　可以给Java虚拟机设置使用的内存，但是如果你的选择不对的话，虚拟机不会补偿。可通过命令行的方式改变虚拟机使用内存的大小。如下表所示有两个参数用来设置虚拟机使用内存的大小。<br />
参数<br />
&nbsp;描述<br />
&nbsp;<br />
-Xms&lt;size&gt;<br />
&nbsp;JVM初始化堆的大小<br />
&nbsp;<br />
-Xmx&lt;size&gt;<br />
&nbsp;JVM堆的最大值<br />
&nbsp;</span></p>
<p><br />
<span style="color: #0000ff">　　这两个值的大小一般根据需要进行设置。初始化堆的大小执行了虚拟机在启动时向系统申请的内存的大小。一般而言，这个参数不重要。但是有的应用程序在大负载的情况下会急剧地占用更多的内存，此时这个参数就是显得非常重要，如果虚拟机启动时设置使用的内存比较小而在这种情况下有许多对象进行初始化，虚拟机就必须重复地增加内存来满足使用。由于这种原因，我们一般把-Xms和-Xmx设为一样大，而堆的最大值受限于系统使用的物理内存。一般使用数据量较大的应用程序会使用持久对象，内存使用有可能迅速地增长。当应用程序需要的内存超出堆的最大值时虚拟机就会提示内存溢出，并且导致应用服务崩溃。因此一般建议堆的最大值设置为可用内存的最大值的80%。</span></p>
<p><span style="color: #0000ff">　　Tomcat默认可以使用的内存为128MB，在较大型的应用项目中，这点内存是不够的，需要调大。</span></p>
<p><span style="color: #0000ff">　　Windows下，在文件{tomcat_home}/bin/catalina.bat，Unix下，在文件{tomcat_home}/bin/catalina.sh的前面，增加如下设置：</span></p>
<p><span style="color: #0000ff">　　JAVA_OPTS='-Xms【初始化内存大小】 -Xmx【可以使用的最大内存】'</span></p>
<p><span style="color: #0000ff">　　需要把这个两个参数值调大。例如：</span></p>
<p><span style="color: #0000ff">　　JAVA_OPTS='-Xms256m -Xmx512m'</span></p>
<p><span style="color: #0000ff">　　表示初始化内存为256MB，可以使用的最大内存为512MB。</span></p>
<p><span style="color: #0000ff">　　另外需要考虑的是Java提供的垃圾回收机制。虚拟机的堆大小决定了虚拟机花费在收集垃圾上的时间和频度。收集垃圾可以接受的速度与应用有关，应该通过分析实际的垃圾收集的时间和频率来调整。如果堆的大小很大，那么完全垃圾收集就会很慢，但是频度会降低。如果你把堆的大小和内存的需要一致，完全收集就很快，但是会更加频繁。调整堆大小的的目的是最小化垃圾收集的时间，以在特定的时间内最大化处理客户的请求。在基准测试的时候，为保证最好的性能，要把堆的大小设大，保证垃圾收集不在整个基准测试的过程中出现。</span></p>
<p><span style="color: #0000ff">　　如果系统花费很多的时间收集垃圾，请减小堆大小。一次完全的垃圾收集应该不超过 3-5 秒。如果垃圾收集成为瓶颈，那么需要指定代的大小，检查垃圾收集的详细输出，研究 垃圾收集参数对性能的影响。一般说来，你应该使用物理内存的 80% 作为堆大小。当增加处理器时，记得增加内存，因为分配可以并行进行，而垃圾收集不是并行的。</span></p>
<p><span style="color: #0000ff">2.操作系统性能优化</span></p>
<p><span style="color: #0000ff">　　这里说的操作系统是指运行web服务器的系统软件，当然，不同的操作系统是为不同的目的而设计的。比如OpenBSD是面向安全的，因此在它的内核中有许多的限制来防止不同形式的服务攻击（OpenBSD的一句座右铭是&#8220;默认是最安全的&#8221;）。这些限制或许更多地用来运行活跃的web服务器。</span></p>
<p><span style="color: #0000ff">　　而我们常用的Linux操作系统的目标是易用使用，因此它有着更高的限制。使用BSD内核的系统都带有一个名为&#8220;Generic&#8221;的内核，表明所有的驱动器都静态地与之相连。这样就使系统易于使用，但是如果你要创建一个自定义的内核来加强其中某些限制，那就需要排除不需要的设备。Linux内核中的许多驱动都是动态地加载的。但是换而言之，内存现在变得越来越便宜，所以因为加载额外的设备驱动就显得不是很重要的。重要的是要有更多的内存，并且在服务器上腾出更多的可用内存。</span></p>
<p><span style="color: #0000ff">　　小提示：虽然现在内存已经相当的便宜，但还是尽量不要购买便宜的内存。那些有牌子的内存虽然是贵一点，但是从可靠性上来说，性价比会更高一些。</span></p>
<p><span style="color: #0000ff">　　如果是在Windows操作系统上使用Tomcat，那么最好选择服务器版本。因为在非服务器版本上，最终用户授权数或者操作系统本身所能承受的用户数、可用的网络连接数或其它方面的一些方面都是有限制的。并且基于安全性的考虑，必须经常给操作系统打上最新的补丁。</span></p>
<p><span style="color: #0000ff">　　3.Tomcat与其它web服务器整合使用</span></p>
<p><span style="color: #0000ff">　　虽然tomcat也可以作web服务器,但其处理静态html的速度比不上apache,且其作为web服务器的功能远不如apache,因此我们想把 apache和tomcat集成起来，将html与jsp的功能部分进行明确分工，让tomcat只处理jsp部分，其它的由apache,IIS等这些 web服务器处理，由此大大节省了tomcat有限的工作&#8220;线程&#8221;。</span></p>
<p><span style="color: #0000ff">　　4.负载均衡</span></p>
<p><span style="color: #0000ff">　　在负载均衡的思路下，多台服务器为对称方式，每台服务器都具有同等的地位，可以单独对外提供服务而无须其他服务器的辅助。通过负载分担技术，将外部发送来的请求按一定规则分配到对称结构中的某一台服务器上，而接收到请求的服务器都独立回应客户机的请求。</span></p>
<p><span style="color: #0000ff">　　提供服务的一组服务器组成了一个应用服务器集群(cluster)，并对外提供一个统一的地址。当一个服务请求被发至该集群时，根据一定规则选择一台服务器，并将服务转定向给该服务器承担，即将负载进行均衡分摊。</span></p>
<p><span style="color: #0000ff">　　通过应用负载均衡技术，使应用服务超过了一台服务器只能为有限用户提供服务的限制，可以利用多台服务器同时为大量用户提供服务。当某台服务器出现故障时，负载均衡服务器会自动进行检测并停止将服务请求分发至该服务器，而由其他工作正常的服务器继续提供服务，从而保证了服务的可靠性。</span></p>
<p><span style="color: #0000ff">　　负载均衡实现的方式大概有四种：第一是通过DNS，但只能实现简单的轮流分配，不能处理故障，第二如果是基于MS IIS，Windows 2003 server本身就带了负载均衡服务，第三是硬件方式，通过交换机的功能或专门的负载均衡设备可以实现，第四种是软件方式，通过一台负载均衡服务器进行，上面安装软件。使用Apache Httpd Server做负载平衡器，Tomcat集群节点使用Tomcat就可以做到以上第四种方式。这种方式比较灵活，成本相对也较低。另外一个很大的优点就是可以根据应用的情况和服务器的情况采取一些策略。 </span></p>
<p><span style="color: #0000ff">四. 自身调整<br />
本节将向您详细介绍一些加速可使Tomcat实例加速运行的技巧和方法，无论是在什么操作系统或者何种Java虚拟机上。在有些情况下，您可能没有控制部署环境上的操作系统或者Java虚拟机。在这种情况下，您就需要逐行了解以下的的一些建议，然而你应该在修改后使之生效。我认为以下方法是Tomcat性能自身调整的最佳方式。</span></p>
<p><span style="color: #0000ff">　　1.禁用DNS查询</span></p>
<p><span style="color: #0000ff">　　当web应用程序向要记录客户端的信息时，它也会记录客户端的IP地址或者通过域名服务器查找机器名转换为IP地址。DNS查询需要占用网络，并且包括可能从很多很远的服务器或者不起作用的服务器上去获取对应的IP的过程，这样会消耗一定的时间。为了消除DNS查询对性能的影响我们可以关闭DNS查询，方式是修改server.xml文件中的enableLookups参数值：</span></p>
<p><br />
<span style="color: #0000ff">Tomcat4</span></p>
<p><span style="color: #0000ff">&lt;Connector className="org.apache.coyote.tomcat4.CoyoteConnector" port="80" minProcessors="5" maxProcessors="75" enableLookups="false" redirectPort="8443" acceptCount="100" debug="0" connectionTimeout="20000" useURIValidationHack="false" disableUploadTimeout="true" /&gt;</span></p>
<p><span style="color: #0000ff">Tomcat5</span></p>
<p><span style="color: #0000ff">&lt;Connector port="80" maxThreads="150" minSpareThreads="25" maxSpareThreads="75" enableLookups="false" redirectPort="8443" acceptCount="100" debug="0" connectionTimeout="20000" disableUploadTimeout="true"/&gt;</span></p>
<p><br />
<span style="color: #0000ff">　　除非你需要连接到站点的每个HTTP客户端的机器名，否则我们建议在生产环境上关闭DNS查询功能。可以通过Tomcat以外的方式来获取机器名。这样不仅节省了网络带宽、查询时间和内存，而且更小的流量会使日志数据也会变得更少，显而易见也节省了硬盘空间。对流量较小的站点来说禁用DNS查询可能没有大流量站点的效果明显，但是此举仍不失为一良策。谁又见到一个低流量的网站一夜之间就流量大增呢？</span></p>
<p><span style="color: #0000ff">　　2.调整线程数</span></p>
<p><span style="color: #0000ff">　　另外一个可通过应用程序的连接器（Connector）进行性能控制的的参数是创建的处理请求的线程数。Tomcat使用线程池加速响应速度来处理请求。在 Java中线程是程序运行时的路径，是在一个程序中与其它控制线程无关的、能够独立运行的代码段。它们共享相同的地址空间。多线程帮助程序员写出CPU最大利用率的高效程序，使空闲时间保持最低，从而接受更多的请求。</span></p>
<p><span style="color: #0000ff">　　Tomcat4中可以通过修改minProcessors和 maxProcessors的值来控制线程数。这些值在安装后就已经设定为默认值并且是足够使用的，但是随着站点的扩容而改大这些值。 minProcessors服务器启动时创建的处理请求的线程数应该足够处理一个小量的负载。也就是说，如果一天内每秒仅发生5次单击事件，并且每个请求任务处理需要1秒钟，那么预先设置线程数为5就足够了。但在你的站点访问量较大时就需要设置更大的线程数，指定为参数maxProcessors的值。 maxProcessors的值也是有上限的，应防止流量不可控制（或者恶意的服务攻击），从而导致超出了虚拟机使用内存的大小。如果要加大并发连接数，应同时加大这两个参数。web server允许的最大连接数还受制于操作系统的内核参数设置，通常Windows是2000个左右，Linux是1000个左右。</span></p>
<p><span style="color: #0000ff">　　在Tomcat5对这些参数进行了调整，请看下表：<br />
属性名<br />
&nbsp;描述<br />
&nbsp;<br />
maxThreads<br />
&nbsp;Tomcat使用线程来处理接收的每个请求。这个值表示Tomcat可创建的最大的线程数。<br />
&nbsp;<br />
acceptCount <br />
&nbsp;指定当所有可以使用的处理请求的线程数都被使用时，可以放到处理队列中的请求数，超过这个数的请求将不予处理。<br />
&nbsp;<br />
connnectionTimeout <br />
&nbsp;网络连接超时，单位：毫秒。设置为0表示永不超时，这样设置有隐患的。通常可设置为30000毫秒。<br />
&nbsp;<br />
minSpareThreads <br />
&nbsp;Tomcat初始化时创建的线程数。<br />
&nbsp;<br />
maxSpareThreads <br />
&nbsp;一旦创建的线程超过这个值，Tomcat就会关闭不再需要的socket线程。<br />
&nbsp;</span></p>
<p><br />
<span style="color: #0000ff">　　最好的方式是多设置几次并且进行测试，观察响应时间和内存使用情况。在不同的机器、操作系统或虚拟机组合的情况下可能会不同，而且并不是所有人的web站点的流量都是一样的，因此没有一刀切的方案来确定线程数的值。</span></p>
<p><br />
<span style="color: #0000ff">3.加速JSP编译速度</span></p>
<p><span style="color: #0000ff">　　当第一次访问一个JSP文件时，它会被转换为Java serverlet源码，接着被编译成Java字节码。你可以控制使用哪个编译器，默认情况下，Tomcat使用使用命令行javac进行使用的编译器。也可以使用更快的编译器，但是这里我们将介绍如何优化它们。</span></p>
<p><span style="color: #0000ff">　　另外一种方法是不要把所有的实现都使用JSP页面，而是使用一些不同的java模板引擎变量。显然这是一个跨越很大的决定，但是事实证明至少这种方法是只得研究的。如果你想了解更多有关在Tomcat可使用的模板语言，你可以参考Jason Hunter和William Crawford合著的《Java Servlet Programming 》一书（O'Reilly公司出版）。</span></p>
<p><span style="color: #0000ff">　　在Tomcat 4.0中可以使用流行而且免费的Jikes编译器。Jikes编译器的速度要由于Sun的Java编译器。首先要安装Jikes（可访问</span><a href="http://oss.software.ibm.com/pub/jikes"><span style="color: #0000ff">http://oss.software.ibm.com/pub/jikes</span></a><span style="color: #0000ff"> 获得更多的信息），接着需要在环境变量中设置JIKESPATH包含系统运行时所需的JAR文件。装好Jikes以后还需要设置让JSP编译servlet使用Jikes，需要修改web.xml文件中jspCompilerPlugin的值：</span></p>
<p><br />
<span style="color: #0000ff">&lt;servlet&gt;<br />
&lt;servlet-name&gt;jsp&lt;/servlet-name&gt;<br />
&lt;servlet-class&gt;<br />
org.apache.jasper.servlet.JspServlet<br />
&lt;/servlet-class&gt;&lt;init-param&gt;<br />
&lt;param-name&gt;logVerbosityLevel&lt;/param-name&gt;<br />
&lt;param-value&gt;WARNING&lt;/param-value&gt;<br />
&lt;/init-param&gt;<br />
&lt;init-param&gt;<br />
&lt;param-name&gt;jspCompilerPlugin&lt;/param-name&gt;<br />
&lt;param-value&gt;<br />
org.apache.jasper.compiler.JikesJavaCompiler<br />
&lt;/param-value&gt;<br />
&lt;/init-param&gt;<br />
&lt;init-param&gt;<br />
&lt;!-- &lt;param-name&gt;<br />
org.apache.catalina.jsp_classpath<br />
&lt;/param-name&gt; --&gt;<br />
&lt;param-name&gt;classpath&lt;/param-name&gt;<br />
&lt;param-value&gt;<br />
/usr/local/jdk1.3.1-linux/jre/lib/rt.jar:<br />
/usr/local/lib/java/servletapi/servlet.ja<br />
r&lt;/param-value&gt;<br />
&lt;/init-param&gt;<br />
&lt;load-on-startup&gt;3&lt;/load-on-startup&gt;<br />
&lt;/servlet&gt;</span></p>
<p><br />
<span style="color: #0000ff">　　在Tomcat 4.1（或更高版本），JSP的编译由包含在Tomcat里面的Ant程序控制器直接执行。这听起来有一点点奇怪，但这正是Ant有意为之的一部分，有一个API文档指导开发者在没有启动一个新的JVM的情况下，使用Ant。这是使用Ant进行Java开发的一大优势。另外，这也意味着你现在能够在Ant 中使用任何javac支持的编译方式，这里有一个关于Apache Ant使用手册的javac page列表。使用起来是容易的，因为你只需要在元素中定义一个名字叫&#8220;compiler&#8221;，并且在value中有一个支持编译的编译器名字，示例如下：</span></p>
<p><br />
<span style="color: #0000ff">&lt;servlet&gt;<br />
&lt;servlet-name&gt;jsp&lt;/servlet-name&gt;<br />
&lt;servlet-class&gt;<br />
org.apache.jasper.servlet.JspServlet<br />
&lt;/servlet-class&gt;<br />
&lt;init-param&gt;<br />
&lt;param-name&gt;logVerbosityLevel&lt;/param-name&gt;<br />
&lt;param-value&gt;WARNING&lt;/param-value&gt;<br />
&lt;/init-param&gt;<br />
&lt;init-param&gt;<br />
&lt;param-name&gt;compiler&lt;/param-name&gt;<br />
&lt;param-value&gt;jikes&lt;/param-value&gt;<br />
&lt;/init-param&gt;<br />
&lt;load-on-startup&gt;3&lt;/load-on-startup&gt;<br />
&lt;/servlet&gt;</span></p>
<p><span style="color: #0000ff">&nbsp;</span></p>
<p><span style="color: #0000ff">Ant可用的编译器<br />
名称<br />
&nbsp;别名<br />
&nbsp;调用的编译器<br />
&nbsp;<br />
classic <br />
&nbsp;javac1.1, javac1.2 <br />
&nbsp;Standard JDK 1.1/1.2 compiler <br />
&nbsp;<br />
modern <br />
&nbsp;javac1.3, javac1.4 <br />
&nbsp;Standard JDK 1.3/1.4 compiler <br />
&nbsp;<br />
jikes <br />
&nbsp;　　 The Jikes compiler <br />
&nbsp;<br />
JVC Microsoft <br />
&nbsp;Microsoft command-line compiler from the Microsoft SDK for Java/Visual J++ <br />
&nbsp;<br />
KJC 　　 The kopi compiler <br />
&nbsp;<br />
GCJ 　　 The gcj compiler (included as part of gcc) <br />
&nbsp;<br />
SJ Symantec <br />
&nbsp;Symantec's Java compiler <br />
&nbsp;<br />
extJavac<br />
&nbsp;　　 Runs either the modern or classic compiler in a JVM of its own <br />
&nbsp;</span></p>
<p><br />
<span style="color: #0000ff">　　由于JSP页面在第一次使用时已经被编译，那么你可能希望在更新新的jsp页面后马上对它进行编译。实际上，这个过程完全可以自动化，因为可以确认的是新的JSP页面在生产服务器和在测试服务器上的运行效果是一样的。 </span></p>
<p><span style="color: #0000ff">在Tomcat4的bin目录下有一个名为jspc的脚本。它仅仅是运行翻译阶段，而不是编译阶段，使用它可以在当前目录生成Java源文件。它是调试JSP页面的一种有力的手段。</span></p>
<p><span style="color: #0000ff">　　可以通过浏览器访问再确认一下编译的结果。这样就确保了文件被转换成serverlet，被编译了可直接执行。这样也准确地模仿了真实用户访问JSP页面，可以看到给用户提供的功能。也抓紧这最后一刻修改出现的bug并且修改它J</span></p>
<p><span style="color: #0000ff">　　Tomcat提供了一种通过请求来编译JSP页面的功能。例如，你可以在浏览器地址栏中输入</span><a href="http://localhost:8080/examples/jsp/dates/date.jsp?jsp_precompile=true"><span style="color: #0000ff">http://localhost:8080/examples/jsp/dates/date.jsp?jsp_precompile=true</span></a><span style="color: #0000ff">，这样Tomcat就会编译data.jsp而不是执行它。此举唾手可得，不失为一种检验页面正确性的捷径。</span></p>
<p><span style="color: #0000ff">　　4. 其它</span></p>
<p><span style="color: #0000ff">　　前面我们提到过操作系统通过一些限制手段来防止恶意的服务攻击，同样Tomcat也提供了防止恶意攻击或禁止某些机器访问的设置。</span></p>
<p><span style="color: #0000ff">　　Tomcat提供了两个参数供你配置：RemoteHostValve 和RemoteAddrValve。 </span></p>
<p><span style="color: #0000ff">　　通过配置这两个参数，可以让你过滤来自请求的主机或IP地址，并允许或拒绝哪些主机/IP。与之类似的，在Apache的httpd文件里有对每个目录的允许/拒绝指定。 </span></p>
<p><span style="color: #0000ff">　　例如你可以把Admin Web application设置成只允许本地访问，设置如下：</span></p>
<p><br />
<span style="color: #0000ff">&lt;Context path="/path/to/secret_files" ...&gt; <br />
&lt;Valve className="org.apache.catalina.valves.RemoteAddrValve" </span></p>
<p><span style="color: #0000ff">allow="127.0.0.1" deny=""/&gt; <br />
&lt;/Context&gt;</span></p>
<p><br />
<span style="color: #0000ff">　　如果没有给出允许主机的指定，那么与拒绝主机匹配的主机就会被拒绝，除此之外的都是允许的。与之类似，如果没有给出拒绝主机的指定，那么与允许主机匹配的主机就会被允许，除此之外的都是拒绝的。</span></p>
<p><span style="color: #0000ff">五. 容量计划<br />
　容量计划是在生产环境中使用Tomcat不得不提的提高性能的另一个重要的话题。如果你没有对预期的网络流量下的硬件和带宽做考虑的话那么无论你如何做配置修改和测试都无济于事。</span></p>
<p><span style="color: #0000ff">　　这里先对提及的容量计划作一个简要的定义：容量计划是指评估硬件、操作系统和网络带宽，确定应用服务的服务范围，寻求适合需求和软件特性的软硬件的一项活动。因此这里所说的软件不仅包括Tomcat，也包括与Tomcat结合使用的任何第三方web服务器软件。</span></p>
<p><span style="color: #0000ff">　　如果在购买软硬件或部署系统前你对容量计划一无所知，不知道现有的软硬件环境能够支撑多少的访问量，甚至更糟直到你已经交付并且在生产环境上部署产品后才意识到配置有问题时再进行变更可能为时已晚。此时只能增加硬件投入，增加硬盘容量甚至购买更好的服务器。如果事先做了容量计划那么就不会搞的如此焦头烂额了。</span></p>
<p><span style="color: #0000ff">　　我们这里只介绍与Tomcat相关的内容。</span></p>
<p><span style="color: #0000ff">　　首先为了确定Tomcat使用机器的容量计划，你应该从一下列表项目种着手研究和计划：</span></p>
<p><span style="color: #0000ff">　　1. 硬件</span></p>
<p><span style="color: #0000ff">　　采用什么样的硬件体系？需要多少台计算机？使用一个大型的，还是使用多台小型机？每个计算机上使用几个CPU？使用多少内存？使用什么样的存储设备， I/O的处理速度有什么要求？怎样维护这些计算机？不同的JVM在这些硬件上运行的效果如何（比如IBM AIX系统只能在其设计的硬件系统上运行）？</span></p>
<p><span style="color: #0000ff">　　2. 网络带宽</span></p>
<p><span style="color: #0000ff">　　带宽的使用极限是多少？web应用程序如何处理过多的请求？</span></p>
<p><span style="color: #0000ff">　　3. 服务端操作系统</span></p>
<p><span style="color: #0000ff">　　采用哪种操作系统作为站点服务器最好？在确定的操作系统上使用哪个JVM最好？例如，JVM在这种系统上是否支持本地多线程，对称多处理？哪种系统可使web服务器更快、更稳定，并且更便宜。是否支持多CPU？ <br />
4. Tomcat容量计划</span></p>
<p><span style="color: #0000ff">　　以下介绍针对Tomcat做容量计划的步骤：</span></p>
<p><span style="color: #0000ff">　　1） 量化负载。如果站点已经建立并运行，可以使用前面介绍的工具模仿用户访问，确定资源的需求量。</span></p>
<p><span style="color: #0000ff">　　2） 针对测试结果或测试过程中进行分析。需要知道那些请求造成了负载过重或者使用过多的资源，并与其它请求做比较，这样就确定了系统的瓶颈所在。例如：如果servlet在查询数据库的步骤上耗用较长的时间，那么就需要考虑使用缓冲池来降低响应时间。</span></p>
<p><span style="color: #0000ff">　　3）确定性能最低标准。例如，你不想让用户花20秒来等待结果页面的返回，也就是说甚至在达到访问量的极限时，用户等待的时间也不能超过20秒种（从点击链接到看到返第一条返回数据）。这个时间中包含了数据库查询时间和文件访问时间。同类产品性能在不同的公司可能有不同的标准，一般最好采取同行中的最低标准或对这个标准做出评估。</span></p>
<p><span style="color: #0000ff">　　4）确定如何合理使用底层资源，并逐一进行测试。底层资源包括CPU、内存、存储器、带宽、操作系统、JVM等等。在各种生产环境上都按顺序进行部署和测试，观察是否符合需求。在测试Tomcat时尽量多采用几种JVM，并且调整JVM使用内存和Tomcat线程池的大小进行测试。同时为了达到资源充分合理稳定地使用的效果，还需针对测试过程中出现的硬件系统瓶颈进行处理确定合理的资源配置。这个过程最为复杂，而且一般由于没有可参考的值所以只能靠理论推断和经验总结。</span></p>
<p><span style="color: #0000ff">　　5） 如果通过第4步的反复测试如果达到了最优的组合，就可以在相同的生产环境上部署产品了。</span></p>
<p><span style="color: #0000ff">　　此外应牢记一定要文档化你的测试过程和结果，因为此后可能还会进行测试，这样就可以拿以前的测试结果做为参考。另外测试过程要反复多次进行，每次的条件可能都不一样，因此只有记录下来才能进行结果比较和最佳条件的选择。</span></p>
<p><span style="color: #0000ff">　　这样我们通过测试找到了最好的组合方式，各种资源得到了合理的配置，系统的性能得到了极大的提升。</span></p>
<p><span style="color: #0000ff">六. 附加资料<br />
　很显然本文也很难全面而详尽地阐述性能优化过程。如果你进行更多研究的话可能会把性能调优做的更好，比如Java程序的性能调整、操作系统的调整、各种复杂环境与应用系统和其它所有与应用程序相关的东西。在这里提供一些文中提到的一些资源、文中提到的相关内容的链接以及本文的一些参考资料。</span></p>
<p><span style="color: #0000ff">　　1. Web性能测试资料及工具</span></p>
<p><span style="color: #0000ff">　　1） Jmeter Wiki首页，Jmeter为一个开源的100%Java开发的性能测试工具<br />
　　</span><a href="http://wiki.apache.org/jakarta-jmeter/"><span style="color: #0000ff">http://wiki.apache.org/jakarta-jmeter/</span></a></p>
<p><span style="color: #0000ff">　　2） Apache Benchmark使用说明<br />
　　</span><a href="http://httpd.apache.org/docs-2.0/programs/ab.html"><span style="color: #0000ff">http://httpd.apache.org/docs-2.0/programs/ab.html</span></a></p>
<p><span style="color: #0000ff">　　3） 一些Java相关测试工具的介绍，包含可以与Tomcat集成进行测试的工具<br />
　　</span><a href="http://blog.csdn.net/wyingquan/"><span style="color: #0000ff">http://blog.csdn.net/wyingquan/</span></a></p>
<p><span style="color: #0000ff">　　4） LoadRunner? 是一种预测系统行为和性能的工业标准级负载测试工具。它通过模拟数据以千万计用户来实施并发负载来对整个企业架构进行测试，来帮助您更快的查找和发现问题。<br />
　　</span><a href="http://www.mercury.com/us/products/performance-center/loadrunner/"><span style="color: #0000ff">http://www.mercury.com/us/products/performance-center/loadrunner/</span></a></p>
<p><br />
<span style="color: #0000ff">　　2. 文中介绍的相关内容的介绍</span></p>
<p><span style="color: #0000ff">　　1） Apache 2.x + Tomcat 4.x做负载均衡，描述了如何利用jk配置集群的负载均衡。<br />
　　</span><a href="http://raibledesigns.com/tomcat/index.html"><span style="color: #0000ff">http://raibledesigns.com/tomcat/index.html</span></a></p>
<p><span style="color: #0000ff">　　2） 容量计划的制定，收集了许多有关制定web站点容量计划的例子：<br />
　　</span><a href="http://www.capacityplanning.com/"><span style="color: #0000ff">http://www.capacityplanning.com/</span></a></p>
<p><span style="color: #0000ff">　　3） 评测Tomcat5负载平衡与集群，<br />
　　</span><a href="http://www.javaresearch.org/article/showarticle.jsp?column=556&amp;thread=19777"><span style="color: #0000ff">http://www.javaresearch.org/article/showarticle.jsp?column=556&amp;thread=19777</span></a></p>
<p><span style="color: #0000ff">　　4） Apache与Tomcat的安装与整合之整合篇<br />
　　</span><a href="http://www.javaresearch.org/article/showarticle.jsp?column=23&amp;thread=18139"><span style="color: #0000ff">http://www.javaresearch.org/article/showarticle.jsp?column=23&amp;thread=18139</span></a></p>
<p><span style="color: #0000ff">　　5） 性能测试工具之研究，介绍了性能测试工具的原理与思路<br />
　　</span><a href="http://www.51testing.com/emagzine/No2_2.htm"><span style="color: #0000ff">http://www.51testing.com/emagzine/No2_2.htm</span></a></p>
<p><span style="color: #0000ff">　　6） Java的内存泄漏<br />
　　</span><a href="http://www.matrix.org.cn/resource/article/409.html"><span style="color: #0000ff">http://www.matrix.org.cn/resource/article/409.html</span></a></p>
<p><span style="color: #0000ff">　　7） Web服务器和应用程序服务器有什么区别？<br />
　　</span><a href="http://www.matrix.org.cn/resource/article/1429.html"><span style="color: #0000ff">http://www.matrix.org.cn/resource/article/1429.html</span></a></p>
<p><span style="color: #0000ff">　　8） 详细讲解性能中数据库集群的问题<br />
　　</span><a href="http://www.theserverside.com/articles/article.tss?l=DB_Break"><span style="color: #0000ff">http://www.theserverside.com/articles/article.tss?l=DB_Break</span></a><span style="color: #0000ff">&nbsp; </span></p>
</div>
<img src ="http://www.blogjava.net/sutao/aggbug/162665.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/sutao/" target="_blank">苏醄</a> 2007-11-23 16:27 <a href="http://www.blogjava.net/sutao/articles/162665.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>Tomcat集群与负载均衡</title><link>http://www.blogjava.net/sutao/articles/161873.html</link><dc:creator>苏醄</dc:creator><author>苏醄</author><pubDate>Tue, 20 Nov 2007 07:42:00 GMT</pubDate><guid>http://www.blogjava.net/sutao/articles/161873.html</guid><wfw:comment>http://www.blogjava.net/sutao/comments/161873.html</wfw:comment><comments>http://www.blogjava.net/sutao/articles/161873.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/sutao/comments/commentRss/161873.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/sutao/services/trackbacks/161873.html</trackback:ping><description><![CDATA[<h1 id="pageName">Tomcat集群与负载均衡</h1>
<div class="feature">　　在单一的<a href="http://www.pcdog.com/net/3566/index.html" target="_blank">服务器</a>上执行WEB应用程序有一些重大的问题，当<nobr oncontextmenu="return false;" onmousemove="kwM(1);" id="key1" onmouseover="kwE(event,1, this);" style="color: rgb(102,0,255); border-bottom: rgb(102,0,255) 1px dotted; background-color: transparent; text-decoration: underline" onclick="return kwC();" onmouseout="kwL(event, this);" target="_blank">网站</nobr>成功建成并开始接受大量请求时，单一<nobr oncontextmenu="return false;" onmousemove="kwM(0);" id="key0" onmouseover="kwE(event,0, this);" style="color: rgb(102,0,255); border-bottom: 0px dotted; background-color: transparent; text-decoration: underline" onclick="return kwC();" onmouseout="kwL(event, this);" target="_blank">服务</nobr>器终究无法满足需要处理的负荷量，所以就有点显得有点力不从心了。另外一个常见的问题是会产生单点故障，如果该服务器坏掉，那么网站就立刻无法运作了。 </div>
<div class="story">
<div class="ad0">不论是因为要有较佳的扩充性还是容错能力，我们都会想在一台以上的服务器计算机上执行WEB应用程序。所以，这时候我们就需要用到<a href="http://www.pcdog.com/special/1128/index.html" target="_blank">集群</a>这一门技术了。<br />
<br />
在进入集群<a href="http://www.pcdog.com/net/3655/index.html" target="_blank">系统</a>架构探讨之前，先定义一些专门术语：<br />
1. 集群(Cluster)：是一组独立的计算机系统构成一个松耦合的多<a href="http://www.pcdog.com/net/3033/index.html" target="_blank">处理器</a>系统，它们之间通过网络实现进程间的通信。应用程序可以通过网络<a href="http://www.pcdog.com/net/3569/index.html" target="_blank">共享内存</a>进行消息传送，实现分布式计算机。 <br />
2. 负载均衡(Load Balance)：先得从集群讲起，集群就是一组连在一起的计算机，从外部看它是一个系统，各节点可以是不同的<a href="http://www.pcdog.com/special/1108/index.html" target="_blank">操作系统</a>或不同硬件构成的计算机。如一个提供Web服务的集群，对外界来看是一个大<a href="http://www.pcdog.com/net/454/index.html" target="_blank">Web服务器</a>。不过集群的节点也可以单独提供服务。<br />
3. 特点：在现有网络结构之上，负载均衡提供了一种廉价有效的方法扩展服务器带宽和增加吞吐量，加强网络数据处理能力，提高网络的灵活性和可用性。集群系统(Cluster)主要<nobr oncontextmenu="return false;" onmousemove="kwM(2);" id="key2" onmouseover="kwE(event,2, this);" style="color: rgb(102,0,255); border-bottom: rgb(102,0,255) 1px dotted; background-color: transparent; text-decoration: underline" onclick="return kwC();" onmouseout="kwL(event, this);" target="_blank">解决</nobr>下面几个问题： <br />
高可靠性（HA）：利用集群管理软件，当主<a href="http://www.pcdog.com/net/z3727/index.html" target="_blank">服务器故障</a>时，<a href="http://www.pcdog.com/net/3555/index.html" target="_blank">备份</a>服务器能够自动接管主服务器的工作，并及时切换过去，以实现对用户的不间断服务。<br />
高性能计算（HP）：即充分利用集群中的每一台计算机的资源，实现复杂运算的并行处理，通常用于科学计算领域，比如基因分析，化学分析等。 <br />
负载平衡：即把负载压力根据某种算法合理分配到集群中的每一台计算机上，以减轻主服务器的压力，降低对主服务器的硬件和软件要求。<br />
<br />
目前比较常用的负载均衡技术主要有： <br />
　　1. 基于<a href="http://www.pcdog.com/net/507/index.html" target="_blank">DNS</a>的负载均衡 <br />
　　通过DNS服务中的随机名字解析来实现负载均衡，在<a href="http://www.pcdog.com/net/508/index.html" target="_blank">DNS服务器</a>中，可以为多个不同的地址配置同一个名字，而最终查询这个名字的客户机将在解析这个名字时得到其中一个地址。因此，对于同一个名字，不同的客户机会得到不同的地址，他们也就访问不同地址上的Web服务器，从而达到负载均衡的目的。 <br />
<br />
　　2. 反向代理负载均衡 （如Apache+JK2+Tomcat这种组合）<br />
　　使用<a href="http://www.pcdog.com/special/1040/index.html" target="_blank">代理服务器</a>可以将请求转发给内部的Web服务器，让代理服务器将请求均匀地转发给多台内部Web服务器之一上，从而达到负载均衡的目的。这种代理方式与普通的代理方式有所不同，标准代理方式是客户使用代理访问多个外部Web服务器，而这种代理方式是多个客户使用它访问内部Web服务器，因此也被称为反向代理模式。<br />
<br />
　　3. 基于NAT（Network Address Translation）的负载均衡技术 （如<a href="http://www.pcdog.com/special/1193/index.html" target="_blank">Linux</a> Virtual Server，简称LVS）<br />
　　网络<a href="http://www.pcdog.com/net/355/index.html" target="_blank">地址转换</a>为在内部地址和外部地址之间进行转换，以便具备内部地址的计算机能访问外部网络，而当外部网络中的计算机访问地址转换<a href="http://www.pcdog.com/net/3334/index.html" target="_blank">网关</a>拥有的某一外部地址时，地址转换网关能将其转发到一个映射的内部地址上。因此如果地址转换网关能将每个连接均匀转换为不同的内部服务器地址，此后外部网络中的计算机就各自与自己转换得到的地址上服务器进行通信，从而达到负载分担的目的。<br />
<br />
介绍完上面的<a href="http://www.pcdog.com/special/1144/index.html" target="_blank">集群技术</a>之后，下面就基于Tomcat的集群架构方案进行说明：<br />
<br />
上面是采用了Apache httpd作为web服务器的，即作为Tomcat的前端处理器，根据具体情况而定，有些情况下是不需要Apache httpd作为 web 服务器的，如系统展现没有静态页面那就不需要Apache httpd，那时可以直接使用Tomcat作为web 服务器来使用。使用Apache httpd主要是它在处理静态页面方面的能力比Tomcat强多了。<br />
1、 用户的网页浏览器做完本地 DNS和企业授权的DNS之的请求/响应后，这时候企业授权的DNS（即21cn BOSS DNS）会给用户本地的DNS服务器提供一个NAT请求分配器（即网关）IP。<br />
<br />
2、 NAT分配器，它会根据特定的分配算法，来决定要将连接交给哪一台内部 Apache httpd来处理请求。大多数的NAT请求分配器提供了容错能力：根据侦测各种WEB服务器的失效状况，停止将请求分配给已经宕掉的服务器。并且有些分配器还可以监测到WEB服务器机器的负载情况，并将请求分配给负载最轻的服务器等等。Linux Virtual Server是一个基于Linux操作系统上执行的VS-NAT开源软件套件，而且它有丰富的功能和良好的说明文件。商业硬件<a href="http://www.pcdog.com/special/1142/index.html" target="_blank">解决方案</a> Foundry Networks的ServerIron是目前业界公认最佳的请求分配器之一。<br />
<br />
3、 Apache httpd + Mod_JK2在这里是作为负载均衡器，那为什么要做集群呢？如果集群系统要具备容错能力，以便在任何单一的硬件或软件组件失效时还能100%可用，那么集群系统必须没有单点故障之忧。所以，不能只架设一台有mod_jk2的Apache httpd，因为如果 httpd或mod_jk2失效了，将不会再有请求被会送交到任何一个Tomcat 实例。这种情况下，Apache httpd就是瓶劲，特别在访问量大的网站。<br />
<br />
4、 Mod_JK2负载均衡与故障复原，决定把Apache httpd当成web服务器，而且使用mod_jk2将请求传送给Tomcat，则可以使用mod_jk2的负载均衡与容错功能。在集群系统中，带有 mod_jk2的Apache httpd可以做的事情包括：<br />
A、 将请求分配至一或多个Tomcat实例上<br />
你可以在mod_jk2的workers.properties文件中，设定许多Tomcat实例，并赋于每个实例一个lb_factor值，以作为请求分配的加权因子。<br />
<br />
B、 侦测Tomcat实例是否失败<br />
当Tomcat实例的连接器服务不再响应时，mod_jk2会及时侦测到，并停止将请求送给它。其他的Tomcat实例则会接受失效实例的负载。<br />
<br />
C、 侦测Tomcat实例在失效后的何时恢复<br />
因连接器服务失效，而停止将请求分配给Tomcat实例之后，mod_jk2会周期性地检查是否已恢复使用性，并自动将其加入现行的Tomcat实例池中。<br />
<br />
5、 Tomcat中的集群原理是通过组播的方式进行节点的查找并使用TCP连接进行会话的复制。这里提示一下就是，对每个请求的处理，Tomcat都会进行会话复制，复制后的会话将会慢慢变得庞大。<br />
<br />
6、 Mod_jk2同时支持会话亲和和会话复制。在tomcat 5中如何实现会话亲和和会话复制？把server.xml中的<cluster></cluster>标签去掉就实现会话亲和，把<cluster></cluster>标签加上就实现会话复制。<br />
<br />
7、 会话亲和：就是表示来自同会话的所有请求都由相同的Tomcat 实例来处理，这种情况下，如果Tomcat实例或所执行的服务器机器失效，也会丧失Servlet的会话数据。即使在<nobr oncontextmenu="return false;" onmousemove="kwM(3);" id="key3" onmouseover="kwE(event,3, this);" style="color: rgb(102,0,255); border-bottom: rgb(102,0,255) 1px dotted; background-color: transparent; text-decoration: underline" onclick="return kwC();" onmouseout="kwL(event, this);" target="_blank">集群</nobr>系统中执行更多的Tomcat实例，也永远不会复制会话数据。这样是提高集群性能的一种方案，但不具备有容错能力了。<br />
<br />
8、 使用会话复制，则当一个Tomcat实例宕掉时，由于至少还有另一个Tomcat实例保有一份会话状态数据，因而数据不会丧失。但性能会有所降低。</div>
</div>
<img src ="http://www.blogjava.net/sutao/aggbug/161873.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/sutao/" target="_blank">苏醄</a> 2007-11-20 15:42 <a href="http://www.blogjava.net/sutao/articles/161873.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>Apache mod_rewrite规则重写的标志一览</title><link>http://www.blogjava.net/sutao/articles/158760.html</link><dc:creator>苏醄</dc:creator><author>苏醄</author><pubDate>Wed, 07 Nov 2007 03:03:00 GMT</pubDate><guid>http://www.blogjava.net/sutao/articles/158760.html</guid><wfw:comment>http://www.blogjava.net/sutao/comments/158760.html</wfw:comment><comments>http://www.blogjava.net/sutao/articles/158760.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/sutao/comments/commentRss/158760.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/sutao/services/trackbacks/158760.html</trackback:ping><description><![CDATA[Apache mod_rewrite规则重写的标志一览<br />
<br />
1) R[=code](force redirect) 强制外部重定向<br />
&nbsp;&nbsp; 强制在替代字符串加上http://thishost[:thisport]/前缀重定向到外部的URL.如果code不指定，将用缺省的302 HTTP状态码。<br />
2) F(force URL to be forbidden)禁用URL,返回403HTTP状态码。<br />
3) G(force URL to be gone) 强制URL为GONE，返回410HTTP状态码。<br />
4) P(force proxy) 强制使用代理转发。<br />
5) L(last rule) 表明当前规则是最后一条规则，停止分析以后规则的重写。<br />
6) N(next round) 重新从第一条规则开始运行重写过程。<br />
7) C(chained with next rule) 与下一条规则关联<br />
&nbsp;&nbsp; 如果规则匹配则正常处理，该标志无效，如果不匹配，那么下面所有关联的规则都跳过。<br />
8) T=MIME-type(force MIME type) 强制MIME类型<br />
9) NS (used only if no internal sub-request) 只用于不是内部子请求<br />
10) NC(no case) 不区分大小写<br />
11) QSA(query string append) 追加请求字符串<br />
12) NE(no URI escaping of output) 不在输出转义特殊字符<br />
&nbsp;&nbsp;&nbsp; 例如：RewriteRule /foo/(.*) /bar?arg=P1"%3d$1 [R,NE] 将能正确的将/foo/zoo转换成/bar?arg=P1=zed<br />
13) PT(pass through to next handler) 传递给下一个处理<br />
&nbsp;&nbsp;&nbsp; 例如：<br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; RewriteRule ^/abc(.*) /def$1 [PT] # 将会交给/def规则处理<br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Alias /def /ghi<br />
14) S=num(skip next rule(s)) 跳过num条规则<br />
15) E=VAR:VAL(set environment variable) 设置环境变量<br />
replace(Content,'"n','&lt;br&gt;')
<img src ="http://www.blogjava.net/sutao/aggbug/158760.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/sutao/" target="_blank">苏醄</a> 2007-11-07 11:03 <a href="http://www.blogjava.net/sutao/articles/158760.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>轻松实现Apache,Tomcat集群和负载均衡 </title><link>http://www.blogjava.net/sutao/articles/152568.html</link><dc:creator>苏醄</dc:creator><author>苏醄</author><pubDate>Sat, 13 Oct 2007 06:51:00 GMT</pubDate><guid>http://www.blogjava.net/sutao/articles/152568.html</guid><wfw:comment>http://www.blogjava.net/sutao/comments/152568.html</wfw:comment><comments>http://www.blogjava.net/sutao/articles/152568.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/sutao/comments/commentRss/152568.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/sutao/services/trackbacks/152568.html</trackback:ping><description><![CDATA[<p><strong>0， 环境说明</strong></p>
<p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Apache&nbsp; :apache_2.0.55&nbsp;&nbsp;&nbsp;&nbsp; 1 个</p>
<p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Tomcat:&nbsp; apache-tomcat-5.5.17 (zip版) 2个</p>
<p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;mod_jk:: mod_jk-apache-2.0.55.so&nbsp; 1个</p>
<p><strong>第一部分：负载均衡</strong></p>
<p>&nbsp;&nbsp;&nbsp; 负载均衡，就是apache将客户请求均衡的分给tomcat1,tomcat2....去处理</p>
<p><strong>&nbsp;&nbsp; 1.安装apche,tomcat</strong></p>
<p>&nbsp;&nbsp; <a href="http://httpd.apache.org/">http://httpd.apache.org/</a>&nbsp;下载Apache 2.0.55</p>
<p>&nbsp;&nbsp;&nbsp; <a href="http://tomcat.apache.org/download-55.cgi">http://tomcat.apache.org/download-55.cgi</a>&nbsp;下载tomcat5.5 zip版本（解压即可，绿色版）</p>
<p>&nbsp;&nbsp; <a href="http://apache.justdn.org/tomcat/tomcat-connectors/jk/binaries/win32/jk-1.2.15/">http://apache.justdn.org/tomcat/tomcat-connectors/jk/binaries/win32/jk-1.2.15/</a>&nbsp; 下载mod_jk,注意和&nbsp; apache版本匹配</p>
<p>&nbsp;&nbsp; 按照jdk,我的路径为:E:"ide"apache"Apache2</p>
<p>&nbsp;&nbsp; 解压两份Tomcat, 路径分别为 E:"ide"tomcat1,E:"ide"tomcat2</p>
<div forimg="1"><img alt="1.gif" src="../../images/blogjava_net/killme2008/1.gif" border="0" height="436" width="618" /><br />
</div>
<p>下载mod_jk</p>
<div forimg="1"><img alt="2.gif" src="../../images/blogjava_net/killme2008/2.gif" border="0" height="436" width="618" /><br />
</div>
<div forimg="1"><br />
</div>
<p><strong>2.修改Apache配置文件http.conf</strong></p>
<p>&nbsp;&nbsp; 在apache安装目录下conf目录中找到http.conf</p>
<p>&nbsp;&nbsp; 在文件最后加上下面一句话就可以了</p>
<p>&nbsp; include "E:"ide"apache"Apache2"conf"mod_jk.conf"</p>
<div forimg="1"><img alt="3.gif" src="../../images/blogjava_net/killme2008/3.gif" border="0" height="331" width="648" /><br />
</div>
<div forimg="1"><strong>2. http.conf 同目录下新建mod_jk.conf文件，内容如下</strong></div>
<div forimg="1">&nbsp;&nbsp; </div>
<div forimg="1">#加载mod_jk Module<br />
LoadModule jk_module modules/mod_jk-apache-2.0.55.so</div>
<div forimg="1">#指定 workers.properties文件路径<br />
JkWorkersFile conf/workers.properties</div>
<div forimg="1">#指定那些请求交给tomcat处理,"controller"为在workers.propertise里指定的负载分配控制器</div>
<div forimg="1">JkMount /*.jsp controller</div>
<div forimg="1"><strong>3.在http.conf同目录下新建 workers.properties文件，内容如下</strong></div>
<div forimg="1">&nbsp;</div>
<div forimg="1">worker.list = controller,tomcat1,tomcat2&nbsp; #server 列表</div>
<div forimg="1">#========tomcat1========</div>
<div forimg="1">worker.tomcat1.port=8009&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; #ajp13 端口号，在tomcat下server.xml配置,默认8009<br />
worker.tomcat1.host=localhost&nbsp; #tomcat的主机地址，如不为本机，请填写ip地址<br />
worker.tomcat1.type=ajp13<br />
worker.tomcat1.lbfactor = 1&nbsp;&nbsp; #server的加权比重，值越高，分得的请求越多</div>
<div forimg="1">#========tomcat2========</div>
<div forimg="1">worker.tomcat2.port=9009&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; #ajp13 端口号，在tomcat下server.xml配置,默认8009<br />
worker.tomcat2.host=localhost&nbsp; #tomcat的主机地址，如不为本机，请填写ip地址<br />
worker.tomcat2.type=ajp13<br />
worker.tomcat2.lbfactor = 1&nbsp;&nbsp; #server的加权比重，值越高，分得的请求越多</div>
<div forimg="1"><br />
#========controller,负载均衡控制器========<br />
worker.controller.type=lb<br />
worker.controller.balanced_workers=tomcat1,tomcat2&nbsp;&nbsp; #指定分担请求的tomcat<br />
worker.controller.sticky_session=1</div>
<div forimg="1"><strong>4.修改tomcat配置文件server.xml</strong></div>
<div forimg="1">如果你在不同电脑上安装tomcat,tomcat的安装数量为一个，可以不必修改tomcat配置文件</div>
<div forimg="1">我这里是在同一台电脑上安装两个tomcat，所以需要更改其中一个的设置</div>
<div forimg="1">打开tomcat2/conf/server.xml文件</div>
<img alt="4.gif" src="../../images/blogjava_net/killme2008/4.gif" border="0" height="329" width="742" /><br />
<div forimg="1"><img alt="5.gif" src="../../images/blogjava_net/killme2008/5.gif" border="0" height="329" width="742" /><br />
</div>
<div forimg="1"><img alt="6.gif" src="../../images/blogjava_net/killme2008/6.gif" border="0" height="329" width="742" /><br />
</div>
<div forimg="1"><strong>5.编写一个测试jsp</strong></div>
<div forimg="1">建立一个目录test.里面新建一个test.jsp,内容为</div>
<div forimg="1">&lt;% <br />
&nbsp;&nbsp; System.out.println("===========================");<br />
%&gt;<br />
</div>
<div forimg="1">把test放到tomcat1,tomcat2的webapps下</div>
<div forimg="1"><strong>6.启动apache,tomcat1,tomcat2,进行测试</strong></div>
<div forimg="1">通过 <a href="http://localhost/test/test.jsp">http://localhost/test/test.jsp</a>&nbsp;访问，查看tomcat1的窗口，可以看到打印了一行"=========="</div>
<div forimg="1">再刷新一次，tomcat2也打印了一条，再刷新，可以看到请求会被tomcat1,tomcat2轮流处理,实现了负载均衡<br />
<img alt="7.gif" src="../../images/blogjava_net/killme2008/7.gif" border="0" height="500" width="1139" /><br />
</div>
<div forimg="1"><br />
</div>
<div forimg="1"><strong>第二部分，配置集群</strong></div>
<div forimg="1">&nbsp;&nbsp; 只配置负载均衡还不行，还要session复制，也就是说其中任何一个tomcat的添加的session，是要同步复制到其它tomcat， 集群内的tomcat都有相同的session</div>
<div forimg="1"><strong>1. 修改tomcat1, tomcat2的server.xml</strong>,将集群部分配置的在注释符删掉,并将tomcat2的4001端口改为4002，以避免与tomcat冲突，当然，如果是两台电脑，是不用改端口的，去掉注释符即可</div>
&nbsp;&nbsp;
<div forimg="1"><img alt="8.gif" src="../../images/blogjava_net/killme2008/8.gif" border="0" height="348" width="682" /><br />
</div>
<div forimg="1">
<div forimg="1"><img alt="9.gif" src="../../images/blogjava_net/killme2008/9.gif" border="0" height="348" width="682" /><br />
</div>
</div>
<div forimg="1"><img alt="10.gif" src="../../images/blogjava_net/killme2008/10.gif" border="0" height="348" width="682" /><br />
</div>
<div forimg="1"><strong>
<div forimg="1"><img alt="11.gif" src="../../images/blogjava_net/killme2008/11.gif" border="0" height="348" width="682" /><br />
</div>
</strong></div>
<div forimg="1"><strong>2，修改测试项目test</strong></div>
<div forimg="1">修改test.jsp,内容如下</div>
<div forimg="1">&nbsp; &lt;%@ page contentType="text/html; charset=GBK" %&gt;<br />
&lt;%@ page import="java.util.*" %&gt;<br />
&lt;html&gt;&lt;head&gt;&lt;title&gt;Cluster App Test&lt;/title&gt;&lt;/head&gt;<br />
&lt;body&gt;<br />
Server Info:<br />
&lt;%<br />
out.println(request.getLocalAddr() + " : " + request.getLocalPort()+"&lt;br&gt;");%&gt;<br />
&lt;%<br />
&nbsp; out.println("&lt;br&gt; ID " + session.getId()+"&lt;br&gt;");</div>
<div forimg="1">&nbsp; // 如果有新的 Session 属性设置<br />
&nbsp; String dataName = request.getParameter("dataName");<br />
&nbsp; if (dataName != null &amp;&amp; dataName.length() &gt; 0) {<br />
&nbsp;&nbsp;&nbsp;&nbsp; String dataValue = request.getParameter("dataValue");<br />
&nbsp;&nbsp;&nbsp;&nbsp; session.setAttribute(dataName, dataValue);<br />
&nbsp; }</div>
<div forimg="1">&nbsp; out.print("&lt;b&gt;Session 列表&lt;/b&gt;");</div>
<div forimg="1">&nbsp; Enumeration e = session.getAttributeNames();<br />
&nbsp; while (e.hasMoreElements()) {<br />
&nbsp;&nbsp;&nbsp;&nbsp; String name = (String)e.nextElement();<br />
&nbsp;&nbsp;&nbsp;&nbsp; String value = session.getAttribute(name).toString();<br />
&nbsp;&nbsp;&nbsp;&nbsp; out.println( name + " = " + value+"&lt;br&gt;");<br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; System.out.println( name + " = " + value);<br />
&nbsp;&nbsp; }<br />
%&gt;<br />
&nbsp; &lt;form action="index.jsp" method="POST"&gt;<br />
&nbsp;&nbsp;&nbsp; 名称:&lt;input type=text size=20 name="dataName"&gt;<br />
&nbsp;&nbsp;&nbsp;&nbsp; &lt;br&gt;<br />
&nbsp;&nbsp;&nbsp; 值:&lt;input type=text size=20 name="dataValue"&gt;<br />
&nbsp;&nbsp;&nbsp;&nbsp; &lt;br&gt;<br />
&nbsp;&nbsp;&nbsp; &lt;input type=submit&gt;<br />
&nbsp;&nbsp; &lt;/form&gt;<br />
&lt;/body&gt;<br />
&lt;/html&gt;</div>
<div forimg="1">然后在test 新建WEB-INF目录，WEB-INF下新建web.xml,内容如下</div>
<div forimg="1">&lt;web-app xmlns="<a href="http://java.sun.com/xml/ns/j2ee">http://java.sun.com/xml/ns/j2ee</a>" xmlns:xsi="<a href="http://www.w3.org/2001/XMLSchema-instance">http://www.w3.org/2001/XMLSchema-instance</a>" xsi:schemaLocation="<a href="http://java.sun.com/xml/ns/j2ee">http://java.sun.com/xml/ns/j2ee</a><a href="http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd</a>" version="2.4"&gt;<br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;display-name&gt;TomcatDemo&lt;/display-name&gt;<br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<strong><font color="#ff0000"> &lt;distributable/&gt;</font></strong><br />
&lt;/web-app&gt;</div>
<div forimg="1">注意：在你的应用的web.xml加入&nbsp;<font color="#ff0000"><strong> &lt;distributable/&gt;</strong></font><font color="#000000">即可</font></div>
<div forimg="1">ok,讲test复制到tomcat1,tomcat2的webapps下，重启apache,tomcat1,tomcat2,</div>
<div forimg="1">输入网址 <a href="http://localhost/test/test.jsp">http://localhost/test/test.jsp</a>&nbsp;&nbsp; </div>
<div forimg="1">新建一个 名称为 xiaoluo&nbsp; ,值为 cdut 的session,提交查询，新开一个ie窗口，再提交查询，如图，可以看到，两个tomcat 是负载均衡，并且session同步的</div>
<div forimg="1">
<div forimg="1"><img alt="12.gif" src="../../images/blogjava_net/killme2008/12.gif" border="0" height="705" width="969" /><br />
</div>
</div>
需要注意的是，配置集群时设置jvmRoute时，要把原来的Engine注释掉，去掉上面那一行的注释，也就是修改成<br />
&nbsp;&lt;!-- You should set jvmRoute to support load-balancing via JK/JK2 ie :&nbsp;&nbsp;&nbsp; --&gt; <br />
&nbsp;&nbsp;&nbsp; &lt;Engine name="Standalone" defaultHost="localhost" debug="0" jvmRoute="tomcat1"&gt;&nbsp;&nbsp; <br />
<img src ="http://www.blogjava.net/sutao/aggbug/152568.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/sutao/" target="_blank">苏醄</a> 2007-10-13 14:51 <a href="http://www.blogjava.net/sutao/articles/152568.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>apache+tomcat+mysql负载均衡和集群.txt－－一系列的流程</title><link>http://www.blogjava.net/sutao/articles/131133.html</link><dc:creator>苏醄</dc:creator><author>苏醄</author><pubDate>Wed, 18 Jul 2007 10:29:00 GMT</pubDate><guid>http://www.blogjava.net/sutao/articles/131133.html</guid><wfw:comment>http://www.blogjava.net/sutao/comments/131133.html</wfw:comment><comments>http://www.blogjava.net/sutao/articles/131133.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/sutao/comments/commentRss/131133.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/sutao/services/trackbacks/131133.html</trackback:ping><description><![CDATA[<h2>apache+tomcat+mysql负载均衡和集群.txt</h2>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
<p style="COLOR: #0000ff"></p>
<p style="COLOR: #0000ff">扬子江 发表于 2006-4-11 15:12:38 <br>&nbsp;<br>前言：<br>公司开发了一个网站，估计最高在线人数是3万，并发人数最多100人。开发的网站是否能否承受这个压力，如何确保网站的负荷没有问题，经过研究决定如下：<br>（1） 采用负载平衡和集群技术，初步机构采用Apache+Tomcat的机群技术。<br>（2） 采用压力测试工具，测试压力。工具是Loadrunner。<br>硬件环境搭建：<br>为了能够进行压力测试，需要搭建一个环境。刚开始时，测试在公司局域网内进行，但很快发现了一个问题，即一个脚本的压力测试结果每次都不一样，并且差别很大。原来是受公司网络的影响，于是决定搭建一个完全隔离的局域网测试。搭建后的局域网配置如下：<br>（1） 网络速度：100M<br>（2） 三台服务器：<br>负载服务器 ：操作系统windows2003，<br>Tomcat服务器：操作系统windows2000 Professional<br>数据库服务器：操作系统windows2000 Professional<br>三台机器的cpu 2.4 G, 内存 1G。<br>软件环境搭建：<br>软件的版本如下：<br>Apache 版本：2.054，<br>Tomcat5.0.30,<br>mysql ：4.1.14.<br>JDK1.5<br>压力测试工具：Loadrunner7.8。 </p>
<p style="COLOR: #0000ff">负载平衡方案如下：<br>一台机器（操作系统2003）安装apache，作为负载服务器，并安装tomcat作为一个worker；一个单独安装tomcat，作为第二个worker；剩下的一台单独作为数据库服务器。<br>Apache和tomcat的负载平衡采用JK1.2.14（没有采用2.0，主要是2.0不再维护了）。<br>集群方案：<br>采用Tomcat本身的集群方案。在server.xml配置。<br>压力测试问题：<br>压力测试后，发现了一些问题，现一一列出来：<br>（1）采用Tocmat集群后，速度变得很慢。因为集群后，要进行session复制，导致速度较慢。Tomcatd的复制，目前不支持application 复制。复制的作用，主要用来容错的，即一台机器有故障后，apache可以把请求自动转发到另外一个机器。在容错和速度的考虑上，我们最终选择速度，去掉了Tomcat集群。<br>（2） 操作系统最大并发用户的限制：<br>为了采用网站的压力，我们开始的时候，仅测试Tomcat的最大负载数。 Tomcat服务器安装的操作系统是windows2000 Professional。当我们用压力测试工具，并发测试时，发现只要超过15个并发用户，会经常出现无法连接服务器的情况。经过研究，发现是操作系统的问题：windows2000 Professional 支持的并发访问用户有限，默认的好像是15个。于是我们把操作系统全部采用windows2003 server版本。<br>（3） 数据库连接池的问题：<br>测试数据库连接性能时，发现数据库连接速度很慢。每增加一些用户，连接性能就差了很多。我们采用的数据库连接池是DBCP，默认的初始化为50个，应该不会很慢吧。查询数据库的连接数，发现初始化，只初始化一个连接。并发增加一个用户时，程序就会重新创建一个连接，导致连接很慢。原因就在这里了。如何解决呢？偶尔在JDK1.4下的Tomcat5.0.30下执行数据库连接压力测试，发现速度很快，程序创建数据库连接的速度也是很快的。看来JDK1.5的 JDBC驱动程序有问题。于是我们修改 JDK的版本为1.4.</p>
<p style="COLOR: #0000ff">（4） C3P0和DBCP<br>C3P0是Hibernate3.0默认的自带数据库连接池，DBCP是Apache开发的数据库连接池。我们对这两种连接池进行压力测试对比，发现在并发300个用户以下时，DBCP比C3P0平均时间快1秒左右。但在并发400个用户时，两者差不多。</p>
<p style="COLOR: #0000ff">速度上虽然DBCP比C3P0快些，但是有BUG：当DBCP建立的数据库连接，因为某种原因断掉后，DBCP将不会再重新创建新的连接，导致必须重新启动Tomcat才能解决问题。DBCP的BUG使我们决定采用C3P0作为数据库连接池。<br>调整后的方案：<br>操作系统Windows2003 server&lt;&lt;apache使用mod_jk.so，不可能是windows&gt;&gt;版本<br>JDK1.4<br>Tomcat 5.0.30<br>数据库连接池C3P0<br>仅采用负载平衡，不采用集群。<br>软件的配置：<br>Apache配置：主要配置httpd.conf和新增加的文件workers.properties<br>Httpd.conf：<br>#一个连接的最大请求数量<br>MaxKeepAliveRequests 10000 <br>#NT环境，只能配置这个参数来提供性能<br>&lt;IfModule mpm_winnt.c&gt; <br>#每个进程的线程数，最大1920。NT只启动父子两个进程，不能设置启动多个进程<br>ThreadsPerChild 1900 <br>每个子进程能够处理的最大请求数<br>MaxRequestsPerChild 10000<br>&lt;/IfModule&gt;</p>
<p style="COLOR: #0000ff"># 加载mod_jk<br>#<br>LoadModule jk_module modules/mod_jk.so<br>#<br># 配置mod_jk<br>#<br>JkWorkersFile conf/workers.properties<br>JkLogFile logs/mod_jk.log<br>JkLogLevel info<br>#请求分发，对jsp文件，.do等动态请求交由tomcat处理<br>DocumentRoot "C:/Apache/htdocs"<br>JkMount /*.jsp loadbalancer<br>JkMount /*.do loadbalancer<br>JkMount /servlet/* loadbalancer<br>#关掉主机Lookup，如果为on，很影响性能，可以有10多秒钟的延迟。<br>HostnameLookups Off<br>#缓存配置<br>LoadModule cache_module modules/mod_cache.so<br>LoadModule disk_cache_module modules/mod_disk_cache.so<br>LoadModule mem_cache_module modules/mod_mem_cache.so</p>
<p style="COLOR: #0000ff">&lt;IfModule mod_cache.c&gt;<br>CacheForceCompletion 100<br>CacheDefaultExpire 3600<br>CacheMaxExpire 86400<br>CacheLastModifiedFactor 0.1</p>
<p style="COLOR: #0000ff">&lt;IfModule mod_disk_cache.c&gt;<br>CacheEnable disk /<br>CacheRoot c:/cacheroot<br>CacheSize 327680<br>CacheDirLength 4<br>CacheDirLevels 5<br>CacheGcInterval 4<br>&lt;/IfModule&gt;<br>&lt;IfModule mod_mem_cache.c&gt;<br>CacheEnable mem /<br>MCacheSize 8192<br>MCacheMaxObjectCount 10000<br>MCacheMinObjectSize 1<br>MCacheMaxObjectSize 51200<br>&lt;/IfModule&gt;<br>&lt;/IfModule&gt;<br>worker. Properties文件<br>#<br># workers.properties ，可以参考<br><a href="http://jakarta.apache.org/tomcat/connectors-doc/config/workers.html" _base_href="http://zeeslo.bokee.com/5111063.html" _base_target="original">http://jakarta.apache.org/tomcat/connectors-doc/config/workers.html</a> <br># In Unix, we use forward slashes:<br>ps=</p>
<p style="COLOR: #0000ff"># list the workers by name</p>
<p style="COLOR: #0000ff">worker.list=tomcat1, tomcat2, loadbalancer</p>
<p style="COLOR: #0000ff"># ------------------------<br># First tomcat server<br># ------------------------<br>worker.tomcat1.port=8009<br>worker.tomcat1.host=localhost<br>worker.tomcat1.type=ajp13</p>
<p style="COLOR: #0000ff"># Specify the size of the open connection cache.<br>#worker.tomcat1.cachesize</p>
<p style="COLOR: #0000ff">#<br># Specifies the load balance factor when used with<br># a load balancing worker.<br># Note:<br># ----&gt; lbfactor must be &gt; 0<br># ----&gt; Low lbfactor means less work done by the worker.<br>worker.tomcat1.lbfactor=900</p>
<p style="COLOR: #0000ff"># ------------------------<br># Second tomcat server<br># ------------------------<br>worker.tomcat1.port=8009<br>worker.tomcat1.host=202.88.8.101<br>worker.tomcat1.type=ajp13</p>
<p style="COLOR: #0000ff"># Specify the size of the open connection cache.<br>#worker.tomcat1.cachesize</p>
<p style="COLOR: #0000ff">#<br># Specifies the load balance factor when used with<br># a load balancing worker.<br># Note:<br># ----&gt; lbfactor must be &gt; 0<br># ----&gt; Low lbfactor means less work done by the worker.<br>worker.tomcat1.lbfactor=2000</p>
<p style="COLOR: #0000ff"># ------------------------<br># Load Balancer worker<br># ------------------------</p>
<p style="COLOR: #0000ff">#<br># The loadbalancer (type lb) worker performs weighted round-robin<br># load balancing with sticky sessions.<br># Note:<br># ----&gt; If a worker dies, the load balancer will check its state<br># once in a while. Until then all work is redirected to peer<br># worker.<br>worker.loadbalancer.type=lb<br>worker.loadbalancer.balanced_workers=tomcat1,tomcat2</p>
<p style="COLOR: #0000ff">#<br># END workers.properties<br>#</p>
<p style="COLOR: #0000ff">Tomcat1配置:<br>&lt;!--配置server.xml<br>去掉8080端口，即注释掉如下代码：--&gt;<br>&lt;Connector <br>port="8080" maxThreads="150" minSpareThreads="25" maxSpareThreads="75"<br>enableLookups="false" redirectPort="8443" acceptCount="100"<br>debug="0" connectionTimeout="20000" <br>disableUploadTimeout="true" /&gt;</p>
<p style="COLOR: #0000ff">&lt;!--配置8009端口如下：--&gt;<br>&lt;Connector port="8009" <br>maxThreads="500" minSpareThreads="400" maxSpareThreads="450"<br>enableLookups="false" redirectPort="8443" debug="0"<br>protocol="AJP/1.3" /&gt;<br>&lt;!--配置引擎--&gt; <br>&lt;Engine name="Catalina" defaultHost="localhost" debug="0" jvmRoute="tomcat1"&gt;</p>
<p style="COLOR: #0000ff">启动内存配置,开发configure tomcat程序即可配置：<br>Initial memory pool: 200 M<br>Maxinum memory pool:300M<br>Tomcat2配置：<br>配置和tomcat1差不多，需要改动的地方如下：<br>&lt;!--配置引擎--&gt; <br>&lt;Engine name="Catalina" defaultHost="localhost" debug="0" jvmRoute="tomcat2"&gt;</p>
<p style="COLOR: #0000ff">启动内存配置,开发configure tomcat程序即可配置：<br>Initial memory pool: 512 M<br>Maxinum memory pool:768M<br>Mysql配置：<br>Server类型：Dedicated MySQL Server Machine <br>Database usage:Transational Database Only<br>并发连接数量：Online Transaction Processing(OLTP)<br>字符集：UTF8<br>数据库连接池的配置：<br>我们采用的是spring 框架，配置如下：<br>&lt;property name="hibernateProperties"&gt;<br>&lt;props&gt;<br>&lt;prop key="hibernate.dialect"&gt;org.hibernate.dialect.MySQLDialect&lt;/prop&gt;<br>&lt;prop key="hibernate.connection.driver_class"&gt;com.mysql.jdbc.Driver&lt;/prop&gt;<br>&lt;prop key="hibernate.connection.url"&gt;jdbc:mysql://202.88.1.103/db&lt;/prop&gt; <br>&lt;prop key="hibernate.connection.username"&gt;sa&lt;/prop&gt;<br>&lt;prop key="hibernate.connection.password"&gt;&lt;/prop&gt;</p>
<p style="COLOR: #0000ff">&lt;prop key="hibernate.show_sql"&gt;false&lt;/prop&gt;<br>&lt;prop key="hibernate.use_sql_comments"&gt;false&lt;/prop&gt;</p>
<p style="COLOR: #0000ff">&lt;prop key="hibernate.cglib.use_reflection_optimizer"&gt;true&lt;/prop&gt;<br>&lt;prop key="hibernate.max_fetch_depth"&gt;2&lt;/prop&gt;</p>
<p style="COLOR: #0000ff">&lt;prop key="hibernate.c3p0.max_size"&gt;200&lt;/prop&gt;<br>&lt;prop key="hibernate.c3p0.min_size"&gt;5&lt;/prop&gt;<br>&lt;prop key="hibernate.c3p0.timeout"&gt;12000&lt;/prop&gt;<br>&lt;prop key="hibernate.c3p0.max_statements"&gt;50&lt;/prop&gt;<br>&lt;prop key="hibernate.c3p0.acquire_increment"&gt;1&lt;/prop&gt; <br>&lt;/props&gt;<br>&lt;/property&gt;<br>其他的没有额外配置。<br>LoadRunner 常见问题：<br>（1）sofeware caused connction：这种情况，一般是脚本有问题，或者loadrunner有问题。解决方法：重新启动机器，或者重新录制脚本，估计是loadrunner的bug。<br>（2）cannot connect to server:无法连接到服务器。这种情况是服务器的配置有问题，服务器无法承受过多的并发连接了。需要优化服务器的配置，<br>如操作系统采用windows 2003 server，<br>优化tomcat配置：maxThreads="500" minSpareThreads="400" maxSpareThreads="450"。但是tomcat 最多支持500个并发访问<br>优化apache配置：<br>ThreadsPerChild 1900 <br>MaxRequestsPerChild 10000<br>其他的错误如：<br>Action.c(10): Error -27791: Server has shut down the connection prematurely<br>HTTP Status-Code=503 (Service Temporarily Unavailable)<br>一般都是由于服务器配置不够好引起的，按照问题（2）处理，如果仍旧不行，需要优化硬件和调整程序了。<br>Apache问题：<br>（1） File does not exist: C:/Apache/htdocs/favicon.ico：<br>这个问题是apache，htdocs目录没有favicon.ico文件引起的，该文件是网站的图标，仅在firefox,myIE等浏览器出现。<br>（2） 图片无法显示：<br>配置apache后，却无法显示图片。<br>解决方法：把程序的图片，按照程序结构copy到apache的htdocs目录下。<br>（3） 无法处理请求：<br>当我们输入 ***.do 命令后，apache确返回错误信息，而连接tomcat却没有问题。原因是没有把.do命令转发给tomcat处理。解决方法如下：<br>在apache配置文件中配置如下内容：<br>DocumentRoot "C:/Apache/htdocs"<br>JkMount /*.jsp loadbalancer<br>JkMount /*.do loadbalancer</p>
<p style="COLOR: #0000ff"><br>总结：<br>网站的压力测试，涉及的知识面挺广的，不仅要熟悉压力测试工具，还要知道如何配置和优化应用服务器和数据库，并且需要知道如何优化网络、操作系统、硬件系统。<br>测试中不仅要善于发现问题，要知道如何解决。最重要的一点，要有良好的测试方法。刚开始测试时，可以从最简单的测试脚本入手，不需要太复杂的脚本，这样便于发现问题。如我们刚开始时，就从一个简单的下载登陆界面的脚本入手，测试一个tomcat的压力负载。一个简单的获取登陆的脚本，帮助我们优化了 tomcat的配置；后来再测试数据库连接，也是一个简单的数据库连接脚本，帮助我们优化了数据库连接池；然后利用这些简单的脚本，测试apache的负载平衡，优化了apache配置。最后运行复杂的脚本，模拟多种角色的用户在不同时间下的处理，以测试网站压力负载。<br>&nbsp;</p>
<p style="COLOR: #0000ff"></p>
<p style="COLOR: #0000ff"><br>DBCP使用apache的对象池ObjectPool作为连接池的实现，在构造GenericObjectPool时，会生成一个内嵌类Evictor，实现自Runnable接口。如果_timeBetweenEvictionRunsMillis大于0，每过 _timeBetweenEvictionRunsMillis毫秒Evictor会调用evict()方法，检查对象的闲置时间是否大于 _minEvictableIdleTimeMillis毫秒（_minEvictableIdleTimeMillis小于等于0时则忽略，默认为30 分钟），是则销毁此对象，否则就激活并校验对象，然后调用ensureMinIdle方法检查确保池中对象个数不小于_minIdle。在调用 returnObject方法把对象放回对象池，首先检查该对象是否有效，然后调用PoolableObjectFactory 的passivateObject方法使对象处于非活动状态。再检查对象池中对象个数是否小于_maxIdle，是则可以把此对象放回对象池，否则销毁此对象</p>
<p style="COLOR: #0000ff">还有几个很重要的属性，_testOnBorrow、_testOnReturn、_testWhileIdle，这些属性的意义是取得、返回对象和空闲时是否进行验证，检查对象是否有效，默认都为false即不验证。所以当使用DBCP时，数据库连接因为某种原因断掉后，再从连接池中取得连接又不进行验证，这时取得的连接实际已经时无效的数据库连接了。网上很多说DBCP的bug应该都是如此吧，只有把这些属性设为true，再提供 _validationQuery语句就可以保证数据库连接始终有效了，oracle数据库可以使用SELECT COUNT(*) FROM DUAL，不过DBCP要求_validationQuery语句查询的记录集必须不为空，可能这也可以算一个小小的BUG，其实只要 _validationQuery语句执行通过就可以了。</p>
<img src ="http://www.blogjava.net/sutao/aggbug/131133.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/sutao/" target="_blank">苏醄</a> 2007-07-18 18:29 <a href="http://www.blogjava.net/sutao/articles/131133.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>基于DNS的负载均衡--一个域名绑定多个IP</title><link>http://www.blogjava.net/sutao/articles/131132.html</link><dc:creator>苏醄</dc:creator><author>苏醄</author><pubDate>Wed, 18 Jul 2007 10:28:00 GMT</pubDate><guid>http://www.blogjava.net/sutao/articles/131132.html</guid><wfw:comment>http://www.blogjava.net/sutao/comments/131132.html</wfw:comment><comments>http://www.blogjava.net/sutao/articles/131132.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/sutao/comments/commentRss/131132.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/sutao/services/trackbacks/131132.html</trackback:ping><description><![CDATA[<div class="f14 wr"><span style="COLOR: #0000ff">1．基于特定服务器软件的负载均衡 ---- 这种技术是利用网络协议的重定向功能来实现负载均衡的，例如在Http协议中支持定位指令，接收到这个指令的浏览器将自动重定向到该指令指明的另一个 URL上。由于和执行服务请求相比，发送定位指令对Web服务器的负载要小得多，因此可以根据这个功能来设计一种负载均衡的服务器。一旦Web服务器认为自己的负载较大，它就不再直接发送回浏览器请求的网页，而是送回一个定位指令，让浏览器去服务器集群中的其他服务器上获得所需要的网页。在这种方式下，服务器本身必须支持这种功能，然而具体实现起来却有很多困难，例如一台服务器如何能保证它重定向过的服务器是比较空闲的，并且不会再次发送定位指令？定位指令和浏览器都没有这方面的支持能力，这样很容易在浏览器上形成一种死循环。因此这种方式实际应用当中并不多见，使用这种方式实现的服务器集群软件也较少。 <br>---- 2．基于DNS的负载均衡 ---- DNS负载均衡技术是最早的负载均衡解决方案，它是通过DNS服务中的随机名字解析来实现的，在DNS服务器中，可以为多个不同的地址配置同一个名字，而最终查询这个名字的客户机将在解析这个名字时得到其中的一个地址。因此，对于同一个名字，不同的客户机会得到不同的地址，它们也就访问不同地址上的Web 服务器，从而达到负载均衡的目的。 <br><br>---- 这种技术的优点是，实现简单、实施容易、成本低、适用于大多数TCP/IP应用；但是，其缺点也非常明显，首先这种方案不是真正意义上的负载均衡，DNS 服务器将Http请求平均地分配到后台的Web服务器上，而不考虑每个Web服务器当前的负载情况；如果后台的Web服务器的配置和处理能力不同，最慢的 Web服务器将成为系统的瓶颈，处理能力强的服务器不能充分发挥作用；其次未考虑容错，如果后台的某台Web服务器出现故障，DNS服务器仍然会把DNS 请求分配到这台故障服务器上，导致不能响应客户端。最后一点是致命的，有可能造成相当一部分客户不能享受Web服务，并且由于DNS缓存的原因，所造成的后果要持续相当长一段时间(一般DNS的刷新周期约为24小时)。所以在国外最新的建设中心Web站点方案中，已经很少采用这种方案了。 <br><br>---- 3.基于四层交换技术的负载均衡 ---- 这种技术是在第四层交换机上设置Web服务的虚拟IP地址，这个虚拟IP地址是DNS服务器中解析到的Web服务器的IP地址，对客户端是可见的。当客户访问此Web应用时，客户端的Http请求会先被第四层交换机接收到，它将基于第四层交换技术实时检测后台Web服务器的负载，根据设定的算法进行快速交换。常见的算法有轮询、加权、最少连接、随机和响应时间等。 <br><br>---- 4．基于七层交换技术的负载均衡 ---- 基于第七层交换的负载均衡技术主要用于实现Web应用的负载平衡和服务质量保证。它与第四层交换机比较起来有许多优势：第七层交换机不仅能检查 TCP/IP数据包的TCP和UDP端口号，从而转发给后台的某台服务器来处理，而且能从会话层以上来分析Http请求的URL，根据URL的不同将不同的Http请求交给不同的服务器来处理(可以具体到某一类文件，直至某一个文件)，甚至同一个URL请求可以让多个服务器来响应以分担负载(当客户访问某一个URL，发起Http请求时，它实际上要与服务器建立多个会话连接，得到多个对象，例如.txt/.gif/.jpg文档，当这些对象都下载到本地后，才组成一个完整的页面)。 <br><br>---- 5．站点镜像技术 ---- 以上几种负载均衡技术主要应用于一个站点内的服务器群，但是由于一个站点接入Internet的带宽是有限的，因此可以把负载均衡技术开始应用于不同的网络站点之间，这就是站点镜像技术，站点镜像技术实际上利用了DNS负载均衡技术。</ca><br>参考资料：</span><a href="http://www.iopoo.cn/help/pt.htm" target=_blank><u><span style="COLOR: #0000ff">http://www.iopoo.cn/help/pt.htm</span></u></a><br><br><br><br><br></div>
<div class=gray align=right><span style="COLOR: #0000ff"></span></div>
<img src ="http://www.blogjava.net/sutao/aggbug/131132.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/sutao/" target="_blank">苏醄</a> 2007-07-18 18:28 <a href="http://www.blogjava.net/sutao/articles/131132.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>谈Web服务器的负载均衡技术</title><link>http://www.blogjava.net/sutao/articles/131130.html</link><dc:creator>苏醄</dc:creator><author>苏醄</author><pubDate>Wed, 18 Jul 2007 10:17:00 GMT</pubDate><guid>http://www.blogjava.net/sutao/articles/131130.html</guid><wfw:comment>http://www.blogjava.net/sutao/comments/131130.html</wfw:comment><comments>http://www.blogjava.net/sutao/articles/131130.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/sutao/comments/commentRss/131130.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/sutao/services/trackbacks/131130.html</trackback:ping><description><![CDATA[<div id=art_top1 style="COLOR: #0000ff">
<div id=art_top style="COLOR: #0000ff">
<div id=art_title style="COLOR: #0000ff">[技术]谈Web服务器的<a name=baidusnap0 _base_href="http://www.it.com.cn/f/server/0511/1/192742.htm"></a><strong style="COLOR: black; BACKGROUND-COLOR: rgb(255,255,102)">负载均衡技术</strong></div>
</div>
</div>
<div id=art_center style="COLOR: #0000ff">&nbsp;</div>
<div class=text1 id=art_text style="COLOR: #0000ff">　　当前，无论在企业网、园区网还是在广域网如Internet上，业务量的发展都超出了过去最乐观的估计，上网热潮风起云涌，新的应用层出不穷，即使按照当时最优配置建设的网络，也很快会感到吃不消。尤其是各个网络的核心部分，其数据流量和计算强度之大，使得单一设备根本无法承担，而如何在完成同样功能的多个网络设备之间实现合理的业务量分配，使之不致于出现一台设备过忙、而别的设备却未充分发挥处理能力的情况，就成了一个问题，负载均衡机制也因此应运而生。 <br><br>　　负载均衡建立在现有网络结构之上，它提供了一种廉价有效的方法扩展服务器带宽和增加吞吐量，加强网络数据处理能力，提高网络的灵活性和可用性。它主要完成以下任务：解决网络拥塞问题，服务就近提供，实现地理位置无关性；为用户提供更好的访问质量；提高服务器响应速度；提高服务器及其他资源的利用效率；避免了网络关键部位出现单点失效。 <br><br>　　在负载均衡的思路下，多台服务器为对称方式，每台服务器都具有同等的地位，可以单独对外提供服务而无须其他服务器的辅助。通过负载分担技术，将外部发送来的请求按一定规则分配到对称结构中的某一台服务器上，而接收到请求的服务器都独立回应客户机的请求。 <br><br>　　提供服务的一组服务器组成了一个应用服务器集群(cluster)，并对外提供一个统一的地址。当一个服务请求被发至该集群时，根据一定规则选择一台服务器，并将服务转定向给该服务器承担，即将负载进行均衡分摊。 <br><br>　　通过应用<strong style="COLOR: black; BACKGROUND-COLOR: rgb(255,255,102)">负载均衡技术</strong>，使应用服务超过了一台服务器只能为有限用户提供服务的限制，可以利用多台服务器同时为大量用户提供服务。当某台服务器出现故障时，负载均衡服务器会自动进行检测并停止将服务请求分发至该服务器，而由其他工作正常的服务器继续提供服务，从而保证了服务的可靠性。 <br><br>　　上述的集群技术一般都用于Web服务器、应用服务器等，而不是用于数据库服务器，即不是用于有共享的存储的服务。数据库服务器将涉及到加锁、回滚等一系列问题，要复杂的多。一般数据库服务器只是使用双机，其中一台工作，另一台备份。数据库的双机并行只用于大型数据库中。<br><br>　　负载均衡实现的方法有几种： <br><br>　　■最简单的是通过DNS，但只能实现简单的轮流分配，也不能处理故障。 <br><br>　　■如果是基于MS IIS，Windows 2003 Server本身就带了负载均衡服务。但这一服务也只是轮流分配。 <br><br>　　■硬件方式，通过交换机的功能或专门的负载均衡设备可以实现。对于流量的分配可以有多种方式，但基本上都是应用无关的，与服务器的实现负载关系也不大。另外，设备的价格较贵(优点是能支持很多台服务器)。这种方式往往适合大流量、简单应用。 <br><br>　　■软件方式，通过一台负载均衡服务器进行，上面安装软件。这种方式比较灵活，成本相对也较低。另外一个很大的优点就是可以根据应用的情况和服务器的情况采取一些策略。 <br><br>　　关于负载均衡中比较高级的功能是FailOver，即一台出现故障时，在这台服务器上正在进行中的进程也会被其他服务器接过去。相应的成本也很高，一般是要象WebLogic、WebSphere软件的群集版本才支持。 </div>
<img src ="http://www.blogjava.net/sutao/aggbug/131130.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/sutao/" target="_blank">苏醄</a> 2007-07-18 18:17 <a href="http://www.blogjava.net/sutao/articles/131130.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>一台服务器多个web服务器的配置（apache+tomcat）</title><link>http://www.blogjava.net/sutao/articles/131124.html</link><dc:creator>苏醄</dc:creator><author>苏醄</author><pubDate>Wed, 18 Jul 2007 09:43:00 GMT</pubDate><guid>http://www.blogjava.net/sutao/articles/131124.html</guid><wfw:comment>http://www.blogjava.net/sutao/comments/131124.html</wfw:comment><comments>http://www.blogjava.net/sutao/articles/131124.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/sutao/comments/commentRss/131124.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/sutao/services/trackbacks/131124.html</trackback:ping><description><![CDATA[<div class=htitle style="COLOR: #0000ff" align=center>
<h1><strong>一台服务器多个web服务器的配置（apache+tomcat）</strong></h1>
</div>
<!--content_b-->
<ul><br>
    <p style="COLOR: #0000ff"><br>系统环境：Rad Hat Linux as 4<br>apache 2.2.0<br>tomcat 5.5<br>系统起了两个tomcat，分别访问端口是8080、8060 AJP13端口是8009、8049<br>有两个域名www.xxx.com和www.yyy.com对应这两个tomcat服务<br>怎么配置apache能实现根据域名访问两个网站<br><br>解决问题保证500份奉上..<br></p>
</ul>
<ul>回复：一台服务器多个web服务器的配置（apache+tomcat）500分求解<br>
    <p style="COLOR: #0000ff"><br>为什么要两个 tomcat 进程呢？一个不行吗？<br></p>
</ul>
<ul>回复：一台服务器多个web服务器的配置（apache+tomcat）500分求解<br>
    <p style="COLOR: #0000ff"><br>分别是两个网站......一个是另一个的升级。但是要两个都跑着...<br></p>
</ul>
<ul>回复：一台服务器多个web服务器的配置（apache+tomcat）500分求解<br>
    <p style="COLOR: #0000ff"><br>up一下。没人会吗？解决问题500分，不够再加<br><br></p>
</ul>
<ul>回复：一台服务器多个web服务器的配置（apache+tomcat）500分求解<br>
    <p style="COLOR: #0000ff"><br>在不同的端口上运行不同的站点(基于多端口的服务器上配置基于域名的虚拟主机)：<br>Listen 80<br>Listen 8080<br><br>NameVirtualHost 172.20.30.40:80<br>NameVirtualHost 172.20.30.40:8080<br><br>&lt;VirtualHost 172.20.30.40:80&gt;<br>ServerName www.example1.com<br>DocumentRoot /www/domain-80<br>&lt;/VirtualHost&gt;<br><br>&lt;VirtualHost 172.20.30.40:8080&gt;<br>ServerName www.example1.com<br>DocumentRoot /www/domain-8080<br>&lt;/VirtualHost&gt;<br><br>&lt;VirtualHost 172.20.30.40:80&gt;<br>ServerName www.example2.org<br>DocumentRoot /www/otherdomain-80<br>&lt;/VirtualHost&gt;<br><br>&lt;VirtualHost 172.20.30.40:8080&gt;<br>ServerName www.example2.org<br>DocumentRoot /www/otherdomain-8080<br>&lt;/VirtualHost&gt;<br></p>
</ul>
<ul>回复：一台服务器多个web服务器的配置（apache+tomcat）500分求解<br>
    <p style="COLOR: #0000ff"><br>http://www.ahbvc.cn:8080/info_Show.asp?ArticleID=2382<br></p>
</ul>
<ul>回复：一台服务器多个web服务器的配置（apache+tomcat）500分求解<br>
    <p style="COLOR: #0000ff"><br>建立两个httpd.conf ，分别设置不用得端口及目录。<br><br>分别启动两个apache<br>./apachectl -f conf文件 -k start<br></p>
</ul>
<ul>回复：一台服务器多个web服务器的配置（apache+tomcat）500分求解<br>
    <p style="COLOR: #0000ff"><br>谢谢各位。<br>我用的jk2插件，linux系统，这个环境下有配成功的吗？<br>主要是怎么在workers2.properties里定义多个worker，还能根据不同的条件转发...<br>谢谢<br></p>
</ul>
<ul>回复：一台服务器多个web服务器的配置（apache+tomcat）500分求解<br>
    <p style="COLOR: #0000ff"><br><a name=baidusnap0 _base_href="http://www.dianao2.cn/doc3/malaga/11730b07879k790925/"></a><strong style="COLOR: black; BACKGROUND-COLOR: rgb(255,255,102)">Apache2.2</strong>自带<a name=baidusnap4 _base_href="http://www.dianao2.cn/doc3/malaga/11730b07879k790925/"></a><strong style="COLOR: black; BACKGROUND-COLOR: rgb(255,102,255)">负载均衡</strong>模块，不需要用JK2了，你可以参考一下我这个做法：<br><strong style="COLOR: black; BACKGROUND-COLOR: rgb(255,255,102)">Apache2.2</strong>+Tomcat5.5<strong style="COLOR: black; BACKGROUND-COLOR: rgb(255,102,255)">负载均衡</strong>+集群forAS4&amp;Solaris<br>http://blog.kaila.com.cn/user1/49574/archives/2006/17307.shtml<br></p>
</ul>
<ul>回复：一台服务器多个web服务器的配置（apache+tomcat）500分求解<br>
    <p style="COLOR: #0000ff"><br>大家是不是说得太麻烦了。。<br><br>TOMCAT本身就支持HOST设置。。<br><br>跟APACHE的VHOST设置一样。。<br><br>不过。如果APACHE use port 80<br>那tomcat不要用80<br></p>
</ul>
<ul>回复：一台服务器多个web服务器的配置（apache+tomcat）500分求解<br>
    <p style="COLOR: #0000ff"><br>通过配置不同端口<br></p>
</ul>
<ul>回复：一台服务器多个web服务器的配置（apache+tomcat）500分求解<br>
    <p style="COLOR: #0000ff"><br>用虚拟主机啊，就是为了实现你这个目的，才发明的虚拟主机。<br></p>
</ul>
<ul>回复：一台服务器多个web服务器的配置（apache+tomcat）500分求解<br>
    <p style="COLOR: #0000ff"><br>我的是在WINDOWS下配置的，整合了apache和tomcat，端口都是用80:<br>conf.xml:<br>&lt;Server port="8005" shutdown="SHUTDOWN"&gt;<br><br>&lt;GlobalNamingResources&gt;<br>&lt;!-- Used by Manager webapp --&gt;<br>&lt;Resource name="UserDatabase" auth="Container"<br>type="org.apache.catalina.UserDatabase"<br>description="User database that can be updated and saved"<br>factory="org.apache.catalina.users.MemoryUserDatabaseFactory"<br>pathname="conf/tomcat-users.xml" /&gt;<br>&lt;/GlobalNamingResources&gt;<br><br>&lt;Service name="Catalina"&gt;<br>&lt;Connector port="8080" /&gt;<br><br>&lt;!-- This is here for compatibility only, not required --&gt;<br>&lt;Connector port="8009" protocol="AJP/1.3" /&gt;<br><br>&lt;Engine name="Catalina" defaultHost="localhost"&gt;<br>&lt;Realm className="org.apache.catalina.realm.UserDatabaseRealm"<br>resourceName="UserDatabase" /&gt;<br>&lt;Host name="10.137.200.46" appBase="E:\code\oa"<br>unpackWARs="true" autoDeploy="true"<br>xmlValidation="false" xmlNamespaceAware="false"&gt;<br>&lt;Context path="" <br>docBase="."<br>crossContext="false"<br>debug="0" <br>reloadable="true" /&gt;<br>&lt;/Host&gt;<br>&lt;Host name="10.137.200.48" appBase="E:\code\oa_mysql"<br>unpackWARs="true" autoDeploy="true"<br>xmlValidation="false" xmlNamespaceAware="false"&gt;<br>&lt;Context path="" <br>docBase="."<br>crossContext="false"<br>debug="0" <br>reloadable="true" /&gt;<br>&lt;/Host&gt;<br>&lt;/Engine&gt;<br>&lt;/Service&gt;<br>&lt;/Server&gt;<br></p>
</ul>
<ul>回复：一台服务器多个web服务器的配置（apache+tomcat）500分求解<br>
    <p style="COLOR: #0000ff"><br>workers.properties<br>workers.tomcat_home=D:\program\Tomcat 5.5 #让mod_jk模块知道Tomcat<br>workers.java_home=C:\j2sdk1.4.2_11 #让mod_jk模块知道j2sdk<br>ps=\<br>worker.list=ajp13 #模块版本,现有ajp14了,不要修改<br>worker.ajp13.port=8009 #工作端口,若没占用则不用修改<br>worker.ajp13.host=localhost #本机,若上面的Apache主机不为localhost,作相应修改<br>worker.ajp13.type=ajp13 #类型<br>worker.ajp13.lbfactor=1 #代理数,不用修改<br></p>
</ul>
<ul>回复：一台服务器多个web服务器的配置（apache+tomcat）500分求解<br>
    <p style="COLOR: #0000ff"><br>httpd.conf下加下一段（相应参数要改）：<br>LoadModule jk_module modules/mod_jk.dll<br>JkWorkersFile "D:/program/Tomcat 5.5/conf/workers.properties"<br>JkLogFile "D:/program/Tomcat 5.5/logs/mod_jk2.log" <br>JkLogLevel info<br>JkMount /servlet/* ajp13 <br>JkMount /*.jsp ajp13<br></p>
</ul>
<ul>回复：一台服务器多个web服务器的配置（apache+tomcat）500分求解<br>
    <p style="COLOR: #0000ff"><br>在<strong style="COLOR: black; BACKGROUND-COLOR: rgb(255,255,102)">APACHE2.2</strong>里面就不要用JK啦.有更好的方法.mod_proxy_ajp.so<br><br>再配合虚拟主机里面设置<br>ProxyPass / ajp://localhost:8009/<br>ProxyPassReverse / ajp://localhost:8009/<br>使用比work2配置方便容易得多.<br></p>
</ul>
<ul>回复：一台服务器多个web服务器的配置（apache+tomcat）500分求解<br>
    <p style="COLOR: #0000ff"><br>配置httpd-vhosts.conf就行了<br>&lt;VirtualHost *:80&gt;<br>ServerAdmin flylibin@sina.com<br>DocumentRoot /var/www/html/apache/www<br>ServerName www.aaaa.com<br>ErrorLog logs/error_log<br>&lt;/VirtualHost&gt;<br><br>&lt;VirtualHost *:80&gt;<br>ServerAdmin flylibin@sina.com<br>DocumentRoot /var/www/html/tomcat/www<br>ServerName www.bbbb.com<br>ErrorLog logs/tomcat-error_log<br>&lt;/VirtualHost&gt;<br>然后把tomcat和apache集成一下就行了，这个网上到处都是。<br>这样绝对可以，我的就是这么弄的。<br></p>
</ul>
<ul>回复：一台服务器多个web服务器的配置（apache+tomcat）500分求解<br>
    <p style="COLOR: #0000ff"><br></p>
</ul>
<img src ="http://www.blogjava.net/sutao/aggbug/131124.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/sutao/" target="_blank">苏醄</a> 2007-07-18 17:43 <a href="http://www.blogjava.net/sutao/articles/131124.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item></channel></rss>