BlogJava-无所惧，无所悔,为梦想执着的拼搏-文章分类-Tomcat 技术文档http://www.blogjava.net/DreamFight/category/36494.htmlzh-cnSat, 01 May 2010 23:47:36 GMTSat, 01 May 2010 23:47:36 GMT60修改MYSQLroot密码命令http://www.blogjava.net/DreamFight/articles/319518.htmlDreamFightDreamFightTue, 27 Apr 2010 10:57:00 GMThttp://www.blogjava.net/DreamFight/articles/319518.htmlhttp://www.blogjava.net/DreamFight/comments/319518.htmlhttp://www.blogjava.net/DreamFight/articles/319518.html#Feedback0http://www.blogjava.net/DreamFight/comments/commentRss/319518.htmlhttp://www.blogjava.net/DreamFight/services/trackbacks/319518.html修改MYSQLroot密码命令
如果忘记密码快速的办法：

先确认已经杀掉mysqld 进程了，然后执行这个
/usr/bin/mysqld --skip-grant-tables &
再这样登录
mysql -h 192.168.1.2 -u root

这里192.168.1.2为你的机器ip地址,如果在本机可使用127.0.0.1
执行完上边的后执行：
use mysql;
update user set password =password('yourpass') where user='root'
这样您的root密码就修改ok了。

一、请问在win2K命令提示符下怎样更改mysql的root管理员密码？

>mysql -u root -p
Enter password: ******
mysql> use mysql;
mysql> update user set password=password('new_password') where user='root';

通过这种方法就可以直接修改密码了。至于在CMD下能否登陆MySQL，就要在Windows环境变量PATH中添加“C:\Program Files\MySQL\MySQL Server 5.0\bin;”（请改为你自己的安装路径）了。

二、MYSQL 修改root密码命令

cmd下切换到 mysql 安装目录
例
d:/mysql/bin
前提：mysql用户root密码为空.
输入 mysql -u root mysql
mysql> 状态下输入 update user set password=password('新密码') where user='root';
回显
Query OK, 0 rows affected (0.00 sec)
Rows matched: 2 Changed: 0 Warnings: 0
mysql> 状态下输入 FLUSH PRIVILEGES;
回显
Query OK, 0 rows affected (0.00 sec)
mysql> 状态下输入 quit
退出 sql

注意每个命令后都要加上一个分号 ";"
mysql 才开始执行该行命令
而第二个指令会让已载入记忆体的 mysql 系统资料库更新

重起 mysql .
在更新 root 密码後，日後要与 MySQL 连线的方法为：

mysql -uroot -p新密码

忘记mysql 的root 密码：
先确认已经杀掉mysqld 进程了，然后执行这个
/usr/bin/safe_mysqld --skip-grant-tables &
再这样登录
mysql -h 192.168.1.2 -u root
上边的192.168.1.2 是cloud 的mysqld 运行机器，你换成自己的，这样登录上
去，就可以修改密码了。
修改密码
1.mysql -h hostname –u root 命令登录到mysqld server 用grant 命令改变口令:
Grant all on *.* to root indentified by "111111"
2. mysqladmin -u 用户名-p 旧密码password 新密码
例1：给root 加个密码ab12。首先在DOS 下进入目录mysqlbin，然后键入
以下命令
mysqladmin -uroot password ab12
注：因为开始时root 没有密码，所以-p 旧密码一项就可以省略了。
2、例2：再将root 的密码改为djg345。
mysqladmin –u root -pab12 password djg345 (注意-p 不要和后面的密码分
开写，要写在一起)
3.
use mysql; update user set password =password('yourpass') where user='r
oot'
4. 载入权限表： `mysqladmin -h hostname flush-privileges' ，或者使
用SQL 命令`FLUSH PRIVILEGES'。（当然，在这里，你也可以重启mysqld。）
mysql 的建库，添加数据方法：
mysqi –u root
mysql>create database ttt;
mysql>source 1.txt
mysql>load data local infile "2.txt" into table board;
1.txt 内容:
CREATE TABLE board (
boardid int(11) NOT NULL auto_increment,
boardname char(255),
PRIMARY KEY (boardid)
);
2.txt 内容:
1 lk(Tab 键分开)
2 lklk
3 lklklk
导出database:
#mysqldump –opt ttt –uroot –p111111 > 111.sql
导入database
1. #mysql –u root –p111111 ttt < 111.sql
2. mysql>source 111.sql;
导出的多个database：#mysqldump –-databases ttt1 ttt2 ttt3 –uroot –p111111
> 111.sql
导出所有database：#mysqldump –-all-databases –uroot –p111111 > 111.sql


DreamFight 2010-04-27 18:57 发表评论
]]>为特定的web设置虚拟目录http://www.blogjava.net/DreamFight/articles/247866.htmlDreamFightDreamFightTue, 23 Dec 2008 01:59:00 GMThttp://www.blogjava.net/DreamFight/articles/247866.htmlhttp://www.blogjava.net/DreamFight/comments/247866.htmlhttp://www.blogjava.net/DreamFight/articles/247866.html#Feedback0http://www.blogjava.net/DreamFight/comments/commentRss/247866.htmlhttp://www.blogjava.net/DreamFight/services/trackbacks/247866.html 1.如果我有一个web它的位置在c:\myweb在这个目录下有一个jsp文件：a.jsp,在c:\myweb\image下有一个b.jsp文件
并且我在浏览器中输入http://localhost:8080/web可以访问到这个web

如果我没有设置虚拟目录的话我想要运行这个web必须要把这个文件复制到webapps下，但是现在由于需要我不能把它复制到这个目录下，所以我要设置虚拟目录。

首先我要打开conf/server.xml文件然后找到<host 这个标签，在里边加入：
<context path="/web" docbase="c:\myweb" reloadable="true">便可以了。
下面来说一上它的几个参数代表的意思：
path:就是你在地址栏中输入的web
docbase:就是你的实际目录c:\myweb
reloadable:就是让你的web 是否能够重加载

当们访问b.jsp的时候就可以在浏览器中输入：http://localhost:8080/web/image/b.jsp
如果在a.jsp中要做链接可以：
<a href="image/b.jsp">

DreamFight 2008-12-23 09:59 发表评论
]]>在Tomcat中添加多个监听端口http://www.blogjava.net/DreamFight/articles/247858.htmlDreamFightDreamFightTue, 23 Dec 2008 01:35:00 GMThttp://www.blogjava.net/DreamFight/articles/247858.htmlhttp://www.blogjava.net/DreamFight/comments/247858.htmlhttp://www.blogjava.net/DreamFight/articles/247858.html#Feedback0http://www.blogjava.net/DreamFight/comments/commentRss/247858.htmlhttp://www.blogjava.net/DreamFight/services/trackbacks/247858.html
 <Connector port="8080"
         maxThreads="150"
      minSpareThreads="25"
      maxSpareThreads="75"
               enableLookups="false"
      redirectPort="8443"
      acceptCount="100"
               debug="0"
      connectionTimeout="20000"
               disableUploadTimeout="true" />
把它复制一份 然后再其一粘贴，修改 port

DreamFight 2008-12-23 09:35 发表评论
]]>Tomcat-server.xml讲解http://www.blogjava.net/DreamFight/articles/247856.htmlDreamFightDreamFightTue, 23 Dec 2008 01:31:00 GMThttp://www.blogjava.net/DreamFight/articles/247856.htmlhttp://www.blogjava.net/DreamFight/comments/247856.htmlhttp://www.blogjava.net/DreamFight/articles/247856.html#Feedback0http://www.blogjava.net/DreamFight/comments/commentRss/247856.htmlhttp://www.blogjava.net/DreamFight/services/trackbacks/247856.html<!-- Example Server Configuration File -->
<!-- Note that component elements are nested corresponding to their
     parent-child relationships with each other -->
 
<!-- A "Server" is a singleton element that represents the entire JVM,
     which may contain one or more "Service" instances.  The Server
     listens for a shutdown command on the indicated port.
 
     Note:  A "Server" is not itself a "Container", so you may not
     define subcomponents such as "Valves" or "Loggers" at this level.
 -->
 
