BlogJava-xsong-随笔分类-tomcathttp://www.blogjava.net/ghost/category/48565.htmlzh-cnFri, 13 May 2011 04:21:18 GMTFri, 13 May 2011 04:21:18 GMT60Tomcat ClassLoaderhttp://www.blogjava.net/ghost/archive/2011/05/13/350153.htmlxsongxsongFri, 13 May 2011 03:44:00 GMThttp://www.blogjava.net/ghost/archive/2011/05/13/350153.htmlhttp://www.blogjava.net/ghost/comments/350153.htmlhttp://www.blogjava.net/ghost/archive/2011/05/13/350153.html#Feedback0http://www.blogjava.net/ghost/comments/commentRss/350153.htmlhttp://www.blogjava.net/ghost/services/trackbacks/350153.html Tomcat Server的ClassLoader结构如下：

其中：
- Bootstrap - 载入JVM自带的类和$JAVA_HOME/jre/lib/ext/*.jar
- System - 载入$CLASSPATH/*.class
- Common - 载入$CATALINA_HOME/common/...，它们对TOMCAT和所有的WEB APP都可见
- Catalina - 载入$CATALINA_HOME/server/...，它们仅对TOMCAT可见，对所有的WEB APP都不可见
- Shared - 载入$CATALINA_HOME/shared/...，它们仅对所有WEB APP可见，对TOMCAT不可见（也不必见）
- WebApp? - 载入ContextBase?/WEB-INF/...，它们仅对该WEB APP可见



xsong 2011-05-13 11:44 发表评论
]]>tomcat 请求流程http://www.blogjava.net/ghost/archive/2011/05/13/350154.htmlxsongxsongFri, 13 May 2011 03:44:00 GMThttp://www.blogjava.net/ghost/archive/2011/05/13/350154.htmlhttp://www.blogjava.net/ghost/comments/350154.htmlhttp://www.blogjava.net/ghost/archive/2011/05/13/350154.html#Feedback0http://www.blogjava.net/ghost/comments/commentRss/350154.htmlhttp://www.blogjava.net/ghost/services/trackbacks/350154.html

假设来自客户的请求为：
http://localhost:8080/wsota/wsota_index.jsp

1) 请求被发送到本机端口8080，被在那里侦听的Coyote HTTP/1.1 Connector获得
2) Connector把该请求交给它所在的Service的Engine来处理，并等待来自Engine的回应
3) Engine获得请求localhost/wsota/wsota_index.jsp，匹配它所拥有的所有虚拟主机Host
4) Engine匹配到名为localhost的Host（即使匹配不到也把请求交给该Host处理，因为该Host被定义为该Engine的默认主机）
5) localhost Host获得请求/wsota/wsota_index.jsp，匹配它所拥有的所有Context
6) Host匹配到路径为/wsota的Context（如果匹配不到就把该请求交给路径名为""的Context去处理）
7) path="/wsota"的Context获得请求/wsota_index.jsp，在它的mapping table中寻找对应的servlet
8) Context匹配到URL PATTERN为*.jsp的servlet，对应于JspServlet类
9) 构造HttpServletRequest对象和HttpServletResponse对象，作为参数调用JspServlet的doGet或doPost方法
10)Context把执行完了之后的HttpServletResponse对象返回给Host
11)Host把HttpServletResponse对象返回给Engine
12)Engine把HttpServletResponse对象返回给Connector
13)Connector把HttpServletResponse对象返回给客户browser



xsong 2011-05-13 11:44 发表评论
]]>Bootstrap 的 init 方法中 通过反射动态调用 Catalina.start()http://www.blogjava.net/ghost/archive/2011/05/13/350151.htmlxsongxsongFri, 13 May 2011 03:31:00 GMThttp://www.blogjava.net/ghost/archive/2011/05/13/350151.htmlhttp://www.blogjava.net/ghost/comments/350151.htmlhttp://www.blogjava.net/ghost/archive/2011/05/13/350151.html#Feedback0http://www.blogjava.net/ghost/comments/commentRss/350151.htmlhttp://www.blogjava.net/ghost/services/trackbacks/350151.html
Bootstrap 的 init 方法中 通过反射动态调用 Catalina.start() 
Catalina 类 负责开始或者停止服务
 Class<?> startupClass = catalinaLoader.loadClass("org.apache.catalina.startup.Catalina");
 Object startupInstance = startupClass.newInstance();
Catalina 完成了3个任务 
  •  处理xml文件， load 方法中使用 Digester 处理server.xml文件，转化为java对象
if (getServer() == null) {
            load();
        }
  •     实例化一个server  

 getServer().start();
  •      给jvm 注册一个关闭 的Hook（钩子）
Runtime.getRuntime().addShutdownHook(shutdownHook);
  • 线程等待
 await();  调用 StandardServer 的 await()   StandardServer 处理 Server相关的操作，
     /**
     * Wait until a proper shutdown command is received, then return.
     * This keeps the main thread alive - the thread pool listening for http
     * connections is daemon threads.
     */
     StandardServer.await() 处理 当前的主线程，即 启动 tomcat 的主线程

    try {
        awaitSocket = new ServerSocket(port, 1,
                InetAddress.getByName(address));
    }

    catch( IOException e ) {
        log.error("StandardServer.await: create[" + address + ":" + port + "]: ", e);
        return;
    }

    try {
        awaitThread = Thread.currentThread();

// Loop waiting for a connection and a valid command
        while (!stopAwait) {
            ServerSocket serverSocket = awaitSocket;

            if (serverSocket == null) {
                break;
            }
// Wait for the next connection
            Socket socket = null;
            StringBuilder command = new StringBuilder();
            try {
                InputStream stream;
                try {
                    socket = serverSocket.accept();
                    socket.setSoTimeout(10 * 1000);  // Ten seconds
                    stream = socket.getInputStream();
                } catch (AccessControlException ace) {
                    log.warn("StandardServer.accept security exception: " + ace.getMessage(), ace);
                    continue;
                } catch (IOException e) {
                    if (stopAwait) {
// Wait was aborted with socket.close()
                        break;
                    }
                    log.error("StandardServer.await: accept: ", e);
                    break;
                }
// Read a set of characters from the socket
                int expected = 1024; // Cut off to avoid DoS attack
                while (expected < shutdown.length()) {
                    if (random == null)
                        random = new Random();
                    expected += (random.nextInt() % 1024);
                }
                while (expected > 0) {
                    int ch = -1;
                    try {
                        ch = stream.read();
                    } catch (IOException e) {
                        log.warn("StandardServer.await: read: ", e);
                        ch = -1;
                    }
                    if (ch < 32)  // Control character or EOF terminates loop
                        break;
                    command.append((char) ch);
                    expected--;
                }
            } finally {
// Close the socket now that we are done with it
                try {
                    if (socket != null) {
                        socket.close();
                    }
                } catch (IOException e) {
// Ignore
                }
            }

// Match against our command string
            boolean match = command.toString().equals(shutdown);
            if (match) {
                log.info(sm.getString("standardServer.shutdownViaPort"));
                break;
            } else
                log.warn("StandardServer.await: Invalid command '"
                        + command.toString() + "' received");
        }
    }

    finally {
        ServerSocket serverSocket = awaitSocket;
        awaitThread = null;
        awaitSocket = null;
// Close the server socket and return
        if (serverSocket != null) {
            try {
                serverSocket.close();
            } catch (IOException e) {
// Ignore
            }
        }
    }


