亚洲免费在线-亚洲免费在线播放-亚洲免费在线观看-亚洲免费在线观看视频-亚洲免费在线看-亚洲免费在线视频

How Tomcat Works(三)

系統 2136 0

上文中描述的簡單的服務器是不符合Servlet規范的,所以本文進一步描述一個簡單的Servlet容器是怎么實現的

所以我們首先要明白Servlet接口規范,規范有不同版本,本人就先一視同仁了:

      
        public
      
      
        interface
      
      
         Servlet {
    
      
      
        public
      
      
        void
      
       init(ServletConfig config) 
      
        throws
      
      
         ServletException;      
      
      
        public
      
      
         ServletConfig getServletConfig();
      
      
        public
      
      
        void
      
      
         service(ServletRequest req, ServletResponse res)
    
      
      
            throws
      
      
         ServletException, IOException;
        
public String getServletInfo(); public void destroy(); }

上面的方法中,init() 、service()和 destroy()是與Servlet的生命周期密切相關的方法,熟悉Servlet生命周期的童鞋是比較清楚的

Servlet容器通常只調用Servlet實例的init()方法一次,用于初始化相關信息;

service()方法用于響應客戶端請求,傳入ServletRequest和ServletResponse參數,service()方法會被多次調用

當Servlet容器關閉或Servlet容器需要釋放內存時,會調用Servlet實例的destroy()方法,用于清理自身持有的資源,如內存、文件句柄和線程等,確保所有的持久化狀態與內存中該Servlet對象的當前狀態同步。

下面我們來看一個簡單的Servlet容器怎么實現:

HttpServer1類:

      
        public
      
      
        class
      
      
         HttpServer1 {

  
      
      
        /**
      
      
         WEB_ROOT is the directory where our HTML and other files reside.
   *  For this package, WEB_ROOT is the "webroot" directory under the working
   *  directory.
   *  The working directory is the location in the file system
   *  from where the java command was invoked.
   
      
      
        */
      
      
        //
      
      
         shutdown command
      
      
        private
      
      
        static
      
      
        final
      
       String SHUTDOWN_COMMAND = "/SHUTDOWN"
      
        ;

  
      
      
        //
      
      
         the shutdown command received
      
      
        private
      
      
        boolean
      
       shutdown = 
      
        false
      
      
        ;

  
      
      
        public
      
      
        static
      
      
        void
      
      
         main(String[] args) {
    HttpServer1 server 
      
      = 
      
        new
      
      
         HttpServer1();
    server.await();
  }

  
      
      
        public
      
      
        void
      
      
         await() {
    ServerSocket serverSocket 
      
      = 
      
        null
      
      
        ;
    
      
      
        int
      
       port = 8080
      
        ;
    
      
      
        try
      
      
         {
      serverSocket 
      
      =  
      
        new
      
       ServerSocket(port, 1, InetAddress.getByName("127.0.0.1"
      
        ));
    }
    
      
      
        catch
      
      
         (IOException e) {
      e.printStackTrace();
      System.exit(
      
      1
      
        );
    }

    
      
      
        //
      
      
         Loop waiting for a request
      
      
        while
      
       (!
      
        shutdown) {
      Socket socket 
      
      = 
      
        null
      
      
        ;
      InputStream input 
      
      = 
      
        null
      
      
        ;
      OutputStream output 
      
      = 
      
        null
      
      
        ;
      
      
      
        try
      
      
         {
        socket 
      
      =
      
         serverSocket.accept();
        input 
      
      =
      
         socket.getInputStream();
        output 
      
      =
      
         socket.getOutputStream();

        
      
      
        //
      
      
         create Request object and parse
      
      
        Request request = 
      
        new
      
      
         Request(input);
        request.parse();

        
      
      
        //
      
      
         create Response object
      
      
        Response response = 
      
        new
      
      
         Response(output);
        response.setRequest(request);

        
      
      
        //
      
      
         check if this is a request for a servlet or a static resource
        
      
      
        //
      
      
         a request for a servlet begins with "/servlet/"
      
      
        if
      
       (request.getUri().startsWith("/servlet/"
      
        )) {
          ServletProcessor1 processor 
      
      = 
      
        new
      
      
         ServletProcessor1();
          processor.process(request, response);
        }
        
      
      
        else
      
      
         {
          StaticResourceProcessor processor 
      
      = 
      
        new
      
      
         StaticResourceProcessor();
          processor.process(request, response);
        }

        
      
      
        //
      
      
         Close the socket
      
      
                socket.close();
        
      
      
        //
      
      
        check if the previous URI is a shutdown command
      
      
        shutdown =
      
         request.getUri().equals(SHUTDOWN_COMMAND);
      }
      
      
      
        catch
      
      
         (Exception e) {
        e.printStackTrace();
        System.exit(
      
      1
      
        );
      }
    }
  }
}
      
    

