JAVA程序员的成长经历——和疯BLOG

1。原理简介
 dtree是一个免费的javascript脚本，只需定义有限的几个参数，就可以做出漂亮的树型菜单。下载目录：http://www.destroydrop.com/javascripts/tree/
 以下是dtree的用法示例：
 1）初始化菜单
 <script type="text/javascript">
  <!--
  var Tree = new Array;
  // nodeId | parentNodeId | nodeName | nodeUrl
  Tree[0]  = "1|0|Page 1|#";
  Tree[1]  = "2|1|Page 1.1|#";
  Tree[2]  = "3|1|Page 1.2|#";
  Tree[3]  = "4|3|Page 1.2.1|#";
  Tree[4]  = "5|1|Page 1.3|#";
  Tree[5]  = "6|2|Page 1.1.1|#";
  Tree[6]  = "7|6|Page 1.1.1.1|#";
  Tree[7]  = "8|6|Page 1.1.1.2|#";
  Tree[8]  = "9|1|Page 1.4|#";
  Tree[9]  = "10|9|Page 1.4.1|#";
  Tree[10] = "11|0|Page 2|#";
  //-->
 </script>
 2）调用函数
 <div class="tree">
  <script type="text/javascript">
  <!--
   createTree(Tree,1,7);  // starts the tree at the top and open it at node nr. 7
  //-->
  </script>
 </div>

 显然，如果用动态的脚本来初始化菜单数组（asp,jsp均可），那就可以很方便的实现动态的树型菜单了。

2。jsp动态实现
   分以下步骤实现动态的树型菜单：
   1）在数据库建tree_info表，有nodeId，parentNodeId，nodeName，nodeUrl四个字段，来存储节点信息。
   2）编写java类，用于从数据库找出节点信息，并且生成javascript脚本。
   3）编写tag类。用于封装逻辑，简化jsp的开发。
   4）建一个web程序进行测试。

3。详细过程
   1）在数据库建表，脚本如下：
   CREATE TABLE `test`.`tree_info` (
   `node_id` INTEGER UNSIGNED NOT NULL DEFAULT -1,
   `parent_id` INTEGER UNSIGNED NOT NULL DEFAULT -1,
   `node_name` VARCHAR(45) NOT NULL,
   `ref_url` VARCHAR(45) NOT NULL,
   PRIMARY KEY(`node_id`)
 )
 我使用mysql数据库，如果脚本细节有出入，请自行修改
    按照上面的dTree示例插入数据
   2）编写TreeInfo.java，这个类用于封装节点信息
     package com.diegoyun.web.tree;
  /**
   * @author Diegoyun
   * @version 1.0
   */
  public class TreeInfo {
   private int nodeId = -1;//node id
   private int parentId = -1;//parentId
   private String nodeName = null;//node name
   private String url = null;//url references

   public int getNodeId() {
    return nodeId;
   }

   public void setNodeId(int nodeId) {
    this.nodeId = nodeId;
   }

   public int getParentId() {
    return parentId;
   }

   public void setParentId(int parentId) {
    this.parentId = parentId;
   }

   public String getNodeName() {
    return nodeName;
   }

   public void setNodeName(String nodeName) {
    this.nodeName = nodeName;
&nsp;  }

   public String getUrl() {
    return url;
   }

   public void setUrl(String url) {
    this.url = url;
   }

  }
   编写TreeUtil.java，用于从数据库得到节点信息，封装到TreeInfo对象，并生成javascript脚本
   TreeUtil.java
   package com.diegoyun.web.tree;
  import java.util.Collection;
  import java.util.ArrayList;
  import java.util.Iterator;
  import java.util.List;
  import java.sql.PreparedStatement;
  import java.sql.ResultSet;
  import java.sql.Connection;
  import java.sql.DriverManager;

  /**
   * @author Diegoyun
   * @version 1.0
   */
  public class TreeUtil {
   public static List retrieveNodeInfos(){
    List coll = new ArrayList();

    String driverName = "com.mysql.jdbc.Driver";
    String host = "localhost";
    String port = ":3306";
    String serverID = "test";
    String userName = "root";
    String userPwd = "root";
    String url = "jdbc:mysql://" + host + port + "/" + serverID ;

    Connection conn = null ;
    PreparedStatement ps = null;
    ResultSet rs = null;
    try{
     Class.forName(driverName).newInstance();
     conn = DriverManager.getConnection(url , userName , userPwd);
     String sql = "select * from tree_info";
     ps = conn.prepareStatement(sql);
     rs = ps.executeQuery();

     TreeInfo info = null;
     while(rs!=null && rs.next()){
      info = new TreeInfo();
      info.setNodeId(rs.getInt(1));
      info.setParentId(rs.getInt(2));
      info.setNodeName(rs.getString(3));
      info.setUrl(rs.getString(4));
      coll.add(info);
     }
  //            if(rs!=null){
  //                rs.close();
  //                rs=null;
  //            }
  //            if(ps!=null){
  //                ps.close();
  //                ps=null;
  //            }
    }catch(Exception e){
     System.out.println(e);
    }

    return coll;
   }
   public static String createTreeInfo(List alist){
    StringBuffer contents = new StringBuffer();
    contents.append("<!--\n");
    contents.append("var Tree = new Array;");//create a array in javascript
    TreeInfo info =null;
    for(int max = alist.size(),i=0;i<max;i++){
     info = (TreeInfo)alist.get(i);
     //define elements of array
     contents.append("Tree[");
     contents.append(i);
     contents.append("]=\"");
     contents.append(info.getNodeId());
     contents.append("|");
     contents.append(info.getParentId());
     contents.append("|");
     contents.append(info.getNodeName());
     contents.append("|");
     contents.append(info.getUrl());
     contents.append("\";");
    }

contents.append("docment.writer(Tree);");
    contents.append("//-->");

    return contents.toString();
   }
   public static void main(String[]args){
    List alist = TreeUtil.retrieveNodeInfos();
  //        TreeInfo info = null;
  //        for(Iterator i = c.iterator();i.hasNext();){
  //            info = (TreeInfo)i.next();
  //            System.out.println("*****" + info.getNodeName());
  //        }
    System.out.println(TreeUtil.createTreeInfo(alist));
   }
  }

 3)编写标签类
 InitTreeTag.java
 package com.diegoyun.web.taglibs;
 import com.diegoyun.web.tree.TreeUtil;
 import javax.servlet.jsp.tagext.TagSupport;
 import javax.servlet.jsp.JspException;
 import java.io.IOException;

 /**
  * @author Diegoyun
  * @version 1.0
  */
 public class InitTreeTag extends TagSupport{

  public int doEndTag() throws JspException {
   StringBuffer tree = new StringBuffer();
   tree.append("<script type=\"text/javascript\">\n");
   tree.append(TreeUtil.createTreeInfo(TreeUtil.retrieveNodeInfos()));
   tree.append("</script>\n");
   try{
    pageContext.getOut().println(tree.toString());
   }catch(IOException ioe){
    ioe.printStackTrace();
   }
   return super.doEndTag();
  }
 }

 ShowTreeTag.java :

 package com.diegoyun.web.taglibs;

 import javax.servlet.jsp.tagext.TagSupport;
 import javax.servlet.jsp.JspException;
 import java.io.IOException;

 /**
  * @author Diegoyun
  * @version 1.0
  */
 public class ShowTreeTag extends TagSupport{
  public int doEndTag() throws JspException {
   StringBuffer buffer = showTree();
   try {
    pageContext.getOut().println(buffer.toString());
   }
   catch (IOException ioe) {
    ioe.printStackTrace();
   }
   return super.doEndTag();
  }
  private StringBuffer showTree(){br />   StringBuffer sb = new StringBuffer();
   sb.append("<div class=\"tree\">\n");
   sb.append("<script type=\"text/javascript\">\n");
   sb.append("<!--\n");
   sb.append("createTree(Tree);\n");
   sb.append("//-->\n");
   sb.append("</script>\n");
   sb.append("</div>\n");
   return sb;
  }  
 }

 标签的tld如下：
 <?xml version="1.0" encoding="ISO-8859-1" ?>
 <!DOCTYPE taglib
   PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"
   "http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd">
 <taglib>
  <tlib-version>1.0</tlib-version>
  <jsp-version>1.2</jsp-version>
  <short-name>tree</short-name>
  <!--initTreeTag-->
  <tag>
   <name>init</name>
   <tag-class>com.diegoyun.web.taglibs.InitTreeTag</tag-class>
   <body-content>empty</body-content>
  </tag>
  <!--ShowTreeTag-->
  <tag>
   <name>show</name>
   <tag-class>com.diegoyun.web.taglibs.ShowTreeTag</tag-class>
   <body-content>empty</body-content>
  </tag>
 </taglib>

 4）建立web过程，编写jsp进行测试。

 index.jsp如下：
 <%@ page language="java"%>
 <%@ taglib uri="/WEB-INF/tlds/tree.tld" prefix="tree"%>

 <html>
 <head>
  <title>Tree example</title>
  <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
  <link rel="StyleSheet" href="tree.css" type="text/css">
  <script type="text/javascript" src="tree.js"></script>
  <tree:init/>
 </head>

 <body>

 <b>Tree example :</b><br /><br />
 <tree:show/>
 <br /><br />

  </body>
 </html>

 测试，enjoy yourself！

4。待解决问题
 dTree有点小bug，如果把css，img，js的路径改变，树就有可能不会正确显示。

eclipse.exe -nl en_US -clean -vmargs -Xverify:none -XX:+UseParallelGC -XX:PermSize=20M -XX:MaxNewSize=32M -XX:NewSize=32M -Xx256m -Xms128m

-nl 后面跟的是语言

-clean 是当启动Eclipse IDE时清空缓冲，一般来说在没有更新插件的情况下，去掉这个参数启动速度更快。

-vmargs 使用JRE的参数，后面就是JRE的参数了：

-Xverify:none 去掉JAR包数据验证，一般来说只有在网络环境下才需要验证JAR包数据的有效性。本地的话可以不用验证。

-XX:+UseParallelGC 使用并行垃圾收集机制，据说这个GC算法比较快。具体不清楚。

-XX:PermSize=20M -XX:MaxNewSize=32M -XX:NewSize=32M 这三个就是设置详细的缓冲数据了。详情看Java官方网站的介绍吧。

-Xmx256m Java虚拟机最大使用内存容量，根据你所使用机器的内容大小设置，只要不超过最大内存容量就好。

-Xms128m Java虚拟机初始化内存容量。

　　.验证你的Apache来源途径。不要以为在Google上能够搜索到合适的Apache版本。如果你需要下载最新版本的Apache，那么你最好通过一个权威的镜像站点来下载。然而，即使这样也可能有问题，事实上，曾经就有黑客入侵过apache.org官方网站。所以，采用类似PGP的工具来验证Apache的数字签名就显得尤为重要。

　　.保持更新Apache的补丁程序。如果你安装了Apache，你就必须及时更新安全补丁。如果没有及时的更新，那你的系统很容易受到网络上那些高危病毒的攻击。幸好，有几个简便方法可以更新Apache的补丁。参考我们关于保持更新Apache补丁的文章了解更多关于Apache服务器公告列表、Linux包管理系统和RedHat操作系统更新服务的信息。

　　.避免使用.htaccess文件（分布式配置文件）。很多情况下需要几个管理员和内容管理者共同管理Apache服务器。一个常用的共享管理办法就是使用.htaccess文件，这样可以很灵活地对管理员以外的用户提供不同的配置控制权限。然而，这些文件也使得在集中安全管理之外还有相当多的安全控制权限——这些文件允许安全专业人士以外的其他用户改变服务器的访问控制许可配置。那些对粒度访问控制根本不熟悉的用户修改的配置可能在无意中会危害到你的系统安全。所以，除非必须使用，否则我们应该尽可能地避免使用这种访问控制系统。如果需要了解更多相关信息，可以参考“摒弃Apache服务器中的.htaccess文件”这篇文章。

