自己实现Tomcat底层机制

TomcatV1版本-该版本为单线程

TomcatV1

该版本：仅支持单线程

package tomcat;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * ClassName: TomcatV1
 * Package: tomcat
 * Description:
 *
 * @Author 王文福
 * @Create 2024/1/10 21:46
 * @Version 1.0
 * 建立与浏览器的连接
 */
public class TomcatV1 {
    //设置的响应头
    private static final String HEADER = "HTTP/1.1 200 OK\r\n" +
            "Content-Type: text/html;charset=utf-8\r\n\r\n";

    public static void main(String[] args) throws IOException {
        //监听的端口号
        int port = 8080;
        ServerSocket serverSocket = new ServerSocket(port);
        System.out.println("正在监听" + port + "端口......");
        while (!serverSocket.isClosed()) {
            //连接成功后，得到socket对象
            Socket socket = serverSocket.accept();
            // 得到字节流(http请求头的数据)
            InputStream inputStream = socket.getInputStream();
            //将字节流转换成字符流
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream, "utf-8"));
            //一行一行读取
            String mes = null;
            while ((mes = bufferedReader.readLine()) != null) {
                if (mes.length() == 0) {
                    break;
                }
                System.out.println(mes);
            }
            //读取完毕后，响应数据返回给浏览器
            String responseInfo = HEADER + "<h1>返回给浏览器的响应</h1>";
            //得到输出流-响应数据给浏览器
            OutputStream outputStream = socket.getOutputStream();
            outputStream.write(responseInfo.getBytes());
            outputStream.flush();
            outputStream.close();
            inputStream.close();
            socket.close();
        }
    }
}

TomcatV2版本-该版本为多线程

该版本：增加了多线程的功能

TomcatV2

package tomcat;

import thread.TomcatV2Thread;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * ClassName: TomcatV2
 * Package: tomcat
 * Description:
 * 实现多线程，每次浏览器访问服务器都会启动1个线程
 *
 * @Author 王文福
 * @Create 2024/1/10 22:17
 * @Version 1.0
 */
public class TomcatV2 {
    public static void main(String[] args) throws IOException {
        int port = 8080;
        ServerSocket serverSocket = new ServerSocket(port);
        //监听80端口
        System.out.println("正在监听" + port + "端口......");
        while (!serverSocket.isClosed()) {
            //建立连接后，得到socket对象
            Socket socket = serverSocket.accept();
            //启动线程
            new Thread(new TomcatV2Thread(socket)).start();
        }
    }
}

TomcatV2Thread

package thread;

import servlet.WwfHttpResponse;

import java.io.*;
import java.net.Socket;

/**
 * ClassName: TomcatV2Thread
 * Package: Thread
 * Description:
 *
 * @Author 王文福
 * @Create 2024/1/10 22:26
 * @Version 1.0
 */
public class TomcatV2Thread implements Runnable {

    private Socket socket;

    public TomcatV2Thread(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        try {
            //得到socket的输入流
            InputStream inputStream = socket.getInputStream();
            //将字节流转换字符流
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream, "utf-8"));
            //逐行读取
            String mes = null;
            while ((mes = bufferedReader.readLine()) != null) {
                if (mes.length() == 0) {
                    break;
                }
                System.out.println(mes);
            }
            //读取完毕后，响应数据给浏览器
            String responseInfo = WwfHttpResponse.HEADER + "<h1>响应数据给浏览器</h1>";
            //得到对象输出流
            OutputStream outputStream = socket.getOutputStream();
            outputStream.write(responseInfo.getBytes());
            //关流
            outputStream.flush();
            outputStream.close();
            inputStream.close();
            socket.close();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

TomcatV3版本

封装Request

Request 类核心思路

得到 Sokcet 对象的字节流，该字节流保存的时 Http 请求头的数据

1.需要将得到的字节数据转换成字符流读取，并逐行的读取

2.并使用字符分割/正则表达式

2-1 得到请求的方式(String)

2-2 请求的 url 地址(String)

2-3 请求的参数列表的参数名和参数值(通过 HashMap 保存)

3.在启动 线程 后，得到 Sokcet 对象，传入该字节对象，调用对应封装的方法就可以解析出需要的数据(请求方式、url 地址、形参列表(名和值))

package servlet;

import java.io.*;
import java.util.concurrent.ConcurrentHashMap;

/**
 * ClassName: HttpRequest
 * Package: Servlet
 * Description:
 * 解析Socket对象传入的字节流(http信息)
 *
 * @Author 王文福
 * @Create 2024/1/10 22:49
 * @Version 1.0
 */
public class WwfHttpRequest {
    //1.字节流对象
    private InputStream inputStream = null;

