1、一個簡單的 HTTP 服務器

在Web應用中，瀏覽器請求一個URL，服務器就把生成的html網頁發送給瀏覽器，而瀏覽器和服務器之間的傳輸協議是HTTP,那么接下來我們看下如何用JAVA來實現一個簡單的HTTP服務器。

具體代碼實現

import java.nio.charset.StandardCharsets;
import java.io.*;
import java.util.*;
import java.net.*;

/**
 * HTTP 服務
 */
public class HttpServer {
    public static void main(String[] args) throws IOException {
        // 監聽指定端口
        ServerSocket ss = new ServerSocket(9901);
        System.out.println("server is running...");
        for (;;) {
            Socket sock = ss.accept();
            System.out.println("connected from " + sock.getRemoteSocketAddress());
            // 開啟線程處理接收到的socket數據
            Thread t = new Handler(sock);
            t.start();
        }
    }
}

/**
 * 執行類
 */
class Handler extends Thread {
    Socket sock;

    public Handler(Socket sock) {
        this.sock = sock;
    }

    public void run() {
        try (InputStream input = this.sock.getInputStream()) {
            try (OutputStream output = this.sock.getOutputStream()) {
                handle(input, output);
            }
        } catch (Exception e) {
            try {
                this.sock.close();
            } catch (IOException ioe) {
            }
            System.out.println("client disconnected.");
        }
    }

    /**
     * 具體執行方法
     * 處理http輸入數據，轉換輸出
     * @param input
     * @param output
     * @throws IOException
     */
    private void handle(InputStream input, OutputStream output) throws IOException {
        System.out.println("Process new http request...");
        BufferedReader reader = new BufferedReader(new InputStreamReader(input, StandardCharsets.UTF_8));
        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(output, StandardCharsets.UTF_8));
        // 讀取HTTP請求:
        boolean requestOk = false;
        String first = reader.readLine();
        if (first.startsWith("GET / HTTP/1.")) {
            requestOk = true;
        }
        for (;;) {
            String header = reader.readLine();
            if (header.isEmpty()) { // 讀取到空行時, HTTP Header讀取完畢
                break;
            }
            System.out.println(header);
        }
        System.out.println(requestOk ? "Response OK" : "Response Error");
        if (!requestOk) {
            // 發送錯誤響應:
            writer.write("HTTP/1.0 404 Not Found-lzfrn");
            writer.write("Content-Length: 0rn");
            writer.write("rn");
            writer.flush();
        } else {
            // 發送成功響應:
            String data = "<html><body><h1 style="color:red">Hello, LZF!</h1></body></html>";
            int length = data.getBytes(StandardCharsets.UTF_8).length;
            writer.write("HTTP/1.0 200 OKrn");
            writer.write("Connection: closern");
            writer.write("Content-Type: text/htmlrn");
            writer.write("Content-Length: " + length + "rn");
            writer.write("rn"); // 空行標識Header和Body的分隔
            writer.write(data);
            writer.flush();
        }
    }
}
復制代碼

我們用 javac HttpServer.java 命令將java文件編譯成可執行類，然后運行命令 java HttpServer

可以看到 server 已經正常啟動，我們在網頁上輸入 127.0.0.1:9901, 可以看到已經能夠正常返回了，是不是很簡單呀。

2、使用 Tomcat 處理HTTP請求

從上面我們可以看到編寫HTTP服務器其實是非常簡單的，只需要先編寫基于多線程的TCP服務，然后在一個TCP連接中讀取HTTP請求，發送HTTP響應就可以了。

但是，要編寫一個完善的HTTP服務器，還要考慮更多東西例如：

識別正確和錯誤的HTTP請求；
識別正確和錯誤的HTTP頭；
IO異常處理；
...

我們一直都在強調不要重復造輪子，Java發展了這么久處理TCP連接，解析HTTP協議這些底層工作早已有了現成的API。JavaEE提供的Servlet API，我們可以使用Servlet API編寫自己的Servlet來處理HTTP請求，

接下來我們看一個簡單的例子

import java.nio.charset.StandardCharsets;
import java.io.*;
import java.util.*;
import java.net.*;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