　　.监视系统日志。Apache为管理员提供了很全面的日志管理工具来对服务器的活动进行事后分析。Apache提供了多种不同的记录日志，但是对安全专业人士最重要的是访问日志。这个灵活的工具还具有了相当多的自定义功能，你可以按照你的需要很方便地记录尽可能多或者少的日志，以保证有效的分析。至少，你应该记录那些失败的认证企图和系统产生的错误。使用像AWStats一样的免费工具可以很轻松地完成分析任务。但是必须明确的一点是：监视日志只是一种事后分析手段。你可以利用它回顾和判断对服务器的攻击（和攻击企图），但是希望及时查看日志来对紧急情况做出快速反应是不可能的。如果需要进行预判反应，你应该考虑使用入侵预防系统如信息安全杂志评选的2003年度最新兴技术奖得主：Lucid Security公司的ipAngel系统。

　　.管理文件系统。我们已经讨论了使用（或不使用）.htaccess文件对管理文件访问权限的重要性。禁止通过文件系统许可对Apache服务器进行非授权修改也是很重要的。特别值得一提的是，你应该保证只有根用户才能修改存储在“/usr/local/apache ”目录的文件（或者你选择的任何Apache服务器的根目录）。确保只有根用户才能修改日志文件也很关键，这样可以防止用户掩盖他们的操作。

　　考虑这些基本的原则，你就能够安装配置一个安全的Apache服务器。

Apache服务器的设置文件位于/usr/local/apache/conf/目录下，传统上使用三个配置文件httpd.conf,access.conf和srm.conf，来配置Apache服务器的行为。

　　httpd.conf提供了最基本的服务器配置，是对守护程序httpd如何运行的技术描述；srm.conf是服务器的资源映射文件，告诉服务器各种文件的MIME类型，以及如何支持这些文件；access.conf用于配置服务器的访问权限，控制不同用户和计算机的访问限制；这三个配置文件控制着服务器的各个方面的特性，因此为了正常运行服务器便需要设置好这三个文件。

　　除了这三个设置文件之外，Apache还使用mime.types文件用于标识不同文件对应的MIME类型， magic文件设置不同MIME类型文件的一些特殊标识，使得Apache 服务器从文档后缀不能判断出文件的MIME 类型时，能通过文件内容中的这些特殊标记来判断文档的MIME类型。

bash-2.02$ ls -l /usr/local/apache/conf  

total 100  

-rw-r--r-- 1 root wheel 348 Apr 16 16:01 access.conf  

-rw-r--r-- 1 root wheel 348 Feb 13 13:33 access.conf.default  

-rw-r--r-- 1 root wheel 30331 May 26 08:55 httpd.conf  

-rw-r--r-- 1 root wheel 29953 Feb 13 13:33 httpd.conf.default  

-rw-r--r-- 1 root wheel 12441 Apr 19 15:42 magic  

-rw-r--r-- 1 root wheel 12441 Feb 13 13:33 magic.default  

-rw-r--r-- 1 root wheel 7334 Feb 13 13:33 mime.types  

-rw-r--r-- 1 root wheel 383 May 13 17:01 srm.conf  

-rw-r--r-- 1 root wheel 357 Feb 13 13:33 srm.conf.efault  

　　事实上当前版本的Apache将原来httpd.conf、srm.conf与access.conf中的所有配置参数均放在了一个配置文件httpd.conf中，只是为了与以前的版本兼容的原因（使用这三个设置文件的方式来源于NCSA-httpd），才使用三个配置文件。而提供的access.conf和srm.conf文件中没有具体的设置。

　　由于在新版本的Apache中，所有的设置都被放在了httpd.conf中，因此只需要调整这个文件中的设置。以下使用缺省提供的httpd.conf为例，解释Apache服务器的各个设置选项。然而不必因为它提供设置的参数太多而烦恼，基本上这些参数都很明确，也可以不加改动运行Apache服务器。但如果需要调整Apache服务器的性能，以及增加对某种特性的支持，就需要了解这些设置参数的含义。

　　关于Apache服务器的性能，在Internet上存在很大的争议，基本上使用Apache的使用者几乎都不怀疑它的优秀性能，Apache也支撑了很多著名的高负载的网站，但是在商业机构的评测中，Apache往往得分不高。很多人指出，在这些评测中，商业Web服务器及其操作系统往往由其专业公司的工程师进行过性能调整，而Free 的操作系统和Web服务器往往就使用其缺省配置或仅仅作很小的更改。需要指出的是，除了操作系统的性能调整之外，Apache 服务器本身的缺省配置绝不是最优化和最高效的，而是要适应几乎所有种类操作系统、所有种类硬件下的设置，多平台的软件不可能为特定平台和特定硬件提供最优化的缺省配置。因此要使用Apache的时候，性能调整是必不可少的。

　　在商业评测中忽略了的另一个事实是，评测时往往对不同种类的功能进行比较，例如使用Apache的标准CGI 的性能与ISAPI，NSAPI等服务器端API比较，事实上Apache服务器与此可以比较的功能为modperl ，FastCGI，与ASP类似的功能为PHP等等，只不过由于Apache的开放模式，这些功能是由独立的开发组，作为独立的模块来实现的。但是在评测中，测试人员没有加入相应的模块评测其性能。

HTTP守护进程的运行参数

　　httpd.conf中首先定义了一些httpd守护进程运行时需要的参数，来决定其运行方式和运行环境。

　　ServerType standalone

　　ServerType定义服务器的启动方式，缺省值为独立方式standalone，httpd服务器将由其本身启动，并驻留在主机中监视连接请求。在Linux下将在启动文件 /etc/rc.d/rc.local/init.d/apache中自动启动Web服务器，这种方式是推荐设置。  

　　启动Apache服务器的另一种方式是inet方式，使用超级服务器inetd监视连接请求并启动服务器。当需要使用inetd启动方式时，便需要更改为这个设置，并屏蔽/etc/rc.d/rc.local/init.d/apache文件，以及更改/etc/inetd.conf并重起inetd，那么Apache就能从inetd中启动了。  

　　两种方式的区别是独立方式是由服务器自身管理自己的启动进程，这样在启动时能立即启动服务器的多个副本，每个副本都驻留在内存中，一有连接请求不需要生成子进程就可以立即进行处理，对于客户浏览器的请求反应更快，性能较高。而 inetd方式要由inetd发现有连接请求后才去启动http服务器，由于inetd 要监听太多的端口，因此反应较慢、效率较低，但节约了没有连接请求时Web服务器占用的资源。因此inetd方式只用于偶尔被访问并且不要求访问速度的服务器上。事实上inetd方式不适合http的突发和多连接的特性，因为一个页面可能包含多个图象，而每个图象都会引起一个连接请求，即使虽然访问人数造成教少，但瞬间的连接请求并不少，这就受到inetd性能的限制，甚至会影响由inetd启动的其他服务器程序。

　　ServerRoot "/usr/local"  

　　ServerRoot用于指定守护进程httpd的运行目录，httpd在启动之后将自动将进程的当前目录改变为这个目录，因此如果设置文件中指定的文件或目录是相对路径，那么真实路径就位于这个ServerRoot定义的路径之下。  

　　由于httpd会经常进行并发的文件操作，就需要使用加锁的方式来保证文件操作不冲突，由于NFS文件系统在文件加锁方面能力有限，因此这个目录应该是本地磁盘文件系统，而不应该使用NFS文件系统。

　　#LockFile /var/run/httpd.lock  

　　LockFile参数指定了httpd守护进程的加锁文件，一般不需要设置这个参数， Apache服务器将自动在ServerRoot下面的路径中进行操作。但如果ServerRoot为NFS文件系统，便需要使用这个参数指定本地文件系统中的路径。  

　　PidFile /var/run/httpd.pid  

　　PidFile指定的文件将记录httpd守护进程的进程号，由于httpd能自动复制其自身，因此系统中有多个httpd进程，但只有一个进程为最初启动的进程，它为其他进程的父进程，对这个进程发送信号将影响所有的httpd进程。PidFILE定义的文件中就记录httpd父进程的进程号。

　　ScoreBoardFile /var/run/httpd.scoreboard  

　　httpd使用ScoreBoardFile来维护进程的内部数据，因此通常不需要改变这个参数，除非管理员想在一台计算机上运行几个Apache服务器，这时每个Apache服务器都需要独立的设置文件htt pd.conf，并使用不同的ScoreBoardFile。  

　　#ResourceConfig conf/srm.conf  

　　#AccessConfig conf/access.conf  

　　这两个参数ResourceConfig和AccessConfig，就用于和使用 srm.conf 和 access.conf 设置文件的老版本Apache兼容。如果没有兼容的需要，可以将对应的设置文件指定为/dev/null，这将表示不存在其他设置文件，而仅使用httpd.conf 一个文件来保存所有的设置选项。

　　Timeout 300  

　　Timeout定义客户程序和服务器连接的超时间隔，超过这个时间间隔（秒）后服务器将断开与客户机的连接。

　　eepAlive On  

　　在HTTP 1.0中，一次连接只能作传输一次HTTP请求，而KeepAlive参数用于支持HTTP 1.1版本的一次连接、多次传输功能，这样就可以在一次连接中传递多个HTTP请求。虽然只有较新的浏览器才支持这个功能，但还是打开使用这个选项。

　　MaxKeepAliveRequests 100  

　　MaxKeepAliveRequests为一次连接可以进行的HTTP请求的最大请求次数。将其值设为0将支持在一次连接内进行无限次的传输请求。事实上没有客户程序在一次连接中请求太多的页面，通常达不到这个上限就完成连接了。

　　KeepAliveTimeout 15  

　　KeepAliveTimeout测试一次连接中的多次请求传输之间的时间，如果服务器已经完成了一次请求，但一直没有接收到客户程序的下一次请求，在间隔超过了这个参数设置的值之后，服务器就断开连接。

MinSpareServers 5MaxSpareServers 10  

　　在使用子进程处理HTTP请求的Web服务器上，由于要首先生成子进程才能处理客户的请求，因此反应时间就有一点延迟。但是，Apache服务器使用了一个特殊技术来摆脱这个问题，这就是预先生成多个空余的子进程驻留在系统中，一旦有请求出现，就立即使用这些空余的子进程进行处理，这样就不存在生成子进程造成的延迟了。在运行中随着客户请求的增多，启动的子进程会随之增多，但这些服务器副本在处理完一次HTTP请求之后并不立即退出，而是停留在计算机中等待下次请求。但是空余的子进程副本不能光增加不减少，太多的空余子进程没有处理任务，也占用服务器的处理能力，因此也要限制空余副本的数量，使其保持一个合适的数量，使得既能及时回应客户请求，又能减少不必要的进程数量。  

　　因此就可以使用参数MinSpareServers来设置最少的空余子进程数量， 以及使用参数MaxSpareServers 来限制最多的空闲子进程数量，多余的服务器进程副本就会退出。根据服务器的实际情况来进行设置，如果服务器性能较高，并且也被频繁访问，就应该增大这两个参数的设置。对于高负载的专业网站，这两个值应该大致相同，并且等同于系统支持的最多服务器副本数量，也减少不必要的副本退出。  

　　StartServers 5  

　　StartServers参数就是用来设置httpd启动时启动的子进程副本数量，这个参数与上面定义的MinSpareServers和MaxSpareServers参数相关，都是用于启动空闲子进程以提高服务器的反应速度的。这个参数应该设置为前两个值之间的一个数值，小于MinSpareServers和大于MaxS pareServers都没有意义。  

　　MaxClients 150  

　　在另一方面，服务器的能力毕竟是有限的，不可能同时处理无限多的连接请  

求，因此参数Maxclient s就用于规定服务器支持的最多并发访问的客户数，如果这个值设置得过大，系统在繁忙时不得不在过多的进程之间进行切换来为太多的客户进行服务，这样对每个客户的反应就会减慢，并降低了整体的效率。如果这个值设置的较小，那么系统繁忙时就会拒绝一些客户的连接请求。当服务器性能较高时，就可以适当增加这个值的设置。对于专业网站，应该使用提高服务器效率的策略，因此这个参数不能超过硬件本身的限制，如果频繁出现拒绝访问现象，就说明需要升级服务器硬件了。对于非专业网站，不太在意对客户浏览器的反应速度，或者认为反应速度较慢也比拒绝连接好，就也可以略微超过硬件条件来设置这个参数。  