    public WwfHttpRequest(InputStream inputStream) {
        this.inputStream = inputStream;
        init(); //初始化构造器的时候调用
    }

//    public HttpRequest() {
//        System.out.println("执行了init方法");
//        init(); //初始化构造器的时候调用
//    }

    //2.请求的方式
    private String method;
    //3.请求的url地址
    private String url;
    //4.请求的形参列表，key：参数 value:值
    private ConcurrentHashMap<String, String> parameterList = new ConcurrentHashMap<>();

    //定义方法-通key，得到value
    public String getParams(String name) {
        if (parameterList.containsKey(name)) { //判断该键是否存在
            return parameterList.get(name);
        } else {
            return "";
        }
    }

    //定义1个初始化方法，解析InputStream对象
    public void init() {
        try {
            //1.将字节流转换为字符流
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream, "utf-8"));
            //2.读取第1行
            String readLine = bufferedReader.readLine();
            //3.使用空格分割
            String[] readLineArr = readLine.split(" ");
            this.method = readLineArr[0];//请求的方法
            //得到url地址
            //1。查找当前是否存在地址是否存在参数
            String url = readLineArr[1];//局部变量的url
            //查找?出现的位置
            int index = url.indexOf("?");
            if (index == -1) { //没有找到?，则表示当前url不带参数
                this.url = url; //直接赋值
            } else { //带? /localhost?name = 10 & age = 20;
                this.url = url.substring(0, index);
                //得到形参列表[username=10&password=20]
                String parameterList = url.substring(index + 1);
                //根据&分割[username=10,password=20]
                String[] parameterVal = parameterList.split("&");
                if ((parameterVal != null && !"".equals(parameterVal))) { //tomcat?
                    for (String parameters : parameterVal) {
                        //根据=分割[username,10]
                        String[] parameter = parameters.split("=");
                        if (parameter.length == 2) { //数组长度==2
                            //将形参名，和形参值添加进HashMap集合
                            this.parameterList.put(parameter[0], parameter[1]);
                        }
                    }
                }
            }
//            System.out.println(Arrays.toString(readLineArr));
//            System.out.println(this.url);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    public String getMethod() {
        return method;
    }

    public void setMethod(String method) {
        this.method = method;
    }

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }
}

封装Response

Response 类核心思路

1.定义 1 个输出流，并提供有参构造器传入 Sokcet 输出流，并进行保存

2.定义静态的请求头，发送消息的类型，方便响应数据的时候直接调用

3.提供 get 方法，方便得到输出流对象，供外部使用

package servlet;

import java.io.OutputStream;

/**
 * ClassName: HttpResponse
 * Package: Servlet
 * Description:
 *
 * @Author 王文福
 * @Create 2024/1/11 0:04
 * @Version 1.0
 */
public class WwfHttpResponse {
    //1.设置响应头
    public static final String HEADER = "HTTP/1.1 200 OK\r\n" +
            "Content-Type: text/html;charset=utf-8\r\n\r\n";
    //2.通过构造器得到输出流,主要是为了后续HttpResponse传参
    OutputStream outputStream;

    public WwfHttpResponse(OutputStream outputStream) {
        this.outputStream = outputStream;
    }

    //提供get方法
    public OutputStream getOutputStream() {
        return outputStream;
    }
}

ThreadV3

package tomcat;

import thread.TomcatV3Thread;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * ClassName: TomcatV3
 * Package: tomcat
 * Description:
 * 封装request对象，传入Socket对象输出流-解析浏览器的http请求数据，得到请求类型，请求地址，请求参数列表
 *
 * @Author 王文福
 * @Create 2024/1/10 22:44
 * @Version 1.0
 */
public class TomcatV3 {
    public static void main(String[] args) throws IOException {
        int port = 8080;
        ServerSocket serverSocket = new ServerSocket(port);
        System.out.println("正在监听" + port + "端口......");
        while (!serverSocket.isClosed()) {
            //连接成功后，返回socket对象
            Socket socket = serverSocket.accept();
            //启动线程
            new Thread(new TomcatV3Thread(socket)).start();
        }
    }
}

TomcatV3Thread

package thread;

import servlet.WwfHttpRequest;
import utils.WebUtils;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