上面方法中,Servlet容器根據請求的路徑分發到不同的處理類進行處理,servlet請求交給ServletProcessor1類處理,靜態資源交給StaticResourceProcessor類處理

注:本文中的Servlet容器跟上文相比,將響應請求的功能解耦, 由處理器類(ServletProcessor1類和StaticResourceProcessor類)來承擔

Request類(注意我們這里的Request類已經實現了ServletRequest 接口,已經是按照規范來搞的了)

      
        public
      
      
        class
      
       Request 
      
        implements
      
      
         ServletRequest {

  
      
      
        private
      
      
         InputStream input;
  
      
      
        private
      
      
         String uri;

  
      
      
        public
      
      
         Request(InputStream input) {
    
      
      
        this
      
      .input =
      
         input;
  }

  
      
      
        public
      
      
         String getUri() {
    
      
      
        return
      
      
         uri;
  }

  
      
      
        private
      
      
         String parseUri(String requestString) {
    
      
      
        int
      
      
         index1, index2;
    index1 
      
      = requestString.indexOf(' '
      
        );
    
      
      
        if
      
       (index1 != -1
      
        ) {
      index2 
      
      = requestString.indexOf(' ', index1 + 1
      
        );
      
      
      
        if
      
       (index2 >
      
         index1)
        
      
      
        return
      
       requestString.substring(index1 + 1
      
        , index2);
    }
    
      
      
        return
      
      
        null
      
      
        ;
  }

  
      
      
        public
      
      
        void
      
      
         parse() {
    
      
      
        //
      
      
         Read a set of characters from the socket
      
      
    StringBuffer request = 
      
        new
      
       StringBuffer(2048
      
        );
    
      
      
        int
      
      
         i;
    
      
      
        byte
      
      [] buffer = 
      
        new
      
      
        byte
      
      [2048
      
        ];
    
      
      
        try
      
      
         {
      i 
      
      =
      
         input.read(buffer);
    }
    
      
      
        catch
      
      
         (IOException e) {
      e.printStackTrace();
      i 
      
      = -1
      
        ;
    }
    
      
      
        for
      
       (
      
        int
      
       j=0; j<i; j++
      
        ) {
      request.append((
      
      
        char
      
      
        ) buffer[j]);
    }
    System.out.print(request.toString());
    uri 
      
      =
      
         parseUri(request.toString());
  }

  
      
      
        /*
      
      
         implementation of the ServletRequest
      
      
        */
      
      
        public
      
      
         Object getAttribute(String attribute) {
    
      
      
        return
      
      
        null
      
      
        ;
  }
        
      
          /
      
      
        /省略后面的代碼
      
    
      
        }
      
    