　　这个参数限制了MinSpareServers和MaxSpareServers的设置，它们不应该大于这个参数的设置。  

　　MaxRequestsPerChild 30  

　　使用子进程的方式提供服务的Web服务，常用的方式是一个子进程为一次连接服务，这样造成的问题就是每次连接都需要生成、退出子进程的系统操作，使得这些额外的处理过程占据了计算机的大量处理能力。因此最好的方式是一个子进程可以为多次连接请求服务，这样就不需要这些生成、退出进程的系统消耗，Apache就采用了这样的方式，一次连接结束后，子进程并不退出，而是停留在系统中等待下一次服务请求，这样就极大的提高了性能。  

　　但由于在处理过程中子进程要不断的申请和释放内存，次数多了就会造成一些内存垃圾，就会影响系统的稳定性，并且影响系统资源的有效利用。因此在一个副本处理过一定次数的请求之后，就可以让这个子进程副本退出，再从原始的httpd进程中重新复制一个干净的副本，这样就能提高系统的稳定性。这样，每个子进程处理服务请求次数由MaxRe questPerChild定义。 缺省的设置值为30，这个值对于具备高稳定性特点的Linux系统来讲是过于保守的设置，可以设置为1000甚至更高，设置为0支持每个副本进行无限次的服务处理。  

　　#Listen 3000  

　　#Listen 12.34.56.78:80  

　　#BindAddress *  

　　Listen参数可以指定服务器除了监视标准的80端口之外，还监视其他端口的HTTP请求。由于FreeBSD系统可以同时拥有多个IP地址，因此也可以指定服务器只听取对某个BindAddress< /B>的IP地址的HTTP请求。如果没有配置这一项，则服务器会回应对所有IP的请求。  

　　即使使用了BindAddress参数，使得服务器只回应对一个IP地址的请求，但是通过使用扩展的Listen参数，仍然可以让HTTP守护进程回应对其他IP地址的请求。此时Listen参数的用法与上面的第二个例子相同。这种比较复杂的用法主要用于设置虚拟主机。此后可以用VirtualHost参数定义对不同IP的虚拟主机，然而这种用法是较早的HTTP 1.0标准中设置虚拟主机的方法，每针对一个虚拟主机就需要一个IP地址，实际上用处并不大。在HTTP 1.1中，增加了对单IP地址多域名的虚拟主机的支持，使得虚拟主机的设置具备更大的意义。  

LoadModule mime_magic_module libexec/apache/mod_mime_magic.so  

LoadModule info_module libexec/apache/mod_info.so  

LoadModule speling_module libexec/apache/mod_speling.so  

LoadModule proxy_module libexec/apache/libproxy.so  

LoadModule rewrite_module libexec/apache/mod_rewrite.so  

LoadModule anon_auth_module libexec/apache/mod_auth_anon.so  

LoadModule db_auth_module libexec/apache/mod_auth_db.so  

LoadModule digest_module libexec/apache/mod_digest.so  

LoadModule cern_meta_module libexec/apache/mod_cern_meta.so  

LoadModle expires_module libexec/apache/mod_expires.so  

LoadModule headers_module libexec/apache/mod_headers.so  

LoadModule usertrack_module libexec/apache/mod_usertrack.so  

LoadModule unique_id_module libexec/apache/mod_unique_id.so  

ClearModuleList  

AddModule mod_env.c  

AddModule mod_log_config.c  

AddModule mod_mime_magic.c  

AddModule mod_mime.c  

AddModule mod_negotiation.c  

AddModule mod_status.c  

AddModule mod_info.c  

AddModule mod_include.c  

AddModule mod_autoindex.c  

AddModule mod_dir.c  

AddModule mod_cgi.c  

AddModule mod_asis.c  

AddModule mod_imap.c  

AddModule mod_actions.c  

AddModule mod_speling.c  

AddModule mod_userdir.c  

AddModule mod_proxy.c  

AddModule mod_alias.c  

AddModule mod_rewrite.c  

AddModule mod_access.c  

AddModule mod_auth.c  

AddModule mod_auth_anon.c  

AddModule mod_auth_db.c  

AddModule mod_digest.c  

AddModule mod_cern_meta.c  

AddModule mod_expires.c  

AddModule mod_headers.c  

AddModule mod_usertrack.c  

AddModule mod_unique_id.c  

AddModule mod_so.c  

AddModule mod_setenvif.c  

　　Apache服务器的一个重要特性就是其模块化的结构，这不但表现为其能在编译时能通过新的模块加入新的功能，还表现为其模块可以动态加载入http服务程序中，而不必载入不需要的模块。使用Apache的动态加载模块只需要设置好Load Module和AddModule参数就可以了，这种特性就是Apache的 DSO（Dynamic Shared Object）特性，然而要想充分使用DSO特性仍然不是一个简单的事情，不适当的改动这里的设置就可能造成服务器不能正常启动。因此如果不是要增加或减少服务器提供的功能，就不要改动这里的设置。  

　　上面这些列表就显示了Linux下的缺省Apache服务器支持的模块，事实上很多模块是没有必要的，不必要模块不会被载入内存。模块可以静态连接到pache 服务器内部，也可以这样动态加载，将Apache的特性都编译成动态可加载模块是该Port的做法，而不是Apache的缺省做法，这样就以牺牲很小的性能的同时，带来极大的灵活性。  

　　因而动态可加载的能力还是对性能有轻微的影响，因此可以重新编译Apache，将自己所需要的功能编译进Apache 服务器内部，可以让系统显得更为干净，效率也有轻微的提高。通常仅仅为了这一个目的就重新编译Apache是没有必要的，如果需要增加其他特性而重新编译Apache，不妨在增加其他模块的同时将所有的模块都静态连接入Apache 服务器。有的使用者更喜欢动态加载模块，那么也不妨全部都使用动态加载模块。  

　　这些模块都被放置到/usr/local/apache/libexec/目录下， 每个模块对应Apache服务器的一个特性。详细解释每个模块的功能需要相当多的篇幅，其中比较重要的特性将在后面相应的地方中进行解释，而具体每个模块的功能及用法就需要查看Apache的文档。  

　　#ExtendedStatus On  

　　Apache服务器可以通过特殊的HTTP请求，来报告自身的运行状态，打开这个ExtendedStatus 参数可以让服务器报告更全面的运行状态信息。
主服务器设置

　　Apache服务器需要各种设置，以定义自己使用各种参数以提供Web服务。对于使用虚拟主机的情况，除了在虚拟主机的定义项中覆盖的设置之外（有的设置必须重新定义），这里的设置也是虚拟主机的缺省设置。  

　　Port 80  

　　Port定义了Standalone模式下httpd守护进程使用的端口，标准端口是80。这个选项只对于以独立方式启动的服务器才有效，对于以inetd方式启动的服务器则在inetd.conf中定义使用哪个端口。  

　　在Unix下使用80端口需要root权限，一些管理员为了安全的原因，认为 httpd 服务器不可能没有安全漏洞，因而更愿意使用普通用户的权限来启动服务器，这样就不能使用80端口及其他小于1024的端口，而必须使用大于 1024的端口来启动httpd，一般情况下8000或8080也是常用的端口。而Apache httpd服务器本身可以在以root权限打开80端口后再改变为普通用户身份进行运行，这样就减少了危险性，因而就不需要考虑这个安全问题。但是如果普通用户也想安装配置自己的WWW服务器，那么就不得不使用大于1024的端口。  

　　User nobody  

　　Group nogroup  

　　User和Group配置是Apache的安全保证，Apache在打开端口之后，就将其本身设置为这两个选项设置的用户和组权限进行运行，这样就降低了服务器的危险性。这个选项也只用于 Standalone模式，inetd模式在inetd.conf中指定运行Apache的用户。由于服务器必须执行改变身份的setuid()操作，因此初始进程应该具备root权限，如果是使用非root用户来启动Aapche，这个配置就不会发挥作用。  

　　缺省设置为nobody和nogroup，这个用户和组在系统中不拥有文件，保证了服务器本身和由它启动的CGI 进程没有权限更改文件系统。在某些情况下，例如为了运行CGI与Unix交互，也需要让服务器来访问服务器上的文件，如果仍然使用nobody和nogroup，那么系统中将会出现属于nobody的文件，这对于系统安全是不利的，因为其他程序也会以nobody和nogroup的权限执行某些操作，就有可能访问这些nobody拥有的文件，造成安全问题。一般情况下要为Web服务设定一个特定的用户和组，同时在这里更改用户和组设置。  

　　ServerAdmin you@your.address  

　　配置文件中应该改变的也许只有ServerAdmin， 这一项用于配置WWW服务器的管理员的email地址，这将在HTTP服务出现错误的条件下返回给浏览器，以便让Web使用者和管理员联系，报告错误。习惯上使用服务器上的webmaster作为WWW服务器的管理员，通过邮件服务器的别名机制，将发送到webmaster 的电子邮件发送给真正的Web管理员。  

　　#ServerName new.host.name  

　　缺省情况下，并不需要指定这个ServerName参数，服务器将自动通过名字解析过程来获得自己的名字，但如果服务器的名字解析有问题（通常为反向解析不正确），或者没有正式的DNS名字，也可以在这里指定IP地址。当ServerName设置不正确的时候，服务器不能正常启动。  

　　通常一个Web服务器可以具有多个名字，客户浏览器可以使用所有这些名字或IP地址来访问这台服务器，但在没有定义虚拟主机的情况下，服务器总是以自己的正式名字回应浏览器。ServerName就定义了Web服务器自己承认的正式名字，例如一台服务器名字（在DNS中定义了A类型）为exmaple.org.cn，同时为了方便记忆还定义了一个别名（CNAME记录）为www.exmaple.org.cn，那么Apache自动解析得到的名字就为example.org.cn，这样不管客户浏览器使用哪个名字发送请求，服务器总是告诉客户程序自己为 example.org.cn。虽然这一般并不会造成什么问题，但是考虑到某一天服务器可能迁移到其他计算机上，而只想通过更改DNS中的www别名配置就完成迁移任务，所以不想让客户在其书签中使用 Linux 记录下这个服务器的地址，就必须使用ServerName来重新指定服务器的正式名字。  

　　DocumentRoot "/www/"  

　　DocumentRoot定义这个服务器对外发布的超文本文档存放的路径，客户程序请求的UR L就被映射为这个目录下的网页文件。这个目录下的子目录，以及使用符号连接指出的文件和目录都能被浏览器访问，只是要在URL上使用同样的相对目录名。  

　　注意，符号连接虽然逻辑上位于根文档目录之下，但实际上可以位于计算机上的任意目录中，因此可以使客户程序能访问那些根文档目录之外的目录，这在增加了灵活性的同时但减少了安全性。Apache在目录的访问控制中提供了FollowSymLinks选项来打开或关闭支持符号连接的特性。
Options FollowSymLinks  

AllowOverride None  

　　Apache服务器可以针对目录进行文档的访问控制，然而访问控制可以通过两种方式来实现，一个是在设置文件 httpd.conf（或access.conf）中针对每个目录进行设置，另一个方法是在每个目录下设置访问控制文件，通常访问控制文件名字为.htaccess。虽然使用这两个方式都能用于控制浏览器的访问，然而使用配置文件的方法要求每次改动后重新启动httpd守护进程，比较不灵活，因此主要用于配置服务器系统的整体安全控制策略，而使用每个目录下的.htaccess文件设置具体目录的访问控制更为灵活方便。  

　　Directory语句就是用来定义目录的访问限制的，这里可以看出它的标准语法，为一个目录定义访问限制。上例的这个设置是针对系统的根目录进行的，设置了允许符号连接的选项FollowSymLinks ，以及使用AllowOverride None表示不允许这个目录下的访问控制文件来改变这里进行的配置，这也意味着不用查看这个目录下的相应访问控制文件。  

　　由于Apache对一个目录的访问控制设置是能够被下一级目录继承的，因此对根目录的设置将影响到它的下级目录。注意由于AllowOverride None的设置，使得Apache服务器不需要查看根目录下的访问控制文件，也不需要查看以下各级目录下的访问控制文件，直至httpd.conf（或access.conf ）中为某个目录指定了允许Alloworride，即允许查看访问控制文件。由于Apache对目录访问控制是采用的继承方式，如果从根目录就允许查看访问控制文件，那么Apache就必须一级一级的查看访问控制文件，对系统性能会造成影响。而缺省关闭了根目录的这个特性，就使得Apache从httpd.conf中具体指定的目录向下搜寻，减少了搜寻的级数，增加了系统性能。因此对于系统根目录设置AllowOverride None不但对于系统安全有帮助，也有益于系统性能。  

