当前位置:首页 > 开发 > 互联网 > 正文

TOM源码第一课

发表于: 2013-03-03   作者:cywhoyi   来源:转载   浏览次数:
摘要: /*   * Licensed to the Apache Software Foundation (ASF) under one or more   * contributor license agreements.  See the NOTICE file distributed with   * this work for additional

/*

  * Licensed to the Apache Software Foundation (ASF) under one or more

  * contributor license agreements.  See the NOTICE file distributed with

  * this work for additional information regarding copyright ownership.

  * The ASF licenses this file to You under the Apache License, Version 2.0

  * (the "License"); you may not use this file except in compliance with

  * the License.  You may obtain a copy of the License at

  * 

  *      http://www.apache.org/licenses/LICENSE-2.0

  * 

  * Unless required by applicable law or agreed to in writing, software

  * distributed under the License is distributed on an "AS IS" BASIS,

  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  * See the License for the specific language governing permissions and

  * limitations under the License.

  */ 

  

 package javax.servlet;

 

 import java.io.IOException;

 

 

 /**

  * Defines methods that all servlets must implement.

  *

  * <p>A servlet is a small Java program that runs within a Web server.

  * Servlets receive and respond to requests from Web clients,

  * usually across HTTP, the HyperText Transfer Protocol. 

  *

  * <p>To implement this interface, you can write a generic servlet

  * that extends

  * <code>javax.servlet.GenericServlet</code> or an HTTP servlet that

  * extends <code>javax.servlet.http.HttpServlet</code>.

  *

  * <p>This interface defines methods to initialize a servlet,

  * to service requests, and to remove a servlet from the server.

  * These are known as life-cycle methods and are called in the

  * following sequence:

  * <ol>

  * <li>The servlet is constructed, then initialized with the <code>init</code> method.

  * <li>Any calls from clients to the <code>service</code> method are handled.

  * <li>The servlet is taken out of service, then destroyed with the 

  * <code>destroy</code> method, then garbage collected and finalized.

  * </ol>

  *

  * <p>In addition to the life-cycle methods, this interface

  * provides the <code>getServletConfig</code> method, which the servlet 

  * can use to get any startup information, and the <code>getServletInfo</code>

  * method, which allows the servlet to return basic information about itself,

  * such as author, version, and copyright.

  *

  * @author     Various

  * @version     $Version$

  *

  * @see     GenericServlet

  * @see     javax.servlet.http.HttpServlet

  *

  */

 

 

 public interface Servlet {

 

     /**

      * Called by the servlet container to indicate to a servlet that the 

      * servlet is being placed into service.

      *

      * <p>The servlet container calls the <code>init</code>

      * method exactly once after instantiating the servlet.

      * The <code>init</code> method must complete successfully

      * before the servlet can receive any requests.

      *

      * <p>The servlet container cannot place the servlet into service

      * if the <code>init</code> method

      * <ol>

      * <li>Throws a <code>ServletException</code>

      * <li>Does not return within a time period defined by the Web server

      * </ol>

      *

      *

      * @param config            a <code>ServletConfig</code> object 

      *                    containing the servlet's

      *                     configuration and initialization parameters

      *

      * @exception ServletException     if an exception has occurred that

      *                    interferes with the servlet's normal

      *                    operation

      *

      * @see                 UnavailableException

      * @see                 #getServletConfig

      *

      */

 

     public void init(ServletConfig config) throws ServletException;

     

     

 

     /**

      *

      * Returns a {@link ServletConfig} object, which contains

      * initialization and startup parameters for this servlet.

      * The <code>ServletConfig</code> object returned is the one 

      * passed to the <code>init</code> method. 

      *

      * <p>Implementations of this interface are responsible for storing the 

      * <code>ServletConfig</code> object so that this 

      * method can return it. The {@link GenericServlet}

      * class, which implements this interface, already does this.

      *

      * @return        the <code>ServletConfig</code> object

      *            that initializes this servlet

      *

      * @see         #init

      *

      */

 

     public ServletConfig getServletConfig();

     

     

 

     /**

      * Called by the servlet container to allow the servlet to respond to 

      * a request.

      *

      * <p>This method is only called after the servlet's <code>init()</code>

      * method has completed successfully.

      * 

      * <p>  The status code of the response always should be set for a servlet 

      * that throws or sends an error.

      *

      * 

      * <p>Servlets typically run inside multithreaded servlet containers

      * that can handle multiple requests concurrently. Developers must 

      * be aware to synchronize access to any shared resources such as files,

      * network connections, and as well as the servlet's class and instance 

      * variables. 

      * More information on multithreaded programming in Java is available in 

      * <a href="http://java.sun.com/Series/Tutorial/java/threads/multithreaded.html">

      * the Java tutorial on multi-threaded programming</a>.

      *

      *

      * @param req     the <code>ServletRequest</code> object that contains

      *            the client's request

      *

      * @param res     the <code>ServletResponse</code> object that contains

      *            the servlet's response

      *

      * @exception ServletException     if an exception occurs that interferes

      *                    with the servlet's normal operation 

      *

      * @exception IOException         if an input or output exception occurs

      *

      */

 

     public void service(ServletRequest req, ServletResponse res)

     throws ServletException, IOException;

     

     

 

     /**

      * Returns information about the servlet, such

      * as author, version, and copyright.

      * 

      * <p>The string that this method returns should

      * be plain text and not markup of any kind (such as HTML, XML,

      * etc.).

      *

      * @return         a <code>String</code> containing servlet information

      *

      */

 

     public String getServletInfo();

     

     

 

     /**

      *

      * Called by the servlet container to indicate to a servlet that the

      * servlet is being taken out of service.  This method is

      * only called once all threads within the servlet's

      * <code>service</code> method have exited or after a timeout

      * period has passed. After the servlet container calls this 

      * method, it will not call the <code>service</code> method again

      * on this servlet.

      *

      * <p>This method gives the servlet an opportunity 

      * to clean up any resources that are being held (for example, memory,

      * file handles, threads) and make sure that any persistent state is

      * synchronized with the servlet's current state in memory.

      *

      */

 

     public void destroy();

 }

 在Servlet接口中声明了5个方法里,init(),service(),destory()方法是与servlet的生命周期相关的方法,当实例化某个servlet类后,Servlet容器会调用其init()方法进行初始化,至于Servlet容器是如何调用,后面会分析。后面会被类与类之间的衔接来做一定的分析。在servlet接收任何请求之前,必须是经过正确初始化的。一般情况下init()方法可以留空。

 当servlet的一个客户端请求到达后,servlet容器就调用相应的servlet的service()方法,并将javax.serlvet.servletRequest对象和javax.servlet.servletResponse对象作为参数传入,ServletResquest对象包含客户端的HTTP请求的信息,ServletResponse对象则封装servlet的请求信息。这两个类的设计十分有趣,在后面就具体分析这两个类。在servlet对象的整个生命周期内,service()方法会被多次调用。

 在将servlet实例从服务中移除前,servlet容器会调用servlet实例的destory()方法,一般当Servlet容器关闭或servlet容器要释放内存时,才会将servlet实例移除,而且只有当servlet实例的service()方法中的线程都退出或执行超时后,才会调用destory()方法,当servlet容器调用了某个servlet实例的destory()方法后,它就不再调用该servlet实例的service()方法了,调用destory()方法让servlet对象有机会去清理自身持有的资源,如内存,文件句柄和线程等,确保有所的持久化与内存中该servlet对象的当前状态同步。

 下面<how tomcat work>中的一个servlet类:

 import javax.servlet.*;

 import java.io.IOException;

 import java.io.PrintWriter;

 public class PrimitiveServlet implements Servlet {

 public void init(ServletConfig config) throws ServletException {

 System.out.println("init");

 }

 public void service(ServletRequest request, ServletResponse response)

 throws ServletException, IOException {

 System.out.println("from service");

 PrintWriter out = response.getWriter();

 out.println("Hello. Roses are red.");

 out.print("Violets are blue.");

 }

 public void destroy() {

 System.out.println("destroy");

 }

 public String getServletInfo() {

 return null;

 }

 public ServletConfig getServletConfig() {

 return null;

 }

 }

 一个功能齐全的servlet容器有以下几件事要做:

 1,当第一次调用某个servlet,要载入该servlet类,并调用其init()方法(仅此一次);

 2,针对每个request请求,创建一个javax.servlet.ServletRequest实例和一个javax.servlet.ServletResponse实例;

 3,调用该servlet的service()方法,将servletRequest对象和servletResponse对象作为参数传入;

 4,当关闭该servlet类时,调用其destory()方法,并卸载该servlet类。

 

 那么从客户连接到tomcat上来,最重要要做的事就是如何处理客户的请求并且把请求传递给Servlet容器,虽然看起来很简单,但是这整个过程确是如此的繁杂,包括字符串的解析,以及cookies,session,参数请求等等的工作。那么我们首先的工作就是分析客户连接到tomcat上来这一块,也就是tomcat的默认连接器。

 

 Tomcat的连接器必须实现org.apache.catalina.Connecor接口,在接口中声明了很多方法,其中最重要的是getContainer(),setContainer(),createRequest(),createResponse()方法。为什么这么说呢?看看以下分析:

 setContainer()方法用于将连接器和某个servlet容器相关联。如果不跟特定的servlet容器关联起来,我靠,你准备要把包装好的HttpRequest和HttpResponse对象传给谁阿??

 getContainer()方法返回与当前连接器相关联的servlet容器。createRequest()方法会引入的HTTP请求创建request对象,相应的,createResponse()方法会创建一个response对象。

 org.apache.catalina.connector.http.HttpConnector类实现了Connector接口,首先大概说以下HttpConnector类做的一些工作:

 1,首先它实现了org.apache.catalina.Connector接口(使其可以成为Catalina中的连接器),又实现了java.lang.Runnble接口(确保它的实例在自己的线程中运行)和实现了org.apache.catalina.Lifecycle接口,Lifecycle接口用于维护每个实现了该接口的每个Catalina组件的生命周期。但是这个接口目前不是重点,在后面会讲到。

 2,由于HttpConnector实现了Lifecycle接口,因此当创建一个HttpConnector实例后,就应该调用其initialize()方法和start()方法,这两个方法如何调用在后面会详细讲到,现在就记住一点:这两个方法只应该被调用一次。

 3,HttpConnector类还负责创建服务器套接字,这是最重要的一点,没有这个,啥事都不用做了。HttpConnector类的initialize()方法会调用一个私有方法open(),后者返回一个java.net.ServerSocket实例,赋值给成员变量serverSocket。但是,这里没有直接调用ServerSocket类的构造函数,而是通过open()方法从一个服务器套接字工厂得到一个实例。

 4,维护HttpProcessor实例:HttpProcessor实例是用来处理HTTP请求的,在Tomcat的默认连接器中,HttpConnector实例有一个HttpProcessor对象池,每个HttpProcessor实例都运行在其自己的线程中。这样HttpConnector实例就可以同时处理多个HTTP请求了。

 好了,接下来就是具体看看它们这几个步骤中tomcat源码的实现:

 首先我们从连接用户开始入手:

 org.apache.catalina.connector.http.HttpConnector

         /**

      * The shutdown signal to our background thread

      */

     private boolean stopped = false;

     

      /**

      * Use TCP no delay ?

      */

     private boolean tcpNoDelay = true;

     

       /**

      * Timeout value on the incoming connection.

      * Note : a value of 0 means no timeout.

      */

     private int connectionTimeout = Constants.DEFAULT_CONNECTION_TIMEOUT;

     

       /**

      * Has this component been started yet?

      */

     private boolean started = false;

     

     

      /**

      * The thread synchronization object.

      */

     private Object threadSync = new Object();

         

         //该方法运行在一个线程中

  // ---------------------------------------------- Background Thread Methods

 

 

     /**

      * The background thread that listens for incoming TCP/IP connections and

      * hands them off to an appropriate processor.

      */

     public void run() {

 

         // Loop until we receive a shutdown command

                //如果tomcat接收到shutdown的命令,那么将会关闭连接器

         while (!stopped) {

 

             // Accept the next incoming connection from the server socket

             Socket socket = null;

             try {

                 //                if (debug >= 3)

                 //                    log("run: Waiting on serverSocket.accept()");

                 socket = serverSocket.accept();//服务器等待用户的连接

                 //                if (debug >= 3)

                 //                    log("run: Returned from serverSocket.accept()");

                 if (connectionTimeout > 0)

                     socket.setSoTimeout(connectionTimeout);//设置超时时间

                 socket.setTcpNoDelay(tcpNoDelay);//启用/禁用 TCP_NODELAY

             } catch (AccessControlException ace) {

                 log("socket accept security exception", ace);

                 continue;

             } catch (IOException e) {

                 //                if (debug >= 3)

                 //                    log("run: Accept returned IOException", e);

                 try {

                     // If reopening fails, exit

                     synchronized (threadSync) {

                         if (started && !stopped)//如何其他组件还在运行或者socket还没关闭

                             log("accept error: ", e);

                         if (!stopped) {//如果socket还没关闭

                             //                    if (debug >= 3)

                             //                        log("run: Closing server socket");

                             serverSocket.close();//关闭服务器

                             //                        if (debug >= 3)

                             //                            log("run: Reopening server socket");

                             serverSocket = open();//创建新的serverSocket对象

                         }

                     }

                     //                    if (debug >= 3)

                     //                        log("run: IOException processing completed");

                 } catch (IOException ioe) {

                     log("socket reopen, io problem: ", ioe);

                     break;

                 } catch (KeyStoreException kse) {

                     log("socket reopen, keystore problem: ", kse);

                     break;

                 } catch (NoSuchAlgorithmException nsae) {

                     log("socket reopen, keystore algorithm problem: ", nsae);

                     break;

                 } catch (CertificateException ce) {

                     log("socket reopen, certificate problem: ", ce);

                     break;

                 } catch (UnrecoverableKeyException uke) {

                     log("socket reopen, unrecoverable key: ", uke);

                     break;

                 } catch (KeyManagementException kme) {

                     log("socket reopen, key management problem: ", kme);

                     break;

                 }

 

                 continue;

             }

 

             // Hand this socket off to an appropriate processor

             HttpProcessor processor = createProcessor();//从HttpProcessor获得一个HttpProcessor对象或者是当池中没有HttpProcessor对象。

             if (processor == null) {

                 try {

                     log(sm.getString("httpConnector.noProcessor"));

                     socket.close();//关闭socket

                 } catch (IOException e) {

                     ;

                 }

                 continue;

             }

             //            if (debug >= 3)

             //                log("run: Assigning socket to processor " + processor);

             processor.assign(socket);//处理HTTP请求

 

             // The processor will recycle itself when it finishes

 

         }

 

         // Notify the threadStop() method that we have shut ourselves down

         //        if (debug >= 3)

         //            log("run: Notifying threadStop() that we have shut down");

         synchronized (threadSync) {

             threadSync.notifyAll();//唤醒有所的线程

         }

 

     }

     这段代码衍生出来的需要注意的东西有很多,但是先说一点,上面的log()方法是日志记录,这里暂时不说它,后面会详细的说它。好了,现在要从这段代码开始来把握几点需要注意的地方。有些地方需要加上UML来进行解释会比较好!

     

     第一点需要关注的地方:serverSocket = open();我们来看看open()方法做了些什么事情先。首先它是一个私有的方法,也就是用户不能去重写它的方法。

    org.apache.catalina.connector.http.HttpConnector

    

     /**

      * The IP address on which to bind, if any.  If <code>null</code>, all

      * addresses on the server will be bound.

      */

     private String address = null;

     

     

      /**

      * The port number on which we listen for HTTP requests.

      */

     private int port = 8080;

     

     

      /**

      * The accept count for this Connector.

      */

     private int acceptCount = 10;

     

     

     

      private ServerSocket open()

     throws IOException, KeyStoreException, NoSuchAlgorithmException,

            CertificateException, UnrecoverableKeyException,

            KeyManagementException

     {

 

         // Acquire the server socket factory for this Connector

         ServerSocketFactory factory = getFactory();利用工厂方法来创建一个套接字

 

         // If no address is specified, open a connection on all addresses

         if (address == null) {

             log(sm.getString("httpConnector.allAddresses"));

             try {

                 return (factory.createSocket(port, acceptCount));//返回创建好了的套接字

             } catch (BindException be) {

                 throw new BindException(be.getMessage() + ":" + port);

             }

         }

 

         // Open a server socket on the specified address

         try {

             InetAddress is = InetAddress.getByName(address);//在给定主机名的情况下确定主机的IP地址

             log(sm.getString("httpConnector.anAddress", address));

             try {

                 return (factory.createSocket(port, acceptCount, is));

             } catch (BindException be) {

                 throw new BindException(be.getMessage() + ":" + address +

                                         ":" + port);

             }

         } catch (Exception e) {

             log(sm.getString("httpConnector.noAddress", address));

             try {

                 return (factory.createSocket(port, acceptCount));

             } catch (BindException be) {

                 throw new BindException(be.getMessage() + ":" + port);

             }

         }

 

     }

     看看open()方法:很简单,不多说。主要要加索,保证线程安全

       /**

      * Return the server socket factory used by this Container.

      */

     public ServerSocketFactory getFactory() {

 

         if (this.factory == null) {

             synchronized (this) {

                 this.factory = new DefaultServerSocketFactory();

             }

         }

         return (this.factory);

 

     }

     

     

     那么从上面的代码用到了工厂设计模式,具体继续跟踪源码的实现:

     apache.catalina.net.ServerSocketFactory,该类是一个接口,提供了三个方法:

     其实也就是java.net.ServerSocket的三个方法构造,只不过换了以下名字调用而已,它的子类DefaultServerSocketFactory实现了这个接口,并且这个类是fianl类,不可以被集成。具体看看这个类的实现:

     /*

  * Licensed to the Apache Software Foundation (ASF) under one or more

  * contributor license agreements.  See the NOTICE file distributed with

  * this work for additional information regarding copyright ownership.

  * The ASF licenses this file to You under the Apache License, Version 2.0

  * (the "License"); you may not use this file except in compliance with

  * the License.  You may obtain a copy of the License at

  * 

  *      http://www.apache.org/licenses/LICENSE-2.0

  * 

  * Unless required by applicable law or agreed to in writing, software

  * distributed under the License is distributed on an "AS IS" BASIS,

  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  * See the License for the specific language governing permissions and

  * limitations under the License.

  */

 

 

 package org.apache.catalina.net;

 

 

 import java.io.IOException;

 import java.net.InetAddress;

 import java.net.ServerSocket;

 import java.security.KeyStoreException;

 import java.security.NoSuchAlgorithmException;

 import java.security.UnrecoverableKeyException;

 import java.security.KeyManagementException;

 import java.security.cert.CertificateException;

 import org.apache.catalina.net.ServerSocketFactory;

 

 

 /**

  * Default server socket factory, which returns unadorned server sockts.

  *

  * @author db@eng.sun.com

  * @author Harish Prabandham

  * @author Craig R. McClanahan

  */

 

 public final class DefaultServerSocketFactory implements ServerSocketFactory {

 

 

     // --------------------------------------------------------- Public Methods

 

 

     /**

      * Returns a server socket which uses all network interfaces on

      * the host, and is bound to a the specified port.  The socket is

      * configured with the socket options (such as accept timeout)

      * given to this factory.

      *

      * @param port the port to listen to

      *

      * @exception IOException                input/output or network error

      * @exception KeyStoreException          error instantiating the

      *                                       KeyStore from file (SSL only)

      * @exception NoSuchAlgorithmException   KeyStore algorithm unsupported

      *                                       by current provider (SSL only)

      * @exception CertificateException       general certificate error (SSL only)

      * @exception UnrecoverableKeyException  internal KeyStore problem with

      *                                       the certificate (SSL only)

      * @exception KeyManagementException     problem in the key management

      *                                       layer (SSL only)

      */

     public ServerSocket createSocket (int port)

     throws IOException, KeyStoreException, NoSuchAlgorithmException,

            CertificateException, UnrecoverableKeyException,

            KeyManagementException {

 

         return (new ServerSocket(port));

 

     }

 

 

     /**

      * Returns a server socket which uses all network interfaces on

      * the host, is bound to a the specified port, and uses the

      * specified connection backlog.  The socket is configured with

      * the socket options (such as accept timeout) given to this factory.

      *

      * @param port the port to listen to

      * @param backlog how many connections are queued

      *

      * @exception IOException                input/output or network error

      * @exception KeyStoreException          error instantiating the

      *                                       KeyStore from file (SSL only)

      * @exception NoSuchAlgorithmException   KeyStore algorithm unsupported

      *                                       by current provider (SSL only)

      * @exception CertificateException       general certificate error (SSL only)

      * @exception UnrecoverableKeyException  internal KeyStore problem with

      *                                       the certificate (SSL only)

      * @exception KeyManagementException     problem in the key management

      *                                       layer (SSL only)

      */

     public ServerSocket createSocket (int port, int backlog)

     throws IOException, KeyStoreException, NoSuchAlgorithmException,

            CertificateException, UnrecoverableKeyException,

            KeyManagementException {

 

         return (new ServerSocket(port, backlog));

 

     }

 

 

     /**

      * Returns a server socket which uses only the specified network

      * interface on the local host, is bound to a the specified port,

      * and uses the specified connection backlog.  The socket is configured

      * with the socket options (such as accept timeout) given to this factory.

      *

      * @param port the port to listen to

      * @param backlog how many connections are queued

      * @param ifAddress the network interface address to use

      *

      * @exception IOException                input/output or network error

      * @exception KeyStoreException          error instantiating the

      *                                       KeyStore from file (SSL only)

      * @exception NoSuchAlgorithmException   KeyStore algorithm unsupported

      *                                       by current provider (SSL only)

      * @exception CertificateException       general certificate error (SSL only)

      * @exception UnrecoverableKeyException  internal KeyStore problem with

      *                                       the certificate (SSL only)

      * @exception KeyManagementException     problem in the key management

      *                                       layer (SSL only)

      */

     public ServerSocket createSocket (int port, int backlog,

                                       InetAddress ifAddress)

     throws IOException, KeyStoreException, NoSuchAlgorithmException,

            CertificateException, UnrecoverableKeyException,

            KeyManagementException {

 

         return (new ServerSocket(port, backlog, ifAddress));

 

     }

 是吧,是java.nio.ServerSocket类的三个构造方法吧。port端口号,backlog可接收的队列长度,ifAddress要将服务器绑定到的InetAddress

TOM源码第一课

  • 0

    开心

    开心

  • 0

    板砖

    板砖

  • 0

    感动

    感动

  • 0

    有用

    有用

  • 0

    疑问

    疑问

  • 0

    难过

    难过

  • 0

    无聊

    无聊

  • 0

    震惊

    震惊

编辑推荐
项目名称:Tom猫 项目知识:UIImageView控件动画播放 效果图: 开始项目 一、 (1)添加一个项目,在st
作者 Gavin Terrill译者 胡键 发布于 2008年5月4日 上午4时17分 随着jBPM过程虚拟机(Process Virtu
作者 Gavin Terrill译者 胡键 发布于 2008年5月4日 上午4时17分 随着jBPM过程虚拟机(Process Virtu
Uncle Tom's Inherited Land* Time Limit : 2000/1000ms (Java/Other) Memory Limit : 65536/32768K
Uncle Tom's Inherited Land* Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768
Uncle Tom's Inherited Land* Time Limit : 2000/1000ms (Java/Other) Memory Limit : 65536/32768K
实现汤米猫学说话的demo,即实现变声功能。 开发者说:自己经常来看code4app,看看有没有新的功能代
人人都喜歡拍攝名勝景點,來自美國費城的攝影師 Tom Storm,卻能夠把景點濃縮在泡泡之中,浪漫之餘
2009-05-02 12:50:59 分类:提高班学习 为了牛人展示,我们也算是好好练练手哈~ 小兵主刀的,“超酷
2009-05-02 12:50:59 分类:提高班学习 为了牛人展示,我们也算是好好练练手哈~ 小兵主刀的,“超酷
版权所有 IT知识库 CopyRight © 2009-2015 IT知识库 IT610.com , All Rights Reserved. 京ICP备09083238号