xsong 2011-05-13 11:31 发表评论
]]>Servlet 工作原理http://www.blogjava.net/ghost/archive/2011/05/13/350150.htmlxsongxsongFri, 13 May 2011 03:29:00 GMThttp://www.blogjava.net/ghost/archive/2011/05/13/350150.htmlhttp://www.blogjava.net/ghost/comments/350150.htmlhttp://www.blogjava.net/ghost/archive/2011/05/13/350150.html#Feedback0http://www.blogjava.net/ghost/comments/commentRss/350150.htmlhttp://www.blogjava.net/ghost/services/trackbacks/350150.html
 Tomcat 容器模型

从上图中可以看出 Tomcat 的心脏是两个组件：Connector 和 Container多个 Connector 和一个 Container 就形成了一个 Service，有了 Service 就可以对外提供服务了。但是 Service 还要一个生存的环境，必须要有人能够给她生命、掌握其生死大权，那就非 Server 莫属了。所以整个 Tomcat 的生命周期由 Server 控制
从 Service  
它主要是为了关联 Connector 和 Container。
Service 继承了 
Lifecycle接口
 ， 这样所有实现 Service接口 组件的生命周期在一个 Lifecycle 的接口中控制，这里用到了一个重要的设计模式，关于这个接口将在后面介绍。


Tomcat 中 Service 接口的标准实现类是 StandardService 它不仅实现了 Service 借口同时还实现了 Lifecycle 接口，这样它就可以控制它下面的组件的生命周期了。
Server 要完成的任务很简单，就是要能够提供一个接口让其它程序能够访问到这个 Service 集合、同时要维护它所包含的所有 Service 的生命周期，包括如何初始化、如何结束服务、如何找到别人要访问的 Service。
StandardServer doc:
Standard implementation of the Server interface, available for use (but not required) when deploying and starting Catalina.
StandardServer 类实现了 Server 接口，部署和启动tomcat实例

