實作01
1.實作任務階段1
撰寫mytomcat，該服務器能給瀏覽器回傳“你好，我是服務器！”的簡單資訊，
根據之前的tomcat框架整體分析，我們將瀏覽器發送請求，tomcat服務器處理請求，回傳資源的整個程序分為三個部分，現在來分析并初步實作第一部分的功能，
1.1基于socket開發服務端流程
1.2需求分析/圖解
作業：先打通自定義web服務器和瀏覽器之間的通道，
如瀏覽器請求http://localhost:8080/Xxx，服務器可以接收請求并回傳簡單資料，
注意：這里的互動是都建立在http協議之上的，服務器獲取到的資料是http格式的，回傳的資料也要封裝成http格式，瀏覽器才能正常決議，
http格式詳見javaweb-day14-HTTP協議
1.3代碼實作
MyTomcatV1：
package com.li.MyTomcat;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
/**
* @author 李
* @version 1.0
* 這是第一個版本的tomcat，可以完成接收瀏覽器請求，并回傳資訊功能
*/
public class MyTomcatV1 {
public static void main(String[] args) throws IOException {
//1.創建ServerSocket,在8080埠監聽
ServerSocket serverSocket = new ServerSocket(8080);
System.out.println("==========mytomcat在8080埠監聽=========");
while (!serverSocket.isClosed()) {
//等待瀏覽器或客戶端的連接
//如果有連接來，就創建socket
//這個socket就是瀏覽器和服務器之間的連接（通道）
Socket socket = serverSocket.accept();
//先接收瀏覽器發送的資料
InputStream inputStream = socket.getInputStream();//位元組流
//為了方便，將其轉成字符流(InputStreamReader==>轉換流，將一個位元組流轉換成字符流)
//BufferedReader==>字符處理流
BufferedReader bufferedReader =
new BufferedReader(new InputStreamReader(inputStream, "utf-8"));
String mes = null;
System.out.println("========接收到瀏覽器發送的資料=======");
//回圈地讀取
while ((mes = bufferedReader.readLine()) != null) {//按行讀取資料，如果已到達流末尾，則回傳 null
//判斷mes的長度是否為0
if (mes.length() == 0) {
break;//退出while
}
System.out.println(mes);
}
//我們的tomcat回送資料-按照http格式
//關閉資源
inputStream.close();
socket.close();
}
}
}
運行代碼，在瀏覽器中發送請求http://localhost:8080/cal.html，后端輸出如下：
可以看到，程式成功接收到了瀏覽器的請求（http格式）
下面以http格式回應瀏覽器請求：
package com.li.MyTomcat;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
/**
* @author 李
* @version 1.0
* 這是第一個版本的tomcat，可以完成接收瀏覽器請求，并回傳資訊功能
*/
public class MyTomcatV1 {
public static void main(String[] args) throws IOException {
//1.創建ServerSocket,在8080埠監聽
/**
* ..........
*/
//mytomcat服務器回送資料-按照http格式
OutputStream outputStream = socket.getOutputStream();
//模仿回應頭
//\r\n表示回車換行：因為回應頭最后一行和回應體中間要隔一個空行，
// 所以最后一行要寫兩個\r\n（回應頭換行是空行，空行再換行才是回應體）
//即 http回應體前面需要有兩個換行\r\n\r\n
String respHeader = "HTTP/1.1 200 OK\r\n" +
"Content-Type: text/html;charset=utf-8\r\n\r\n";
String resp = respHeader + "你好，我是服務器！";
System.out.println("=====MyTomcat給瀏覽器回送的資料=====");
System.out.println(resp);
//注意：這里回傳資料要以位元組流方式回傳
outputStream.write(resp.getBytes());//將resp字串以byte[]方式回傳
//關閉資源
outputStream.flush();
outputStream.close();
inputStream.close();
socket.close();
}
}
}
1.4測驗
運行代碼，在瀏覽器中發送請求http://localhost:8080/，后臺輸出如下：
瀏覽器輸出如下：
2.實作任務階段2-使用BIO執行緒模型，支持多執行緒
2.1BIO執行緒模型介紹
這里為了簡單，使用方式一來完成操作，每次請求都會創建一個執行緒，
2.2需求分析/圖解
- 需求分析如圖所示，瀏覽器請求http://localhost:8080/，服務器回傳“你好，我是服務器”，
- 后臺mytomcat使用BIO執行緒模型，支持多執行緒，對資料的回傳和處理移至執行緒里處理，
階段1存在一個問題：當一個客戶端被服務端在等待讀取資料的時候，服務端會卡在那里，使得別的客戶端無法與服務端連接以及收發資料，
解決方案是讓等待接收資料的那塊讓子執行緒去做，主執行緒只需要一直監聽是否有客戶端連接即可，這樣每個客戶端就相互不影響了，
2.3代碼實作
RequestHandler：
package com.li.MyTomcat.hander;
import java.io.*;
import java.net.Socket;
/**
* @author 李
* @version 1.0
* RequestHandler是一個執行緒物件
* 用來處理一個http請求
*/
public class RequestHandler implements Runnable {
//定義一個Socket
private Socket socket = null;
//在創建RequestHandler物件的時候，將主執行緒的socket傳給執行緒物件來使用
public RequestHandler(Socket socket) {
this.socket = socket;
}
@Override
public void run() {
//對客戶端進行互動
try {
System.out.println("當前執行緒="+Thread.currentThread().getName());
InputStream inputStream = socket.getInputStream();
//將位元組流轉成字符流--方便按行讀取瀏覽器請求
BufferedReader bufferedReader =
new BufferedReader(new InputStreamReader(inputStream, "utf-8"));
System.out.println("=====MyTomcat接收瀏覽器資料=====");
String mes = null;
while ((mes = bufferedReader.readLine()) != null) {
//如果讀取到的長度為零，即空串""
if (mes.length() == 0) {
break;//退出回圈
}
System.out.println(mes);
}
//將資料回傳給瀏覽器/客戶端（注意要將資料封裝成http回應的格式，瀏覽器才能決議）
//構建http回應頭（注意換行-回應頭和回應體之間有一個空行，需要兩個換行）
String respHeader = "HTTP/1.1 200 OK\r\n" +
"Content-Type: text/html;charset=utf-8\r\n\r\n";
String resp = respHeader + "<h1>Hello，我是服務器！<h1>";
System.out.println("=====MyTomcatV2給瀏覽器回送的資料=====");
System.out.println(resp);
//獲取輸出流
OutputStream outputStream = socket.getOutputStream();
outputStream.write(resp.getBytes());//將字串轉成位元組陣列
//關閉流
outputStream.flush();
outputStream.close();
inputStream.close();
socket.close();
} catch (IOException e) {
e.printStackTrace();
} finally {
//一定要確保socket關閉
if (socket != null) {
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
MyTomcatV2：
package com.li.MyTomcat;
import com.li.MyTomcat.hander.RequestHandler;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
public class MyTomcatV2 {
public static void main(String[] args) throws IOException {
//監聽
ServerSocket serverSocket = new ServerSocket(8080);
System.out.println("==========MyTomcatV2在8080埠監聽=========");
//只要serverSocket沒有關閉，就會一直等待客戶端來連接
while (!serverSocket.isClosed()) {
//每接收一個瀏覽器連接，就會得到一個socket物件（這個socket就是服務器和瀏覽器的資料通道）
Socket socket = serverSocket.accept();
//創建一個執行緒，將該socket傳給該執行緒，啟動執行緒
new Thread(new RequestHandler(socket)).start();
}
}
}
2.4測驗
運行代碼，在瀏覽器輸入http://localhost:8080/，輸出如下：
后臺輸出：
3.實作任務階段3-處理Servlet
- Servlet宣告周期
3.1需求分析/圖解
問題分析：第二階段只是簡單地回傳結果，沒有和Servlet，web.xml關聯起來
下面來完成第三階段實作：
- 自定義Servlet規范
要完成Servlet的呼叫就要先制定好Servlet規范，我們模仿Servlet的規范來制訂一套自己的Servlet，
如下，模仿實際的Servlet來撰寫MyServlet及其抽象類MyHttpServlet，實作類MyCalServlet
- 模擬實作request和response
另外，在真實的tomcat服務器中，接收http請求后會將其封裝成HttpServletRequest物件，回傳資料則是通過HttpServletResponse物件，
因此，除了自定義Servlet規范外，還要定義用于與http協議互動的兩個物件
這里為了簡化，就不使用實作介面的形式一層層封裝了，直接用兩個類來實作，
- 在實作上面兩個作業之前，先來看一個需求
我們現在做一個簡單的需求：
瀏覽器請求http://localhost:8080/calServlet，提交資料，完成計算任務，如果該Servlet不存在，就回傳404，大致的界面如下：
由于真正的HttpServletRequest和HttpServletResponse方法以及Servlet方法很多，這里為了簡化，上述模擬的Servlet和自定義的request，response等只實作滿足此需求的部分方法，
3.2模擬實作request和response
3.2.1MyRequest
package com.li.MyTomcat.http;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.HashMap;
/**
* @author 李
* @version 1.0
* 1.MyRequest的作用是封裝http請求的資料
* 2.比如 method,uri,還有引數串列等
* 3.MyRequest 的作用相當于原生的Servlet中的HttpServletRequest
* 4.這里先考慮get請求
*/
public class MyRequest {
private String method;
private String uri;
//存放引數串列 引數名-引數值=>HashMap
private HashMap<String, String> parametersMapping = new HashMap<>();
private InputStream inputStream = null;
//構造器==>對http請求進行封裝
//在構造 MyRequest物件的時候，將關聯的socket的InputStream傳進來
// 這樣就可以拿到該http請求的資料
public MyRequest(InputStream inputStream) {
this.inputStream = inputStream;
packageHttp();
}
/**
* 將http請求的相關引數進行封裝，然后提供相關的方法，進行獲取
*/
public void packageHttp() {
System.out.println("MyRequest packageHttp()被呼叫...");
try {
//將位元組流轉成字符流
BufferedReader bufferedReader =
new BufferedReader(new InputStreamReader(inputStream, "utf-8"));
/**
* GET /myCalServlet?num1=11&num2=12 HTTP/1.1
* Host: localhost:8080
* User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:106.0) Gecko/20100101 Firefox/106.0
* ......
*/
//1.先讀取第一行（請求行）
String requestLine = bufferedReader.readLine();
//第0組：GET 第1組：/myCalServlet?num1=11&num2=12 第2組：HTTP/1.1
String[] requestLineArr = requestLine.split(" ");
//2.得到method
method = requestLineArr[0];
//3.決議得到uri=/myCalServlet
//先看看uri有沒有引數串列
int index = requestLineArr[1].indexOf("?");//找到?號的索引
if (index == -1) {//沒有問號，說明uri沒有引數串列
uri = requestLineArr[1];
} else {
//截取到?號的前一位,即為uri
uri = requestLineArr[1].substring(0, index);
//獲取引數串列
String parameters = requestLineArr[1].substring(index + 1);//parameters => num1=11&num2=12
String[] parametersPair = parameters.split("&");//parametersPair=["num1=11","num2=12",...]
//防止瀏覽器的提交的地址為 /myCalServlet?
if (null != parametersPair && !"".equals(parametersPair)) {
//再分割
for (String parameterPair : parametersPair) {
//parameterVal=["num1","10"]
String[] parameterVal = parameterPair.split("=");
if (parameterVal.length == 2) {
//放入到parametersMapping中
parametersMapping.put(parameterVal[0], parameterVal[1]);
}
}
}
}
//這里不能關閉流inputStream，因為inputStream和socket關聯，
// 如果關閉了inputStream則socket也會一起關閉
} catch (Exception e) {
e.printStackTrace();
}
}
//request有一個特別重要的方法-getParameter()
public String getParameter(String name) {
if (parametersMapping.containsKey(name)) {
return parametersMapping.get(name);
} else {
return "";
}
}
public String getMethod() {
return method;
}
public void setMethod(String method) {
this.method = method;
}
public String getUri() {
return uri;
}
public void setUri(String uri) {
this.uri = uri;
}
@Override
public String toString() {
return "MyRequest{" +
"method='" + method + '\'' +
", uri='" + uri + '\'' +
", parametersMapping=\n" + parametersMapping +
'}';
}
}
3.2.2MyResponse
package com.li.MyTomcat.http;
import java.io.OutputStream;
/**
* @author 李
* @version 1.0
* 1.MyResponse可以封裝OutputStream（和socket關聯）
* 2.即可以通過 MyResponse物件回傳http回應給瀏覽器或客戶端
* 3.MyResponse的作用等價于原生的Servlet的HttpServletResponse
*/
public class MyResponse {
private OutputStream outputStream = null;
//寫一個http的回應頭
public static final String respHeader = "HTTP/1.1 200 OK\r\n" +
"Content-Type: text/html;charset=utf-8\r\n\r\n";
//在構造 MyResponse 物件的時候，將關聯的socket的OutputStream傳進來
public MyResponse(OutputStream outputStream) {
this.outputStream = outputStream;
}
//當我們需要給瀏覽器回傳資料時，可以通過MyResponse的屬性獲得輸出流
public OutputStream getOutputStream() {
return outputStream;
}
}
3.2.3修改RequestHandler
package com.li.MyTomcat.hander;
import com.li.MyTomcat.http.MyRequest;
import com.li.MyTomcat.http.MyResponse;
import java.io.*;
import java.net.Socket;
/**
* @author 李
* @version 1.0
* RequestHandler是一個執行緒物件
* 用來處理一個http請求
*/
public class RequestHandler implements Runnable {
//定義一個Socket
private Socket socket = null;
//在創建RequestHandler物件的時候，將主執行緒的socket傳給執行緒物件來使用
public RequestHandler(Socket socket) {
this.socket = socket;
}
@Override
public void run() {
//對客戶端進行互動
try {
System.out.println("當前執行緒=" + Thread.currentThread().getName());
InputStream inputStream = socket.getInputStream();
MyRequest myRequest = new MyRequest(inputStream);
String num1 = myRequest.getParameter("num1");
String num2 = myRequest.getParameter("num2");
String name = myRequest.getParameter("name");
String email = myRequest.getParameter("email");
System.out.println("請求的引數num1= " + num1);
System.out.println("請求的引數num2= " + num2);
System.out.println("請求的引數name= " + name);
System.out.println("請求的引數email= " + email);
System.out.println(myRequest);
//這里我們可以通過myResponse物件回傳資料給客戶端
MyResponse myResponse = new MyResponse(socket.getOutputStream());
String resp = MyResponse.respHeader + "<h1>Hello,我是myResponse回傳的資訊</h1>";
//這里的應用場景是:為了將來在Servlet中使用response物件，可以獲取到輸出流
OutputStream outputStream = myResponse.getOutputStream();
outputStream.write(resp.getBytes());
outputStream.flush();
outputStream.close();
inputStream.close();
socket.close();
} catch (IOException e) {
e.printStackTrace();
} finally {
//一定要確保socket關閉
if (socket != null) {
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
MyTomcatV2類保持不變，
3.2.4測驗
運行MyTomcatV2，在瀏覽器中輸入如下請求：
http://localhost:8080/myCalServlet?num1=100&num2=200&name=jack&[email protected]
瀏覽器輸出：
后臺輸出：
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/535174.html
標籤：其他
上一篇：python中的for回圈
下一篇：fork的倉庫同步源倉庫