<Server port="8005" //监听端口
        shutdown="SHUTDOWN" //要监听的命令
  debug="0">
 

  <!-- Comment these entries out to disable JMX MBeans support -->
  <!-- You may also configure custom components (e.g. Valves/Realms) by
       including your own mbean-descriptor file(s), and setting the
       "descriptors" attribute to point to a ';' seperated list of paths
       (in the ClassLoader sense) of files to add to the default list.
       e.g. descriptors="/com/myfirm/mypackage/mbean-descriptor.xml"
  -->
  <Listener className="org.apache.catalina.mbeans.ServerLifecycleListener"
            debug="0"/>
  <Listener className="org.apache.catalina.mbeans.GlobalResourcesLifecycleListener"
            debug="0"/>
 
  <!-- Global JNDI resources -->
  <GlobalNamingResources>
 
    <!-- Test entry for demonstration purposes -->
    <Environment name="simpleValue" type="java.lang.Integer" value="30"/>
 
    <!-- Editable user database that can also be used by
         UserDatabaseRealm to authenticate users -->
    <Resource name="UserDatabase" auth="Container"
              type="org.apache.catalina.UserDatabase"
       description="User database that can be updated and saved">
    </Resource>
    <ResourceParams name="UserDatabase">
      <parameter>
        <name>factory</name>
        <value>org.apache.catalina.users.MemoryUserDatabaseFactory</value>
      </parameter>
      <parameter>
        <name>pathname</name>
        <value>conf/tomcat-users.xml</value>
      </parameter>
    </ResourceParams>
 
  </GlobalNamingResources>
 
  <!-- A "Service" is a collection of one or more "Connectors" that share
       a single "Container" (and therefore the web applications visible
       within that Container).  Normally, that Container is an "Engine",
       but this is not required.
 
       Note:  A "Service" is not itself a "Container", so you may not
       define subcomponents such as "Valves" or "Loggers" at this level.
   -->
 
  <!-- Define the Tomcat Stand-Alone Service -->
  <Service name="Catalina">
 
    <!-- A "Connector" represents an endpoint by which requests are received
         and responses are returned.  Each Connector passes requests on to the
         associated "Container" (normally an Engine) for processing.
 
         By default, a non-SSL HTTP/1.1 Connector is established on port 8080.
         You can also enable an SSL HTTP/1.1 Connector on port 8443 by
         following the instructions below and uncommenting the second Connector
         entry.  SSL support requires the following steps (see the SSL Config
         HOWTO in the Tomcat 5 documentation bundle for more detailed
         instructions):
         * If your JDK version 1.3 or prior, download and install JSSE 1.0.2 or
           later, and put the JAR files into "$JAVA_HOME/jre/lib/ext".
         * Execute:
             %JAVA_HOME%\bin\keytool -genkey -alias tomcat -keyalg RSA (Windows)
             $JAVA_HOME/bin/keytool -genkey -alias tomcat -keyalg RSA  (Unix)
           with a password value of "changeit" for both the certificate and
           the keystore itself.
 
         By default, DNS lookups are enabled when a web application calls
         request.getRemoteHost().  This can have an adverse impact on
         performance, so you can disable it by setting the
         "enableLookups" attribute to "false".  When DNS lookups are disabled,
         request.getRemoteHost() will return the String version of the
         IP address of the remote client.
    -->
 
    <!-- Define a non-SSL Coyote HTTP/1.1 Connector on the port specified
         during installation  -->
    <Connector port="8080"
         maxThreads="150"
      minSpareThreads="25"
      maxSpareThreads="75"
               enableLookups="false"
      redirectPort="8443"
      acceptCount="100"
               debug="0"
      connectionTimeout="20000"
               disableUploadTimeout="true" />
    <!-- Note : To disable connection timeouts, set connectionTimeout value
     to 0 -->
 
 <!-- Note : To use gzip compression you could set the following properties :
 
      compression="on"
      compressionMinSize="2048"
      noCompressionUserAgents="gozilla, traviata"
      compressableMimeType="text/html,text/xml"
 -->
 
    <!-- Define a SSL Coyote HTTP/1.1 Connector on port 8443 -->
    <!--
    <Connector port="8443"
               maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
               enableLookups="false" disableUploadTimeout="true"
               acceptCount="100" debug="0" scheme="https" secure="true"
               clientAuth="false" sslProtocol="TLS" />
    -->
 
    <!-- Define a Coyote/JK2 AJP 1.3 Connector on port 8009 -->
    <Connector port="8009"
               enableLookups="false" redirectPort="8443" debug="0"
               protocol="AJP/1.3" />
 
    <!-- Define a Proxied HTTP/1.1 Connector on port 8082 -->
    <!-- See proxy documentation for more information about using this. -->
    <!--
    <Connector port="8082"
               maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
               enableLookups="false"
               acceptCount="100" debug="0" connectionTimeout="20000"
               proxyPort="80" disableUploadTimeout="true" />
    -->
 
    <!-- An Engine represents the entry point (within Catalina) that processes
         every request.  The Engine implementation for Tomcat stand alone
         analyzes the HTTP headers included with the request, and passes them
         on to the appropriate Host (virtual host). -->
 
    <!-- You should set jvmRoute to support load-balancing via JK/JK2 ie :
    <Engine name="Standalone" defaultHost="localhost" debug="0" jvmRoute="jvm1">        
    -->
        
    <!-- Define the top level container in our container hierarchy -->
    <Engine name="Catalina"
      defaultHost="localhost" //缺省的服务器地址
   debug="0">
 
      <!-- The request dumper valve dumps useful debugging information about
           the request headers and cookies that were received, and the response
           headers and cookies that were sent, for all requests received by
           this instance of Tomcat.  If you care only about requests to a
           particular virtual host, or a particular application, nest this
           element inside the corresponding <Host> or <Context> entry instead.
 
           For a similar mechanism that is portable to all Servlet 2.4
           containers, check out the "RequestDumperFilter" Filter in the
           example application (the source for this filter may be found in
           "$CATALINA_HOME/webapps/examples/WEB-INF/classes/filters").
 
           Request dumping is disabled by default.  Uncomment the following
           element to enable it. -->
      <!--
      <Valve className="org.apache.catalina.valves.RequestDumperValve"/>
      -->
 
      <!-- Global logger unless overridden at lower levels -->
      <Logger className="org.apache.catalina.logger.FileLogger"
              prefix="catalina_log." suffix=".txt"
              timestamp="true"/>
 
      <!-- Because this Realm is here, an instance will be shared globally -->
 
      <!-- This Realm uses the UserDatabase configured in the global JNDI
           resources under the key "UserDatabase".  Any edits
           that are performed against this UserDatabase are immediately
           available for use by the Realm.  -->
      <Realm className="org.apache.catalina.realm.UserDatabaseRealm"
                 debug="0" resourceName="UserDatabase"/>
 
      <!-- Comment out the old realm but leave here for now in case we
           need to go back quickly -->
      <!--
      <Realm className="org.apache.catalina.realm.MemoryRealm" />
      -->
 
      <!-- Replace the above Realm with one of the following to get a Realm
           stored in a database and accessed via JDBC -->
 
      <!--
      <Realm  className="org.apache.catalina.realm.JDBCRealm" debug="99"
             driverName="org.gjt.mm.mysql.Driver"
          connectionURL="jdbc:mysql://localhost/authority"
         connectionName="test" connectionPassword="test"
              userTable="users" userNameCol="user_name" userCredCol="user_pass"
          userRoleTable="user_roles" roleNameCol="role_name" />
      -->
 
      <!--
      <Realm  className="org.apache.catalina.realm.JDBCRealm" debug="99"
             driverName="oracle.jdbc.driver.OracleDriver"
          connectionURL="jdbc:oracle:thin:@ntserver:1521:ORCL"
         connectionName="scott" connectionPassword="tiger"
              userTable="users" userNameCol="user_name" userCredCol="user_pass"
          userRoleTable="user_roles" roleNameCol="role_name" />
      -->
 
      <!--
      <Realm  className="org.apache.catalina.realm.JDBCRealm" debug="99"
             driverName="sun.jdbc.odbc.JdbcOdbcDriver"
          connectionURL="jdbc:odbc:CATALINA"
              userTable="users" userNameCol="user_name" userCredCol="user_pass"
          userRoleTable="user_roles" roleNameCol="role_name" />
      -->
 
      <!-- Define the default virtual host
           Note: XML Schema validation will not work with Xerces 2.2.
       -->
      <Host name="localhost" //服务器的地址
     debug="0"
   appBase="webapps" //服务器web的存放地址
            unpackWARs="true"
   autoDeploy="true"
            xmlValidation="false"
   xmlNamespaceAware="false">
 
        <!-- Defines a cluster for this node,
             By defining this element, means that every manager will be changed.
             So when running a cluster, only make sure that you have webapps in there
             that need to be clustered and remove the other ones.
             A cluster has the following parameters:
 
             className = the fully qualified name of the cluster class
 
             name = a descriptive name for your cluster, can be anything
 
             debug = the debug level, higher means more output
 
             mcastAddr = the multicast address, has to be the same for all the nodes
 
             mcastPort = the multicast port, has to be the same for all the nodes
 
             mcastFrequency = the number of milliseconds in between sending a "I'm alive" heartbeat
 
             mcastDropTime = the number a milliseconds before a node is considered "dead" if no heartbeat is received
 
             tcpThreadCount = the number of threads to handle incoming replication requests, optimal would be the same amount of threads as nodes
 
             tcpListenAddress = the listen address (bind address) for TCP cluster request on this host,
                                in case of multiple ethernet cards.
                                auto means that address becomes
                                InetAddress.getLocalHost().getHostAddress()
 
             tcpListenPort = the tcp listen port
 
             tcpSelectorTimeout = the timeout (ms) for the Selector.select() method in case the OS
                                  has a wakup bug in java.nio. Set to 0 for no timeout
 
             printToScreen = true means that managers will also print to std.out
 
             expireSessionsOnShutdown = true means that
 
             useDirtyFlag = true means that we only replicate a session after setAttribute,removeAttribute has been called.
                            false means to replicate the session after each request.
                            false means that replication would work for the following piece of code:
                            <%
                            HashMap map = (HashMap)session.getAttribute("map");
                            map.put("key","value");
                            %>
             replicationMode = can be either 'pooled', 'synchronous' or 'asynchronous'.
                               * Pooled means that the replication happens using several sockets in a synchronous way. Ie, the data gets replicated, then the request return. This is the same as the 'synchronous' setting except it uses a pool of sockets, hence it is multithreaded. This is the fastest and safest configuration. To use this, also increase the nr of tcp threads that you have dealing with replication.
                               * Synchronous means that the thread that executes the request, is also the
                               thread the replicates the data to the other nodes, and will not return until all
                               nodes have received the information.
                               * Asynchronous means that there is a specific 'sender' thread for each cluster node,
                               so the request thread will queue the replication request into a "smart" queue,
                               and then return to the client.
                               The "smart" queue is a queue where when a session is added to the queue, and the same session
                               already exists in the queue from a previous request, that session will be replaced
                               in the queue instead of replicating two requests. This almost never happens, unless there is a
                               large network delay.
        -->            
        <!--
            When configuring for clustering, you also add in a valve to catch all the requests
            coming in, at the end of the request, the session may or may not be replicated.
            A session is replicated if and only if all the conditions are met:
            1. useDirtyFlag is true or setAttribute or removeAttribute has been called AND
            2. a session exists (has been created)
            3. the request is not trapped by the "filter" attribute
 
            The filter attribute is to filter out requests that could not modify the session,
            hence we don't replicate the session after the end of this request.
            The filter is negative, ie, anything you put in the filter, you mean to filter out,
            ie, no replication will be done on requests that match one of the filters.
            The filter attribute is delimited by ;, so you can't escape out ; even if you wanted to.
 
            filter=".*\.gif;.*\.js;" means that we will not replicate the session after requests with the URI
            ending with .gif and .js are intercepted.
        -->
       
        <!--
        <Cluster className="org.apache.catalina.cluster.tcp.SimpleTcpCluster"
                 managerClassName="org.apache.catalina.cluster.session.DeltaManager"
                 expireSessionsOnShutdown="false"
                 useDirtyFlag="true">
 
            <Membership
                className="org.apache.catalina.cluster.mcast.McastService"
                mcastAddr="228.0.0.4"
                mcastPort="45564"
                mcastFrequency="500"
                mcastDropTime="3000"/>
 
            <Receiver
                className="org.apache.catalina.cluster.tcp.ReplicationListener"
                tcpListenAddress="auto"
                tcpListenPort="4001"
                tcpSelectorTimeout="100"
                tcpThreadCount="6"/>
 
            <Sender
                className="org.apache.catalina.cluster.tcp.ReplicationTransmitter"
                replicationMode="pooled"/>
 
            <Valve className="org.apache.catalina.cluster.tcp.ReplicationValve"
                   filter=".*\.gif;.*\.js;.*\.jpg;.*\.htm;.*\.html;.*\.txt;"/>
        </Cluster>
        -->       
 
 
 
        <!-- Normally, users must authenticate themselves to each web app
             individually.  Uncomment the following entry if you would like
             a user to be authenticated the first time they encounter a
             resource protected by a security constraint, and then have that
             user identity maintained across *all* web applications contained
             in this virtual host. -->
        <!--
        <Valve className="org.apache.catalina.authenticator.SingleSignOn"
                   debug="0"/>
        -->
 
        <!-- Access log processes all requests for this virtual host.  By
             default, log files are created in the "logs" directory relative to
             $CATALINA_HOME.  If you wish, you can specify a different
             directory with the "directory" attribute.  Specify either a relative
             (to $CATALINA_HOME) or absolute path to the desired directory.
        -->
        <!--
        <Valve className="org.apache.catalina.valves.AccessLogValve"
                 directory="logs"  prefix="localhost_access_log." suffix=".txt"
                 pattern="common" resolveHosts="false"/>
        -->
 
        <!-- Logger shared by all Contexts related to this virtual host.  By
             default (when using FileLogger), log files are created in the "logs"
             directory relative to $CATALINA_HOME.  If you wish, you can specify
             a different directory with the "directory" attribute.  Specify either a
             relative (to $CATALINA_HOME) or absolute path to the desired
             directory.-->
        <Logger className="org.apache.catalina.logger.FileLogger"
                 directory="logs"  prefix="localhost_log." suffix=".txt"
            timestamp="true"/>
 
      </Host>
 
    </Engine>
 
  </Service>
 
</Server>


DreamFight 2008-12-23 09:31 发表评论
]]>Tomcat中server.xml配置介绍http://www.blogjava.net/DreamFight/articles/247853.htmlDreamFightDreamFightTue, 23 Dec 2008 01:21:00 GMThttp://www.blogjava.net/DreamFight/articles/247853.htmlhttp://www.blogjava.net/DreamFight/comments/247853.htmlhttp://www.blogjava.net/DreamFight/articles/247853.html#Feedback0http://www.blogjava.net/DreamFight/comments/commentRss/247853.htmlhttp://www.blogjava.net/DreamFight/services/trackbacks/247853.html<Server port="8005" shutdown="SHUTDOWN" debug="0">  
<Listener className="org.apache.catalina.mbeans.ServerLifecycleListener"

            debug="0"/>

<Listener className="org.apache.catalina.mbeans.GlobalResourcesLifecycleListener"

            debug="0"/>

  <GlobalNamingResources>

<Environment name="simpleValue" type="java.lang.Integer" value="30"/>

    <Resource name="UserDatabase" auth="Container"

              type="org.apache.catalina.UserDatabase"

       description="User database that can be updated and saved">

    </Resource>

    <ResourceParams name="UserDatabase">

      <parameter>

        <name>factory</name>

        <value>org.apache.catalina.users.MemoryUserDatabaseFactory</value>

      </parameter>

      <parameter>

        <name>pathname</name>

        <value>conf/tomcat-users.xml</value>

      </parameter>

    </ResourceParams>

  </GlobalNamingResources>

  <Service name="Tomcat-Standalone">

    <Connector className="org.apache.coyote.tomcat4.CoyoteConnector"