/**
 * ClassName: TomcatV3Thread
 * Package: thread
 * Description:
 *
 * @Author 王文福
 * @Create 2024/1/10 23:06
 * @Version 1.0
 */
public class TomcatV3Thread implements Runnable {
    //响应头
    private static final String HEADER = "HTTP/1.1 200 OK\r\n" +
            "Content-Type: text/html;charset=utf-8\r\n\r\n";
    private Socket socket;

    public TomcatV3Thread(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        InputStream inputStream = null;
        try {
            inputStream = socket.getInputStream();
            //将InputStream传入到封装的request对象解析出需要的值
            WwfHttpRequest wwfHttpRequest = new WwfHttpRequest(inputStream);
//            httpRequest.init();
            //调用获取形参列表的方法
            String num1 = wwfHttpRequest.getParams("num1");
            String num2 = wwfHttpRequest.getParams("num2");
            System.out.println("num1=" + num1);
            System.out.println("num2=" + num2);
            //关流-只有当响应给浏览器的时候才适合关流，
            // 因为如果字节流inputStream关闭了会导致socket被关闭，socket被关闭会导致线程出现空指针异常
            OutputStream outputStream = socket.getOutputStream();
            //字符串转数字
            int number1 = WebUtils.stringParseNumber(num1, 0);
            int number2 = WebUtils.stringParseNumber(num2, 0);
            String responseInfo = HEADER + "<h1>" + number1 + "+" + number2 + "=" + (number1 + number2) + "</h1>";
            outputStream.write(responseInfo.getBytes());
            //关流
            outputStream.close();
            inputStream.close();
            socket.close();

        } catch (IOException e) {
            throw new RuntimeException(e);
        }

    }
}

TomcatV4版本

声明Servlet接口

package servlet;

import java.io.IOException;

/**
 * ClassName: Servlet
 * Package: Servlet
 * Description:
 *
 * @Author 王文福
 * @Create 2024/1/11 0:10
 * @Version 1.0
 */
public interface WwfServlet {
    public void init() throws Exception; //初始化方法

    //核心的方法service,通过反射调用
    public void service(WwfHttpRequest requset, WwfHttpResponse response)
            throws IOException;


    public void destroy(); //Servlet销毁的方法，服务器重启、重新发布web项目，强制停止项目
}

声明HttpServlet抽象方法

package servlet;

import java.io.IOException;

/**
 * ClassName: wwfHttpServlet
 * Package: Servlet
 * Description:
 *
 * @Author 王文福
 * @Create 2024/1/11 0:16
 * @Version 1.0
 */
public abstract class WwfHttpServlet implements WwfServlet {
    @Override
    public void init() throws Exception {

    }

    @Override
    public void service(WwfHttpRequest request, WwfHttpResponse response) throws IOException {
        //模板设计模式
        if ("GET".equalsIgnoreCase(request.getMethod())) {
            this.doget(request, response);
        } else if ("POST".equalsIgnoreCase(request.getMethod())) {
            this.dopost(request, response);
        }
    }

    //定义两个抽象方法，请求方法
    public abstract void doget(WwfHttpRequest wwfHttpRequest, WwfHttpResponse wwfHttpResponse);

    public abstract void dopost(WwfHttpRequest wwfHttpRequest, WwfHttpResponse wwfHttpResponse);

    @Override
    public void destroy() {

    }
}

继承HttpServlet并重写方法

package servlet;

import utils.WebUtils;

import java.io.IOException;
import java.io.OutputStream;

/**
 * ClassName: WwfCalServlet
 * Package: Servlet
 * Description:
 *
 * @Author 王文福
 * @Create 2024/1/11 0:21
 * @Version 1.0
 */
public class WwfCalServlet extends WwfHttpServlet {