Options Indexes FollowSymLinks  

AllowOverride None  

Order allow,deny  

Allow from all  

　　这里定义的是系统对外发布文档的目录的访问设置，设置不同的 AllowOverride选项，以定义配置文件中的目录设置和用户目录下的安全控制文件的关系，而Options选项用于定义该目录的特性。  

　　配置文件和每个目录下的访问控制文件都可以设置访问限制，设置文件是由管理员设置的，而每个目录下的访问控制文件是由目录的属主设置的，因此管理员可以规定目录的属主是否能覆盖系统在设置文件中的设置，这就需要使用 啊AllowOverride参数进行设置，通常可以设置的值为：  

AllowOverride的设置 对每个目录访问控制文件作用的影响  

All 缺省值，使访问控制文件可以覆盖系统配置  

None 服务器忽略访问控制文件的设置  

Options 允许访问控制文件中可以使用Options参数定义目录的选项  

FileInfo 允许访问控制文件中可以使用AddType等参数设置  

AuthConfig 允许访问控制文件使用AuthName，AuthType等针对每个用户的认证机制，这使目录属主能用口令和用户名来保护目录 Limit 允许对访问目录的客户机的IP地址和名字进行限制每个目录具备一定属性，可以使用Options来控制这个目录下的一些访问特性设置，以下为常用的特性选项：  

Options设置 服务器特性设置  

All 所有的目录特性都有效，这是缺省状态  

None 所有的目录特性都无效  

FollowSymLinks 允许使用符号连接，这将使浏览器有可能访问文档根目录 （DocumentRoot）之外的文档 SymLinksIfOwnerMatch 只有符号连接的目的与符号连接本身为同一用户所拥有时，才允许访问，这个设置将增加一些安全性  

ExecCGI 允许这个目录下可以执行CGI程序 Indexes 允许浏览器可以生成这个目录下所有文件的索引，使得在这个目录下没有index.html（或其他索引文件）时，能向浏览器发送这个目录下的文件列表  

　此外，上例中还使用了Order、Allow、Deny等参数，这是Limit语句中用来根据浏览器的域名和 IP地址来控制访问的一种方式。其中Order定义处理Allow和Deny的顺序，而Allow、Deny则针对名字或IP进行访问控制设置，上例使用allowfrom all，表示允许所有的客户机访问这个目录，而不进行任何限制。  

　　UserDir public_html  

　　当在一台Linux上运行Apache服务器时，这台计算机上的所有用户都可以有自己的网页路径，形如 http://example.org.cn/~user，使波浪符号加上用户名就可以映射到用户自己的网页目录上。映射目录为用户个人主目录下的一个子目录，其名字就用UseDir这个参数进行定义，缺省为public_html。如果不想为正式的用户提供网页服务，使用DISABLED作UserDir的参数即可。  

#
# AllowOverride FileInfo AuthConfig Limit
# Options MultiViews Indexes SymLinksIfOwnerMatch IncludesNoExec
#
# Order allow,deny
# Allow from all
#
#
# Order deny,allow
# Deny from all
#
#  

　　这里可以看到Directory的另一个用法，即可以通过简单的模式匹配方法，针对分布在不同目录下的子目录定义访问控制权限。这样设置就需要Apache服务器对每个路径进行额外的处理，因此就会降低服务器的性能，所以缺省情况并没有打开这种访问限制。

这里可以看到另外一个语句Limit，Limit语句就是用来针对具体的请求方法来设定访问控制的，其中可以使用GET、POST等各种服务器支持的请求方法做Limit的参数，来设定对不同请求方法的访问限制。一般可以打开对GET、POST、 HEAD三种请求方法，而屏蔽其他的请求方法，以增加安全性。Limit语句中，可以用Order 、Allow、Deny，Allow和Deny中可以使用匹配的方法针对域名和IP进行限制，只是对于域名是从后向前匹配，对于IP地址则从前向后匹配。  

　　DirectoryIndex index.html  

　　很多情况下，URL中并没有指定文档的名字，而只是给出了一个目录名。那么Apache服务器就自动返回这个目录下由DirectoryIndex定义的文件，当然可以指定多个文件名字，系统会这个目录下顺序搜索。当所有由DirectoryIndex指定的文件都不存在时，Apache服务器可以根据系统设置，生成这个目录下的所有文件列表，提供用户选择。此时该目录的访问控制选项中的Indexes选项（Options Indexes ）必须打开，以使得服务器能够生成目录列表，否则Apache将拒绝访问。  

　　AccessFileName .htaccess  

　　AccessFileName定义每个目录下的访问控制文件的文件名，缺省为.htaccess，可以通过更改这个文件，来改变不同目录的访问控制限制。  

　　Order allow,deny  

　　Deny from all  

　　除了可以针对目录进行访问控制之外，还可以根据文件来设置访问控制，这就是File语句的任务。使用File 语句，不管文件处于哪个目录，只要名字匹配， 就必须接受相应的访问控制。这个语句对于系统安全比较重要，例如上例将屏蔽所有的使用者不能访问.htaccess文件，这样就避免.htaccess中的关键安全信息不至于被客户获取。  

　　#CacheNegotiatedDocs  

　　缺省情况下如果代理服务器和Apache服务器协商是否缓存其网页，Apache给予否定的回答，不希望自己的网页被代理服务器缓存。然而这样就不能有效的利用代理服务器的优势，因此可以设置CacheNegotiatieDocs 选项， 使得代理服务器可以对网页进行缓存。然而即使不设置这个选项，有的代理服务器（或通过调整设置）也能对网页进行缓存。  

　　UseCanonicalName On  

　　打开这个UseCanonicalName是Web服务器的标准做法，因为客户发送的大部分请求都是对本服务器的引用，这样服务器就能使用ServerName和Port选项的设置内容构建完整的URL，并回应客户，使浏览器能得到规范的URL。如果将这个参数设置为Off，那么Apache将使用从客户请求中获得服务器的名字和端口值（支持HTTP 1.1的客户的请求中将会有这些信息），重新构建URL。  

　　TypesConfig /usr/local/apache/etc/mime.types  

　　TypeConfig用于设置保存有不同的MIME类型数据的文件名，在Linux下缺省设置为/usr/local/apache/etc/mime.types。  

　　DefaultType text/plain  

　　如果Web服务器不能决定一个文档的缺省类型，这通常表示文档使用了非标准的后缀，那么服务器就使用 DefaultType定义的MIME类型将文档发送给客户浏览器。这里的设置为text/plain，这样设置的问题是，如果服务器不能判断出文档的MIME，那么大部分情况下这个文档为一个二进制文档，但使用 text/plain格式发送回去，浏览器将在内部打开它而不会提示保存。因此建议将这个设置更改为application/octet-stream，这样浏览器将提示用户进行保存。  

　　MIMEMagicFile /usr/local/apache/etc/magic  

　　除了从文件的后缀出发来判断文件的MIME类型之外，Apache还可以进一步分析文件的一些特征，来判断文件的真实MIME类型。这个功能是由mod_mime_magic 模块实现的，它需要一个记录各种MIME类型特征的文件，以进行分析判断。上面的设置是一个条件语句，如果载入了这个模块，就必须指定相应的标志文件magic的位置。

通常连接时，服务器仅仅可以得到客户机的IP地址，如果要想获得客户机的主机名，以进行日志记录和提供给 CGI程序使用，就需要使用这个HostnameLookups 选项，将其设置为On打开DNS反查功能。但是这将使服务器对每次客户请求都进行DNS查询，增加了系统开销，使得反应变慢，因此缺省设置为使用Off关闭此选项。关闭选项之后，服务器就不会获得客户机的主机名，而只能使用IP地址来记录客户。  

ErrorLog /var/log/httpd-error.log
LogLevel warn
LogFormat "%h %l %u %t "%r" %>s %b "%{Referer}i" "%{User-Agent} "" combined  
LogFormat "%h %l %u %t "%r" %>s %b" common  
LogFormat "%{Referer}i -> %U" referer  
LogFormat "%{User-agent}i" agent  
#CustomLog /var/log/httpd-access.log common  
#CustomLog /var/log/httpd-referer.log referer  
#CustomLog /var/log/httpd-agent.log agent  
CustomLog /var/log/httpdaccess.log combined

　　这里定义了系统日志的形式，对于服务器错误记录， 由ErrorLog、 LogLevel 来定义不同的错误日志文件及其记录内容。  

　　对于系统的访问日志，缺省使用CustomLog参数定义日志的位置，缺省使用 combined 参数指定将所有的访问日志放在一个文件中，然而也可以将不同种类的访问日志放在不同的日志记录文件中，这是通过在 CustomLog中指定不同的记录类型来完成的。common表示普通的对单页面请求访问记录，referer表示每个页面的引用记录，可以看出一个页面中包含的请求数，agent表示对客户机的类型记录，显然可以将现有的combined 定义的设置行注释掉，并使用common、referer和agent作为CustomLog的参数，来为不同种类的日志分别指定日志记录文件。  

　　显然，LogFormat是用于定义不同类型的日志进行记录时使用的格式， 这里使用了以%开头的宏定义，以记录不同的内容。  

　　如果这些参数指定的文件使用的是相对路径，那么就是相对于ServerRoot的路径。  

　　ServerSignature On  

　　一些情况下，例如当客户请求的网页并不存在时，服务器将产生错误文档，缺省情况下由于打开了 ServerSignature选项，错误文档的最后一行将包含服务器的名字、Apache的版本等信息。有的管理员更倾向于不对外显示这些信息，就可以将这个参数设置为Off，或者设置为Email，最后一行将替换为对 ServerAdmin 的Email提示。  

Alias /icons/ "/www/icons/"  
Options Indexes MultiViews  
AllowOverride None  
Order allow,deny  
Allow from all  

　　Alias参数用于将URL与服务器文件系统中的真实位置进行直接映射，一般的文档将在DocumentRoot 中进行查询，然而使用Alias定义的路径将直接映射到相应目录下，而不再到DocumentRoot 下面进行查询。因此Alias可以用来映射一些公用文件的路径，例如保存了各种常用图标的icons路径。这样使得除了使用符号连接之外，文档根目录（DocumentRoot）外的目录也可以通过使用了Alias映射，提供给浏览器访问。  

　　定义好映射的路径之后，应该需要使用Directory语句设置访问限制。  

ScriptAlias /cgi-bin/ "/www/cgi-bin/"  
AllowOverride None  
Options None  
Order allow,deny  
Allow from all  

　　ScriptAlias也是用于URL路径的映射，但与Alias的不同在于，ScriptAlias 是用于映射CGI程序的路径，这个路径下的文件都被定义为CGI程序，通过执行它们来获得结果，而非由服务器直接返回其内容。缺省情况下CGI程序使用cgi-bin目录作为虚拟路径。  

　　# Redirect old-URI new-URL  

　　Redirect参数是用来重写URL的，当浏览器访问服务器上的一个已经不存在的资源的时候，服务器返回给浏览器新的URL，告诉浏览器从该URL中获取资源。这主要用于原来存在于服务器上的文档，改变了位置之后，而又希望能使用老URL能访问到，以保持与以前的URL兼容。  