port="8080"               minProcessors="5" maxProcessors="75"

               enableLookups="true" redirectPort="8443"

               acceptCount="100" debug="0" connectionTimeout="20000"

               useURIValidationHack="false" disableUploadTimeout="true" />

    <Connector className="org.apache.coyote.tomcat4.CoyoteConnector"

               port="8009" minProcessors="5" maxProcessors="75"

               enableLookups="true" redirectPort="8443"

               acceptCount="10" debug="0" connectionTimeout="20000"

               useURIValidationHack="false"

               protocolHandlerClassName="org.apache.jk.server.JkCoyoteHandler"/>

<Engine name="Standalone" defaultHost="localhost" debug="0">

<!--

<Valve className="org.apache.catalina.valves.RequestDumperValve"/>

-->

      <Logger className="org.apache.catalina.logger.FileLogger"

              prefix="catalina_log." suffix=".txt"

              timestamp="true"/>

      <Realm className="org.apache.catalina.realm.UserDatabaseRealm"

                 debug="0" resourceName="UserDatabase"/>

      <Host name="localhost" debug="0" appBase="webapps"

       unpackWARs="true" autoDeploy="true">

        <Logger className="org.apache.catalina.logger.FileLogger"

                 directory="logs"  prefix="localhost_log." suffix=".txt"

               timestamp="true"/>

<Context path="/gdqy" reloadable="true" docBase="D:/gdqy/ept" debug="0"

crossContext="true"/>

      </Host>

</Engine>

  </Service>

</Server>

1、server port：指定一个端口，这个端口负责监听关闭tomcat的请求

2、shut down：指定向端口发送的命令字符串

3、service name：指定service的名字

4、Connector：(表示客户端和service之间的连接)

port 指定服务器端要创建的端口号，并在这个断口监听来自客户端的请求

minProcessors：服务器启动时创建的处理请求的线程数

maxProcessors：最大可以创建的处理请求的线程数

enableLookups：如果为true，则可以通过调用request.getRemoteHost()进行DNS查询来得到远程客户端的实际主机名，若为false则不进行DNS查询，而是返回其ip地址

redirectPort：指定服务器正在处理http请求时收到了一个SSL传输请求后重定向的端口号

acceptCount 指定当所有可以使用的处理请求的线程数都被使用时，可以放到处理队列中的请求数，超过这个数的请求将不予处理

connectionTimeout 指定超时的时间数(以毫秒为单位)
5、Engine：(表示指定service中的请求处理机，接收和处理来自Connector的请求)

defaultHost：指定缺省的处理请求的主机名，它至少与其中的一个host元素的name属性值是一样的
6、Context：(表示一个web应用程序，通常为WAR文件，关于WAR的具体信息见servlet规范) docBase 应用程序的路径或者是WAR文件存放的路径

path：表示此web应用程序的url的前缀，这样请求的url为http://localhost:8080/path/****

reloadable：这个属性非常重要，如果为true，则tomcat会自动检测应用程序的/WEB-INF/lib 和/WEB-INF/classes目录的变化，自动装载新的应用程序，我们可以在不重起tomcat的情况下改变应用程序

7、host：(表示一个虚拟主机)

name：指定主机名

appBase：应用程序基本目录，即存放应用程序的目录

unpackWARs：如果为true，则tomcat会自动将WAR文件解压，否则不解压，直接从WAR文件中运行应用程序

8、Logger：(表示日志，调试和错误信息)

className 指定logger使用的类名，此类必须实现org.apache.catalina.Logger 接口

prefix：指定log文件的前缀

suffix：指定log文件的后缀

timestamp：如果为true，则log文件名中要加入时间，如下例:localhost_log.2001-10-04.txt
9、Realm：(表示存放用户名，密码及role的数据库)

className：指定Realm使用的类名，此类必须实现org.apache.catalina.Realm接口

10、Valve：(功能与Logger差不多，其prefix和suffix属性解释和Logger 中的一样)

className：指定Valve使用的类名，如用org.apache.catalina.valves.AccessLogValve类可以记录应用程序的访问信息

11、directory：指定log文件存放的位置

pattern 有两个值，common方式记录远程主机名或ip地址，用户名，日期，第一行请求的字符串，HTTP响应代码，发送的字节数。combined方式比common方式记录的值更多。

另附tomcat5中server.xml配置

<!-- Example Server Configuration File -->
<!-- Tomcat服务器配置示例文件 -->

<!-- Note that component elements are nested corresponding to their
      parent-child relationships with each other -->
<!-- 注意，这些组件的构成是根据相互之间的父子关系进行嵌套的。-->

<!-- A "Server" is a singleton element that represents the entire JVM,
      which may contain one or more "Service" instances. The Server
      listens for a shutdown command on the indicated port.

      Note: A "Server" is not itself a "Container", so you may not
      define subcomponents such as "Valves" or "Loggers" at this level.
-->
<!-- 一个“Server”是一个提供完整的JVM的独立组件，它可以包含一个或多个
      “Service”实例。服务器在指定的端口上监听shutdown命令。
    
      注意：一个“Server”自身不是一个“Container”（容器），因此在这里你
      不可以定义诸如“Valves”或者“Loggers”子组件
-->

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


   <!-- Comment these entries out to disable JMX MBeans support -->
   <!-- 这些指令组件关闭JMX MBeans支持 -->

   <!-- You may also configure custom components (e.g. Valves/Realms) by
        including your own mbean-descriptor file(s), and setting the
        "descriptors" attribute to point to a ';' seperated list of paths
        (in the ClassLoader sense) of files to add to the default list.
        e.g. descriptors="/com/myfirm/mypackage/mbean-descriptor.xml"
   -->
   <!-- 你也可以通过包含你自己的mbean描述文件配置自定义的组件，然后设置
        “descriptors”属性为以“；”为分隔的文件名列表严将它添加到默认列表
        中，例如：descriptors="/com/myfirm/mypackage/mbean-descriptor.xml"。
-->
      
   <Listener className="org.apache.catalina.mbeans.ServerLifecycleListener"
             debug="0"/>
   <Listener className="org.apache.catalina.mbeans.GlobalResourcesLifecycleListener"
             debug="0"/>

   <!-- Global JNDI resources -->
   <!-- 全局JNDI资源 -->
   <GlobalNamingResources>

     <!-- Test entry for demonstration purposes -->
     <!-- 出于示例目的的测试入口 -->
     <Environment name="simpleValue" type="java.lang.Integer" value="30"/>

     <!-- Editable user database that can also be used by
          UserDatabaseRealm to authenticate users -->
     <!-- 可编辑的，用来通过UserDatabaseRealm认证用户的用户数据库 -->
   
     <Resource name="UserDatabase" auth="Container"
               type="org.apache.catalina.UserDatabase"
        description="User database that can be updated and saved">
     </Resource>
     <ResourceParams name="UserDatabase">
       <parameter>
         <name>factory</name>
         <value>org.apache.catalina.users.MemoryUserDatabaseFactory</value>
       </parameter>
       <parameter>
         <name>pathname</name>
         <value>conf/tomcat-users.xml</value>
       </parameter>
     </ResourceParams>

   </GlobalNamingResources>

   <!-- A "Service" is a collection of one or more "Connectors" that share
        a single "Container" (and therefore the web applications visible
        within that Container). Normally, that Container is an "Engine",
        but this is not required.

        Note: A "Service" is not itself a "Container", so you may not
        define subcomponents such as "Valves" or "Loggers" at this level.
    -->
   <!-- 一个“Service”是一个或多个共用一个单独“Container”(容器)的“Connectors”
        组合（因此，应用程序在容器中可见）。通常，这个容器是一个“Engine”
        （引擎），但这不是必须的。
      
        注意：一个“Service”自身不是一个容器，因此，在这个级别上你不可定义
        诸如“Valves”或“Loggers”子组件。
   -->

DreamFight 2008-12-23 09:21 发表评论
]]>Tomcat 服务器server.xml的关键参数配置（三）http://www.blogjava.net/DreamFight/articles/247852.htmlDreamFightDreamFightTue, 23 Dec 2008 01:19:00 GMThttp://www.blogjava.net/DreamFight/articles/247852.htmlhttp://www.blogjava.net/DreamFight/comments/247852.htmlhttp://www.blogjava.net/DreamFight/articles/247852.html#Feedback0http://www.blogjava.net/DreamFight/comments/commentRss/247852.htmlhttp://www.blogjava.net/DreamFight/services/trackbacks/247852.html
　　1． 配置系统管理（Admin Web Application）

　　大多数商业化的J2EE服务器都提供一个功能强大的管理界面，且大都采用易于理解的Web应用界面。Tomcat按照自己的方式，同样提供一个成熟的管理工具，并且丝毫不逊于那些商业化的竞争对手。Tomcat的Admin Web Application最初在4.1版本时出现，当时的功能包括管理context、data source、user和group等。当然也可以管理像初始化参数，user、group、role的多种数据库管理等。在后续的版本中，这些功能将得到很大的扩展，但现有的功能已经非常实用了。

　　Admin Web Application被定义在自动部署文件：CATALINA_BASE/webapps/admin.xml 。
　　（译者注：CATALINA_BASE即tomcat安装目录下的server目录）

　　你必须编辑这个文件，以确定Context中的docBase参数是绝对路径。也就是说，CATALINA_BASE/webapps/admin.xml 的路径是绝对路径。作为另外一种选择，你也可以删除这个自动部署文件，而在server.xml文件中建立一个Admin Web Application的context，效果是一样的。你不能管理Admin Web Application这个应用，换而言之，除了删除CATALINA_BASE/webapps/admin.xml ，你可能什么都做不了。

　　如果你使用UserDatabaseRealm（默认），你将需要添加一个user以及一个role到CATALINA_BASE/conf/tomcat-users.xml 文件中。你编辑这个文件，添加一个名叫“admin”的role 到该文件中，如下：

＜role name="admin"/＞

　　你同样需要有一个用户，并且这个用户的角色是“admin”。象存在的用户那样，添加一个用户（改变密码使其更加安全）：

＜user name="admin" password="deep_dark_secret" roles="admin"/＞

　　当你完成这些步骤后，请重新启动Tomcat，访问http://localhost:8080/admin，你将看到一个登录界面。Admin Web Application采用基于容器管理的安全机制，并采用了Jakarta Struts框架。一旦你作为“admin”角色的用户登录管理界面，你将能够使用这个管理界面配置Tomcat。

　　2．配置应用管理（Manager Web Application）

　　Manager Web Application让你通过一个比Admin Web Application更为简单的用户界面，执行一些简单的Web应用任务。

　　Manager Web Application被被定义在一个自动部署文件中：

CATALINA_BASE/webapps/manager.xml 。

　　你必须编辑这个文件，以确保context的docBase参数是绝对路径，也就是说CATALINA_HOME/server/webapps/manager的绝对路径。
　　（译者注：CATALINA_HOME即tomcat安装目录）

　　如果你使用的是UserDatabaseRealm，那么你需要添加一个角色和一个用户到CATALINA_BASE/conf/tomcat-users.xml文件中。接下来，编辑这个文件，添加一个名为“manager”的角色到该文件中：

＜role name=”manager”＞

　　你同样需要有一个角色为“manager”的用户。像已经存在的用户那样，添加一个新用户（改变密码使其更加安全）：

＜user name="manager" password="deep_dark_secret" roles="manager"/＞

　　然后重新启动Tomcat，访问http://localhost/manager/list，将看到一个很朴素的文本型管理界面，或者访问http://localhost/manager/html/list，将看到一个HMTL的管理界面。不管是哪种方式都说明你的Manager Web Application现在已经启动了。

