Tomcat 系统架构
Tomcat结构介绍
Tomcat 的结构很复杂，但是Tomcat 也非常的模块化，找到了Tomcat 最核心的模块，您就抓住了Tomcat 的“七寸”。下面是Tomcat 的总体结构图：
图 1.Tomcat 的总体结构
从上图中可以看出Tomcat 的心脏是两个组件：Connector 和Container，关于这两个组件将在后面详细介绍。Connector 组件是可以被替换，这样可以提供给服务器设计者更多的选择，因为这个组件是如此重要，不仅跟服务器的设计的本身，而且和不同的应用场景也十分相关，所以一个Container 可以选择对应多个Connector。多个Connector 和一个Container 就形成了一个Service，Service 的概念大家都很熟悉了，有了Service 就可以对外提供服务了，但是Service 还要一个生存的环境，必须要有人能够给她生命、掌握其生死大权，那就非Server 莫属了。所以整个Tomcat 的生命周期由Server 控制。
以Service 作为“婚姻”
我们将Tomcat 中Connector、Container 作为一个整体比作一对情侣的话，Connector 主要负责对外交流，可以比作为Boy，Container 主要处理Connector 接受的请求，主要是处理内部事务，可以比作为Girl。那么这个Service 就是连接这对男女的结婚证了。是Service 将它们连接在一起，共同组成一个家庭。当然要组成一个家庭还要很多其它的元素。
说白了，Service 只是在Connector 和Container 外面多包一层，把它们组装在一起，向外面提供服务，一个Service 可以设置多个Connector，但是只能有一个Container 容器。这个Service 接口的方法列表如下：
图 2. Service 接口
从Service 接口中定义的方法中可以看出，它主要是为了关联Connector 和Container，同时会初始化它下面的其它组件，注意接口中它并没有规定一定要控制它下面的组件的生命周期。所有组件的生命周期在一个Lifecycle 的接口中控制，这里用到了一个重要的设计模式，关于这个接口将在后面介绍。
Tomcat 中Service 接口的标准实现类是StandardService 它不仅实现了Service 借口同时还实现了Lifecycle 接口，这样它就可以控制它下面的组件的生命周期了。StandardService 类结构图如下：
图 3. StandardService 的类结构图
从上图中可以看出除了Service 接口的方法的实现以及控制组件生命周期的Lifecycle 接口的实现，还有几个方法是用于在事件监听的方法的实现，不仅是这个Service 组件，Tomcat 中其它组件也同样有这几个方法，这也是一个典型的设计模式，将在后面介绍。
下面看一下StandardService 中主要的几个方法实现的代码，下面是setContainer 和addConnector 方法的源码：
清单1. StandardService. SetContainer
public void setContainer(Container container) {
Container oldContainer = this.container;
if ((oldContainer != null) && (oldContainer instanceof Engine))
((Engine) oldContainer).setService(null);
this.container = container;
if ((this.container != null) && (this.container instanceof Engine))
((Engine) this.container).setService(this);
if (started && (this.container != null) && (this.container instanceof Lifecycle)) {
((Lifecycle) this.container).start();
} catch (LifecycleException e) {
;
}
}
synchronized (connectors) {
for (int i = 0; i < connectors.length; i++)
connectors[i].setContainer(this.container);
}
if (started && (oldContainer != null) && (oldContainer instanceof Lifecycle)) { try {
((Lifecycle) oldContainer).stop();
} catch (LifecycleException e) {
;
}
}
support.firePropertyChange("container", oldContainer, this.container);
}
这段代码很简单，其实就是先判断当前的这个Service 有没有已经关联了Container，如果已经关联了，那么去掉这个关联关系——oldContainer.setService(null)。如果这个oldContainer 已经被启动了，结束它的生命周期。然后再替换新的关联、再初始化并开始这个新的Container 的生命周期。最后将这个过程通知感兴趣的事件监听程序。这里值得注意的地方就是，修改Container 时要将新的Container 关联到每个Connector，还好Container 和Connector 没有双向关联，不然这个关联关系将会很难维护。
清单2. StandardService. addConnector
public void addConnector(Connector connector) {
synchronized (connectors) {
connector.setContainer(this.container);
connector.setService(this);
Connector results[] = new Connector[connectors.length + 1];
System.arraycopy(connectors, 0, results, 0, connectors.length);
results[connectors.length] = connector;
connectors = results;
if (initialized) {
try {
connector.initialize();
} catch (LifecycleException e) {
e.printStackTrace(System.err);
}
if (started && (connector instanceof Lifecycle)) {
try {
((Lifecycle) connector).start();
} catch (LifecycleException e) {
;
}
}
support.firePropertyChange("connector", null, connector);
}
}
上面是addConnector 方法，这个方法也很简单，首先是设置关联关系，然后是初始化工作，开始新的生命周期。这里值得一提的是，注意Connector 用的是数组而不是List 集合，这个从性能角度考虑可以理解，有趣的是这里用了数组但是并没有向我们平常那样，一开始就分配一个固定大小的数组，它这里的实现机制是：重新创建一个当前大小的数组对象，然后将原来的数组对象copy 到新的数组中，这种方式实现了类似的动态数组的功能，这种实现方式，值得我们以后拿来借鉴。
最新的Tomcat6 中StandardService 也基本没有变化，但是从Tomcat5 开始Service、Server 和容器类都继承了MBeanRegistration 接口，Mbeans 的管理更加合理。
以Server 为“居”
前面说一对情侣因为Service 而成为一对夫妻，有了能够组成一个家庭的基本条件，但是它们还要有个实体的家，这是它们在社会上生存之本，有了家它们就可以安心的为人民服务了，一起为社会创造财富。
Server 要完成的任务很简单，就是要能够提供一个接口让其它程序能够访问到这个Service 集合、同时要维护它所包含的所有Service 的生命周期，包括如何初始化、如何结束服务、如何找到别人要访问的Service。还有其它的一些次要的任务，如您住在这个地方要向当地政府去登记啊、可能还有要配合当地公安机关日常的安全检查什么的。
Server 的类结构图如下：
图 4. Server 的类结构图
它的标准实现类StandardServer 实现了上面这些方法，同时也实现了Lifecycle、MbeanRegistration 两个接口的所有方法，下面主要看一下StandardServer 重要的一个方法addService 的实现：
清单3. StandardServer.addService
public void addService(Service service) {
service.setServer(this);
synchronized (services) {
Service results[] = new Service[services.length + 1];
System.arraycopy(services, 0, results, 0, services.length);
results[services.length] = service;
services = results;
if (initialized) {
try {
service.initialize();
} catch (LifecycleException e) {
e.printStackTrace(System.err);
}
}
if (started && (service instanceof Lifecycle)) {
try {
((Lifecycle) service).start();
} catch (LifecycleException e) {
;
}
}
support.firePropertyChange("service", null, service);
}
}
从上面第一句就知道了Service 和Server 是相互关联的，Server 也是和Service 管理Connector 一样管理它，也是将Service 放在一个数组中，后面部分的代码也是管理这个新加进来的Service 的生命周期。Tomcat6 中也是没有什么变化的。
组件的生命线“Lifecycle”
前面一直在说Service 和Server 管理它下面组件的生命周期，那它们是如何管理的呢？Tomcat 中组件的生命周期是通过Lifecycle 接口来控制的，组件只要继承这个接口并实现其中的方法就可以统一被拥有它的组件控制了，这样一层一层的直到一个最高级的组件就可以控制Tomcat 中所有组件的生命周期，这个最高的组件就是Server，而控制Server 的是Startup，也就是您启动和关闭Tomcat。
下面是Lifecycle 接口的类结构图：
图 5. Lifecycle 类结构图
除了控制生命周期的Start 和Stop 方法外还有一个监听机制，在生命周期开始和结束的时候做一些额外的操作。这个机制在其它的框架中也被使用，如在Spring 中。关于这个设计模式会在后面介绍。
Lifecycle 接口的方法的实现都在其它组件中，就像前面中说的，组件的生命周期由包含它的父组件控制，所以它的Start 方法自然就是调用它下面的组件的Start 方法，Stop 方法也是一样。如在Server 中Start 方法就会调用Service 组件的Start 方法，Server 的Start 方法代码如下：
清单4. StandardServer.Start
public void start() throws LifecycleException {
if (started) {
log.debug(sm.getString("standardServer.start.started"));
return;
}
lifecycle.fireLifecycleEvent(BEFORE_START_EVENT, null);
lifecycle.fireLifecycleEvent(START_EVENT, null);
started = true;
synchronized (services) {
for (int i = 0; i < services.length; i++) {
if (services[i] instanceof Lifecycle)
((Lifecycle) services[i]).start();
}
}
lifecycle.fireLifecycleEvent(AFTER_START_EVENT, null);
}
监听的代码会包围Service 组件的启动过程，就是简单的循环启动所有Service 组件的Start 方法，但是所有Service 必须要实现Lifecycle 接口，这样做会更加灵活。
Server 的Stop 方法代码如下：
清单5. StandardServer.Stop
public void stop() throws LifecycleException {
if (!started)
return;
lifecycle.fireLifecycleEvent(BEFORE_STOP_EVENT, null);
lifecycle.fireLifecycleEvent(STOP_EVENT, null);
started = false;
for (int i = 0; i < services.length; i++) {
if (services[i] instanceof Lifecycle)
((Lifecycle) services[i]).stop();
}
lifecycle.fireLifecycleEvent(AFTER_STOP_EVENT, null);
}
它所要做的事情也和Start 方法差不多。
Connector 组件
Connector 组件是Tomcat 中两个核心组件之一，它的主要任务是负责接收浏览器的发过来的tcp 连接请求，创建一个Request 和Response 对象分别用于和请求端交换数据，然后会产生一个线程来处理这个请求并把产生的Request 和Response 对象传给处理这个请求的线程，处理这个请求的线程就是Container 组件要做的事了。
由于这个过程比较复杂，大体的流程可以用下面的顺序图来解释：
图 6. Connector 处理一次请求顺序图
Tomcat5 中默认的Connector 是Coyote，这个Connector 是可以选择替换的。Connector 最重要的功能就是接收连接请求然后分配线程让Container 来处理这个请求，所以这必然是多线程的，多线程的处理是Connector 设计的核心。Tomcat5 将这个过程更加细化，它将Connector 划分成Connector、Processor、Protocol, 另外Coyote 也定义自己的Request 和Response 对象。
下面主要看一下Tomcat 中如何处理多线程的连接请求，先看一下Connector 的主要类图：图7. Connector 的主要类图
看一下HttpConnector 的Start 方法：
清单6. HttpConnector.Start
public void start() throws LifecycleException {
if (started)
throw new LifecycleException
(sm.getString("httpConnector.alreadyStarted"));
threadName = "HttpConnector[" + port + "]";
lifecycle.fireLifecycleEvent(START_EVENT, null);
started = true;
threadStart();
while (curProcessors < minProcessors) {
if ((maxProcessors > 0) && (curProcessors >= maxProcessors))
break;
HttpProcessor processor = newProcessor();
recycle(processor);
}
}
threadStart() 执行就会进入等待请求的状态，直到一个新的请求到来才会激活它继续执行，
这个激活是在HttpProcessor 的assign 方法中，这个方法是代码如下：
清单7. HttpProcessor.assign
synchronized void assign(Socket socket) {
while (available) {
try {
wait();
} catch (InterruptedException e) {
}
}
this.socket = socket;
available = true;
notifyAll();
if ((debug >= 1) && (socket != null))
log(" An incoming request is being assigned");
}
创建HttpProcessor 对象是会把available 设为false，所以当请求到来时不会进入while 循环，将请求的socket 赋给当期处理的socket，并将available 设为true，当available 设为true 是HttpProcessor 的run 方法将被激活，接下去将会处理这次请求。
Run 方法代码如下：
清单8. HttpProcessor.Run
public void run() {
while (!stopped) {
Socket socket = await();
if (socket == null)
continue;
try {
process(socket);
} catch (Throwable t) {
log("process.invoke", t);
}
connector.recycle(this);
}
synchronized (threadSync) {
threadSync.notifyAll();
}
}
解析socket 的过程在process 方法中，process 方法的代码片段如下：
清单9. HttpProcessor.process
private void process(Socket socket) {
boolean ok = true;
boolean finishResponse = true;
SocketInputStream input = null;
OutputStream output = null;
try {
input = new SocketInputStream(socket.getInputStream(),connector.getBufferSize());
} catch (Exception e) {
log("process.create", e);
ok = false;
}
keepAlive = true;
while (!stopped && ok && keepAlive) {
finishResponse = true;
try {
request.setStream(input);
request.setResponse(response);
output = socket.getOutputStream();
response.setStream(output);
response.setRequest(request);
((HttpServletResponse) response.getResponse())
.setHeader("Server", SERVER_INFO);
} catch (Exception e) {
log("process.create", e);
ok = false;
}
try {
if (ok) {
parseConnection(socket);
parseRequest(input, output);
if (!request.getRequest().getProtocol().startsWith("HTTP/0"))
parseHeaders(input);
if (http11) {
ackRequest(output);
if (connector.isChunkingAllowed())
response.setAllowChunking(true);
}
}
。。。。。。
try {
((HttpServletResponse) response).setHeader
("Date", FastHttpDateFormat.getCurrentDate());
if (ok) {
connector.getContainer().invoke(request, response);
}
。。。。。。
}
try {
shutdownInput(input);
socket.close();
} catch (IOException e) {
;
} catch (Throwable e) {
log("process.invoke", e);
}
socket = null;
}
当Connector 将socket 连接封装成request 和response 对象后接下来的事情就交给Container 来处理了。
Servlet 容器“Container”
Container 是容器的父接口，所有子容器都必须实现这个接口，Container 容器的设计用的是典型的责任链的设计模式，它有四个子容器组件构成，分别是：Engine、Host、Context、Wrapper，这四个组件不是平行的，而是父子关系，Engine 包含Host,Host 包含Context，Context 包含Wrapper。通常一个Servlet class 对应一个Wrapper，如果有多个Servlet 就可以定义多个Wrapper，如果有多个Wrapper 就要定义一个更高的Container 了，如Context，Context 通常就是对应下面这个配置：
清单10. Server.xml
path="/library" docBase="D:\projects\library\deploy\target\library.war" reloadable="true" /> 容器的总体设计 Context 还可以定义在父容器Host 中，Host 不是必须的，但是要运行war 程序，就必须 要Host，因为war 中必有web.xml 文件，这个文件的解析就需要Host 了，如果要有多个Host 就要定义一个top 容器Engine 了。而Engine 没有父容器了，一个Engine 代表一个完整的Servlet 引擎。 那么这些容器是如何协同工作的呢？先看一下它们之间的关系图： 图8. 四个容器的关系图 （查看清晰大图） 当Connector 接受到一个连接请求时，将请求交给Container，Container 是如何处理这个请求的？这四个组件是怎么分工的，怎么把请求传给特定的子容器的呢？又是如何将最终的请求交给Servlet 处理。下面是这个过程的时序图： 图9. Engine 和Host 处理请求的时序图 这里看到了Valve 是不是很熟悉，没错Valve 的设计在其他框架中也有用的，同样Pipeline 的原理也基本是相似的，它是一个管道，Engine 和Host 都会执行这个Pipeline，您可以在这个管道上增加任意的Valve，Tomcat 会挨个执行这些Valve，而且四个组件都会有自己的一套Valve 集合。您怎么才能定义自己的Valve 呢？在server.xml 文件中可以添加，如给Engine 和Host 增加一个Valve 如下： 清单11. Server.xml ……… xmlNamespaceAware="false" xmlValidation="false"> directory="logs" prefix="localhost_access_log." suffix=".txt" pattern="common" resolveHosts="false"/> ………… StandardEngineValve 和StandardHostValve 是Engine 和Host 的默认的Valve，它们是最后一个Valve 负责将请求传给它们的子容器，以继续往下执行。 前面是Engine 和Host 容器的请求过程，下面看Context 和Wrapper 容器时如何处理请求的。下面是处理请求的时序图： 图10. Context 和wrapper 的处理请求时序图 从Tomcat5 开始，子容器的路由放在了request 中，request 中保存了当前请求正在处理的Host、Context 和wrapper。 Engine 容器 Engine 容器比较简单，它只定义了一些基本的关联关系，接口类图如下： 图11. Engine 接口的类结构 它的标准实现类是StandardEngine，这个类注意一点就是Engine 没有父容器了，如果调用setParent 方法时将会报错。添加子容器也只能是Host 类型的，代码如下： 清单12. StandardEngine. addChild public void addChild(Container child) { if (!(child instanceof Host)) throw new IllegalArgumentException (sm.getString("standardEngine.notHost")); super.addChild(child); } public void setParent(Container container) { throw new IllegalArgumentException (sm.getString("standardEngine.notParent")); } 它的初始化方法也就是初始化和它相关联的组件，以及一些事件的监听。 Host 容器 Host 是Engine 的字容器，一个Host 在Engine 中代表一个虚拟主机，这个虚拟主机的作用就是运行多个应用，它负责安装和展开这些应用，并且标识这个应用以便能够区分它们。它的子容器通常是Context，它除了关联子容器外，还有就是保存一个主机应该有的信息。下面是和Host 相关的类关联图： 图12. Host 相关的类图 从上图中可以看出除了所有容器都继承的ContainerBase 外，StandardHost 还实现了Deployer 接口，上图清楚的列出了这个接口的主要方法，这些方法都是安装、展开、启动和结束每个web application。 Deployer 接口的实现是StandardHostDeployer，这个类实现了的最要的几个方法，Host 可以调用这些方法完成应用的部署等。 Context 容器 Context 代表Servlet 的Context，它具备了Servlet 运行的基本环境，理论上只要有Context 就能运行Servlet 了。简单的Tomcat 可以没有Engine 和Host。 Context 最重要的功能就是管理它里面的Servlet 实例，Servlet 实例在Context 中是以Wrapper 出现的，还有一点就是Context 如何才能找到正确的Servlet 来执行它呢？Tomcat5 以前是通过一个Mapper 类来管理的，Tomcat5 以后这个功能被移到了request 中，在前面的时序图中就可以发现获取子容器都是通过request 来分配的。 Context 准备Servlet 的运行环境是在Start 方法开始的，这个方法的代码片段如下： 清单13. StandardContext.start public synchronized void start() throws LifecycleException { ……… if( !initialized ) { try { init(); } catch( Exception ex ) { throw new LifecycleException("Error initializaing ", ex); } } ……… lifecycle.fireLifecycleEvent(BEFORE_START_EVENT, null); setAvailable(false); setConfigured(false); boolean ok = true; File configBase = getConfigBase(); if (configBase != null) { if (getConfigFile() == null) { File file = new File(configBase, getDefaultConfigFile()); setConfigFile(file.getPath()); try { File appBaseFile = new File(getAppBase()); if (!appBaseFile.isAbsolute()) { appBaseFile = new File(engineBase(), getAppBase()); } String appBase = appBaseFile.getCanonicalPath(); String basePath = (new File(getBasePath())).getCanonicalPath(); if (!basePath.startsWith(appBase)) { Server server = ServerFactory.getServer(); ((StandardServer) server).storeContext(this); } } catch (Exception e) { log.warn("Error storing config file", e); } } else { try { String canConfigFile = (new File(getConfigFile())).getCanonicalPath(); if (!canConfigFile.startsWith (configBase.getCanonicalPath())) { File file = new File(configBase, getDefaultConfigFile()); if (copy(new File(canConfigFile), file)) { setConfigFile(file.getPath()); } } } catch (Exception e) { log.warn("Error setting config file", e); } } } ……… Container children[] = findChildren(); for (int i = 0; i < children.length; i++) { if (children[i] instanceof Lifecycle) ((Lifecycle) children[i]).start(); } if (pipeline instanceof Lifecycle) ((Lifecycle) pipeline).start(); ……… } 它主要是设置各种资源属性和管理组件，还有非常重要的就是启动子容器和Pipeline。 我们知道Context 的配置文件中有个reloadable 属性，如下面配置： 清单14. Server.xml path="/library" docBase="D:\projects\library\deploy\target\library.war" reloadable="true" /> 当这个reloadable 设为true 时，war 被修改后Tomcat 会自动的重新加载这个应用。如何做到这点的呢? 这个功能是在StandardContext 的backgroundProcess 方法中实现的，这个方法的代码如下： 清单15. StandardContext. backgroundProcess public void backgroundProcess() { if (!started) return; count = (count + 1) % managerChecksFrequency; if ((getManager() != null) && (count == 0)) { try { getManager().backgroundProcess(); } catch ( Exception x ) { log.warn("Unable to perform background process on manager",x); } } Tomcat的配置文件server.xml 中各个域的说明及相关配置 2007-04-20 12:42 Tomcat网站发布配置方案详细说明 修改端口、修改默认发布目录、多域名绑定 一、修改发布端口号为80（Tomcat默认为8080） 打开配置文件（我的如下：E:\J2EEServer\Tomcat 6.0\conf\server.xml），找到： 代码如下: 第一章 Tomcat概述 一、Tomcat简介 TOMCAT是APACHE JAKARTA软件组织的一个子项目，TOMCAT是一个JSP/SERVLET容器，它是在SUN公司的JSWDK（JAVA SERVER WEB DEVELOPMENT KIT）基础上发展起来的一个JSP和SERVLET规范的标准实现，使用TOMCAT可以体验JSP和SERVLET的最新规范。经过多年的发展，TOMCAT不仅是JSP和SERVLET规范的标准实现，而且具备了很多商业JAVA SERVLET容器的特性，并被一些企业用于商业用途。 1、Tomcat Tomcat在严格意义上并不是一个真正的应用服务器，它只是一个可以支持运行Serlvet/JSP 的Web容器，不过Tomcat也扩展了一些应用服务器的功能，如JNDI，数据库连接池，用户事务处理等等。Tomcat 是一种具有JSP环境的Servlet容器。Servlet容器是代替用户管理和调用Servlet的运行时外壳。 1．1 SERVLET容器 负责处理客户请求。当客户请求来到时，SERVLET容器获取请求，然后调用某个SERVLET，并把SERVLET的执行结果返回给客户。 当客户请求某个资源时，SERVLET容器使用SERVLETREQUEST对象把客户的请求信息封装起来，然后调用JAVA SERVLET API中定义的SERVLET的一些生命周期方法，完成SERVLET的执行，接着把SERVLET执行的要返回给客户的结果封装到SERVLETRESPONSE对象中，最后SERVLET容器把客户的请求发送给客户，完成为客户的一次服务过程。 1．2 TOMCAT的工作模式 1．2．1 独立的SERVLET容器 TOMCAT的默认工作模式，作为独立的SERVLET容器，是内置在WEB服务器中的一部分，是指使用基于JAVA的WEB服务器的情形。 其他两种方式是TOMCAT与其他服务器集成的方式： 1．2．2 进程内的SERVLET容器 SERVLET容器作为WEB服务器的插件和JAVA容器的实现。WEB服务器的插件在内部地址空间打 tomcat 配置，部署servlet全记录 tomcat 配置，部署servlet全记录本人系菜鸟，刚刚学习servlet，感觉到编写servlet倒是不太难，但部署起来就晕了。在网上 看了很多文章，最后终于搞定了，下面以菜鸟的角度（本人不是高手，嘿嘿所以……）记录下部署的全过程，以备来日参考。高手莫笑。 本文写于2007-8-11，所用软件采用最新版 一、准备工作： 1. 电脑一台，（废话，呵呵） 2. jdk 环境，本文使用的是jdk 1.5.0 （这个版本在今天不算是最新版）。jdk环境的安装和配在此就略过了，安装完后只要能正常编译java程序即可。 3.当然是tomcat了本文采用tomcai5.5 。tomcat的安装很简单，一般有两种方式： 第一是用zip文件，直接解压到目标目录中。第二是从官方下载 tomcat的安装程序，直接双击安装。本文采用的是第二种方式，下载安装文件，然后双击安装。过程略过，一路默认下一步，也可以修改一下安装路径。 4. 用来测试的servlet，自己写一个简单的Helloworld servlet。此处略过。此处如果编译通不过，可以跳过，先看配置。 二、开始配置 1. 配置jdk，以前安装好的j2sdk 是不能编译servlet的，因为找不到servlet相关的类文件。解决方法一般有两个，第一可以从sun官方网站下载servlet 所需的类文件，然后补充到j2sdk的目录下面。第二，由于安装了tomcat，它自带了最新版的servlet类文件，打包成了jar包。 位置在tomcat安装目录下的\common\lib\servlet-api.jar。在我的机器上的全路径为D:\Program Files\Apache Software Foundation\Tomcat 5.5\common\lib\servlet-api.jar 其他机器自己改。 配置方法： 在我的电脑--属性--高级---环境变量打开。在系统环境变量处，如果以前配置了CLASSPATH环境变量，则点击编辑把上面的全路径添加进去，注意用分后与原来的内容隔开。如果以前没有CLASSPATH环境变量，则点击新建，变量名字为CLASSPATH，内容就是上面的全路径。不要忘了在全路径后面加上分号和点，表示当前路径 然后就可以正常编译servlet 了。现在可以编译上面写的HelloWorld.java 了。 tomcat6.0配置 第一步：下载j2sdk和tomcat：到sun官方站点 最新的jdk为1.6.04，tomcat为6.0，建议jdk1.4以上，tomcat4.0以上 第二步：安装和配置你的j2sdk和tomcat：执行j2sdk和tomcat的安装程序，然后设置按照路径进 行安装即可。 1.安装j2sdk以后，需要配置一下环境变量，在我的电脑->属性->高级->环境变量->系统变量中添加 以下环境变量(假定你的j2sdk安装在c:\j2sdk1.4.2）： JAVA_HOME=c:\j2sdk1.4.2 classpath=.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;（.;一定不能少，因为它代表 当前路径) path=%JAVA_HOME%\bin 接着可以写一个简单的java程序来测试J2SDK是否已安装成功： 将上面的这段程序保存为文件名为Test.java的文件。 然后打开命令提示符窗口，cd到你的Test.java所在目录，然后键入下面的命令 javac Test.java java Test 此时如果看到打印出来This is a test program.的话说明安装成功了，如果没有打印出这句话，你需 要仔细检查一下你的配置情况。 2.安装Tomcat后，在我的电脑->属性->高级->环境变量->系统变量中添加以下环境变量(假定你的 tomcat安装在c:\tomcat）： CATALINA_HOME：c:\tomcat CATALINA_BASE：c:\tomcat TOMCAT_HOME: C:\Tomcat 然后修改环境变量中的classpath，把tomat安装目录下的common\lib下的servlet.jar追加到 classpath中去，修改后的classpath如下： Tomcat部署项目时启动报错总结 1、虚拟机报错端口被占用 tomcat的默认端口是8080（或者其他自己设置的），可能已经被其他占用。 解决方法：在tomcat安装路径下conf文件夹中的server.xml中把断口号改掉！如果一台机 器上使用多个tomcat，则改掉所有相关的端口避免重复了，包括想如下 在server.xml中找到如下地方改掉port的值 ● ●(改完后看看和本机上正在用 的tomcat是不是有重复的port) 2、tomcat的启动窗口一闪而过 Tomcat启动的dos窗口一闪而过，如何看出错信息？ 在DOS窗口运行STARTUP.BAT文件， 另外，吧startup.bat文件最后的 call "%EXECUTABLE%" start %CMD_LINE_ARGS% 改成： call "%EXECUTABLE%" run %CMD_LINE_ARGS% 分析原因1：jdk的环境变量没有配置好 解决方法：检查jdk环境变量的配置是否正确，或者重新配置jdk的系统环境变量JDK环境变量配置的步骤如下： 1.我的电脑-->属性-->高级-->环境变量. 2.配置用户变量: a.新建JAVA_HOME C:\Program Files\Java\j2sdk1.5.0（JDK的安装路径） b.新建 PATH (注意：把java的配置放在path的最前面) %JAVA_HOME%\bin;%JAVA_HOME%\jre\bin c.新建CLASSPATH .;%JAVA_HOME%\lib;%JAVA_HOME%\lib\tools.jar 3.测试环境变量配置是否成功： 开始-->运行--〉CMD 键盘敲入：JAVAC JAVA 出现相应的命令，而不是出错信息，即表示配置成功！ 环境变量配置的理解： 1. PATH环境变量。作用是指定命令搜索路径，在i命令行下面执行命令如javac编译java程序时，它会到PATH变量所指定的路径中查找看是否能找到相应的命令程序。我们需要把jdk安装目录下的bin 目录增加到现有的PATH变量中，bin目录中包含经常要用到的可执行文件如javac/java/javadoc等待，设置好PATH变量后，就可以在任何目录下执行javac/java等工具了。 2. CLASSPATH环境变量。作用是指定类搜索路径，要使用已经编写好的类，前提当然是能够找到它们了，JVM就是通过CLASSPTH来寻找类的。我们需要把jdk安装目录下的lib子目录中的dt.jar和tools.jar设置到CLASSPATH中，当然，当前目录“.”也必须加入到该变量中。 3. JAVA_HOME环境变量。它指向jdk的安装目录，Eclipse/NetBeans/Tomcat等软件就是通过搜索JAVA_HOME变量来找到并使用安装好的jdk。 第1章Tomcat的安装与配置 Tomcat可以运行Servlet和JSP，是一个小型的轻量级应用服务器，它性能稳定、扩展性好、源码开放，是开发中小型Web应用系统的首选。本章首先介绍Tomcat服务器特点、层次结构、应用处理流程及发展史，然后讲述Tomcat的安装、设置和测试，接着介绍Tomcat 目录结构、常用配置平台、控制和管理程序等，最后设计一个不需数据库支持的简单聊天室。 1.1 Tomcat简介 Tomcat是Sun的JSWDK（Java Server Web Development Kit）中的Servlet容器，属于Apache软件基金会（Apache Software Foundation）的Jakarta项目中的一个核心项目，由Apache、Sun和其他一些公司和个人共同开发而成。Tomcat既是一个开放源码、免费支持JSP和Servlet技术的容器，同时又是一个Web服务器软件，受到了Sun公司的大力推荐和支持。因此，Servlet和JSP的最新规范都可以在Tomcat的新版本中得到实现。 与传统桌面应用程序不同，Tomcat中的应用程序是一个WAR（Web Archive）文件，它是许多文件构成的一个压缩包，包中的文件按照一定目录结构来组织，不同目录中的文件也具有不同的功能。部署应用程序时，只需要把WAR文件放到Tomcat的webapp目录下，Tomcat会自动检测和解压该文件。JSP文件第一次执行时，要先由Tomcat将其转化为Servlet文件，然后编译，所以速度会慢一些，但后继执行时速度会很快。 Tomcat既是一个Servlet容器，又是一个独立运行的服务器，像IIS、Apache等Web 服务器一样，具有处理HTML页面的功能。但它处理静态HTML文件的能力并不是太强，所以一般都是把它当作JSP/Servlet引擎，通过适配器（Adapter）与其他Web服务器软件（如Apache）配合使用。此外，Tomcat还可与其他一些软件集成起来实现更多功能，例如，与JBoss集成起来开发EJB、与OpenJMS集成起来开发JMS应用、与Cocoon（Apache的另外一个项目）集成起来开发基于XML的应用等。 Tomcat是一个小型的轻量级应用服务器，运行时占用系统资源小、扩展性好、支持负载平衡与邮件服务等开发应用系统中的常用功能，并且不断改进和完善。Tomcat适用于中小型系统和并发访问用户不太多的场合，是开发和调试JSP程序的首选。先进的技术、稳定的性能、源码开放和免费获取的机制，使得Tomcat深受Java爱好者的喜爱并得到了许多软件开发商的认可，成为目前相当流行的Web应用服务器。 1.1.1 Servlet简述 谈起Tomcat，就不能不说Servlet，如果没有Servlet的应用需求，就没有Tomcat的产 一：安装JDK 1、按照“下一步”安装，安装目录路径不要包含空格字符 2、安装完JDK后会自动安装JRE 3、配置系统环境变量JAVA_HOME、CLASSPATH和Path环境变量 右击我的电脑-属性，点击“高级设置”选项卡，单击“环境变量” 在系统变量里新建系统变量JAVA_HOME和CLASSPATH JAVA_HOME：D:\Program Files\Java\jdk1.6.0_02 CLASSPATH：.;%JAVA_HOME%lib;%JAVA_HOME%lib\tools.jar;%JAVA_HOME%lib\dt.jar 在path里添加：%JAVA_HOME%\bin 4、Cmd-javac 查看jdk是否安装成功 5、Java –version查看安装java的版本 二：安装oracle（安装“下一步”进行安装） 三：配置tomcat 1、解压tocmcat 2、启动tomcat：service.bat install 3、设置tomcat依赖于oracle服务启动： sc config tomcat6 depend= OracleServiceORCL 4、设置tomcat自动启动：开始-services.msc打开服务页设置tomcatzi-自动 5、设置tomcat端口号 修改tomcat/conf/server.xml配置文件内容 tomcat部署项目总结 自己在工作当中遇到的一些部署方面的问题，在网上也找到一些但有时候他们说的不是很清楚所以我总结了出来 1.最简单的：在tomcat下的webapps目录下创建一个与你项目相同名字的文件夹，将你的web项目的WebRoot文件夹下的所有文件复制到你创建的文件夹下面。启动tomcat就可以访问了。 2.在eclipse/myeclipse中部署不需要自己创建文件夹系统会自动创建 3.在tomcat下的conf目录下的server.xml中的 一、静态部署 1、直接将web项目文件件拷贝到webapps 目录中 Tomcat的Webapps目录是Tomcat默认的应用目录，当服务器启动时，会加载所有这个目录下的应用。所以可以将JSP程序打包成一个war包放在目录下，服务器会自动解开这个war包，并在这个目录下生成一个同名的文件夹。一个war包就是有特性格式的jar包，它是将一个web程序的所有内容进行压缩得到。具体如何打包，可以使用许多开发工具的IDE环境，如Eclipse等。也可以用cmd 命令：jar -cvf mywar.war myweb webapps这个默认的应用目录也是可以改变。打开Tomcat的conf目录下的server.xml文件，找到下面内容： 第一种方法：在tomcat 中的conf 目录中，在server.xml 中的， 在Tomcat 中部署Web 项目在Tomcat 中部署Web 工程有多种方法，根据自己的经验，在这里描述下以下2 种方法：方法一、直接使用MyEclipse 开发工具来自动部署Web 工程。具体步骤如下：首先添加Tomcat （我使用的是Tomcat5.0）服务器到MyEclipse 中来，如进入 window->Preferences->MyEclipse->Application Servers->Tomcat -> Tomcat 5.x 右边页面，在Tomcat home directory 中添加Tomcat 安装目录，记住在Tomcat server 中一定要选择Enable，不然Tomcat 服务器是不能正常使用的。，然后在Tomcat 5.x 目录下有一个JDK，点击进入后，添加相应的JDK 路径，点击OK，就行了。第二、在MyEclipse 工作区，单击需要部署的工程，点击MyElipse- > Add web project Capabilities，为应工程自动添加到Tomcat 服务器中的webapp 中，这样，每次当修改某个文件后，只要刷新项目工程，则该工程的内容自动会部署到Tomcat 中的webapp 中。方法二、使用xml 文件的配置来部署工程。具体步骤如下：第一、进入Tomcat 安装目录下中的conf\Catalina\localhost 文件夹，里面正常来说有自带的三 个.xml(admin.xml,balancer.xml.manager.xml)，那么直接cpoy 其中的一个文件，并重装命名为自己想要的文件名（一般为工程名，或者工程名的简写）如：test.xml。第二、 TOMCAT的安装配置 第一步：下载jdk和tomcat 第二步：安装和配置你的jdk和tomcat：执行jdk和tomcat的安装程序，然后设置按照路径进行安装即可。 1.安装jdk以后，需要配置一下环境变量，在我的电脑->属性->高级->环境变量 ->系统变量中添加以下环境变量(假定你的jdk安装在C:\Program Files\Java）：JA VA_HOME=C:\Program Files\Java\jdk1.6.0_10 classpath=.;%JAV A_HOME%\lib\dt.jar;%JAV A_HOME%\lib\tools.jar;（.;一定不能少，因为它代表当前路径) path=%JA VA_HOME%\bin 接着可以写一个简单的java程序来测试JDK是否已安装成功： public class Test{ public static void main(String args[]){ System.out.println("This is a test program."); } } 将上面的这段程序保存为文件名为Test.java的文件。 然后打开命令提示符窗口，cd到你的Test.java所在目录，然后键入下面的命令javac Test.java java Test 此时如果看到打印出来This is a test program.的话说明安装成功了，如果没有打印出这句话，你需要仔细检查一下你的配置情况。 2.安装Tomcat后，在我的电脑->属性->高级->环境变量->系统变量中添加以下环 境变量(假定你的tomcat安装在c:\tomcat）： CATALINA_HOME：c:\tomcat CATALINA_BASE：c:\tomcat TOMCAT_HOME: C:\Tomcat 然后修改环境变量中的classpath，把tomat安装目录下的common\lib下的servlet.jar追加到classpath中去，修改后的classpath如下： classpath=.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;%CATALIN A_HOME%\common\lib\servlet-api.jar; tomcat6.0配置 第一步：下载jdk和tomcat：JDK下载Tomcat下载 最新的jdk为1.6.10，tomcat为6.0，建议jdk1.4以上，tomcat4.0以上 第二步：安装和配置你的jdk和tomcat：执行jdk和tomcat的安装程序，然后设置按照路径进行安装即可。 1.安装jdk以后，需要配置一下环境变量，在我的电脑->属性->高级->环境变量->系统变量中添加以下环境变量(假定你的jdk安装在C:\Program Files\Java）： JAVA_HOME=C:\Program Files\Java\jdk1.6.0_10 classpath=.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;（.;一定不能少，因为它代表当前路径) path=%JAVA_HOME%\bin 接着可以写一个简单的java程序来测试JDK是否已安装成功： public class Test{ public static void main(String args[]){ System.out.println("This is a test program."); } } 将上面的这段程序保存为文件名为Test.java的文件。 然后打开命令提示符窗口，cd到你的Test.java所在目录，然后键入下面的命令 javac Test.java java Test 此时如果看到打印出来This is a test program.的话说明安装成功了，如果没有打印出这句话，你需要仔细检查一下你的配置情况。 2.安装Tomcat后，在我的电脑->属性->高级->环境变量->系统变量中添加以下环境变量(假定你的tomcat安装在c:\tomcat）：CATALINA_HOME：c:\tomcat CATALINA_BASE：c:\tomcat TOMCAT_HOME: C:\Tomcat 然后修改环境变量中的classpath，把tomat安装目录下的common\lib下的servlet.jar追加到classpath中去，修改后的classpath 如下： classpath=.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;%CATALINA_HOME%\common\lib\servlet-api.jar; 【注意最新版本的Tomcat中可能没有common这个文件夹了。所以servlet-api.jar应该的路径为 %CATALINA_HOME%\lib\servlet-api.jar;请根据自己的情况自己修改！】 接着可以启动tomcat，在IE中访问http://localhost:8080，如果看到tomcat的欢迎页面的话说明安装成功了。 第三步：建立自己的jsp app目录 1.到Tomcat的安装目录的webapps目录，可以看到ROOT，examples, tomcat-docs之类Tomcat自带的的目录； 2.在webapps目录下新建一个目录，起名叫myapp； 3.myapp下新建一个目录WEB-INF，注意，目录名称是区分大小写的； 4.WEB-INF下新建一个文件web.xml，内容如下： 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 到该文件中，如下： Tomcat报告——Tomcat中SSI的配置 1.简介： SSI全称（Server Side Includes）是在HTML静态页面中使用的指令，当页面在服务端执行的时候是可以进行服务端解析的。这种方式可以让我们在存在的HTML页面里面分块动态生成内容而不在整个执行了CGI等服务端技术的基础之上进行动态页面服务。在返回请求的页面(包含SSI指令)前，服务器会处理这些指令，并用处理的结果替换指令，然后把页面返回。我们使用Tomcat作为Http 服务器的时候，我们需要使用SSI可以在Tomcat添加对SSI的支持。 Tomcat服务器的SSI支持的实现方式和Apache里面的SSI指令一样，在Tomcat里面实现SSI支持使用的是一个Servlet和一个Filter（Servlet和Filter的基本信息参考JSP教程），我们可以使用其中一种方式来进行SSI支持的配置，但是不需要两个同时配置，同时配置是否会产生冲突我不太清楚，一般情况下配置一个就可以了。 实现SSI支持的Servlet实现使用了org.apache.catalina.ssi.SSIServlet，另外需要在Servlet的路径解析里面添加映射规则“*.shtml”。 实现SSI支持的Filter使用了org.apache.calalina.ssi.SSIFilter。另外，在Filter 路径解析里面也需要添加映射规则“*.shtml”，而且在Filter配置的时候需要在映射规则里面添加能够执行的mime type，contentType的初始化参数允许你执行服务器下边的资源。在Tomcat里面默认是禁用了SSI的。 注意：SSI指令执行Tomcat外部的JVM，如果我们使用Java的安全管理器需要在calalina.policy文件里面进行配置。若要使用SSI Servlet和SSI Filter，直接在服务器的路径$CATALINA_BASE/conf/web.xml文件里面将SSI的注释去掉。需要注意的是在Tomcat服务器里面仅仅只有标记了privileged的Context可以使用SSI 功能。（*：当privileged设置为true的时候，才允许Tomcat的Web应用使用容器内的Servlet，Tomcat的文档里面讲了使用的lib的域，每个应用程序如果不设置这个属性，是不能访问容器内的Servlet的，这里应该指代的是全局的Servlet）否则这里会遇到异常： https://www.doczj.com/doc/2e534089.html,ng.SecurityException: Filter of class org.apache.catalina.ssi.SSIFilter(SSIServlet)is privileged and cannot be loaded by this web application 2.服务器配置属性： 在配置SSI Servlet的时候需要用到的参数（init parameters）如下： buffered：是需要将输入保存到缓冲区（0=false,1=true）默认是0（false） 这几天在弄个小东西，要用到数据库，以前就听说过数据库连接池这个概念，所以就打算在这个小东西中加入数据库连接池。呵呵。从网上搜了一些资料。今天就整理一下。我搜到的设置基本上主要有两种方法我们以MySQL+TOMCAT为例 1.把DataSource设置到我们的WEB项目中，下面详细的介绍下： 第一步：在我们的WEB项目中的META-INF文件夹下建立一个context.xml Xml代码 Tomcat的配置文件server.xml 中各个域的说明及相关配置
Tomcat网站发布配置方案详细说明
Tomcat完整教程
tomcat配置部署servlet全记录
tomcat配置信息
Tomcat部署项目时启动报错总结
tomcat安装与配置
web端tomcat部署系统
tomcat部署项目总结
Tomcat项目部署方式
tomcat的url配置
在Tomcat中部署Web项目
tomcat安装配置详解+Eclipse的Tomcat插件安装过程
tomcat 6.0配置
Tomcat配置技巧
Tomcat中SSI的详细配置
TOMCAT数据库连接池的配置方法总结
相关主题
文本预览