IndexOptions FancyIndexing  
AddIconByEncoding (CMP,/icons/compressed.gif) x-compress x-gzip  
AddIconByType (TXT,/icons/text.gif) text/*  
AddIconByType (IMG,/icons/image2.gif) image/*  
AddIconByType (SND,/icons/sound2.gif) audio/*  
AddIconByType (VID,/icons/movie.gif) video/*  
AddIcon /icons/binary.gif .bin .exe  
AddIcon /icons/binhex.gif .hqx  
AddIcon /icons/tar.gif .tar  
AddIcon /icons/world2.gif .wrl .wrl.gz .vrml .vrm .iv  
AddIcon /icons/compressed.gif .Z .z .tgz .gz .zip  
AddIcon /icons/a.gif .ps .ai .eps  
AddIcon /icons/layout.gif .html .shtml .htm .pdf  
AddIcon /icons/text.gif .txt  
AddIcon /icons/c.gif .c  
AddIcon /icons/p.gif .pl .py  
AddIcon /icons/f.gif .for  
AddIcon /icons/dvi.gif .dvi  
AddIcon /icons/uuencoded.gif .uu  
AddIcon /icons/script.gif .conf .sh .shar .csh .ksh .tcl  
AddIcon /icons/tex.gif .tex  
AddIcon /icons/bomb.gif core  
AddIcon /icons/back.gif ..  
AddIcon /icons/hand.right.gif README  
AddIcon /icons/folder.gif ^^DIRECTORY^^  
AddIcon /icons/blank.gif ^^BLANKICON^^  
DefaultIcon /icons/unknown.gif  
#AddDescription "GZIP compressed document" .gz  
#AddDescription "tar archive" .tar  
#AddDescription "GZIP compressed tar archive" .tgz  
ReadmeName README  
HeaderName HEADER  
IndexIgnore .??* *~ *# HEADER* README* RCS CVS *,v *,t  

　　当一个HTTP请求的URL为一个目录的时候，服务器返回这个目录中的索引文件。但如果一个目录中不存在缺省的索引文件，并且该服务器又许可显示目录文件列表的时候，就会显示出这个目录中的文件列表，为了使得这个文件列表能具有可理解性，而不仅仅是一个简单的列表，就需要前面的这些设置参数。

如果使用了IndexOptions FancyIndexing选项，可以让服务器产生的目录列表中针对各种不同类型的文档引用各种图标。而哪种文件使用哪种图标，则使用下面的 AddIconByEncoding、AddIconByType以及AddIcon来定义，分别依据MIME 的编码、类型以及文件的后缀来判断使用何种图标。如果不能确定文档使用的图标，就使用 DefaultIcon定义的缺省图标。

　　同样，使用AddDescription可以为不同类型的文档加入不同的描述。并且，服务器还在目录下，查询使用ReadmeName和HeaderName定义的文件（自动加上 .html后缀，如果没有发现，再使用.txt后缀进行搜索），如果发现了这些文件，就在文件列表之前首先显示这些文件的内容，以使得普通目录列表具备更大的可理解性。

　　IndexIgnore让服务器在列出文件列表时忽略相应的文件， 这里使用模式配置的方式定义文件名。

　　AddEncoding x-compress Z

　　AddEncoding x-gzip gz

　　AddEncoding用于告诉一些使用压缩的MIME类型，这样可以让浏览器进行解压缩操作。

　　AddLanguage en .en

　　AddLanguage fr .fr

　　AddLanguage de .de

　　AddLanguage da .da

　　AddLanguage el .el

　　AddLanguage it .it

　　LanguagePriority en fr de

　　一个HTML文档可以同时具备多个语言的版本，如对于file1.html文档可以具备file1.html.en、file1.html.fr 等不同的版本，每个语言后缀必须使用 AddLanguage进行定义。这样服务器可以针对不同国家的客户，通过与浏览器进行协商，发送不同的语言版本。而LanguagePriority 定义不同语言的优先级，以便在浏览器没有特殊要求时，按照顺序使用不同的语言版本回应对file1.html 的请求。这个国际化的能力实际的应用并不多。

　　#AddType application/x-httpd-php .phtml

　　#AddType application/x-httpd-php-source .phps

　　AddType参数可以为特定后缀的文件指定MIME类型，这里的设置将覆盖 mime.types中的设置。

　　#AddHandler cgi-script .cgi

　　AddHandler是用于指定非静态的处理类型，用于定义文档为一个非静态的文档类型，需要进行处理，再向浏览器返回处理结果。例如上面注释中的设置是将以.cgi结尾的文件设置为cgi-script类型，那么服务器将启动这个CGI程序以进行处理。如果需要在前面AliasScript定义的路径之外执行CGI程序，就需要使用这个参数进行设置，此后以.cgi结尾的文件将被当作CGI程序执行。

　　在配置文件、这个目录中的.htaccess以及其上级目录的.htaccess中必须允许执行CGI程序，这需要通过Options ExecCGI参数设定。

　　#AddType text/html .shtml

　　#AddHandler server-parsed .shtml

　　另外一种动态进行处理的类型为server-parsed，由服务器自身预先分析网页内的标记，将标记更改为正确的HTML标识。由于server-parsed需要对text/html 类型的文档进行处理，因此首先定义了对应的.shtml为text/html类型。

　　然而要支持SSI，还要首先要在配置文件（或.htaccess）中使用Options Includes允许该目录下的文档可以为SSI类型，或使用Options IncludesNOExec让执行普通的SSI标志，但不执行其中引用的外部程序。

　　另一种指定server-parsed类型的方式为使用XBitBack设置选项，如果将 XBitHack设置为On，服务器将检查所有text/html类型的文档（包括.html后缀的文档），如果发现文件属性具备执行位 “x"，则服务器就认为它是服务器分析文档，需要服务器进行处理。推荐使用AddHandler进行设置，而将XBitBack 设置为Off，因为使用XBitBack将对所有的HTML文档都执行额外的检查，降低了效率。

　　#AddHandler send-as-is asis

　　#AddHandler imap-file map

　　#AddHandler type-map var

　　上面被注释的AddHandler用于支持Apache服务器的asis、map和var处理能力。

　　# Action media/type /cgi-script/location

　　# Action handler-name /cgi-script/location

　　因为Apache内部提供的处理功能有限，因此可以使用Action为服务器定义外部程序作为可处理的动态文档类型，这些外部程序与标准CGI程序相同，都是对输入的数据处理之后，再输出不同MIME类型的结果。例如要定义一个对特殊后缀wri都先执行wri2txt进行处理操作，再返回结果的操作，可以使用：

　　Action windows-writer /bin/wri2txt

　　AddHandler windows-writer wri

　　更进一步，可以直接使用Action定义对某个MIME类型预先进行处理操作，这需要例子中第一种格式的Action 参数设置方式。这样设置方式就不再需要额外的AddHandler用来将处理操作与文件后缀联系起来，而是使用Action直接处理MIME类型的文件。但如果文档后缀没有正式的MIME类型，还需要先定义一个MIME类型。

　　#MetaDir .web

　　#MetaSuffix .meta

　　Meta信息是在文档发送给客户之前，预先发送给客户浏览器一些数据，因此浏览器可以通过HEAD请求来访问这些Meta信息而不必真正通过GET来返回全部文档数据。服务器通常发送给浏览器的是一些标准的HTTP头信息，如果要想增加额外的信息，就需要使用MetaDir来定义Meta数据存放的目录， 而MetaS uffix用于指定包含Meta数据的文件后缀。

　　#ErrorDocument 500 "The server made a boo boo.

　　#ErrorDocument 404 /missing.html

　　#ErrorDocument 404 /cgi-bin/missing_handler.pl

　　#ErrorDocument 402

　　http://some.other_server.com/subscription_info.html

　　如果客户请求的网页不存在，或者没有访问权限等情况发生时，服务器将产生一个错误代码，同时也将回应客户浏览器一个标识错误的网页。

　　ErrorDocument就用于设置当出现哪个错误时应该回应客户浏览器那些内容，ErrorDocument的第一个参数为错误的序号，第二个参数为回应的数据，可以为简单的文本，本地网页，本地CGI程序，以及远程主机上的网页。

　　BrowserMatch "Mozilla/2" nokeepalive

　　BrowserMatch "MSIE 4.0b2;" nokeepalive downgrade-1.0 force-response-1.0

　　BrowserMatch "RealPlayer 4.0" force-response-1.0

　　BrowserMatch "Java/1.0" force-response-1.0

　　BrowserMatch "JDK/1.0" force-response-1.0

　　BrowserMatch命令为特定的客户程序，设置特殊的参数，以保证对老版本浏览器的兼容性，并支持新浏览器的新特性。

　　#

　　# SetHandler server-status

　　# Order deny,allow

　　# Deny from all

　　# Allow from .your_domain.com

　　#

　　#

　　# SetHandler server-info

　　# Order deny,allow

　　# Deny from all

　　# Allow from .your_domain.com

　　#

　　#

　　# Deny from all

　　# ErrorDocument 403 http://phf.apache.org/phf_abuse_log.cgi

用于设置访问控制的设置主要是针对目录和文件进行设置的，然而也可以针对不同的URL进行访问控制的设置，这样就不必担心ScriptAlias、Alias是否将路径设置到了受控制的目录之外了。针对URL进行控制的语句为 Location语句，这样不但能对服务器上的文件、CGI提供保护，此外，它还能保护不能找到对应文件，而是由服务器本身提供的特殊功能URL。http://servername/server-status用于报告当前Apache服务器的状态，http://servername/server-info用于报告Apache 服务器的统计信息。与此相关的设置还有ExtendedStatus参数，可以让服务器输出更详细的的报告。

　　#

　　#ProxyRequests On

　　#

　　#

　　# Order deny,allow

　　# Deny from all

　　# Allow from .your_domain.com

　　#

　　#ProxyVia On

　　#CacheRoot "/www/proxy"

　　#CacheSize 5

　　#CacheGcInterval 4

　　#CacheMaxExpire 24

　　#CacheLastModifiedFactor 0.1

　　#CacheDefaultExpire 1
　　
　　#NoCache a_domain.com another_domain.edu joes.garage_sale.com

　　#

　　Apache服务器本身就具备代理的功能，然而这要求加载入mod_proxy模块。这能使用IfModule语句进行判断，如果存在mod_proxy模块，就使用ProxyRequests打开代理支持。此后的Directory用于设置对Proxy功能的访问权限设置，以及用于设置缓冲的各个参数设置。

　　虚拟主机

　　#NameVirtualHost 12.34.56.78:80

　　#NameVirtualHost 12.34.56.78

　　#

　　# ServerAdmin webmaster@host.some_domain.com

　　# DcumentRoot /www/docs/host.some_domain.com

　　# ServerName host.some_domain.com

　　# ErrorLog logs/host.some_domain.com-error_log

　　# CustomLog logs/host.some_domain.com-access_log common

　　#
　
　　#

　　缺省设置文件中的这些内容是用于设置命名基础的虚拟主机服务器时使用。

　　其中NameVirtualHost 来指定虚拟主机使用的IP地址，这个IP地址将对应多个 DNS名字，如果Apache使用了Listen 参数控制了多个端口，那么就可以在这里加上端口号以进一步进行区分对不同端口的不同连接请求。此后，使用 VirtualHost 语句，使用NameVirtualHost指定的IP地址作参数，对每个名字都定义对应的虚拟主机设置。

　　虚拟主机是在一台Web服务器上，可以为多个单独域名提供Web服务，并且每个域名都完全独立，包括具有完全独立的文档目录结构及设置，这样域名之间完全独立，不但使用每个域名访问到的内容完全独立，并且使用另一个域名无法访问其他域名提供的网页内容。

　　虚拟主机的概念对于ISP来讲非常有用，因为虽然一个组织可以将自己的网页挂在具备其他域名的服务器上的下级往址上，但使用独立的域名和根网址更为正式，易为众人接受。传统上，必须自己设立一台服务器才能达到单独域名的目的，然而这需要维护一个单独的服务器，很多小单位缺乏足够的维护能力，更为合适的方式是租用别人维护的服务器。ISP也没有必要为一个机构提供一个单独的服务器，完全可以使用虚拟主机能力，使服务器为多个域名提供Web服务，而且不同的服务互不干扰，对外就表现为多个不同的服务器。

　　有两种设定虚拟主机的方式，一种是基于HTTP 1.0标准，需要一个具备多IP地址的服务器，再配置DNS 服务器，给每个IP地址以不同的域名，最后才能配置Apache的配置文件，使服务器对不同域名返回不同的Web文档。由于这需要使用额外的IP地址，对每个要提供服务的域名都要使用单独的IP地址，因此这种方式实现起来问题较多。

　　可以在一个网络界面上绑定多个IP地址，Linux下需要使用ifconfig的 alias参数来进行这个配置，但此时会影响网络性能。

　　HTTP 1.1标准在协议中规定了对浏览器和服务器通信时，服务器能够跟踪浏览器请求的是哪个主机名字。因此可以利用这个新特性，使用更轻松的方式设定虚拟主机。这种方式不需要额外的IP地址，但需要新版本的浏览器支持。这种方式已经成为建立虚拟主机的标准方式。

　　要建立非IP基础的虚拟主机，多个域名是不可少的配置，因为每个域名就对应一个要服务的虚拟主机。因此需要更改DNS服务器的配置，为服务器增加多个C NAME选项，如：

　　linux IN A 192.168.1.64

　　vhost1 IN CNAME linux

　　vhost2 IN CNAME linux

　　基本的设置选项都是为了linux主机设定的，如果要为vhost1和vhost2设定虚拟主机，就要使用VirtualHost语句定义不同的选项，在语句中可以使用配置文件前面中的大部分选项，而可以重新定义几乎所有的针对服务器的设置。

　　NameVirtualHost 192.168.1.64

　　DocumentRoot /www/data

　　ServerName linux.example.org.cn

　　DocumentRoot /vhost1

　　ServerName vhost1.example.org.cn

　　DocumentRoot /vhost2

　　ServerName vhost2.example.org.cn

　　这里需要注意的是，VirtualHost的参数地址一定要和NameVirtualHost定义的地址相一致，必须保证所有的值严格一致，Apache服务器才承认这些定义是为这个IP地址定义的虚拟主机。

　　此外，定义过NameVirtualHost之后，那么对这个IP地址的访问都被区分不同的虚拟主机进行处理，而对其他IP地址的访问，例如127.0.0.1，才应用前面定义的缺省选项。

#!/bin/sh 
# 
# Startup Script for Tomcat5 
# 
# chkconfig: 345 87 13 
# description: Tomcat Daemon 
# processname: jsvc 
# pidfile: /var/run/jsvc.pid 
# config: 
# 
# Source function library.
. /etc/rc.d/init.d/functions 
# 
prog=tomcat 
# 
# Small shell script to show how to start/stop Tomcat using jsvc 
# If you want to have Tomcat running on port 80 please modify the server.xml 
# file: 
# 
# <!-- Define a non-SSL HTTP/1.1 Connector on port 80 --> 
# <Connector className="org.apache.catalina.connector.http.HttpConnector" 
# port="80" minProcessors="5" maxProcessors="75" 
# enableLookups="true" redirectPort="8443" 
# acceptCount="10" debug="0" connectionTimeout="60000"/> 
# 
# You need a developement version of Tomcat (Apache Tomcat/4.1-dev) 
# 
# Adapt the following lines to your configuration 

JAVA_HOME=/usr/jdk1.5.0 
CATALINA_HOME=/apache/tomcat
DAEMON_HOME=$CATALINA_HOME/bin/jsvc-src 
TOMCAT_USER=root
TMP_DIR=/var/tmp 
CATALINA_OPTS= 
CLASSPATH=$JAVA_HOME/lib/tools.jar:$CATALINA_HOME/bin/commons-daemon.jar:$CATALINA_HOME/bin/bootstrap.jar

start(){ 
echo -n $"Starting $prog: " 
    #
    # Start Tomcat
    #
    $DAEMON_HOME/jsvc \
    -user $TOMCAT_USER \
    -home $JAVA_HOME \
    -Dcatalina.home=$CATALINA_HOME \
    -Djava.io.tmpdir=$TMP_DIR \
    -outfile $CATALINA_HOME/logs/catalina.out \
    -errfile '&1' \
    $CATALINA_OPTS \
    -cp $CLASSPATH \
    org.apache.catalina.startup.Bootstrap
    #
    # To get a verbose JVM
    #-verbose \
    # To get a debug of jsvc.
    #-debug \
    RETVAL=$? 
    [ $RETVAL = 0 ] && touch /var/lock/subsys/jsvc 
    [ $RETVAL = 0 ] && echo_success || echo_failure 
    echo 
    return $RETVAL 
} 
stop(){ 
    echo -n $"Stopping $prog: " 
    # 
    # Stop Tomcat 
    # 
    PID=`cat /var/run/jsvc.pid` 
    kill $PID 
    RETVAL=$? 
    [ $RETVAL = 0 ] && rm /var/lock/subsys/jsvc 
    [ $RETVAL = 0 ] && echo_success || echo_failure 
    echo 
    return $RETVAL 
} 

case "$1" in 
start) 
start 
;; 

stop) 
stop 
;; 

restart|reload) 
stop 
start 
;; 

*) 
echo "Usage $0 start/stop" 
exit 1;; 
esac

修改下载的脚本里面有关路径的信息以及要启动Tomcat的用户(用户必须已存在)
拷贝脚本到/etc/rc.d/init.d目录下的tomcat文件，给该脚本赋予可执行权限

chmod +x tomcat
你可以使用命令

/etc/rc.d/init.d/tomcat start|stop 

来验证守护进程是否可以正常启动和停止。

接下来就是把这个脚本设置成系统启动时自动执行，系统关闭时自动停止，使用如下命令：
chkconfig --add tomcat
重新启动系统后可以启动的过程中看到Starting Tomcat ..... [OK]的信息，这样就完成设置过程。

Tomcat 5.5.15 和SQLServer2000 SP3基于SQLServer2000JDBC SP3 的连接池配制
一、准备
需要下载：
1． tomcat5.5.15
2． Tomcat5.5.15admin
3． SQLServer2000JDBC SP3或者jtds

安装tomcat。并添加admin角色和用户。
将jdbc驱动包放到tomcat_home\common\lib目录下。
在MyEclipse建立一个新的Web项目。使用刚才配置的tomcat作为服务器。

启动tomcat。

二、配置
打开tomcat。
 
登录 Tomcat Web Server Administration Tool.

 
点击左侧的Data Sources。
 
在右侧Available Actions下拉菜单中选择Create New Data Source.
 
输入
JNDI Name：
Data Source URL：
JDBC Driver Class：
User Name：
Password：
Max.Active Connections：最大活动连结数 ，0为不限 。
Max.Idle Connections：最大等待连结数 ，0为不限 。
Max.Wait for Connection：建立连接超时时间ms,-1为无限 。

注：使用SQLServer的官方JDBC驱动，Class=com.microsoft.jdbc.sqlserver.SQLServerDriver，URL=jdbc:Microsoft:sqlserver://127.0.0.1:1433;databaseName=aa；使用开源的驱动Jtds，Class=net.sourceforge.jtds.jdbc.sqlserver，URL=jdbc:jtds:sqlserver://127.0.0.1:1433/aa

输入完毕，点击“Save”按钮保存。
 
点击页面右上侧“Commit Changes”按钮，保存刚才的设置。（这一步很重要哦！）

打开tomcat_home\conf\server.xml的< GlobalNamingResources></ GlobalNamingResources>中找到

    <Resource
      name="jdbc/mydbcp"
      type="javax.sql.DataSource"
      password="aa"
      driverClassName="com.microsoft.jdbc.sqlserver.SQLServerDriver"
      maxIdle="2"
      maxWait="5000"
      username="aa"
      url="jdbc:microsoft:sqlserver://10.0.2.37:1433;databaseName=aa"
      maxActive="4"/>
这是JNDI的主要配置文件，可以不使用图形界面直接写入server.xml中。
在tomcat_home\webapps\dbcp\ META-INF\context.xml的<context></context>中填入上面的代码。
如果更改了JNDI，则必须手动更改context.xml。

    <Resource
      name="mydbcp" 注：此处不同
      type="javax.sql.DataSource"
      password="aa"
      driverClassName="com.microsoft.jdbc.sqlserver.SQLServerDriver"
      maxIdle="2"
      maxWait="5000"
      username="aa"
      url="jdbc:microsoft:sqlserver://10.0.2.37:1433;databaseName=aa"
      maxActive="4"/>
和
  <ResourceLink
    global="jdbc/mydbcp"
    name="jdbc/mydbcp"
type="javax.sql.DataSource"/>

重起tomcat。

连接方法：

    Context initCtx = new InitialContext();
    Context envCtx = (Context) initCtx.lookup("java:comp/env");
    DataSource ds = (DataSource) envCtx.lookup("jdbc/mydbcp");
    Connection conn = ds.getConnection();
    Statement stmt = conn.createStatement();
    ResultSet rs = stmt.executeQuery("select * from systypes");
三、测试

测试实例：test.jsp

<%@ page language="java" pageEncoding="UTF-8"%>
<%@ page contentType="text/html; charset=UTF-8"%>
<%@ page import="java.sql.*,javax.sql.DataSource,javax.naming.*"%>
<html>
 <head>
  <title>
   tomcat 连接池
  </title>
 </head>
 <body bgcolor="#ffffff">
  <h3>
   test
   <br>
   连接池3
  </h3>
  <%try {
    Context initCtx = new InitialContext();
    Context envCtx = (Context) initCtx.lookup("java:comp/env");
    DataSource ds = (DataSource) envCtx.lookup("jdbc/mydbcp");
    Connection conn = ds.getConnection();
    Statement stmt = conn.createStatement();
    ResultSet rs = stmt.executeQuery("select * from systypes");
    while (rs.next()) {%>

  <br>
  <%=rs.getString(1)%>
  <%}%>
  <%out.print("<br>Successful!成功！！\n");%>
  <%rs.close();
    stmt.close();
    conn.close();
   } catch (Exception e) {
    out.print("出现例外！" + e.getMessage());
    e.printStackTrace();
   }

  %>

 </body>
</html>

四、错误

错误1：Cannot load JDBC driver class 'com.microsoft.jdbc.sqlserver.SQLServerDriver'
是没有将sql jdbc driver包放在common\lib\目录下。

错误2：Cannot create PoolableConnectionFactory ([Microsoft][SQLServer 2000 Driver for JDBC]Error establishing socket.)
SQL数据库补丁包的问题，如果访问的数据库是SP3，任何问题没有。不是SP3就会出现上面的错误。

错误3：Name mydbcp is not bound in this Context
在context.xml中加入
<ResourceLink
    global="jdbc/mydbcp"
    name="jdbc/mydbcp"
type="javax.sql.DataSource"/>

一、jsp连接Oracle8/8i/9i数据库（用thin模式）

 　　testoracle.jsp如下：

<%@ page contentType=
"text/html;charset=gb2312"%> 
　　<%@ page import="java.sql.*"%> 
　　<html> 
　　<body> 
　　<%Class.forName
("oracle.jdbc.driver.OracleDriver").newInstance(); 
　　String url="jdbc:oracle:thin:@localhost:1521:orcl"; 
　　//orcl为你的数据库的SID 
　　String user="scott"; 
　　String password="tiger"; 
　　Connection conn= 
DriverManager.getConnection(url,user,password); 
　　Statement stmt=conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE); 
　　String sql="select * from test"; 
　　ResultSet rs=stmt.executeQuery(sql); 
　　while(rs.next()) {%> 
　　您的第一个字段内容为：<%=rs.getString(1)%> 
　　您的第二个字段内容为：<%=rs.getString(2)%> 
　　<%}%> 
　　<%out.print("数据库操作成功，恭喜你");%> 
　　<%rs.close(); 
　　stmt.close(); 
　　conn.close(); 
　　%> 
　　</body> 
　　</html>

<%@ page contentType=
"text/html;charset=gb2312"%> 
　　<%@ page import="java.sql.*"%> 
　　<html> 
　　<body> 
　　<%Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver")
.newInstance(); 
　　String　url="jdbc:microsoft:sqlserver:
//localhost:1433;DatabaseName=pubs"; 
　　//pubs为你的数据库的 
　　String user="sa"; 
　　String password=""; 　　
　　Connection conn= DriverManager.getConnection
(url,user,password); 
　　Statement stmt=conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE); 
　　String sql="select * from test"; 
　　ResultSet rs=stmt.executeQuery(sql); 
　　while(rs.next()) {%> 
　　您的第一个字段内容为：<%=rs.getString(1)%> 
　　您的第二个字段内容为：<%=rs.getString(2)%> 
　　<%}%> 
　　<%out.print("数据库操作成功，恭喜你");%> 
　　<%rs.close(); 
　　stmt.close(); 
　　conn.close(); 　　
　　%> 
　　</body> 
　　</html>

<%@ page contentType=
"text/html;charset=gb2312"%> 
　　<%@ page import="java.sql.*"%> 
　　<html> 
　　<body> 
　　<%Class.forName
("com.ibm.db2.jdbc.app.DB2Driver ").newInstance(); 
　　String url="jdbc:db2://localhost:5000/sample"; 
　　//sample为你的数据库名 
　　String user="admin"; 
　　String password=""; 
　　Connection conn= 
DriverManager.getConnection(url,user,password); 
　　Statement stmt=conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE); 
　　String sql="select * from test"; 
　　ResultSet rs=stmt.executeQuery(sql); 
　　while(rs.next()) {%> 
　　您的第一个字段内容为：<%=rs.getString(1)%> 
　　您的第二个字段内容为：<%=rs.getString(2)%> 
　　<%}%> 
　　<%out.print("数据库操作成功，恭喜你");%> 
　　<%rs.close(); 
　　stmt.close(); 
　　conn.close(); 
　　%> 
　　</body> 
　　</html>

四、jsp连接Informix数据库

 　　testinformix.jsp如下：

<%@ page contentType="text/html;charset=gb2312"%> 
　　<%@ page import="java.sql.*"%> 
　　<html> 
　　<body> 
　　<%Class.forName("com.informix.jdbc.IfxDriver").newInstance(); 
　　String url = 
　　"jdbc:informix-sqli://123.45.67.89:1533
/testDB:INFORMIXSERVER=myserver; 
　　user=testuser;password=testpassword"; 
　　//testDB为你的数据库名 
　　Connection conn= DriverManager.getConnection(url); 
　　Statement stmt=conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE); 
　　String sql="select * from test"; 
　　ResultSet rs=stmt.executeQuery(sql); 
　　while(rs.next()) {%> 
　　您的第一个字段内容为：<%=rs.getString(1)%> 
　　您的第二个字段内容为：<%=rs.getString(2)%> 
　　<%}%> 
　　<%out.print("数据库操作成功，恭喜你");%> 
　　<%rs.close(); 
　　stmt.close(); 
　　conn.close(); 
　　%> 
　　</body> 
　　</html>

<%@ page contentType
="text/html;charset=gb2312"%> 
　　<%@ page import="java.sql.*"%> 
　　<html> 
　　<body> 
　　<%Class.forName
("com.sybase.jdbc.SybDriver").newInstance(); 
　　String url =" jdbc:sybase:Tds:localhost:5007/tsdata"; 
　　//tsdata为你的数据库名 
　　Properties sysProps = System.getProperties(); 
　　SysProps.put("user","userid"); 
　　SysProps.put("password","user_password"); 
　　Connection conn= 
DriverManager.getConnection(url, SysProps); 
　　Statement stmt=conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE); 
　　String sql="select * from test"; 
　　ResultSet rs=stmt.executeQuery(sql); 
　　while(rs.next()) {%> 
　　您的第一个字段内容为：<%=rs.getString(1)%> 
　　您的第二个字段内容为：<%=rs.getString(2)%> 
　　<%}%> 
　　<%out.print("数据库操作成功，恭喜你");%> 
　　<%rs.close(); 
　　stmt.close(); 
　　conn.close(); 
　　%> 
　　</body> 
　　</html>

<%@ page contentType
="text/html;charset=gb2312"%> 
　　<%@ page import="java.sql.*"%> 
　　<html> 
　　<body> 
　　<%Class.forName("org.gjt.mm.mysql.Driver").newInstance(); 
　　String url="jdbc:mysql://localhost/softforum?user=soft&password=soft1234&useUnicode=true&characterEncoding=8859_1" 
　　//testDB为你的数据库名 
　　Connection conn= DriverManager.getConnection(url); 
　　Statement stmt=conn.createStatement(ResultSet.TYPE_SCRLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE); 
　　String sql="select * from test"; 
　　ResultSet rs=stmt.executeQuery(sql); 
　　while(rs.next()) {%> 
　　您的第一个字段内容为：<%=rs.getString(1)%> 
　　您的第二个字段内容为：<%=rs.getString(2)%> 
　　<%}%> 
　　<%out.print("数据库操作成功，恭喜你");%> 
　　<%rs.close(); 
　　stmt.close(); 
　　conn.close(); 
　　%> 
　　</body> 
　　</html>

<%@ page contentType
="text/html;charset=gb2312"%> 
　　<%@ page import="java.sql.*"%> 
　　<html> 
　　<body> 
　　<%Class.forName("org.postgresql.Driver").newInstance(); 
　　String url ="jdbc:postgresql://localhost/soft" 
　　//soft为你的数据库名 
　　String user="myuser"; 
　　String password="mypassword"; 
　　Connection conn= 
DriverManager.getConnection(url,user,password); 
　　Statement stmt=conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE); 
　　String sql="select * from test"; 
　　ResultSet rs=stmt.executeQuery(sql); 
　　while(rs.next()) {%> 
　　您的第一个字段内容为：<%=rs.getString(1)%> 
　　您的第二个字段内容为：<%=rs.getString(2)%> 
　　<%}%> 
　　<%out.print("数据库操作成功，恭喜你");%> 
　　<%rs.close(); 
　　stmt.close(); 
　　conn.close(); 
　　%> 
　　</body> 
　　</html>

假设你的属性文件Proxool.properties中有数据库配置信息：
jdbc-0.proxool.alias=Access
jdbc-0.proxool.driver-class=sun.jdbc.odbc.JdbcOdbcDriver
jdbc-0.proxool.driver-url=jdbc:odbc:cwb

jdbc-0.proxool.maximum-connection-count=20
jdbc-0.proxool.prototype-count=4

jdbc-0.proxool.house-keeping-test-sql=select CURRENT_DATE
jdbc-0.proxool.verbose=true
jdbc-0.proxool.statistics=10s,1m,1d
jdbc-0.proxool.statistics-log-level=ERROR

你将这个属性文件放到你的WEB应用程序的web-info/classes目录下，在bean或类文件中访问这个属性文件
的传统方法莫过如此：

package examples;
import java.io.*;
import java.util.*;

public class EnvironmentConfig {
	static EnvironmentConfig ec;//创建对象ec
	private static Hashtable register = new Hashtable();//静态对象初始化[在其它对象之前]

    private EnvironmentConfig() {
        super();
    }

    /**
     * 取得EnvironmentConfig的一个实例
     * @return ec
     */
    public static EnvironmentConfig getInstance() {
        if (ec==null)
            ec = new EnvironmentConfig();//创建EnvironmentConfig对象
        return ec;//返回EnvironmentConfig对象
    }

    /**
     * 读取配置文件
     * @param java.lang.String fileName
     * @return Properties
     */

    public Properties getProperties(String fileName) {//传递配置文件路径
        InputStream is=null;//定义输入流is
        Properties p = null;
        try{
            p = (Properties)register.get(fileName);//将fileName存于一个HashTable
            /**
             * 如果为空就尝试输入进文件
             */
            if (p==null) {
                try{
                    is = new FileInputStream(fileName);//创建输入流
                }
                catch(Exception e){
                    if (fileName.startsWith("/"))
                        //用getResourceAsStream()方法用于定位并打开外部文件。
                        is = EnvironmentConfig.class.getResourceAsStream(fileName);
                    else
                        is = EnvironmentConfig.class.getResourceAsStream("/"+fileName);
                }
                p = new Properties();
                p.load(is);//加载输入流
                register.put(fileName, p);//将其存放于HashTable缓存
                is.close();//关闭输入流
            }
		}
		catch(Exception e){
		     e.printStackTrace(System.out);
		}
        return p;//返回Properties对象
    }

    /**
     * 此处插入方法描述。
     * 创建日期：(2003-8-10 12:30:09)
     * @param fileName java.lang.String
     * @param strKey java.lang.String
     */

    public String getPropertyValue(String fileName, String strKey) {
        Properties p = getProperties(fileName);
		try{
            return (String)p.getProperty(strKey);
        }
        catch(Exception e){
            e.printStackTrace(System.out);
        }
        return null;
    }
}