图 1 . Tomcat 容器模型




http://www.ibm.com/developerworks/cn/java/j-lo-servlet/image003.jpg

Tomcat 的启动逻辑是基于观察者模式设计的，所有的容器都会继承 Lifecycle 接口，它管理者容器的整个生命周期，所有容器的的修改和状态的改变都会由它去通知已经注册的观察者（Listener）
ContextConfig 的 init 方法将会主要完成以下工作：
  1. 创建用于解析 xml 配置文件的 contextDigester 对象
  2. 读取默认 context.xml 配置文件，如果存在解析它
  3. 读取默认 Host 配置文件，如果存在解析它
  4. 读取默认 Context 自身的配置文件，如果存在解析它
  5. 设置 Context 的 DocBase
     protected void init() {
        ...
        contextConfig();
        ...
       
    }
     protected void contextConfig() {
       
        // 解析 content.xml 
        if( defaultContextXml==null && context instanceof StandardContext ) {
            defaultContextXml = ((StandardContext)context).getDefaultContextXml();
        }
        // set the default if we don't have any overrides
        if( defaultContextXml==null ) getDefaultContextXml();

        if (!context.getOverride()) {
            File defaultContextFile = new File(defaultContextXml);
            if (!defaultContextFile.isAbsolute()) {
                defaultContextFile =new File(getBaseDir(), defaultContextXml);
            }
            if (defaultContextFile.exists()) {
                try {
                    URL defaultContextUrl = defaultContextFile.toURI().toURL();
                    processContextConfig(defaultContextUrl);
                } catch (MalformedURLException e) {
                    log.error(sm.getString(
                            "contextConfig.badUrl", defaultContextFile), e);
                }
            }
            //  解析 host
            File hostContextFile = new File(getConfigBase(),
                    getHostConfigPath(Constants.HostContextXml));
            if (hostContextFile.exists()) {
                try {
                    URL hostContextUrl = hostContextFile.toURI().toURL();
                    processContextConfig(hostContextUrl);
                } catch (MalformedURLException e) {
                    log.error(sm.getString(
                            "contextConfig.badUrl", hostContextFile), e);
                }
            }
        }
          // 
        if (context.getConfigFile() != null)
            processContextConfig(context.getConfigFile());
       
    }
StandardContext 的 startInternal 方法 主要包括如下几个部分：
  1. 创建读取资源文件的对象
  2. 创建 ClassLoader 对象
  3. 设置应用的工作目录
  4. 启动相关的辅助类如：logger、realm、resources 等
  5. 修改启动状态，通知感兴趣的观察者（Web 应用的配置）
  6. 子容器的初始化
  7. 获取 ServletContext 并设置必要的参数
  8. 初始化“load on startup”的 Servlet
protected synchronized void startInternal() throws LifecycleException {

     // 创建读取资源文件对象
     if (webappResources == null) {   // (1) Required by Loader
            if (log.isDebugEnabled())
                log.debug("Configuring default Resources");
            try {
                if ((getDocBase() != null) && (getDocBase().endsWith(".war")) &&
                        (!(new File(getBasePath())).isDirectory()))
                    setResources(new WARDirContext());
                else
                    setResources(new FileDirContext());
            } catch (IllegalArgumentException e) {
                log.error("Error initializing resources: " + e.getMessage());
                ok = false;
            }
        }
     // 创建classLoader
     if (getLoader() == null) {
            WebappLoader webappLoader = new WebappLoader(getParentClassLoader());
            webappLoader.setDelegate(getDelegate());
            setLoader(webappLoader);
        }

    }

     //设置工作目录         
     postWorkDirectory();
     //启动相关的辅助类如：logger、realm、resources 等
     if ((logger != null) && (logger instanceof Lifecycle))
                    ((Lifecycle) logger).start();
               
                if ((cluster != null) && (cluster instanceof Lifecycle))
                    ((Lifecycle) cluster).start();
                if ((realm != null) && (realm instanceof Lifecycle))
                    ((Lifecycle) realm).start();
                if ((resources != null) && (resources instanceof Lifecycle))
                    ((Lifecycle) resources).start();

     // 修改启动状态，通知感兴趣的观察者（Web 应用的配置）
     fireLifecycleEvent(Lifecycle.CONFIGURE_START_EVENT, null);
                // 子容器的初始化
                // Start our child containers, if not already started
                for (Container child : findChildren()) {
                    if (!child.getState().isAvailable()) {
                        child.start();
                    }
                }
     // 注册集群管理
     if (manager!=null && (getCluster() != null) && distributable) {
                    //let the cluster know that there is a context that is distributable
                    //and that it has its own manager
                    getCluster().registerManager(manager);
                }


xsong 2011-05-13 11:29 发表评论
]]>