Response類(實現ServletResponse接口)

      
        public
      
      
        class
      
       Response 
      
        implements
      
      
         ServletResponse {

  
      
      
        private
      
      
        static
      
      
        final
      
      
        int
      
       BUFFER_SIZE = 1024
      
        ;
  Request request;
  OutputStream output;
  PrintWriter writer;

  
      
      
        public
      
      
         Response(OutputStream output) {
    
      
      
        this
      
      .output =
      
         output;
  }

  
      
      
        public
      
      
        void
      
      
         setRequest(Request request) {
    
      
      
        this
      
      .request =
      
         request;
  }

  
      
      
        /*
      
      
         This method is used to serve a static page 
      
      
        */
      
      
        public
      
      
        void
      
       sendStaticResource() 
      
        throws
      
      
         IOException {
    
      
      
        byte
      
      [] bytes = 
      
        new
      
      
        byte
      
      
        [BUFFER_SIZE];
    FileInputStream fis 
      
      = 
      
        null
      
      
        ;
    
      
      
        try
      
      
         {
      
      
      
        /*
      
      
         request.getUri has been replaced by request.getRequestURI 
      
      
        */
      
      
        
      File file 
      
      = 
      
        new
      
      
         File(Constants.WEB_ROOT, request.getUri());
      fis 
      
      = 
      
        new
      
      
         FileInputStream(file);
      
      
      
        /*
      
      
        
         HTTP Response = Status-Line
           *(( general-header | response-header | entity-header ) CRLF)
           CRLF
           [ message-body ]
         Status-Line = HTTP-Version SP Status-Code SP Reason-Phrase CRLF
      
      
      
        */
      
      
        int
      
       ch = fis.read(bytes, 0
      
        , BUFFER_SIZE);
      
      
      
        while
      
       (ch!=-1
      
        ) {
        output.write(bytes, 
      
      0
      
        , ch);
        ch 
      
      = fis.read(bytes, 0
      
        , BUFFER_SIZE);
      }
    }
    
      
      
        catch
      
      
         (FileNotFoundException e) {
      String errorMessage 
      
      = "HTTP/1.1 404 File Not Found\r\n" +
        "Content-Type: text/html\r\n" +
        "Content-Length: 23\r\n" +
        "\r\n" +
        "<h1>File Not Found</h1>"
      
        ;
      output.write(errorMessage.getBytes());
    }
    
      
      
        finally
      
      
         {
      
      
      
        if
      
       (fis!=
      
        null
      
      
        )
        fis.close();
    }
  }
 
      
      
        public
      
       PrintWriter getWriter() 
      
        throws
      
      
         IOException {
    
      
      
        //
      
      
         autoflush is true, println() will flush,
    
      
      
        //
      
      
         but print() will not.
      
      
    writer = 
      
        new
      
       PrintWriter(output, 
      
        true
      
      
        );
    
      
      
        return
      
      
         writer;
  }
  
        
           /
        
        
          /省略后面的代碼
        
      
      
        
}
      
    

上面實現了獲取?PrintWriter對象的方法

StaticResourceProcessor類(靜態資源處理)

      
        public
      
      
        class
      
      
         StaticResourceProcessor {

  
      
      
        public
      
      
        void
      
      
         process(Request request, Response response) {
    
      
      
        try
      
      
         {
      response.sendStaticResource();
    }
    
      
      
        catch
      
      
         (IOException e) {
      e.printStackTrace();
    }
  }
}
      
    

方法中僅僅簡單的調用了response對象的sendStaticResource()方法