下面是jsp测试：testpro.jsp

<%@ page contentType="text/html; charset=GBK" %>
<%@ page import="examples.EnvironmentConfig" %>
<%@ page import="java.util.*" %>

配置文件测试<br>
<%
EnvironmentConfig ec=EnvironmentConfig.getInstance();
//Properties p=ec.getProperties("/Proxool.properties");
String s=ec.getPropertyValue("/Proxool.properties","jdbc-0.proxool.driver-class");
out.println("jdbc-0.proxool.driver-class="+s);

%>

运行结果：

配置文件测试
jdbc-0.proxool.driver-class=sun.jdbc.odbc.JdbcOdbcDriver

在tomcat 5.5.x下测试成功。

在JSP中连接到Oracle一般有2种方式：

　　1、Oracle JDBC的oci8方式

　　2、Oracle JDBC的thin方式 

　　我比较喜欢第2种，因为WEB发布服务器与数据库服务器一般都不会放在同一台电脑中，而在使用thin方式连接时，WEB服务器端无须安装oracle的客户端。

　　在动手先代码之前，我们先把环境配置妥善。先从安装了Oracle的数据库服务器中，找到Oracle安装目录，然后将该目录下的jdbc\lib\classes12.jar文件拷贝到WEB发布服务器的某个目录。假设就直接放在C:\根目录下吧，然后把该路径添加到‘系统--高级--环境变量’中变量名为‘CLASSPATH’的值中，如：D:\Program Files\SQLLIB\java\db2java.zip;D:\Program Files\SQLLIB\java\runtime.zip;c:classes12.jar; 也就是让java能够找到这个包。