    @Override
    public void doget(WwfHttpRequest wwfHttpRequest, WwfHttpResponse wwfHttpResponse) {
        //1.通过httpRequest得到形参列表
        String num1 = wwfHttpRequest.getParams("num1");
        String num2 = wwfHttpRequest.getParams("num2");
        System.out.println("num1的值=" + num1);
        System.out.println("num2的值=" + num2);
        //2.将得到的字符传为整型
        int number1 = WebUtils.stringParseNumber(num1, 0);
        int number2 = WebUtils.stringParseNumber(num2, 0);
        //3。将number1和number2的结果响应给浏览器
        String responseInfo = WwfHttpResponse.HEADER + "<h1>" + (number1 + "+" + number2 + "=" + (number1 + number2)) + "</h1>";
        //得到输出流
        OutputStream outputStream = wwfHttpResponse.getOutputStream();
        try {
            outputStream.write(responseInfo.getBytes());
            outputStream.flush();
            outputStream.close();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public void dopost(WwfHttpRequest wwfHttpRequest, WwfHttpResponse wwfHttpResponse) {
        doget(wwfHttpRequest, wwfHttpResponse);
    }
}

Tomcat-Thread线程类 

package thread;

import servlet.WwfHttpRequest;
import servlet.WwfHttpResponse;
import servlet.WwfCalServlet;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

/**
 * ClassName: TomcatV4THread
 * Package: thread
 * Description:
 *
 * @Author 王文福
 * @Create 2024/1/11 0:39
 * @Version 1.0
 */
public class TomcatV4Thread implements Runnable {
    private Socket socket;

    public TomcatV4Thread(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {

        try {
            //1.得到字节流和输出流
            InputStream inputStream = socket.getInputStream();
            OutputStream outputStream = socket.getOutputStream();
            //2.得到HttpRequest对象和HttpResponse对象
            WwfHttpRequest wwfHttpRequest = new WwfHttpRequest(inputStream);
            WwfHttpResponse wwfHttpResponse = new WwfHttpResponse(outputStream);
            //3.调用WwfCalServlet对象的doget方法
            WwfCalServlet wwfCalServlet = new WwfCalServlet();
            //写死的，如果需要动态的调用，需要使用反射+xml
            wwfCalServlet.doget(wwfHttpRequest, wwfHttpResponse);
            inputStream.close();
            socket.close();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

TomcatV5版本-XML+反射+容器

TomcatV5

package tomcat;

import servlet.WwfHttpServlet;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import thread.TomcatV5Thread;

import java.io.File;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;

/**
 * ClassName: TomcatV5
 * Package: tomcat
 * Description:
 * 使用反射+xml+容器模拟Tomcat的调用
 *
 * @Author 王文福
 * @Create 2024/1/11 1:17
 * @Version 1.0
 */
public class TomcatV5 {
    public static void main(String[] args) {
        new TomcatV5().init();//初始化容器
        new TomcatV5().run();//启动线程
    }
    //使用xml+反射+容器
//1.Web.xml标签中的子标签是通过HashMMap集合存放的
// servlet标签            key:servlet-name  value:servlet-class:该类重写了service方法
// servlet-Mapping标签    key:url-pattern， value:servlet-name
//且url-pattern标签与浏览器的url地址相同
//2.定义两个HashMap容器,使用dom4-j得到Web.xml中的子标签的数据，并将该数据通过键值对的方式存入到容器中

//3.在Socket线程对象中，通过得到HttpRequest封装的对象就可以得到url地址，并通过地址容器，得到Servlet-name的值
//  通过Servlet-name的值，就可以在类容器得到反射后的实例对象，通过该对象调用service方法
//service中会根据动态绑定机制调用继承了WwfHttpServlet类的子类的doget方法/dopost方法

    public static ConcurrentHashMap<String, String> servletURLMapping = new ConcurrentHashMap<>();

    public static ConcurrentHashMap<String, WwfHttpServlet> servletClassMapping = new ConcurrentHashMap<>();

    public void run() {
        int port = 8080;
        try {
            ServerSocket serverSocket = new ServerSocket(port);
            System.out.println("正在监听" + port + "端口......");
            while (!serverSocket.isClosed()) {
                //请求成功
                Socket socket = serverSocket.accept();
                //启动线程
                TomcatV5Thread tomcatV5 = new TomcatV5Thread(socket);
                new Thread(tomcatV5).start();
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    public void init() {
        //得到Target/classes路径
        String path = TomcatV5.class.getResource("/").getPath();
        System.out.println("path=" + path);
        SAXReader saxReader = new SAXReader();
        try {
            ///得到Target/classes路径/Web.xml路径
            Document document = saxReader.read(new File(path + "web.xml"));
            System.out.println("document=" + document);
            //根节点
            Element rootElement = document.getRootElement();
            //所有子节点
            List<Element> elements = rootElement.elements();
            //循环遍历，通过equals方法匹配
            for (Element element : elements) {
                if ("servlet".equals(element.getName())) {
                    //得到子标签
                    Element servletName = element.element("servlet-name");
                    Element servletClass = element.element("servlet-class");
                    //添加到类容器中
                    servletClassMapping.put(servletName.getText().trim(),
                            (WwfHttpServlet) Class.forName(servletClass.getText().trim()).newInstance());
                }
                if ("servlet-mapping".equals(element.getName())) {
                    //得到子标签
                    Element urlPattern = element.element("url-pattern");
                    Element servletName = element.element("servlet-name");
                    //添加地址容器中
                    servletURLMapping.put(urlPattern.getText().trim(), servletName.getText().trim());
                }
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        System.out.println(servletURLMapping);
        System.out.println(servletClassMapping);
    }

}

Thread线程 

package thread;

import servlet.WwfHttpRequest;
import servlet.WwfHttpResponse;
import servlet.WwfHttpServlet;
import tomcat.TomcatV5;

import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.sql.SQLOutput;

/**
 * ClassName: TomcatV5Thread
 * Package: thread
 * Description:
 *
 * @Author 王文福
 * @Create 2024/1/11 1:19
 * @Version 1.0
 */
public class TomcatV5Thread implements Runnable {
    private Socket socket;

    public TomcatV5Thread(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {

        //1.得到request方法
        //2.得到response方法
        WwfHttpRequest httpRequest = null;
        WwfHttpResponse httpResponse = null;
        try {
            httpRequest = new WwfHttpRequest(socket.getInputStream());
            httpResponse = new WwfHttpResponse(socket.getOutputStream());
            //得到url地址
            String url = httpRequest.getUrl();

            //根据地址，查找Servlet-name
            String servletName = TomcatV5.servletURLMapping.get(url);
            if (servletName == null) {
                servletName = ""; //如果输入的地址不正确，则servletName返回的是null
            }
            //根据Servlet-name，得到实例对象
            WwfHttpServlet httpServlet = TomcatV5.servletClassMapping.get(servletName);

            //得到的实例不为空
            if (httpServlet != null) {
                httpServlet.service(httpRequest, httpResponse);
            } else {
                //响应数据
                String responseInfo = WwfHttpResponse.HEADER + "<h1>NOT FOUND 404</h1>";
                OutputStream outputStream = httpResponse.getOutputStream();
                outputStream.write(responseInfo.getBytes());
                outputStream.flush();
                outputStream.close();
            }

            socket.close();
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}

 封装Response

package com.hspedu.tomcat.http;

/**
 * @author 韩顺平
 * @version 1.0
 */

import java.io.OutputStream;

/**
 * 老师解读
 * 1. HspResponse对象可以封装OutputStream(是socket关联)
 * 2. 即可以通过 HspResponse对象 返回Http响应给浏览器/客户端
 * 3. HspResponse对象 的作用等价于原生的servlet的 HttpServletResponse
 */
public class HspResponse {

    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";

    //说明同学们如果有兴趣, 在编写更多的方法
    //比如 setContentType

    //在创建 HspResponse 对象时，传入的outputStream是和Socket关联的
    public HspResponse(OutputStream outputStream) {
        this.outputStream = outputStream;
    }
    //当我们需要给浏览器返回数据时，可以通过HspResponse 的输出流完成
    //
    public OutputStream getOutputStream() {  
        return outputStream;
    }
}

 

封装Request

package servlet;

import java.io.*;
import java.util.concurrent.ConcurrentHashMap;

/**
 * ClassName: HttpRequest
 * Package: Servlet
 * Description:
 * 解析Socket对象传入的字节流(http信息)
 *
 * @Author 王文福
 * @Create 2024/1/10 22:49
 * @Version 1.0
 */
public class WwfHttpRequest {
    //1.字节流对象
    private InputStream inputStream = null;

    public WwfHttpRequest(InputStream inputStream) {
        this.inputStream = inputStream;
        init(); //初始化构造器的时候调用
    }

//    public HttpRequest() {
//        System.out.println("执行了init方法");
//        init(); //初始化构造器的时候调用
//    }

    //2.请求的方式
    private String method;
    //3.请求的url地址
    private String url;
    //4.请求的形参列表，key：参数 value:值
    private ConcurrentHashMap<String, String> parameterList = new ConcurrentHashMap<>();

    //定义方法-通key，得到value
    public String getParams(String name) {
        if (parameterList.containsKey(name)) { //判断该键是否存在
            return parameterList.get(name);
        } else {
            return "";
        }
    }

    //定义1个初始化方法，解析InputStream对象
    public void init() {
        try {
            //1.将字节流转换为字符流
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream, "utf-8"));
            //2.读取第1行
            String readLine = bufferedReader.readLine();
            //3.使用空格分割
            String[] readLineArr = readLine.split(" ");
            this.method = readLineArr[0];//请求的方法
            //得到url地址
            //1。查找当前是否存在地址是否存在参数
            String url = readLineArr[1];//局部变量的url
            //查找?出现的位置
            int index = url.indexOf("?");
            if (index == -1) { //没有找到?，则表示当前url不带参数
                this.url = url; //直接赋值
            } else { //带? /localhost?name = 10 & age = 20;
                this.url = url.substring(0, index);
                //得到形参列表[username=10&password=20]
                String parameterList = url.substring(index + 1);
                //根据&分割[username=10,password=20]
                String[] parameterVal = parameterList.split("&");
                if ((parameterVal != null && !"".equals(parameterVal))) { //tomcat?
                    for (String parameters : parameterVal) {
                        //根据=分割[username,10]
                        String[] parameter = parameters.split("=");
                        if (parameter.length == 2) { //数组长度==2
                            //将形参名，和形参值添加进HashMap集合
                            this.parameterList.put(parameter[0], parameter[1]);
                        }
                    }
                }
            }
//            System.out.println(Arrays.toString(readLineArr));
//            System.out.println(this.url);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    public String getMethod() {
        return method;
    }

    public void setMethod(String method) {
        this.method = method;
    }

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }
}

 声明Servlet接口

package servlet;

import java.io.IOException;

/**
 * ClassName: Servlet
 * Package: Servlet
 * Description:
 *
 * @Author 王文福
 * @Create 2024/1/11 0:10
 * @Version 1.0
 */
public interface WwfServlet {
    public void init() throws Exception; //初始化方法

    //核心的方法service,通过反射调用
    public void service(WwfHttpRequest requset, WwfHttpResponse response)
            throws IOException;


    public void destroy(); //Servlet销毁的方法，服务器重启、重新发布web项目，强制停止项目
}

声明HttpServlet抽象方法

package servlet;

import java.io.IOException;

/**
 * ClassName: wwfHttpServlet
 * Package: Servlet
 * Description:
 *
 * @Author 王文福
 * @Create 2024/1/11 0:16
 * @Version 1.0
 */
public abstract class WwfHttpServlet implements WwfServlet {
    @Override
    public void init() throws Exception {

    }

    @Override
    public void service(WwfHttpRequest request, WwfHttpResponse response) throws IOException {
        //模板设计模式
        if ("GET".equalsIgnoreCase(request.getMethod())) {
            this.doget(request, response);
        } else if ("POST".equalsIgnoreCase(request.getMethod())) {
            this.dopost(request, response);
        }
    }

    //定义两个抽象方法，请求方法
    public abstract void doget(WwfHttpRequest wwfHttpRequest, WwfHttpResponse wwfHttpResponse);

    public abstract void dopost(WwfHttpRequest wwfHttpRequest, WwfHttpResponse wwfHttpResponse);

    @Override
    public void destroy() {

    }
}

 

继承了HttpServlet的子类对象

package servlet;

import utils.WebUtils;

import java.io.IOException;
import java.io.OutputStream;

/**
 * ClassName: WwfCalServlet
 * Package: Servlet
 * Description:
 *
 * @Author 王文福
 * @Create 2024/1/11 0:21
 * @Version 1.0
 */
public class WwfCalServlet extends WwfHttpServlet {

    @Override
    public void doget(WwfHttpRequest wwfHttpRequest, WwfHttpResponse wwfHttpResponse) {
        //1.通过httpRequest得到形参列表
        String num1 = wwfHttpRequest.getParams("num1");
        String num2 = wwfHttpRequest.getParams("num2");
        System.out.println("num1的值=" + num1);
        System.out.println("num2的值=" + num2);
        //2.将得到的字符传为整型
        int number1 = WebUtils.stringParseNumber(num1, 0);
        int number2 = WebUtils.stringParseNumber(num2, 0);
        //3。将number1和number2的结果响应给浏览器
        String responseInfo = WwfHttpResponse.HEADER + "<h1>" + (number1 + "+" + number2 + "=" + (number1 + number2)) + "</h1>";
        //得到输出流
        OutputStream outputStream = wwfHttpResponse.getOutputStream();
        try {
            outputStream.write(responseInfo.getBytes());
            outputStream.flush();
            outputStream.close();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public void dopost(WwfHttpRequest wwfHttpRequest, WwfHttpResponse wwfHttpResponse) {
        doget(wwfHttpRequest, wwfHttpResponse);
    }
}