// WebServlet注解表示這是一個Servlet，并映射到地址/:
@WebServlet(urlPatterns = "/")
public class HelloServlet extends HttpServlet {
    protected void doGet(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        // 設置響應類型:
        resp.setContentType("text/html");
        // 獲取輸出流:
        PrintWriter pw = resp.getWriter();
        String name = req.getParameter("name");
        // 寫入響應:
        if (null == name) {
            pw.write("<h1>Hello, world!</h1>");
        } else {
            pw.write("<h1>Hello, " + name + "!</h1>");
        }
        // 最后不要忘記flush強制輸出:
        pw.flush();
    }
}

其中 Servlet API是一個jar包，我們需要通過Maven來引入它，才能正常編譯。編寫pom.xml文件如下

<project xmlns="http://maven.Apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.lzf.learnjava</groupId>
    <artifactId>web-servlet-hello1</artifactId>
    <packaging>war</packaging>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <java.version>8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.0</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

    <build>
        <finalName>hello</finalName>
    </build>
</project>

具體代碼結構目錄如下

Mavean 打包出來的是war包，需要運行的話得先啟動Web服務器，而Web服務我們最常用的就是Tomcat。首先我們到官網下載Tomcat服務器，解壓后

Tomcat目錄：

bin：存放啟動和關閉tomcat腳本 conf：存放不同的配置文件（server.xml和web.xml) doc：存放Tomcat文檔 lib：存放Tomcat運行需要的庫文件（JARS） logs：存放Tomcat執行時的LOG文件 webApps：Tomcat的主要Web發布目錄（包括應用程序示例） work：存放jsp編譯后產生的class文件

把hello.war復制到Tomcat的webapps目錄下，Tomcat 默認監聽的8080的端口，可以通過修改 conf/server.xml -> Connector 里的 port 屬性來改變監聽端口。然后切換到bin目錄，執行startup.sh或startup.bat啟動Tomcat服務器

　網頁上輸入
http://localhost:9903/hello/?name=Qc ，成功訪問！

接下來我們來分析Tomcat 是如何處理一個HTTP請求的過程

首先我們先了解Tomcat 的體系架構

參考上面的圖解釋下：

1.Server組件
   即服務器，每個tomcat程序啟動后，就是一個server。
    
2、Service組件
   一個Server可以包含多個Service，Service這是一種抽象的服務，它把連接器和處理引擎結合在一起。

3、Connector組件：
   一個Service可以有多個Connector，Connector組件用于處理連接和并發。一般說來常見于server.xml
中的連接器類型通常有4種：
  1) HTTP連接器 2) SSL連接器 3) AJP 1.3連接器 4) proxy連接器
  
4、Engine組件：
   Engine是Servlet處理器的一個實例，即servlet引擎，其defaultHost屬性是用來來為其定義一個接收所
有發往非明確定義虛擬主機的請求的host組件。如前面示例中定義的：
   <Engine name=”Catalina” defaultHost=”localhost”>

5、Host組件：
   位于Engine容器中，用于接收請求并進行相應處理的主機或虛擬主機.
   
  <!-- 自定義host , 類似 Nginx 反向代理功能 />   -->
  <Host name="aaatc.test" appBase="webapps2">
  </Host>

  <!--如果一個主機有兩個或兩個以上的主機名，額外的名稱均可以以別名的形式進行定義： -->
  <Host name="localhost" appBase="webapp" unpackWARs="true">
  <Alias>bbbtc.test</Alias>
  </Host>


6、Context組件：
   Context在某些意義上類似于apache中的路徑別名，一個Context定義用于標識tomcat實例中的一個Web應用程序

了解了架構之后我們看請求過程

1、用戶打開瀏覽器輸入地址，請求被發送到本機端口9903，被在那里監聽的Coyote HTTP/1.1 Connector獲得。

2、Connector把該請求交給它所在的Service的Engine來處理，并等待Engine的回應。

3、Engine獲得請求localhost:9903/hello/?name=Qc，匹配所有的虛擬主機Host。

4、Engine匹配到名為localhost的Host（即使匹配不到也把請求交給該Host處理，因為該Host被定義為該Engine的默認主機）名為localhost的Host獲得請求/hello/?name=Qc，匹配它所擁有的所有的Context。 Host匹配到路徑為/hello 的Context（如果匹配不到就把該請求交給路徑名為""的Context去處理）。

5、在它的mapping table中尋找出對應的Servlet 處理數據。

6、構造HttpServletRequest對象和HttpServletResponse對象，作為參數調用JspServlet的doGet（）或doPost（）.執行業務邏輯、數據存儲等程序。

7、Context把執行完之后的HttpServletResponse對象返回給Host。