　　配置好环境后，我们就开始开始动手写代码了。关于数据库连接的代码，应该写个专门的连接类来调用，没必要想网络上有些文章那样，直接写到JSP的代码中。

　　关于连接的代码很简单

private Connection newConnection(String user,String password) {
Connection con = null; 
try { 
Class.forName("oracle.jdbc.driver.OracleDriver").newInstance(); 
con = DriverManager.getConnection (“jdbc:oracle:thin:@192.168.96.1:1521:oracle9i”,user,password); 
} 
catch (SQLException e) { 
return null; 
} 
return con; 
}  

　　如果帐号密码没有错，那这个函数就应该能返回个可用的连接。但如此简单的连接在一个项目中使用，是远远达不到效果的。我们可以在这个数据库连接类中加入更多的功能，如连接池等等。下面我就把该数据库连接类的代码详细的列来，大家可以参考参考。

/*
* @Title 公司网站
* @Author: zf
* @Version 1.0
* @Memo:定义数据库连接及其数据库连接池等
*/
package com.kingson.db;

import java.io.*;
import java.sql.*;
import java.util.*;
import java.util.Date;

public class DBConnectionManager {
static private DBConnectionManager instance; // 唯一实例
static private int clients;

private Vector drivers = new Vector();
private PrintWriter log;
private Hashtable pools = new Hashtable();

/**
* 返回唯一实例.如果是第一次调用此方法,则创建实例
*
* @return DBConnectionManager 唯一实例
*/
static synchronized public DBConnectionManager getInstance() {
if (instance == null) {
instance = new DBConnectionManager();
}
clients++;
return instance;
}

/**
* 建构函数私有以防止其它对象创建本类实例
*/
private DBConnectionManager() {
init();
}

/**
* 将连接对象返回给由名字指定的连接池
*
* @param name 在属性文件中定义的连接池名字
* @param con 连接对象
*/
public void freeConnection(String name, Connection con) {
DBConnectionPool pool = (DBConnectionPool) pools.get(name);
if (pool != null) {
pool.freeConnection(con);
}
}

/**
* 获得一个可用的(空闲的)连接.如果没有可用连接,且已有连接数小于最大连接数
* 限制,则创建并返回新连接
*
* @param name 在属性文件中定义的连接池名字
* @return Connection 可用连接或null
*/
public Connection getConnection(String name) {
DBConnectionPool pool = (DBConnectionPool) pools.get(name);
if (pool != null) {
return pool.getConnection();
}
return null;
}

/**
* 获得一个可用连接.若没有可用连接,且已有连接数小于最大连接数限制,
* 则创建并返回新连接.否则,在指定的时间内等待其它线程释放连接.
*
* @param name 连接池名字
* @param time 以毫秒计的等待时间
* @return Connection 可用连接或null
*/
public Connection getConnection(String name, long time) {
DBConnectionPool pool = (DBConnectionPool) pools.get(name);
if (pool != null) {
return pool.getConnection(time);
}
return null;
}

/**
* 关闭所有连接,撤销驱动程序的注册
*/
public synchronized void release() {
// 等待直到最后一个客户程序调用
if (--clients != 0) {
return;
}

Enumeration allPools = pools.elements();
while (allPools.hasMoreElements()) {
DBConnectionPool pool = (DBConnectionPool) allPools.nextElement();
pool.release();
}
Enumeration allDrivers = drivers.elements();
while (allDrivers.hasMoreElements()) {
Driver driver = (Driver) allDrivers.nextElement();
try {
DriverManager.deregisterDriver(driver);
log("撤销JDBC驱动程序 " + driver.getClass().getName()+"的注册");
}
catch (SQLException e) {
log(e, "无法撤销下列JDBC驱动程序的注册: " + driver.getClass().getName());
}
}
}

/**
* 根据指定属性创建连接池实例.
*
* @param props 连接池属性
*/
private void createPools(Properties props) {
Enumeration propNames = props.propertyNames();
while (propNames.hasMoreElements()) {
String name = (String) propNames.nextElement();
if (name.endsWith(".url")) {
String poolName = name.substring(0, name.lastIndexOf("."));
String url = props.getProperty(poolName + ".url");
if (url == null) {
log("没有为连接池" + poolName + "指定URL");
continue;
}
String user = props.getProperty(poolName + ".user");
String password = props.getProperty(poolName + ".password");
String dbip = props.getProperty(poolName + ".db_ip", "192.168.96.1");
String dbport = props.getProperty(poolName + ".db_port", "1521");
String dbuid = props.getProperty(poolName + ".db_uid", "ORACLE9I");
String maxconn = props.getProperty(poolName + ".maxconn", "0");
//连接信息
String dbInfo = user + "/" + password + "@" + dbip + ":" + dbport + ":" + dbuid;
int max;
try {
max = Integer.valueOf(maxconn).intValue();
}
catch (NumberFormatException e) {
log("错误的最大连接数限制: " + maxconn + " .连接池: " + poolName);
max = 0;
}
DBConnectionPool pool = new DBConnectionPool(poolName, url,dbInfo, max);
pools.put(poolName, pool);
log("成功创建连接池" + poolName);
}
}
}

/**
* 读取属性完成初始化
*/
private void init() {
InputStream is = getClass().getResourceAsStream("db.properties");
Properties dbProps = new Properties();
try {
dbProps.load(is);
}
catch (Exception e) {
System.err.println("不能读取属性文件. " +
"请确保db.properties在CLASSPATH指定的路径中");
return;
}
String logFile = dbProps.getProperty("logfile", "newslog.txt");
try {
log = new PrintWriter(new FileWriter(logFile, true), true);
}
catch (IOException e) {
System.err.println("无法打开日志文件: " + logFile);
log = new PrintWriter(System.err);
}
loadDrivers(dbProps);
createPools(dbProps);
}

/**
* 装载和注册所有JDBC驱动程序
*
* @param props 属性
*/
private void loadDrivers(Properties props) {
String driverClasses = props.getProperty("driver");
StringTokenizer st = new StringTokenizer(driverClasses);
while (st.hasMoreElements()) {
String driverClassName = st.nextToken().trim();
try {
Driver driver = (Driver)
Class.forName(driverClassName).newInstance();
DriverManager.registerDriver(driver);
drivers.addElement(driver);
log("成功注册JDBC驱动程序" + driverClassName);
}
catch (Exception e) {
log("无法注册JDBC驱动程序: " +
driverClassName + ", 错误: " + e);
}
}
}

/**
* 将文本信息写入日志文件
*/
private void log(String msg) {
log.println(ew Date() + ": " + msg);
}

/**
* 将文本信息与异常写入日志文件
*/
private void log(Throwable e, String msg) {
log.println(new Date() + ": " + msg);
e.printStackTrace(log);
}

/***************连接池类*************************************************/

/**
* 此内部类定义了一个连接池.它能够根据要求创建新连接,直到预定的最
* 大连接数为止.在返回连接给客户程序之前,它能够验证连接的有效性.
*/
class DBConnectionPool {
private int checkedOut;
private Vector freeConnections = new Vector();
private int maxConn;
private String name;
private String URL;
private String dbInfo;

/**
* 创建新的连接池
*
* @param name 连接池名字
* @param URL 数据库的JDBC URL
* @param dbInfo 数据库连接信息
* @param maxConn 此连接池允许建立的最大连接数
*/
public DBConnectionPool(String name, String URL, String dbInfo, int maxConn) {
this.name = name;
this.URL = URL;
this.dbInfo = dbInfo;
this.maxConn = maxConn;
}

/**
* 将不再使用的连接返回给连接池
*
* @param con 客户程序释放的连接
*/
public synchronized void freeConnection(Connection con) {
// 将指定连接加入到向量末尾
freeConnections.addElement(con);
checkedOut--;
notifyAll();
}

/**
* 从连接池获得一个可用连接.如没有空闲的连接且当前连接数小于最大连接
* 数限制,则创建新连接.如原来登记为可用的连接不再有效,则从向量删除之,
* 然后递归调用自己以尝试新的可用连接.
*/
public synchronized Connection getConnection() {
Connection con = null;
if (freeConnections.size() > 0) {
// 获取向量中第一个可用连接
con = (Connection) freeConnections.firstElement();
freeConnections.removeElementAt(0);
try {
if (con.isClosed()) {
log("从连接池" + name+"删除一个无效连接");
// 递归调用自己,尝试再次获取可用连接
con = getConnection();
}
}
catch (SQLException e) {
log("从连接池" + name+"删除一个无效连接");
// 递归调用自己,尝试再次获取可用连接
con = getConnection();
}
}
else if (maxConn == 0 || checkedOut < maxConn) {
con = newConnection();
}
if (con != null) {
checkedOut++;
}
return con;
}

/**
* 从连接池获取可用连接.可以指定客户程序能够等待的最长时间
* 参见前一个getConnection()方法.
*
* @param timeout 以毫秒计的等待时间限制
*/
public synchronized Connection getConnection(long timeout) {
long startTime = new Date().getTime();
Connection con;
while ((con = getConnection()) == null) {
try {
wait(timeout);
}
catch (InterruptedException e) {}
if ((new Date().getTime() - startTime) >= timeout) {
// wait()返回的原因是超时
return null;
}
}
return con;
}

/**
* 关闭所有连接
*/
public synchronized void release() {
Enumeration allConnections = freeConnections.elements();
while (allConnections.hasMoreElements()) {
Connection con = (Connection) allConnections.nextElement();
try {
con.close();
log("关闭连接池" + name+"中的一个连接");
}
catch (SQLException e) {
log(e, "无法关闭连接池" + name+"中的连接");
}
}
freeConnections.removeAllElements();
}

/**
* 创建新的连接
*/
private Connection newConnection() {
Connection con = null; 
try { 
con = DriverManager.getConnection(URL+dbInfo); 
log("连接池" + name+"创建一个新的连接"); 
} 
catch (SQLException e) { 
log(e, "无法创建下列URL的连接: " + URL); 
return null; 
} 
return con; 
} 


}
}
 

