实现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需求分析/图解

1. 需求分析如图所示，浏览器请求http://localhost:8080/，服务器返回“你好，我是服务器”。
2. 后台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=jack@qq.com

浏览器输出：

后台输出：