ServletProcessor1類(servlet資源處理類)

      
        public
      
      
        class
      
      
         ServletProcessor1 {

  
      
      
        public
      
      
        void
      
      
         process(Request request, Response response) {

    String uri 
      
      =
      
         request.getUri();
    String servletName 
      
      = uri.substring(uri.lastIndexOf("/") + 1
      
        );
    URLClassLoader loader 
      
      = 
      
        null
      
      
        ;

    
      
      
        try
      
      
         {
      
      
      
        //
      
      
         create a URLClassLoader
      
      
      URL[] urls = 
      
        new
      
       URL[1
      
        ];
      URLStreamHandler streamHandler 
      
      = 
      
        null
      
      
        ;
      File classPath 
      
      = 
      
        new
      
      
         File(Constants.WEB_ROOT);
      
      
      
        //
      
      
         the forming of repository is taken from the createClassLoader method in
      
      
      
        //
      
      
         org.apache.catalina.startup.ClassLoaderFactory
      
      
      String repository = (
      
        new
      
       URL("file", 
      
        null
      
      , classPath.getCanonicalPath() +
      
         File.separator)).toString() ;
      
      
      
        //
      
      
         the code for forming the URL is taken from the addRepository method in
      
      
      
        //
      
      
         org.apache.catalina.loader.StandardClassLoader class.
      
      
      urls[0] = 
      
        new
      
       URL(
      
        null
      
      
        , repository, streamHandler);
      loader 
      
      = 
      
        new
      
      
         URLClassLoader(urls);
    }
    
      
      
        catch
      
      
         (IOException e) {
      System.out.println(e.toString() );
    }
    Class myClass 
      
      = 
      
        null
      
      
        ;
    
      
      
        try
      
      
         {
      myClass 
      
      =
      
         loader.loadClass(servletName);
    }
    
      
      
        catch
      
      
         (ClassNotFoundException e) {
      System.out.println(e.toString());
    }

    Servlet servlet 
      
      = 
      
        null
      
      
        ;

    
      
      
        try
      
      
         {
      servlet 
      
      =
      
         (Servlet) myClass.newInstance();
      servlet.service((ServletRequest) request, (ServletResponse) response);
    }
    
      
      
        catch
      
      
         (Exception e) {
      System.out.println(e.toString());
    }
    
      
      
        catch
      
      
         (Throwable e) {
      System.out.println(e.toString());
    }

  }
}
      
    

上面的步驟是首先根據客戶端請求路徑獲取請求的servlet名稱,然后根據servlet類路徑(類載入器倉庫)創建類載入器,進一步根據servlet名稱載入該servlet類并實例化,最后調用該servlet的serice()方法

其中Constants類保持工作目錄常量(Servlet類路徑)

      
        public
      
      
        class
      
      
         Constants {
  
      
      
        public
      
      
        static
      
      
        final
      
       String WEB_ROOT =
      
        
    System.getProperty(
      
      "user.dir") + File.separator  + "webroot"
      
        ;
}
      
    

我們繼續分析,其實上面的ServletProcessor1類的process()方法是存在問題的,在下面的代碼段

      Servlet servlet = 
      
        null
      
      
        ;

    
      
      
        try
      
      
         {
      servlet 
      
      =
      
         (Servlet) myClass.newInstance();
      servlet.service((ServletRequest) request, (ServletResponse) response);
    }
    
      
      
        catch
      
      
         (Exception e) {
      System.out.println(e.toString());
    }
    
      
      
        catch
      
      
         (Throwable e) {
      System.out.println(e.toString());
    }
      
    

這里的Request對象與Resposne對象分別向上轉型為ServletRequest實例和ServletResponse實例

如果了解這個servlet容器內部原理的servlet程序員就可以(在自己實現的serlet類中)將ServletRequest實例和 ServletResponse實例分別向下轉型為真實的Request實例和Response實例,就可以調用各自的公有方法了(Request實例的 parse()方法和Response實例的sendStaticResource()方法),而servlet容器又不能將這些公有方法私有化,因為其 他外部類還要調用它們,一個比較完美的解決方法是分別為Request類和Response類創建外觀類,分別為RequestFacade類與 ResponseFacade類,與前者實現共同的接口,然后保持對前者的引用,相關的接口實現方法分別調用其引用實例的方法,于是世界從此清靜了

注:其實本人認為這里不應該叫做外觀類,可能叫包裝器類更合適吧(因為本人沒聽過外觀類有實現共同接口的說法)