<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/j2ee/dtds/web-app_2.3.dtd">

<web-app>

<!-- Listeners -->
<listener>
<listener-class>
SessionCount.SessionCounter
</listener-class>
</listener>

</web-app>
然后重新启动你的应用服务器，访问online.jsp检查是否显示正确。

本程序在Tomcat5.5X下调试成功，请多多指教！

一般情况下，在使用开发基于数据库的WEB程序时，传统的模式基本是按以下步骤：
　　1． 在主程序（如Servlet、Beans）中建立数据库连接。
　　2． 进行SQL操作，取出数据。
　　3． 断开数据库连接。
　　使用这种模式开发，存在很多问题。首先，我们要为每一次WEB请求（例如察看某一篇文章的内容）建立一次数据库连接，对于一次或几次操作来讲，或许你觉察不到系统的开销，但是，对于WEB程序来讲，即使在某一较短的时间段内，其操作请求数也远远不是一两次，而是数十上百次（想想全世界的网友都有可能在您的网页上查找资料），在这种情况下，系统开销是相当大的。事实上，在一个基于数据库的WEB系统中，建立数据库连接的操作将是系统中代价最大的操作之一。很多时候，可能您的网站速度瓶颈就在于此。
　　其次，使用传统的模式，你必须去管理每一个连接，确保他们能被正确关闭，如果出现程序异常而导致某些连接未能关闭，将导致数据库系统中的内存泄露，最终我们将不得不重启数据库。
　　针对以上问题，我们首先想到可以采用一个全局的Connection对象，创建后就不关闭，以后程序一直使用它，这样就不存在每次创建、关闭连接的问题了。但是，同一个连接使用次数过多，将会导致连接的不稳定，进而会导致WEB SERVER的频频重启。故而，这种方法也不可取。实际上，我们可以使用连接池技术来解决上述问题。首先，介绍一下连接池技术的基本原理。顾名思义，连接池最基本的思想就是预先建立一些连接放置于内存对象中以备使用：

如图所示，当程序中需要建立数据库连接时，只须从内存中取一个来用而不用新建。同样，使用完毕后，只需放回内存即可。而连接的建立、断开都有连接池自身来管理。同时，我们还可以通过设置连接池的参数来控制连接池中的连接数、每个连接的最大使用次数等等。通过使用连接池，将大大提高程序效率，同时，我们可以通过其自身的管理机制来监视数据库连接的数量、使用情况等。下面我们以一个名为ConnectionPool的连接池为例来看看连接池的实现。先看看ConnectionPool的基本属性：
　　m_ConnectionPoolSize：连接池中连接数量下限
　　m_ConnectionPoolMax：连接池中连接数量上限
　　m_ConnectionUseCount：一个连接的最大使用次数
　　m_ConnectionTimeout：一个连接的最长空闲时间
　　m_MaxConnections = -1：同一时间的最大连接数
　　m_timer：定时器
　　这些属性定义了连接池与其中的每个连接的有效状态值。连接池的自我管理，实际上就是通过定时的对每个连接的状态、连接的数量进行判断而进行相应操作。其管理流程如下：

通过上图，我们可以定义出ConnectionPool要完成管理所需要的基本接口：
public class ConnectionPool implements TimerListener{
　　public boolean initialize() //连接池初始化
　　public void destroy() //连接池的销毁
　　public synchronized java.sql.Connection getConnection() //取一个连接
　　public synchronized void close() //关闭一个连接
　　private synchronized void removeFromPool() //把一个连接从连接池中删除
　　private synchronized void fillPool() //维护连接池大小 　　public synchronized void TimerEvent() //定时器事件处理函数
}
　　通过这几个接口，已经可以完成连接池的基本管理。在TimeEvent（）函数中完成连接池的状态检验工作，fillPool()时连接池至少保持最小连接数。因为我们要保存每一个连接的状态，所以还需要一个数据库连接对象：
class ConnectionObject{
　　public java.sql.Connection con; public boolean inUse; //是否被使用标志
　　public long lastAccess; //最近一次开始使用时间
　　public int useCount; //被使用次数
}
加入了ConnectionObject对象后，在ConnectionPool中操作的应该只是ConnectionObject,而其他进程需要的只是ConnectionObject的con属性，因此我们再加入一个类，作为其他进程获得与返回连接的接口： CLASS Conn{
　　GetConnection(); //从连接池中取出一个有效连接
　　CloseConnection(); //返回连接，此时并没有关闭连接，只是放回了连接池
　　DestroyPool(); //销毁连接池
}
　　最后我们的整个系统总的架构如下：

通过上面的介绍，我们可以看出，连接池技术的关键就是其自身的管理机制，以上的管理流程只是本人一点见解，关键是想向大家介绍一种思路，在此基础上，您可以进一步完善连接池技术为您所用。