　　Manager application让你可以在没有系统管理特权的基础上，安装新的Web应用，以用于测试。如果我们有一个新的web应用位于/home/user/hello下在，并且想把它安装到 /hello下，为了测试这个应用，我们可以这么做，在第一个文件框中输入“/hello”（作为访问时的path），在第二个文本框中输入“file:/home/user/hello”（作为Config URL）。

　　Manager application还允许你停止、重新启动、移除以及重新部署一个web应用。停止一个应用使其无法被访问，当有用户尝试访问这个被停止的应用时，将看到一个503的错误??“503 - This application is not currently available”。

　　移除一个web应用，只是指从Tomcat的运行拷贝中删除了该应用，如果你重新启动Tomcat，被删除的应用将再次出现（也就是说，移除并不是指从硬盘上删除）。
3．部署一个web应用

　　有两个办法可以在系统中部署web服务。

　　1＞ 拷贝你的WAR文件或者你的web应用文件夹（包括该web的所有内容）到$CATALINA_BASE/webapps目录下。

　　2＞ 为你的web服务建立一个只包括context内容的XML片断文件，并把该文件放到$CATALINA_BASE/webapps目录下。这个web应用本身可以存储在硬盘上的任何地方。

　　如果你有一个WAR文件，你若想部署它，则只需要把该文件简单的拷贝到CATALINA_BASE/webapps目录下即可，文件必须以“.war”作为扩展名。一旦Tomcat监听到这个文件，它将（缺省的）解开该文件包作为一个子目录，并以WAR文件的文件名作为子目录的名字。接下来，Tomcat将在内存中建立一个context，就好象你在server.xml文件里建立一样。当然，其他必需的内容，将从server.xml中的DefaultContext获得。

　　部署web应用的另一种方式是写一个Context XML片断文件，然后把该文件拷贝到CATALINA_BASE/webapps目录下。一个Context片断并非一个完整的XML文件，而只是一个context元素，以及对该应用的相应描述。这种片断文件就像是从server.xml中切取出来的context元素一样，所以这种片断被命名为“context片断”。

　　举个例子，如果我们想部署一个名叫MyWebApp.war的应用，该应用使用realm作为访问控制方式，我们可以使用下面这个片断：

＜!--
Context fragment for deploying MyWebApp.war
--＞
＜Context path="/demo" docBase="webapps/MyWebApp.war"
debug="0" privileged="true"＞
＜Realm className="org.apache.catalina.realm.UserDatabaseRealm"
resourceName="UserDatabase"/＞
＜/Context＞

　　把该片断命名为“MyWebApp.xml”，然后拷贝到CATALINA_BASE/webapps目录下。

　　这种context片断提供了一种便利的方法来部署web应用，你不需要编辑server.xml，除非你想改变缺省的部署特性，安装一个新的web应用时不需要重启动Tomcat。

　　4．配置虚拟主机（Virtual Hosts）

　　关于server.xml中“Host”这个元素，只有在你设置虚拟主机的才需要修改。虚拟主机是一种在一个web服务器上服务多个域名的机制，对每个域名而言，都好象独享了整个主机。实际上，大多数的小型商务网站都是采用虚拟主机实现的，这主要是因为虚拟主机能直接连接到Internet并提供相应的带宽，以保障合理的访问响应速度，另外虚拟主机还能提供一个稳定的固定IP。