RequestFacade類

      
        public
      
      
        class
      
       RequestFacade 
      
        implements
      
      
         ServletRequest {

  
      
      
        private
      
       ServletRequest request = 
      
        null
      
      
        ;

  
      
      
        public
      
      
         RequestFacade(Request request) {
    
      
      
        this
      
      .request =
      
         request;
  }

  
      
      
        /*
      
      
         implementation of the ServletRequest
      
      
        */
      
      
        public
      
      
         Object getAttribute(String attribute) {
    
      
      
        return
      
      
         request.getAttribute(attribute);
  }

  
      
      
        public
      
      
         Enumeration getAttributeNames() {
    
      
      
        return
      
      
         request.getAttributeNames();
  }

  
      
      
        public
      
      
         String getRealPath(String path) {
    
      
      
        return
      
      
         request.getRealPath(path);
  }

        
           /
        
        
          /省略后面的代碼
        
      
      
        
}
      
    

ResponseFacade類

      
        public
      
      
        class
      
       ResponseFacade 
      
        implements
      
      
         ServletResponse {

  
      
      
        private
      
      
         ServletResponse response;
  
      
      
        public
      
      
         ResponseFacade(Response response) {
    
      
      
        this
      
      .response =
      
         response;
  }

  
      
      
        public
      
      
        void
      
       flushBuffer() 
      
        throws
      
      
         IOException {
    response.flushBuffer();
  }

  
      
      
        public
      
      
        int
      
      
         getBufferSize() {
    
      
      
        return
      
      
         response.getBufferSize();
  }
  
        
           /
        
        
          /省略后面的代碼
          
}

---------------------------------------------------------------------------?

本系列How Tomcat Works系本人原創?

轉載請注明出處 博客園 刺猬的溫馴?

本人郵箱: chenying998179 # 163.com ( #改為@

本文鏈接 http://www.cnblogs.com/chenying99/p/3231637.html

How Tomcat Works(三)


更多文章、技術交流、商務合作、聯系博主

微信掃碼或搜索:z360901061

微信掃一掃加我為好友

QQ號聯系: 360901061

您的支持是博主寫作最大的動力,如果您喜歡我的文章,感覺我的文章對您有幫助,請用微信掃描下面二維碼支持博主2元、5元、10元、20元等您想捐的金額吧,狠狠點擊下面給點支持吧,站長非常感激您!手機微信長按不能支付解決辦法:請將微信支付二維碼保存到相冊,切換到微信,然后點擊微信右上角掃一掃功能,選擇支付二維碼完成支付。

【本文對您有幫助就好】

您的支持是博主寫作最大的動力,如果您喜歡我的文章,感覺我的文章對您有幫助,請用微信掃描上面二維碼支持博主2元、5元、10元、自定義金額等您想捐的金額吧,站長會非常 感謝您的哦!!!

發表我的評論
最新評論 總共0條評論
主站蜘蛛池模板: 国产精品a区 | 老司机久久精品视频 | 亚洲酒色1314狠狠做 | 欧美三级纯黄版 | 久久爱综合久久爱com | 久久综合久久网 | 日本不卡高清视频 | 日韩精品在线视频观看 | 色老头在线观看精品 | 最新中文字幕一区二区乱码 | 精品午夜寂寞黄网站在线 | 天天天做天天天天爱天天想 | 国产精品午夜激爽毛片 | 中文字幕亚洲一区二区三区 | 国产伦精品一区二区三区视频小说 | 精品一区 二区三区免费毛片 | 精品性久久 | 91精品国产一区二区三区左线 | 四虎视频国产在线观看 | 可以看美女隐私的网站 | 97影院论理手机在线观看 | 午夜宅男免费完整在线观看 | 日韩欧美视频免费观看 | 久久噜 | 天天操天天干天天射 | 精品一区二区三区在线观看视频 | 日本玖玖 | 四虎午夜| 99热这里只有精品首页 | 久久精品亚洲乱码伦伦中文 | 操干干 | 青青影院在线观看 | 色综合久久久久久久久五月 | 精品国产国产综合精品 | 天天成人综合网 | 欧美另类高清xxxxx | 手机在线精品视频每日更新 | 成人欧美日韩高清不卡 | 亚洲一区二区在线 | 岛国精品在线观看 | 国产欧美另类性视频 |