8、Host把HttpServletResponse對象返回給Engine。

9、Engine把HttpServletResponse對象返回Connector。

10、Connector把HttpServletResponse對象返回給瀏覽器。

以上就是 Tomcat 處理一個HTTP請求的完整流程。

3、將 Tomcat 以 Jar 包的方式引入

Tomcat 實際上也是一個Java程序，我們可以把 Tomcat 以 Jar 包的方式引入，然后自己編寫一個main()方法，先啟動Tomcat，然后讓它加載我們的webapp就行。我們常用的 SpringBoot 框架采用的就是這樣的方式。

首先我們需要先建一個項目 web-servlet-hello-tomcat, 編寫pom.xml文件

<project xmlns="http://maven.apache.org/POM/4.0.0"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
 <modelVersion>4.0.0</modelVersion>
 <groupId>com.lzf.learnjava</groupId>
 <artifactId>web-servlet-hello-tomcat</artifactId>
 <packaging>war</packaging>
 <version>1.0-SNAPSHOT</version>

 <properties>
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
     <maven.compiler.source>8</maven.compiler.source>
     <maven.compiler.target>8</maven.compiler.target>
     <java.version>8</java.version>
     <tomcat.version>9.0.58</tomcat.version>
 </properties>

 <dependencies>
     <dependency>
         <groupId>org.apache.tomcat.embed</groupId>
         <artifactId>tomcat-embed-core</artifactId>
         <version>${tomcat.version}</version>
         <scope>provided</scope>
     </dependency>
     <dependency>
         <groupId>org.apache.tomcat.embed</groupId>
         <artifactId>tomcat-embed-jasper</artifactId>
         <version>${tomcat.version}</version>
         <scope>provided</scope>
     </dependency>
 </dependencies>

 <build>
     <finalName>hello</finalName>
 </build>
</project>

然后，我們編寫一個main()方法，啟動Tomcat服務器

package com.lzf.learnjava.servlet;

import org.apache.catalina.Context;
import org.apache.catalina.WebResourceRoot;
import org.apache.catalina.startup.Tomcat;
import org.apache.catalina.webresources.DirResourceSet;
import org.apache.catalina.webresources.StandardRoot;

import java.io.File;

/**
* @author liuzufa
*/
public class Main {
   public static void main(String[] args) throws Exception {
       // 啟動Tomcat:
       Tomcat tomcat = new Tomcat();
       tomcat.setPort(Integer.getInteger("port", 9904));
       tomcat.getConnector();
       // 創建webapp:
       Context ctx = tomcat.addWebapp("", new File("src/main/webapp").getAbsolutePath());
       WebResourceRoot resources = new StandardRoot(ctx);
       resources.addPreResources(
               new DirResourceSet(resources, "/WEB-INF/classes", new File("target/classes").getAbsolutePath(), "/"));
       ctx.setResources(resources);
       tomcat.start();
       tomcat.getServer().await();
   }
}

除去前面的手動輸出HTML的方法，我們還可以使用JSP。JSP是Java Server Pages的縮寫，它的文件必須放到/src/main/webapp下，文件名必須以.jsp結尾，整個文件與HTML并無太大區別，但需要插入變量，或者動態輸出的地方，使用特殊指令<% ... %>。

JSP和Servlet有什么區別？其實它們沒有任何區別，因為JSP在執行前首先被編譯成一個Servlet。在Tomcat的臨時目錄下，可以找到一個hello_jsp.java的源文件，這個文件就是Tomcat把JSP自動轉換成的Servlet源碼。

4、總結

 1、學會使用java編寫一個簡單http服務
 2、解釋了Tomcat處理一次HTTP請求的完整流程
 3、將Tomcat以jar 的方式引入項目中，學會了簡單的JSP開發。

作者：xiao6zi470
鏈接：
https://juejin.cn/post/7067917428319223845

日日操夜夜添-日日操影院-日日草夜夜操-日日干干-精品一区二区三区波多野结衣-精品一区二区三区高清免费不卡

Tomcat處理HTTP請求流程解析

1、一個簡單的 HTTP 服務器

2、使用 Tomcat 處理HTTP請求

3、將 Tomcat 以 Jar 包的方式引入

4、總結

數獨大挑戰2018-06-03

答題星2018-06-03

全階人生考試2018-06-03

運動步數有氧達人2018-06-03

每日養生app2018-06-03

體育訓練成績評定2018-06-03