　　基于名字的虚拟主机可以被建立在任何web服务器上，建立的方法就是通过在域名服务器（DNS）上建立IP地址的别名，并且告诉web服务器把去往不同域名的请求分发到相应的网页目录。因为这篇文章主要是讲Tomcat，我们不准备介绍在各种操作系统上设置DNS的方法，如果你在这方面需要帮助，请参考《DNS and Bind》一书，作者是Paul Albitz and Cricket Liu (O'Reilly)。为了示范方便，我将使用一个静态的主机文件，因为这是测试别名最简单的方法。

　　在Tomcat中使用虚拟主机，你需要设置DNS或主机数据。为了测试，为本地IP设置一个IP别名就足够了，接下来，你需要在server.xml中添加几行内容，如下：

＜Server port="8005" shutdown="SHUTDOWN" debug="0"＞
＜Service name="Tomcat-Standalone"＞
＜Connector className="org.apache.coyote.tomcat4.CoyoteConnector"
port="8080" minProcessors="5" maxProcessors="75"
enableLookups="true" redirectPort="8443"/＞
＜Connector className="org.apache.coyote.tomcat4.CoyoteConnector"
port="8443" minProcessors="5" maxProcessors="75"
acceptCount="10" debug="0" scheme="https" secure="true"/＞
＜Factory className="org.apache.coyote.tomcat4.CoyoteServerSocketFactory"
clientAuth="false" protocol="TLS" /＞
＜/Connector＞
＜Engine name="Standalone" defaultHost="localhost" debug="0"＞
＜!-- This Host is the default Host --＞
＜Host name="localhost" debug="0" appBase="webapps"
unpackWARs="true" autoDeploy="true"＞
＜Context path="" docBase="ROOT" debug="0"/＞
＜Context path="/orders" docBase="/home/ian/orders" debug="0"
reloadable="true" crossContext="true"＞
＜/Context＞
＜/Host＞

＜!-- This Host is the first "Virtual Host": http://www.example.com/ --＞
＜Host name="www.example.com" appBase="/home/example/webapp"＞
＜Context path="" docBase="."/＞
＜/Host＞

＜/Engine＞
＜/Service＞
＜/Server＞

　　Tomcat的server.xml文件，在初始状态下，只包括一个虚拟主机，但是它容易被扩充到支持多个虚拟主机。在前面的例子中展示的是一个简单的server.xml版本，其中粗体部分就是用于添加一个虚拟主机。每一个Host元素必须包括一个或多个context元素，所包含的context元素中必须有一个是默认的context，这个默认的context的显示路径应该为空（例如，path=””）。
　5．配置基础验证（Basic Authentication）

　　容器管理验证方法控制着当用户访问受保护的web应用资源时，如何进行用户的身份鉴别。当一个web应用使用了Basic Authentication（BASIC参数在web.xml文件中auto-method元素中设置），而有用户访问受保护的web应用时，Tomcat将通过HTTP Basic Authentication方式，弹出一个对话框，要求用户输入用户名和密码。在这种验证方法中，所有密码将被以64位的编码方式在网络上传输。

　　注意：使用Basic Authentication通过被认为是不安全的，因为它没有强健的加密方法，除非在客户端和服务器端都使用HTTPS或者其他密码加密码方式（比如，在一个虚拟私人网络中）。若没有额外的加密方法，网络管理员将能够截获（或滥用）用户的密码。但是，如果你是刚开始使用Tomcat，或者你想在你的web应用中测试一下基于容器的安全管理，Basic Authentication还是非常易于设置和使用的。只需要添加＜security-constraint＞和＜login-config＞两个元素到你的web应用的web.xml文件中，并且在CATALINA_BASE/conf/tomcat-users.xml 文件中添加适当的＜role＞和＜user＞即可，然后重新启动Tomcat。

　　下面例子中的web.xml摘自一个俱乐部会员网站系统，该系统中只有member目录被保护起来，并使用Basic Authentication进行身份验证。请注意，这种方式将有效的代替Apache web服务器中的.htaccess文件。

＜!--
Define the Members-only area, by defining
a "Security Constraint" on this Application, and
mapping it to the subdirectory (URL) that we want
to restrict.
--＞
＜security-constraint＞
＜web-resource-collection＞
＜web-resource-name＞
Entire Application
＜/web-resource-name＞
＜url-pattern＞/members/*＜/url-pattern＞
＜/web-resource-collection＞
＜auth-constraint＞
＜role-name＞member＜/role-name＞
＜/auth-constraint＞
＜/security-constraint＞
＜!-- Define the Login Configuration for this Application --＞
＜login-config＞
＜auth-method＞BASIC＜/auth-method＞
＜realm-name＞My Club Members-only Area＜/realm-name＞
＜/login-config＞

　　6．配置单点登录（Single Sign-On）

　　一旦你设置了realm和验证的方法，你就需要进行实际的用户登录处理。一般说来，对用户而言登录系统是一件很麻烦的事情，你必须尽量减少用户登录验证的次数。作为缺省的情况，当用户第一次请求受保护的资源时，每一个web应用都会要求用户登录。如果你运行了多个web应用，并且每个应用都需要进行单独的用户验证，那这看起来就有点像你在与你的用户搏斗。用户们不知道怎样才能把多个分离的应用整合成一个单独的系统，所有他们也就不知道他们需要访问多少个不同的应用，只是很迷惑，为什么总要不停的登录。

　　Tomcat 4的“single sign-on”特性允许用户在访问同一虚拟主机下所有web应用时，只需登录一次。为了使用这个功能，你只需要在Host上添加一个SingleSignOn Valve元素即可，如下所示：

＜Valve className="org.apache.catalina.authenticator.SingleSignOn"
debug="0"/＞

　　在Tomcat初始安装后，server.xml的注释里面包括SingleSignOn Valve配置的例子，你只需要去掉注释，即可使用。那么，任何用户只要登录过一个应用，则对于同一虚拟主机下的所有应用同样有效。

　　使用single sign-on valve有一些重要的限制：

　　1＞ value必须被配置和嵌套在相同的Host元素里，并且所有需要进行单点验证的web应用（必须通过context元素定义）都位于该Host下。

　　2＞ 包括共享用户信息的realm必须被设置在同一级Host中或者嵌套之外。

　　3＞ 不能被context中的realm覆盖。

　　4＞ 使用单点登录的web应用最好使用一个Tomcat的内置的验证方式（被定义在web.xml中的＜auth-method＞中），这比自定义的验证方式强，Tomcat内置的的验证方式包括basic、digest、form和client-cert。

　　5＞ 如果你使用单点登录，还希望集成一个第三方的web应用到你的网站中来，并且这个新的web应用使用它自己的验证方式，而不使用容器管理安全，那你基本上就没招了。你的用户每次登录原来所有应用时需要登录一次，并且在请求新的第三方应用时还得再登录一次。当然，如果你拥有这个第三方web应用的源码，而你又是一个程序员，你可以修改它，但那恐怕也不容易做。

　　6＞ 单点登录需要使用cookies。

　7．配置用户定制目录（Customized User Directores）

　　一些站点允许个别用户在服务器上发布网页。例如，一所大学的学院可能想给每一位学生一个公共区域，或者是一个ISP希望给一些web空间给他的客户，但这又不是虚拟主机。在这种情况下，一个典型的方法就是在用户名前面加一个特殊字符（~），作为每位用户的网站，比如：

http://www.cs.myuniversity.edu/~username
http://members.mybigisp.com/~username

　　Tomcat提供两种方法在主机上映射这些个人网站，主要使用一对特殊的Listener元素。Listener的className属性应该是org.apache.catalina.startup.UserConfig，userClass属性应该是几个映射类之一。如果你的系统是Unix，它将有一个标准的/etc/passwd文件，该文件中的帐号能够被运行中的Tomcat很容易的读取，该文件指定了用户的主目录，使用PasswdUserDatabase 映射类。

＜Listener className="org.apache.catalina.startup.UserConfig"
directoryName="public_html"
userClass="org.apache.catalina.startup.PasswdUserDatabase"/＞

　　web文件需要放置在像/home/users/ian/public_html 或者 /users/jbrittain/public_html一样的目录下面。当然你也可以改变public_html 到其他任何子目录下。

　　实际上，这个用户目录根本不一定需要位于用户主目录下里面。如果你没有一个密码文件，但你又想把一个用户名映射到公共的像/home一样目录的子目录里面，则可以使用HomesUserDatabase类。

＜Listener className="org.apache.catalina.startup.UserConfig"
directoryName="public_html" homeBase="/home"
userClass="org.apache.catalina.startup.HomesUserDatabase"/＞

　　这样一来，web文件就可以位于像/home/ian/public_html 或者 /home/jasonb/public_html一样的目录下。这种形式对Windows而言更加有利，你可以使用一个像c:\home这样的目录。

　　这些Listener元素，如果出现，则必须在Host元素里面，而不能在context元素里面，因为它们都用应用于Host本身。

　　8．在Tomcat中使用CGI脚本

　　Tomcat主要是作为Servlet/JSP容器，但它也有许多传统web服务器的性能。支持通用网关接口（Common Gateway Interface，即CGI）就是其中之一，CGI提供一组方法在响应浏览器请求时运行一些扩展程序。CGI之所以被称为通用，是因为它能在大多数程序或脚本中被调用，包括：Perl，Python，awk，Unix shell scripting等，甚至包括Java。当然，你大概不会把一个Java应用程序当作CGI来运行，毕竟这样太过原始。一般而言，开发Servlet总要比CGI具有更好的效率，因为当用户点击一个链接或一个按钮时，你不需要从操作系统层开始进行处理。

　　Tomcat包括一个可选的CGI Servlet，允许你运行遗留下来的CGI脚本。

　　为了使Tomcat能够运行CGI，你必须做如下几件事：

　　1. 把servlets-cgi.renametojar （在CATALINA_HOME/server/lib/目录下）改名为servlets-cgi.jar。处理CGI的servlet应该位于Tomcat的CLASSPATH下。

　　2. 在Tomcat的CATALINA_BASE/conf/web.xml 文件中，把关于＜servlet-name＞ CGI的那段的注释去掉（默认情况下，该段位于第241行）。

　　3. 同样，在Tomcat的CATALINA_BASE/conf/web.xml文件中，把关于对CGI进行映射的那段的注释去掉（默认情况下，该段位于第299行）。注意，这段内容指定了HTML链接到CGI脚本的访问方式。

　　4. 你可以把CGI脚本放置在WEB-INF/cgi 目录下（注意，WEB-INF是一个安全的地方，你可以把一些不想被用户看见或基于安全考虑不想暴露的文件放在此处），或者你也可以把CGI脚本放置在context下的其他目录下，并为CGI Servlet调整cgiPathPrefix初始化参数。这就指定的CGI Servlet的实际位置，且不能与上一步指定的URL重名。

　　5. 重新启动Tomcat，你的CGI就可以运行了。

　　在Tomcat中，CGI程序缺省放置在WEB-INF/cgi目录下，正如前面所提示的那样，WEB-INF目录受保护的，通过客户端的浏览器无法窥探到其中内容，所以对于放置含有密码或其他敏感信息的CGI脚本而言，这是一个非常好的地方。为了兼容其他服务器，尽管你也可以把CGI脚本保存在传统的/cgi-bin目录，但要知道，在这些目录中的文件有可能被网上好奇的冲浪者看到。另外，在Unix中，请确定运行Tomcat的用户有执行CGI脚本的权限。

　9．改变Tomcat中的JSP编译器（JSP Compiler）

　　在Tomcat 4.1（或更高版本，大概），JSP的编译由包含在Tomcat里面的Ant程序控制器直接执行。这听起来有一点点奇怪，但这正是Ant有意为之的一部分，有一个API文档指导开发者在没有启动一个新的JVM的情况下，使用Ant。这是使用Ant进行Java开发的一大优势。另外，这也意味着你现在能够在Ant中使用任何javac支持的编译方式，这里有一个关于Apache Ant使用手册的javac page列表。使用起来是容易的，因为你只需要在＜init-param＞ 元素中定义一个名字叫“compiler”，并且在value中有一个支持编译的编译器名字，示例如下：

＜servlet＞
＜servlet-name＞jsp＜/servlet-name＞
＜servlet-class＞
org.apache.jasper.servlet.JspServlet
＜/servlet-class＞
＜init-param＞
＜param-name＞logVerbosityLevel＜/param-name＞
＜param-value＞WARNING＜/param-value＞
＜/init-param＞
＜init-param＞
＜param-name＞compiler＜/param-name＞
＜param-value＞jikes＜/param-value＞
＜/init-param＞
＜load-on-startup＞3＜/load-on-startup＞
＜/servlet＞

　　当然，给出的编译器必须已经安装在你的系统中，并且CLASSPATH可能需要设置，那处决于你选择的是何种编译器。

　　10．限制特定主机访问（Restricting Access to Specific Hosts）

　　有时，你可能想限制对Tomcat web应用的访问，比如，你希望只有你指定的主机或IP地址可以访问你的应用。这样一来，就只有那些指定的的客户端可以访问服务的内容了。为了实现这种效果，Tomcat提供了两个参数供你配置：RemoteHostValve 和RemoteAddrValve。

　　通过配置这两个参数，可以让你过滤来自请求的主机或IP地址，并允许或拒绝哪些主机/IP。与之类似的，在Apache的httpd文件里有对每个目录的允许/拒绝指定。

　　例如你可以把Admin Web application设置成只允许本地访问，设置如下：

＜Context path="/path/to/secret_files" ...＞
＜Valve className="org.apache.catalina.valves.RemoteAddrValve"
allow="127.0.0.1" deny=""/＞
＜/Context＞

　　如果没有给出允许主机的指定，那么与拒绝主机匹配的主机就会被拒绝，除此之外的都是允许的。与之类似，如果没有给出拒绝主机的指定，那么与允许主机匹配的主机

DreamFight 2008-12-23 09:19 发表评论
]]>Tomcat 服务器server.xml的关键参数配置（二）http://www.blogjava.net/DreamFight/articles/247851.htmlDreamFightDreamFightTue, 23 Dec 2008 01:18:00 GMThttp://www.blogjava.net/DreamFight/articles/247851.htmlhttp://www.blogjava.net/DreamFight/comments/247851.htmlhttp://www.blogjava.net/DreamFight/articles/247851.html#Feedback0http://www.blogjava.net/DreamFight/comments/commentRss/247851.htmlhttp://www.blogjava.net/DreamFight/services/trackbacks/247851.html
　　1． 配置系统管理（Admin Web Application）

　　大多数商业化的J2EE服务器都提供一个功能强大的管理界面，且大都采用易于理解的Web应用界面。Tomcat按照自己的方式，同样提供一个成熟的管理工具，并且丝毫不逊于那些商业化的竞争对手。Tomcat的Admin Web Application最初在4.1版本时出现，当时的功能包括管理context、data source、user和group等。当然也可以管理像初始化参数，user、group、role的多种数据库管理等。在后续的版本中，这些功能将得到很大的扩展，但现有的功能已经非常实用了。

　　Admin Web Application被定义在自动部署文件：CATALINA_BASE/webapps/admin.xml 。
　　（译者注：CATALINA_BASE即tomcat安装目录下的server目录）

　　你必须编辑这个文件，以确定Context中的docBase参数是绝对路径。也就是说，CATALINA_BASE/webapps/admin.xml 的路径是绝对路径。作为另外一种选择，你也可以删除这个自动部署文件，而在server.xml文件中建立一个Admin Web Application的context，效果是一样的。你不能管理Admin Web Application这个应用，换而言之，除了删除CATALINA_BASE/webapps/admin.xml ，你可能什么都做不了。

　　如果你使用UserDatabaseRealm（默认），你将需要添加一个user以及一个role到CATALINA_BASE/conf/tomcat-users.xml 文件中。你编辑这个文件，添加一个名叫“admin”的role 到该文件中，如下：

＜role name="admin"/＞

　　你同样需要有一个用户，并且这个用户的角色是“admin”。象存在的用户那样，添加一个用户（改变密码使其更加安全）：

＜user name="admin" password="deep_dark_secret" roles="admin"/＞

　　当你完成这些步骤后，请重新启动Tomcat，访问http://localhost:8080/admin，你将看到一个登录界面。Admin Web Application采用基于容器管理的安全机制，并采用了Jakarta Struts框架。一旦你作为“admin”角色的用户登录管理界面，你将能够使用这个管理界面配置Tomcat。

　　2．配置应用管理（Manager Web Application）

　　Manager Web Application让你通过一个比Admin Web Application更为简单的用户界面，执行一些简单的Web应用任务。

　　Manager Web Application被被定义在一个自动部署文件中：

CATALINA_BASE/webapps/manager.xml 。

　　你必须编辑这个文件，以确保context的docBase参数是绝对路径，也就是说CATALINA_HOME/server/webapps/manager的绝对路径。
　　（译者注：CATALINA_HOME即tomcat安装目录）

　　如果你使用的是UserDatabaseRealm，那么你需要添加一个角色和一个用户到CATALINA_BASE/conf/tomcat-users.xml文件中。接下来，编辑这个文件，添加一个名为“manager”的角色到该文件中：

＜role name=”manager”＞

　　你同样需要有一个角色为“manager”的用户。像已经存在的用户那样，添加一个新用户（改变密码使其更加安全）：

＜user name="manager" password="deep_dark_secret" roles="manager"/＞

　　然后重新启动Tomcat，访问http://localhost/manager/list，将看到一个很朴素的文本型管理界面，或者访问http://localhost/manager/html/list，将看到一个HMTL的管理界面。不管是哪种方式都说明你的Manager Web Application现在已经启动了。

　　Manager application让你可以在没有系统管理特权的基础上，安装新的Web应用，以用于测试。如果我们有一个新的web应用位于/home/user/hello下在，并且想把它安装到 /hello下，为了测试这个应用，我们可以这么做，在第一个文件框中输入“/hello”（作为访问时的path），在第二个文本框中输入“file:/home/user/hello”（作为Config URL）。

　　Manager application还允许你停止、重新启动、移除以及重新部署一个web应用。停止一个应用使其无法被访问，当有用户尝试访问这个被停止的应用时，将看到一个503的错误??“503 - This application is not currently available”。

　　移除一个web应用，只是指从Tomcat的运行拷贝中删除了该应用，如果你重新启动Tomcat，被删除的应用将再次出现（也就是说，移除并不是指从硬盘上删除）。
3．部署一个web应用

　　有两个办法可以在系统中部署web服务。

　　1＞ 拷贝你的WAR文件或者你的web应用文件夹（包括该web的所有内容）到$CATALINA_BASE/webapps目录下。

　　2＞ 为你的web服务建立一个只包括context内容的XML片断文件，并把该文件放到$CATALINA_BASE/webapps目录下。这个web应用本身可以存储在硬盘上的任何地方。

　　如果你有一个WAR文件，你若想部署它，则只需要把该文件简单的拷贝到CATALINA_BASE/webapps目录下即可，文件必须以“.war”作为扩展名。一旦Tomcat监听到这个文件，它将（缺省的）解开该文件包作为一个子目录，并以WAR文件的文件名作为子目录的名字。接下来，Tomcat将在内存中建立一个context，就好象你在server.xml文件里建立一样。当然，其他必需的内容，将从server.xml中的DefaultContext获得。

　　部署web应用的另一种方式是写一个Context XML片断文件，然后把该文件拷贝到CATALINA_BASE/webapps目录下。一个Context片断并非一个完整的XML文件，而只是一个context元素，以及对该应用的相应描述。这种片断文件就像是从server.xml中切取出来的context元素一样，所以这种片断被命名为“context片断”。

　　举个例子，如果我们想部署一个名叫MyWebApp.war的应用，该应用使用realm作为访问控制方式，我们可以使用下面这个片断：

＜!--
Context fragment for deploying MyWebApp.war
--＞
＜Context path="/demo" docBase="webapps/MyWebApp.war"
debug="0" privileged="true"＞
＜Realm className="org.apache.catalina.realm.UserDatabaseRealm"
resourceName="UserDatabase"/＞
＜/Context＞

　　把该片断命名为“MyWebApp.xml”，然后拷贝到CATALINA_BASE/webapps目录下。

　　这种context片断提供了一种便利的方法来部署web应用，你不需要编辑server.xml，除非你想改变缺省的部署特性，安装一个新的web应用时不需要重启动Tomcat。

　　4．配置虚拟主机（Virtual Hosts）

　　关于server.xml中“Host”这个元素，只有在你设置虚拟主机的才需要修改。虚拟主机是一种在一个web服务器上服务多个域名的机制，对每个域名而言，都好象独享了整个主机。实际上，大多数的小型商务网站都是采用虚拟主机实现的，这主要是因为虚拟主机能直接连接到Internet并提供相应的带宽，以保障合理的访问响应速度，另外虚拟主机还能提供一个稳定的固定IP。

　　基于名字的虚拟主机可以被建立在任何web服务器上，建立的方法就是通过在域名服务器（DNS）上建立IP地址的别名，并且告诉web服务器把去往不同域名的请求分发到相应的网页目录。因为这篇文章主要是讲Tomcat，我们不准备介绍在各种操作系统上设置DNS的方法，如果你在这方面需要帮助，请参考《DNS and Bind》一书，作者是Paul Albitz and Cricket Liu (O'Reilly)。为了示范方便，我将使用一个静态的主机文件，因为这是测试别名最简单的方法。

　　在Tomcat中使用虚拟主机，你需要设置DNS或主机数据。为了测试，为本地IP设置一个IP别名就足够了，接下来，你需要在server.xml中添加几行内容，如下：

＜Server port="8005" shutdown="SHUTDOWN" debug="0"＞
＜Service name="Tomcat-Standalone"＞
＜Connector className="org.apache.coyote.tomcat4.CoyoteConnector"
port="8080" minProcessors="5" maxProcessors="75"
enableLookups="true" redirectPort="8443"/＞
＜Connector className="org.apache.coyote.tomcat4.CoyoteConnector"
port="8443" minProcessors="5" maxProcessors="75"
acceptCount="10" debug="0" scheme="https" secure="true"/＞
＜Factory className="org.apache.coyote.tomcat4.CoyoteServerSocketFactory"
clientAuth="false" protocol="TLS" /＞
＜/Connector＞
＜Engine name="Standalone" defaultHost="localhost" debug="0"＞
＜!-- This Host is the default Host --＞
＜Host name="localhost" debug="0" appBase="webapps"
unpackWARs="true" autoDeploy="true"＞
＜Context path="" docBase="ROOT" debug="0"/＞
＜Context path="/orders" docBase="/home/ian/orders" debug="0"
reloadable="true" crossContext="true"＞
＜/Context＞
＜/Host＞

＜!-- This Host is the first "Virtual Host": http://www.example.com/ --＞
＜Host name="www.example.com" appBase="/home/example/webapp"＞
＜Context path="" docBase="."/＞
＜/Host＞

＜/Engine＞
＜/Service＞
＜/Server＞

　　Tomcat的server.xml文件，在初始状态下，只包括一个虚拟主机，但是它容易被扩充到支持多个虚拟主机。在前面的例子中展示的是一个简单的server.xml版本，其中粗体部分就是用于添加一个虚拟主机。每一个Host元素必须包括一个或多个context元素，所包含的context元素中必须有一个是默认的context，这个默认的context的显示路径应该为空（例如，path=””）。
　5．配置基础验证（Basic Authentication）

　　容器管理验证方法控制着当用户访问受保护的web应用资源时，如何进行用户的身份鉴别。当一个web应用使用了Basic Authentication（BASIC参数在web.xml文件中auto-method元素中设置），而有用户访问受保护的web应用时，Tomcat将通过HTTP Basic Authentication方式，弹出一个对话框，要求用户输入用户名和密码。在这种验证方法中，所有密码将被以64位的编码方式在网络上传输。

　　注意：使用Basic Authentication通过被认为是不安全的，因为它没有强健的加密方法，除非在客户端和服务器端都使用HTTPS或者其他密码加密码方式（比如，在一个虚拟私人网络中）。若没有额外的加密方法，网络管理员将能够截获（或滥用）用户的密码。但是，如果你是刚开始使用Tomcat，或者你想在你的web应用中测试一下基于容器的安全管理，Basic Authentication还是非常易于设置和使用的。只需要添加＜security-constraint＞和＜login-config＞两个元素到你的web应用的web.xml文件中，并且在CATALINA_BASE/conf/tomcat-users.xml 文件中添加适当的＜role＞和＜user＞即可，然后重新启动Tomcat。

　　下面例子中的web.xml摘自一个俱乐部会员网站系统，该系统中只有member目录被保护起来，并使用Basic Authentication进行身份验证。请注意，这种方式将有效的代替Apache web服务器中的.htaccess文件。

＜!--
Define the Members-only area, by defining
a "Security Constraint" on this Application, and
mapping it to the subdirectory (URL) that we want
to restrict.
--＞
＜security-constraint＞
＜web-resource-collection＞
＜web-resource-name＞
Entire Application
＜/web-resource-name＞
＜url-pattern＞/members/*＜/url-pattern＞
＜/web-resource-collection＞
＜auth-constraint＞
＜role-name＞member＜/role-name＞
＜/auth-constraint＞
＜/security-constraint＞
＜!-- Define the Login Configuration for this Application --＞
＜login-config＞
＜auth-method＞BASIC＜/auth-method＞
＜realm-name＞My Club Members-only Area＜/realm-name＞
＜/login-config＞

　　6．配置单点登录（Single Sign-On）

　　一旦你设置了realm和验证的方法，你就需要进行实际的用户登录处理。一般说来，对用户而言登录系统是一件很麻烦的事情，你必须尽量减少用户登录验证的次数。作为缺省的情况，当用户第一次请求受保护的资源时，每一个web应用都会要求用户登录。如果你运行了多个web应用，并且每个应用都需要进行单独的用户验证，那这看起来就有点像你在与你的用户搏斗。用户们不知道怎样才能把多个分离的应用整合成一个单独的系统，所有他们也就不知道他们需要访问多少个不同的应用，只是很迷惑，为什么总要不停的登录。

　　Tomcat 4的“single sign-on”特性允许用户在访问同一虚拟主机下所有web应用时，只需登录一次。为了使用这个功能，你只需要在Host上添加一个SingleSignOn Valve元素即可，如下所示：

＜Valve className="org.apache.catalina.authenticator.SingleSignOn"
debug="0"/＞

　　在Tomcat初始安装后，server.xml的注释里面包括SingleSignOn Valve配置的例子，你只需要去掉注释，即可使用。那么，任何用户只要登录过一个应用，则对于同一虚拟主机下的所有应用同样有效。

　　使用single sign-on valve有一些重要的限制：

　　1＞ value必须被配置和嵌套在相同的Host元素里，并且所有需要进行单点验证的web应用（必须通过context元素定义）都位于该Host下。

　　2＞ 包括共享用户信息的realm必须被设置在同一级Host中或者嵌套之外。

　　3＞ 不能被context中的realm覆盖。

　　4＞ 使用单点登录的web应用最好使用一个Tomcat的内置的验证方式（被定义在web.xml中的＜auth-method＞中），这比自定义的验证方式强，Tomcat内置的的验证方式包括basic、digest、form和client-cert。

　　5＞ 如果你使用单点登录，还希望集成一个第三方的web应用到你的网站中来，并且这个新的web应用使用它自己的验证方式，而不使用容器管理安全，那你基本上就没招了。你的用户每次登录原来所有应用时需要登录一次，并且在请求新的第三方应用时还得再登录一次。当然，如果你拥有这个第三方web应用的源码，而你又是一个程序员，你可以修改它，但那恐怕也不容易做。

　　6＞ 单点登录需要使用cookies。

　7．配置用户定制目录（Customized User Directores）

　　一些站点允许个别用户在服务器上发布网页。例如，一所大学的学院可能想给每一位学生一个公共区域，或者是一个ISP希望给一些web空间给他的客户，但这又不是虚拟主机。在这种情况下，一个典型的方法就是在用户名前面加一个特殊字符（~），作为每位用户的网站，比如：

http://www.cs.myuniversity.edu/~username
http://members.mybigisp.com/~username

　　Tomcat提供两种方法在主机上映射这些个人网站，主要使用一对特殊的Listener元素。Listener的className属性应该是org.apache.catalina.startup.UserConfig，userClass属性应该是几个映射类之一。如果你的系统是Unix，它将有一个标准的/etc/passwd文件，该文件中的帐号能够被运行中的Tomcat很容易的读取，该文件指定了用户的主目录，使用PasswdUserDatabase 映射类。

＜Listener className="org.apache.catalina.startup.UserConfig"
directoryName="public_html"
userClass="org.apache.catalina.startup.PasswdUserDatabase"/＞

　　web文件需要放置在像/home/users/ian/public_html 或者 /users/jbrittain/public_html一样的目录下面。当然你也可以改变public_html 到其他任何子目录下。

　　实际上，这个用户目录根本不一定需要位于用户主目录下里面。如果你没有一个密码文件，但你又想把一个用户名映射到公共的像/home一样目录的子目录里面，则可以使用HomesUserDatabase类。

＜Listener className="org.apache.catalina.startup.UserConfig"
directoryName="public_html" homeBase="/home"
userClass="org.apache.catalina.startup.HomesUserDatabase"/＞

　　这样一来，web文件就可以位于像/home/ian/public_html 或者 /home/jasonb/public_html一样的目录下。这种形式对Windows而言更加有利，你可以使用一个像c:\home这样的目录。

　　这些Listener元素，如果出现，则必须在Host元素里面，而不能在context元素里面，因为它们都用应用于Host本身。

　　8．在Tomcat中使用CGI脚本

　　Tomcat主要是作为Servlet/JSP容器，但它也有许多传统web服务器的性能。支持通用网关接口（Common Gateway Interface，即CGI）就是其中之一，CGI提供一组方法在响应浏览器请求时运行一些扩展程序。CGI之所以被称为通用，是因为它能在大多数程序或脚本中被调用，包括：Perl，Python，awk，Unix shell scripting等，甚至包括Java。当然，你大概不会把一个Java应用程序当作CGI来运行，毕竟这样太过原始。一般而言，开发Servlet总要比CGI具有更好的效率，因为当用户点击一个链接或一个按钮时，你不需要从操作系统层开始进行处理。

　　Tomcat包括一个可选的CGI Servlet，允许你运行遗留下来的CGI脚本。

　　为了使Tomcat能够运行CGI，你必须做如下几件事：

　　1. 把servlets-cgi.renametojar （在CATALINA_HOME/server/lib/目录下）改名为servlets-cgi.jar。处理CGI的servlet应该位于Tomcat的CLASSPATH下。

　　2. 在Tomcat的CATALINA_BASE/conf/web.xml 文件中，把关于＜servlet-name＞ CGI的那段的注释去掉（默认情况下，该段位于第241行）。

　　3. 同样，在Tomcat的CATALINA_BASE/conf/web.xml文件中，把关于对CGI进行映射的那段的注释去掉（默认情况下，该段位于第299行）。注意，这段内容指定了HTML链接到CGI脚本的访问方式。

　　4. 你可以把CGI脚本放置在WEB-INF/cgi 目录下（注意，WEB-INF是一个安全的地方，你可以把一些不想被用户看见或基于安全考虑不想暴露的文件放在此处），或者你也可以把CGI脚本放置在context下的其他目录下，并为CGI Servlet调整cgiPathPrefix初始化参数。这就指定的CGI Servlet的实际位置，且不能与上一步指定的URL重名。

　　5. 重新启动Tomcat，你的CGI就可以运行了。

　　在Tomcat中，CGI程序缺省放置在WEB-INF/cgi目录下，正如前面所提示的那样，WEB-INF目录受保护的，通过客户端的浏览器无法窥探到其中内容，所以对于放置含有密码或其他敏感信息的CGI脚本而言，这是一个非常好的地方。为了兼容其他服务器，尽管你也可以把CGI脚本保存在传统的/cgi-bin目录，但要知道，在这些目录中的文件有可能被网上好奇的冲浪者看到。另外，在Unix中，请确定运行Tomcat的用户有执行CGI脚本的权限。

　9．改变Tomcat中的JSP编译器（JSP Compiler）

　　在Tomcat 4.1（或更高版本，大概），JSP的编译由包含在Tomcat里面的Ant程序控制器直接执行。这听起来有一点点奇怪，但这正是Ant有意为之的一部分，有一个API文档指导开发者在没有启动一个新的JVM的情况下，使用Ant。这是使用Ant进行Java开发的一大优势。另外，这也意味着你现在能够在Ant中使用任何javac支持的编译方式，这里有一个关于Apache Ant使用手册的javac page列表。使用起来是容易的，因为你只需要在＜init-param＞ 元素中定义一个名字叫“compiler”，并且在value中有一个支持编译的编译器名字，示例如下：

＜servlet＞
＜servlet-name＞jsp＜/servlet-name＞
＜servlet-class＞
org.apache.jasper.servlet.JspServlet
＜/servlet-class＞
＜init-param＞
＜param-name＞logVerbosityLevel＜/param-name＞
＜param-value＞WARNING＜/param-value＞
＜/init-param＞
＜init-param＞
＜param-name＞compiler＜/param-name＞
＜param-value＞jikes＜/param-value＞
＜/init-param＞
＜load-on-startup＞3＜/load-on-startup＞
＜/servlet＞

　　当然，给出的编译器必须已经安装在你的系统中，并且CLASSPATH可能需要设置，那处决于你选择的是何种编译器。

　　10．限制特定主机访问（Restricting Access to Specific Hosts）

　　有时，你可能想限制对Tomcat web应用的访问，比如，你希望只有你指定的主机或IP地址可以访问你的应用。这样一来，就只有那些指定的的客户端可以访问服务的内容了。为了实现这种效果，Tomcat提供了两个参数供你配置：RemoteHostValve 和RemoteAddrValve。

　　通过配置这两个参数，可以让你过滤来自请求的主机或IP地址，并允许或拒绝哪些主机/IP。与之类似的，在Apache的httpd文件里有对每个目录的允许/拒绝指定。

　　例如你可以把Admin Web application设置成只允许本地访问，设置如下：

＜Context path="/path/to/secret_files" ...＞
＜Valve className="org.apache.catalina.valves.RemoteAddrValve"
allow="127.0.0.1" deny=""/＞
＜/Context＞

　　如果没有给出允许主机的指定，那么与拒绝主机匹配的主机就会被拒绝，除此之外的都是允许的。与之类似，如果没有给出拒绝主机的指定，那么与允许主机匹配的主机就会被允许，除此之外的都是拒绝的。

DreamFight 2008-12-23 09:18 发表评论
]]>Tomcat 服务器server.xml的关键配置（一）http://www.blogjava.net/DreamFight/articles/247850.htmlDreamFightDreamFightTue, 23 Dec 2008 01:17:00 GMThttp://www.blogjava.net/DreamFight/articles/247850.htmlhttp://www.blogjava.net/DreamFight/comments/247850.htmlhttp://www.blogjava.net/DreamFight/articles/247850.html#Feedback0http://www.blogjava.net/DreamFight/comments/commentRss/247850.htmlhttp://www.blogjava.net/DreamFight/services/trackbacks/247850.htmlhttp://www.eu.apache.org/dist/jakarta/tomcat-5/
这里注意，在jakarta-tomcat-5.0.28.exe以前是有默认的admin模块，在jakarta-tomcat-5.5.9.exe则没有安装默认的admin模块，这时::URL::http://127.0.0.1:8080/admin打开时则会出现
Tomcat's administration web application is no longer installed by default. Download and install the "admin" package to use it.
因此我们现在需要下载"admin"package 包
把jakarta-tomcat-5.5.x.zip   与    jakarta-tomcat-5.5.x-compat.zip   与   jakarta-tomcat-5.5.x-admin.zip
三个文件解压在同一个目录中
(如果使用jdk1.4，才需要compat.zip用jdk1.5就可以免了这个。)




2.修改jakarta-tomcat-5.5.x\conf\tomcat-users.xml.
添加管理员账号lizongbo，密码为lizongbopass.
新xml如下：
<?xml version='1.0' encoding='utf-8'?>
<tomcat-users>
   <role rolename="tomcat"/>
   <role rolename="role1"/>
   <role rolename="manager"/>
   <role rolename="admin"/>
   <user username="tomcat" password="tomcat" roles="tomcat"/>
   <user username="role1" password="tomcat" roles="role1"/>
   <user username="both" password="tomcat" roles="tomcat,role1"/>
   <user username="lizongbo" password="lizongbopass" roles="admin,manager"/>
</tomcat-users>


有时在%CATALINA_HOME%\server\webapps\admin\WEB-INF\web.xml里面也要做些修改


<!-- Security is active on entire directory -->
   <security-constraint>
     <display-name>Tomcat Server Configuration Security Constraint</display-name>
     <web-resource-collection>
       <web-resource-name>Protected Area</web-resource-name>
       <!-- Define the context-relative URL(s) to be protected -->
       <url-pattern>*.jsp</url-pattern>
       <url-pattern>*.do</url-pattern>
       <url-pattern>*.html</url-pattern>
     </web-resource-collection>
     <auth-constraint>
       <!-- Anyone with one of the listed roles may access this area -->
       <role-name>admin</role-name>
     </auth-constraint>
   </security-constraint>

   <!-- Login configuration uses form-based authentication -->
   <login-config>
     <auth-method>FORM</auth-method>
     <realm-name>Tomcat Server Configuration Form-Based Authentication Area</realm-name>
     <form-login-config>
       <form-login-page>/login.jsp</form-login-page>
       <form-error-page>/error.jsp</form-error-page>
     </form-login-config>
   </login-config>

   <!-- Security roles referenced by this web application -->
   <security-role>
     <description>
       The role that is required to log in to the Administration Application
     </description>
     <role-name>admin</role-name>
   </security-role>
无论是 Authetication ( 身份验证 还是 Authorization ( 权限管控 都只有设置相关的 admin ROLE, 当你想要新增或修改相关的 AA, 就必须修改这一个文件, 来符合你的环境.
3.修改jakarta-tomcat-5.5.x\conf\server.xml来解决编码问题。
(给Connector 添加URIEncoding参数，参考::URL::http://blog.csdn.net/darkxie/archive/2004/10/25/TOMCATAPP.aspx)
(可以设置成GB18030)
     <Connector port="8080"
                maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
                enableLookups="false" redirectPort="8443" acceptCount="200"
                connectionTimeout="20000" disableUploadTimeout="true" URIEncoding="GBK"
                compression="on" compressionMinSize="2048"
       noCompressionUserAgents="gozilla, traviata"
       compressableMimeType="text/html,text/xml"/>

     <Connector port="8009"
                enableLookups="false" redirectPort="8443" protocol="AJP/1.3" URIEncoding="GBK"/>


4.启用支持gzip压缩.
(::URL::http://www.linuxaid.com.cn/forum/showdoc.jsp?l=1&i=81169)
添加下列属性
compression="on"
       compressionMinSize="2048"
       noCompressionUserAgents="gozilla, traviata"
       compressableMimeType="text/html,text/xml"

5.设置虚拟主机。
在jakarta-tomcat-5.5.x\下建立文件夹vhost\www.mydomain.com。
然后修改jakarta-tomcat-5.5.x\conf\server.xml

<Engine defaultHost="localhost" name="Catalina">
       <Host appBase="vhost/www.mydomain.com" name="::URL::http://www.mydomain.com/">
       </Host>
       <Host appBase="webapps" name="localhost">
       </Host>
       <Realm className="org.apache.catalina.realm.UserDatabaseRealm"/>
     </Engine>

6.添加数据库驱动,更新mail.jar和actiovation.jar
复制mysql-connector-java-3.0.16-ga-bin.jar,pg74.215.jdbc3.jar到 jakarta-tomcat-5.5.x\common\lib\
还有javamail 1.3.2的mail.jar，jaf-1_0_2的 activation.jar
msSQl 2000 JDBC sp3，msbase.jar,msutil,jar,mssqlserver.jar


7.配置SSL
参考 ::URL::http://jakarta.apache.org/tomcat/tomcat-5.5-doc/ssl-howto.html
D:\j2sdk1.4.2_06\bin>%JAVA_HOME%\bin\keytool -genkey -alias tomcat -keyalg RSA
输入keystore密码：   lizongbossl
您的名字与姓氏是什么？
   [tomcat5.5.x]：   tomcat5.5.x
您的组织单位名称是什么？
   [jakarta]：   jakarta
您的组织名称是什么？
   [apache]：   apache
您所在的城市或区域名称是什么？
   [hzcity]：   hzcity
您所在的州或省份名称是什么？
   [gdp]：   gdp
该单位的两字母国家代码是什么
   [CN]：   CN
CN=tomcat5.5.x, OU=jakarta, O=apache, L=hzcity, ST=gdp, C=CN 正确吗？
   [否]：   y

输入<tomcat>的主密码
         （如果和 keystore 密码相同，按回车）：

(必须密码一致，因此直接回车)
然后再把userhome(例如：C:\Documents and Settings\lizongbo\)下的.keystore复制到
tomcat的conf\目录下。
(例如：D:\jakarta-tomcat-5.5.x\conf\.keystore
配置jakarta-tomcat-5.5.x\conf\server.xml
加上
     <Connector port="8443"
                maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
                enableLookups="false" disableUploadTimeout="true"
                acceptCount="100" scheme="https" secure="true"
                clientAuth="false" sslProtocol="TLS"
            keystoreFile="conf/.keystore"
            keystorePass="lizongbossl"> <!--与先前设置的密码一致-->
     </Connector>
8.禁止文件目录列表，
修改jakarta-tomcat-5.5.x\conf\web.xml，把listing设置为false

     <servlet>
         <servlet-name>default</servlet-name>
         <servlet-class>org.apache.catalina.servlets.DefaultServlet</servlet-class>
         <init-param>
             <param-name>debug</param-name>
             <param-value>0</param-value>
         </init-param>
         <init-param>
             <param-name>listings</param-name>
             <param-value>true</param-value>
         </init-param>
         <load-on-startup>1</load-on-startup>
     </servlet>

9.指定了自己的javaEncoding
(参考 ::URL::http://gceclub.sun.com.cn/staticcontent/html/sunone/app7/app7-dg-webapp/ch6/ch6-4.html

     <servlet>
         <servlet-name>jsp</servlet-name>
         <servlet-class>org.apache.jasper.servlet.JspServlet</servlet-class>
         <init-param>
             <param-name>fork</param-name>
             <param-value>false</param-value>
         </init-param>
                 <init-param>
             <param-name>javaEncoding</param-name>
             <param-value>GB18030</param-value>
         </init-param>
         <init-param>
             <param-name>xpoweredBy</param-name>
             <param-value>true</param-value>
         </init-param>
         <load-on-startup>3</load-on-startup>
     </servlet>
10.添加rar,iso等的mime-type映射
避免在浏览器里直接打开。
<mime-mapping>
<extension>mht</extension>
<mime-type>text/x-mht</mime-type>
</mime-mapping>
<mime-mapping>
         <extension>rar</extension>
         <mime-type>application/octet-stream</mime-type>
     </mime-mapping>
     <mime-mapping>
         <extension>iso</extension>
         <mime-type>application/octet-stream</mime-type>
     </mime-mapping>
     <mime-mapping>
         <extension>ape</extension>
         <mime-type>application/octet-stream</mime-type>
     </mime-mapping>
     <mime-mapping>
         <extension>rmvb</extension>
         <mime-type>application/octet-stream</mime-type>
     </mime-mapping>
     <mime-mapping>
         <extension>ico</extension>
         <mime-type>image/x-icon</mime-type>
     </mime-mapping>
10.1对html静态页面设置编码
<!--   修改下面两行以支持静态超文本的自动编码
   -->
<mime-mapping>
   <extension>htm</extension>
   <mime-type>text/html;charset=gb2312</mime-type>
   </mime-mapping>
<mime-mapping>
   <extension>html</extension>
   <mime-type>text/html;charset=gb2312</mime-type>
   </mime-mapping>
   </web-app>

11.添加welcome-file-list，并调整顺序。
<welcome-file-list>    
         <welcome-file>index.jsp</welcome-file>
         <welcome-file>index.html</welcome-file>
         <welcome-file>index.htm</welcome-file>
         <welcome-file>default.html</welcome-file>
         <welcome-file>default.htm</welcome-file>
         <welcome-file>default.jsp</welcome-file>
     </welcome-file-list>

DreamFight 2008-12-23 09:17 发表评论
]]>Tomcate 中server.xml 目录讲解http://www.blogjava.net/DreamFight/articles/247848.htmlDreamFightDreamFightTue, 23 Dec 2008 00:46:00 GMThttp://www.blogjava.net/DreamFight/articles/247848.htmlhttp://www.blogjava.net/DreamFight/comments/247848.htmlhttp://www.blogjava.net/DreamFight/articles/247848.html#Feedback0http://www.blogjava.net/DreamFight/comments/commentRss/247848.htmlhttp://www.blogjava.net/DreamFight/services/trackbacks/247848.html Tomcat的配置可以通过两种方式来配置。
1.通过/conf/server.xml来配置。
2.通过可视化的界面来配置。

下面来介绍server.xml的配置：
按装完Tomcat后它的server.xml的配置内容是这样的：


connectionTimeout="2000"
它表式的是：一个客房端连接到服务器如果没有任何动作它如果超过这个时间那么它就视为无效。
2000表式的是毫秒。

maxThreads="150"
它表示的是同一时间连接到服务器上的同一个页面时的最大连接数。，




DreamFight 2008-12-23 08:46 发表评论
]]>Tomcat虚拟目录设置http://www.blogjava.net/DreamFight/articles/244729.htmlDreamFightDreamFightSat, 06 Dec 2008 00:39:00 GMThttp://www.blogjava.net/DreamFight/articles/244729.htmlhttp://www.blogjava.net/DreamFight/comments/244729.htmlhttp://www.blogjava.net/DreamFight/articles/244729.html#Feedback0http://www.blogjava.net/DreamFight/comments/commentRss/244729.htmlhttp://www.blogjava.net/DreamFight/services/trackbacks/244729.htmltomcat 安装好之后，只需要把你的程序包放到$Tomcat_Home$/webapps下就可以直接使用了。这样会使webapps越来越大就需要设置虚拟目录：
1.单个应用设置（为你的单个项目设置虚拟目录）：
 在<Host>和</host>之间加上
 <Context path="/site" docBase="d:\site" reloadable="true" debug="0">
 </Context>
 参数:path 表示在浏览器中输入http://localhost:8080/site
 docBase表示你的程序包的物理绝对路径，默认的绝对路径是$Tomcat_Home$/webapps
 这样设定了之后会在$tomcat_home$/conf/catalina/localhost目录下生成一个site.xml文件，此文件的内容就是刚才设置的内容。
2.通过前面我们知道了在$tomcat_home$/conf/catalina/localhost目录下会生成相应的配置文件，因此我们可以直接在$tomcat_home$/conf/catalina/localhost目录下写配置文件文件名任意取，最好是跟你的web应用相同便于管理，如site.xml内容同上
<Context path="/site" docBase="d:\site" reloadable="true" debug="0">
 </Context>
3.更改整个根目录（为你的所有项目设置虚拟目录）：
  在$tomcat_home$/conf/server.xml中找到<Host name="localhost" debug="0" appBase="webapps"
  unpackWARs="true" autoDeploy="true">
 将appBase的设置成期望的路径（绝对路径）
 出现的问题：输入：http://localhost:8080/没有出现默认的页面
 原因当然是更改了路径造成的。解决也很简单了，把文件拷过来，或者再把原来默认的设成虚拟路径。
在调试过程中你也许会遇到这样的错误：
严重: Error starting static Resources
java.lang.IllegalArgumentException: Document base E:\Tomcat 5.0\webapps\balancerd does not exist or is not a readable directory
 at org.apache.naming.resources.FileDirContext.setDocBase(FileDirContext.java:138)
 at org.apache.catalina.core.StandardContext.resourcesStart(StandardContext.java:3910)
 at org.apache.catalina.core.StandardContext.start(StandardContext.java:4138)
 at org.apache.catalina.core.ContainerBase.addChildInternal(ContainerBase.java:823)
 at org.apache.catalina.core.ContainerBase.addChild(ContainerBase.java:807)
 at org.apache.catalina.core.StandardHost.addChild(StandardHost.java:595)
 at org.apache.catalina.core.StandardHostDeployer.addChild(StandardHostDeployer.java:903)
 at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
 at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
 at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
 at java.lang.reflect.Method.invoke(Method.java:597)
 at org.apache.commons.beanutils.MethodUtils.invokeMethod(MethodUtils.java:216)
 at org.apache.commons.digester.SetNextRule.end(SetNextRule.java:256)
 at org.apache.commons.digester.Rule.end(Rule.java:276)
 at org.apache.commons.digester.Digester.endElement(Digester.java:1058)
 at org.apache.catalina.util.CatalinaDigester.endElement(CatalinaDigester.java:76)
 at org.apache.xerces.parsers.AbstractSAXParser.endElement(Unknown Source)
 at org.apache.xerces.impl.XMLDocumentFragmentScannerImpl.scanEndElement(Unknown Source)
 at org.apache.xerces.impl.XMLDocumentFragmentScannerImpl$FragmentContentDispatcher.dispatch(Unknown Source)
 at org.apache.xerces.impl.XMLDocumentFragmentScannerImpl.scanDocument(Unknown Source)
 at org.apache.xerces.parsers.XML11Configuration.parse(Unknown Source)
 at org.apache.xerces.parsers.XML11Configuration.parse(Unknown Source)
 at org.apache.xerces.parsers.XMLParser.parse(Unknown Source)
 at org.apache.xerces.parsers.AbstractSAXParser.parse(Unknown Source)
 at org.apache.commons.digester.Digester.parse(Digester.java:1567)
 at org.apache.catalina.core.StandardHostDeployer.install(StandardHostDeployer.java:488)
 at org.apache.catalina.core.StandardHost.install(StandardHost.java:863)
 at org.apache.catalina.startup.HostConfig.deployDescriptors(HostConfig.java:483)
 at org.apache.catalina.startup.HostConfig.deployApps(HostConfig.java:427)
 at org.apache.catalina.startup.HostConfig.checkContextLastModified(HostConfig.java:800)
 at org.apache.catalina.startup.HostConfig.check(HostConfig.java:1085)
 at org.apache.catalina.startup.HostConfig.lifecycleEvent(HostConfig.java:327)
 at org.apache.catalina.util.LifecycleSupport.fireLifecycleEvent(LifecycleSupport.java:119)
 at org.apache.catalina.core.StandardHost.backgroundProcess(StandardHost.java:800)
 at org.apache.catalina.core.ContainerBase$ContainerBackgroundProcessor.processChildren(ContainerBase.java:1619)
 at org.apache.catalina.core.ContainerBase$ContainerBackgroundProcessor.processChildren(ContainerBase.java:1628)
 at org.apache.catalina.core.ContainerBase$ContainerBackgroundProcessor.run(ContainerBase.java:1608)
 at java.lang.Thread.run(Thread.java:619)
这是因为在你的$tomcat_home$\conf\Catalina\localhost下对balancerd 这个项目设置虚拟目录的.xml文件指定这个项目的路径不对所造成的把路径改对了该错误消失！


DreamFight 2008-12-06 08:39 发表评论
]]>Tomcat的目录结构及其用途http://www.blogjava.net/DreamFight/articles/244728.htmlDreamFightDreamFightSat, 06 Dec 2008 00:38:00 GMThttp://www.blogjava.net/DreamFight/articles/244728.htmlhttp://www.blogjava.net/DreamFight/comments/244728.htmlhttp://www.blogjava.net/DreamFight/articles/244728.html#Feedback0http://www.blogjava.net/DreamFight/comments/commentRss/244728.htmlhttp://www.blogjava.net/DreamFight/services/trackbacks/244728.html

Tomcat的目录结构及其用途

目 录

用 途

/bin

存放启动和关闭Tomcat的脚本文件

/common/lib

存放Tomcat服务器及所有Web应用程序都可以访问的JAR文件

/conf

存放Tomcat服务器的各种配置文件，其中包括server.xml（Tomcat的主要配置文件）、tomcat-users.xml和web.xml等配置文件

/conf/catalina/localhost

存放Tomcat服务器对每个项目的配置信息，如项目的虚拟目录，所有项目的目录等信息。

work/Catalina/localhost

存放Tomcat这些目录都是以前我们做的Web应用程序的上下文路径命名的，它里边包括了web应用程序生成的java代码，和class字节码,其中“_”目录对应的是ROOT目录。

/logs

存放Tomcat的日志文件

/server/lib

存放Tomcat服务器运行所需的各种JAR文件

/server/webapps

存放Tomcat的两个Web应用程序：admin应用程序和manager应用程序

/shared/lib

存放所有Web应用程序都可以访问的JAR文件(不能被tomcat访问)

/temp

存放Tomcat运行时产生的临时文件

/webapps

当发布Web应用程序时，通常把Web应用程序的目录及文件放到这个目录下

/work

Tomcat将JSP生成的Servlet源文件和字节码文件放到这个目录下

 

 

 

 

 

 

 

 

 

 

从表5-1中可以看到，/common/lib目录、/server/lib和/shared/lib目录下都可以存放JAR文件，它们的区别在于：

— 在/server/lib目录下的JAR文件只能被Tomcat服务器访问；

— 在/shared/lib目录下的JAR文件可以被所有的Web应用程序访问，但不能被Tomcat服务器访问；

— 在/common/lib目录下的JAR文件可以被Tomcat服务器和所有的Web应用程序访问。

此外，对于后面将要介绍的Java Web应用程序，在它的WEB-INF目录下，也可以建立lib子目录，在lib子目录下可以存放各种JAR文件，这些JAR文件只能被当前Web应用程序所访问。



DreamFight 2008-12-06 08:38 发表评论
]]>Tomcat 错误调试技巧http://www.blogjava.net/DreamFight/articles/244727.htmlDreamFightDreamFightSat, 06 Dec 2008 00:32:00 GMThttp://www.blogjava.net/DreamFight/articles/244727.htmlhttp://www.blogjava.net/DreamFight/comments/244727.htmlhttp://www.blogjava.net/DreamFight/articles/244727.html#Feedback0http://www.blogjava.net/DreamFight/comments/commentRss/244727.htmlhttp://www.blogjava.net/DreamFight/services/trackbacks/244727.html常用的参数是start、run和stop，参数start表示在一个单独的窗口中启动Tomcat服务器，参数run表示在当前窗口中启动Tomcat服务器，参数stop表示关闭Tomcat服务器。我们执行startup.bat，实际上执行的就是“catalina.bat start”命令；执行shutdown.bat，实际上执行的是“catalina.bat stop”命令。“catalina.bat run”命令有时候是非常有用的，特别是当我们需要查看Tomcat的出错信息时。我们在开发JSP程序时，经常会碰到自己机器上的8080端口号被别的应用程序占用，或者在配置server.xml时出现错误，当通过startup.bat（相当于执行“catalina.bat start”）启动Tomcat服务器时，会导致启动失败，因为是在单独的窗口中启动Tomcat服务器，所以一旦启动失败，命令提示符窗口就自动关闭了，程序运行中输出的出错信息也随之消失，而且没有任何的日志信息，这就使得我们没有办法找出错误原因。当出现错误时，我们可以换成“catalina.bat run”命令再次启动，一旦启动失败，仅仅是Tomcat服务器异常终止，但是在当前的命令提示符窗口下仍然保留了启动时的出错信息，这样我们就可以查找启动失败的原因了。

DreamFight 2008-12-06 08:32 发表评论
]]>