实现02

3.实现任务阶段3-处理Servlet02

day03-实现02-小白菜博客

3.3Servlet规范设计

3.3.1MyServlet

该类模仿Servlet接口,为了简化,只声明了三个方法:init(),service(),destroy()

package com.li.MyTomcat.servlet;

import com.li.MyTomcat.http.MyRequest;
import com.li.MyTomcat.http.MyResponse;

import java.io.IOException;

/**
 * @author 李
 * @version 1.0
 * 只保留了三个核心的方法声明
 */
public interface MyServlet {
    void init() throws Exception;

    void service(MyRequest request, MyResponse response) throws IOException;

    void destroy();
}

3.3.2MyHttpServlet

该类实现MyServlet接口,并声明了doGet(),doPost()方法让MyHttpServlet的子类去实现

package com.li.MyTomcat.servlet;

import com.li.MyTomcat.http.MyRequest;
import com.li.MyTomcat.http.MyResponse;

import java.io.IOException;

/**
 * @author 李
 * @version 1.0
 */
public abstract class MyHttpServlet implements MyServlet {
    @Override
    public void service(MyRequest request, MyResponse response) throws IOException {
        //equalsIgnoreCase 比较字符串内容是否相同,不区分大小写
        if ("GET".equalsIgnoreCase(request.getMethod())) {
            //这里会有动态绑定
            this.doGet(request, response);

        } else if ("POST".equalsIgnoreCase(request.getMethod())) {
            //这里会有动态绑定
            this.doPost(request, response);
        }
    }

    //这里我们使用一个模板设计模式
    //让MyHttpServlet的子类去实现
    public abstract void doGet(MyRequest request, MyResponse response);

    public abstract void doPost(MyRequest request, MyResponse response);
}

3.3.3MyCalServlet

业务类servlet

package com.li.MyTomcat.servlet;

import com.li.MyTomcat.http.MyRequest;
import com.li.MyTomcat.http.MyResponse;
import com.li.MyTomcat.utils.WebUtils;

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

/**
 * @author 李
 * @version 1.0
 */
public class MyCalServlet extends MyHttpServlet {
    @Override
    public void doGet(MyRequest request, MyResponse response) {
        //动态绑定机制,每次调用doGet方法都会执行service方法

        //业务代码
        //完成计算任务
        int num1 = WebUtils.parseInt(request.getParameter("num1"), 0);
        int num2 = WebUtils.parseInt(request.getParameter("num2"), 0);
        int sum = num1 + num2;
        //返回结算结果给浏览器
        //outputStream和当前连接的socket关联
        OutputStream outputStream = response.getOutputStream();
        String respMes = MyResponse.respHeader + "<h1>" + num1 + "+" + num2 + "=" + sum + "</h1>";
        try {
            outputStream.write(respMes.getBytes());
            outputStream.flush();
            outputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void doPost(MyRequest request, MyResponse response) {
        doGet(request, response);
    }

    @Override
    public void init() throws Exception {}

    @Override
    public void destroy() {}
}

3.3.4WebUtils

该类为工具类,供MyCalServlet使用

package com.li.MyTomcat.utils;

public class WebUtils {
    public static int parseInt(String str, int defaultVal) {
        try {
            return Integer.parseInt(str);
        } catch (NumberFormatException e) {
            System.out.println(str + " 不能转成数字");
        }
        return defaultVal;
    }
}

3.3.5RequestHandler

修改RequestHandler类(线程类),如下:

package com.li.MyTomcat.hander;

import com.li.MyTomcat.http.MyRequest;
import com.li.MyTomcat.http.MyResponse;
import com.li.MyTomcat.servlet.MyCalServlet;

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

            //这里我们可以通过myResponse对象返回数据给客户端
            MyResponse myResponse = new MyResponse(socket.getOutputStream());
            //创建MyCalServlet对象(之后再用反射来构建对象,而不是new)
            MyCalServlet myCalServlet = new MyCalServlet();
            //之后再用反射来调用方法
            myCalServlet.doGet(myRequest, myResponse);

            inputStream.close();
            socket.close();

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //一定要确保socket关闭
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

MyTomcatV2类不变

3.3.6测试

运行MyTomcatV2,在浏览器中输入地址http://localhost:8080/myCalServlet?num1=100&num2=200,回车,浏览器显示如下:

day03-实现02-小白菜博客

3.4容器设计

day03-实现02-小白菜博客

在上面的线程类RequestHandler中,我们是通过new来创建一个 实现了Servlet接口 的对象,但是实际的tomcat是反射来实例化该对象的。

一个问题:Servlet应该在哪里被实例化,以及如何去管理呢?

思路:

day03-实现02-小白菜博客

将来的Servlet会很多,我们不可能去到MyTomcat源码里面去修改,应该用web.xml文件去配置Servlet

为了管理,应该创建两个容器(使用HashMap或ConcurrentHashMap)

一个容器(ServletMapping)存放 :HashMap<ServletName,对应的实例>

另一个容器(ServletUrlMapping)存放:HashMap<url-pattern,ServletName>

当浏览器发送请求,我们获取该请求的uri部分,去容器ServletUrlMapping里面去查该uri,如果有,通过该uri获取对应的ServletName。然后到另一个容器ServletMapping,根据ServletName去找对应的反射对象的实例,然后再去调用它。

3.4.1容器实现

  1. 首先在web.xml文件中配置自己设计的Servlet
<!--配置自己设计的Servlet-->
<servlet>
    <servlet-name>MyCalServlet</servlet-name>
    <!--忽略报错-->
    <servlet-class>com.li.MyTomcat.servlet.MyCalServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>MyCalServlet</servlet-name>
    <url-pattern>/myCalServlet</url-pattern>
</servlet-mapping>

注意:<servlet-class>这里会报错,因为非原生的servlet,xml不会识别,我们忽l略报错即。

记得在target\classes目录手动拷贝一份web.xml [默认是自动拷贝,这里不是原生tomcat,因此不会自动拷贝],配置信息可以从上一个项目web.xml拷贝修改即可。所有报红都忽略

day03-实现02-小白菜博客
  1. 注意在pom.xml文件中导入dom4j的jar包:
<!--导入dom4j-->
<dependency>
    <groupId>dom4j</groupId>
    <artifactId>dom4j</artifactId>
    <version>1.1</version>
</dependency>
day03-实现02-小白菜博客
  1. MyTomcatV3
package com.li.MyTomcat;

import com.li.MyTomcat.hander.RequestHandler;
import com.li.MyTomcat.servlet.MyHttpServlet;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

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;

/**
 * @author 李
 * @version 3.0
 * 第三版MyTomcat,实现通过xml和反射来初始化容器
 * (这里设置为一启动MyTomcat就实例化servlet)
 */
public class MyTomcatV3 {
    //1.容器 ServletMapping 存放 ConcurrentHashMap<ServletName,对应的实例>
    public static final ConcurrentHashMap<String, MyHttpServlet>
            servletMapping = new ConcurrentHashMap<>();

    //2.容器 ServletUrlMapping 存放 ConcurrentHashMap<url-pattern,ServletName>
    public static final ConcurrentHashMap<String, String>
            servletUrlMapping = new ConcurrentHashMap<>();

    public static void main(String[] args) {
        MyTomcatV3 myTomcatV3 = new MyTomcatV3();
        myTomcatV3.init();
        //启动MyTomcatV3容器
        myTomcatV3.run();
    }

    //启动MyTomcatV3容器
    public void run() {
        try {
            ServerSocket serverSocket = new ServerSocket(8080);
            System.out.println("=====MyTomcatV3在8080监听=====");
            while (!serverSocket.isClosed()) {
                Socket socket = serverSocket.accept();
                RequestHandler requestHandler = new RequestHandler(socket);
                new Thread(requestHandler).start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //直接对两个容器进行初始化
    public void init() {
        //读取web.xml文件 => dom4j(注意导jar包)

        //path=/D:/IDEA-workspace/li_tomcat/target/classes/
        String path = MyTomcatV3.class.getResource("/").getPath();

        //使用dom4j技术完成web.xml文件的读取
        SAXReader reader = new SAXReader();
        try {
            Document document = reader.read(new File(path + "web.xml"));
            //得到根元素
            Element rootElement = document.getRootElement();
            //得到根节点下面的所有元素
            List<Element> elements = rootElement.elements();
            //遍历并过滤到servlet和servlet-mapping
            for (Element element : elements) {
                //如果元素为servlet
                if ("servlet".equalsIgnoreCase(element.getName())) {
                    //这是一个servlet配置
                    //System.out.println("发现servlet");
                    //使用反射将该servlet实例放入到容器servletMapping中
                    String servletName = element.element("servlet-name").getText().trim();
                    String servletClass = element.element("servlet-class").getText().trim();
                    servletMapping.put(servletName,
                            (MyHttpServlet) Class.forName(servletClass).newInstance());

                } else if ("servlet-mapping".equalsIgnoreCase(element.getName())) {
                    //如果元素为servlet-mapping
                    //System.out.println("发现servlet-mapping");
                    String servletName = element.element("servlet-name").getText().trim();
                    String urlPattern = element.element("url-pattern").getText().trim();
                    //将uri对应的servletName放入容器servletUrlMapping中
                    servletUrlMapping.put(urlPattern, servletName);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

修改RequestHandler:

package com.li.MyTomcat.hander;

import com.li.MyTomcat.MyTomcatV3;
import com.li.MyTomcat.http.MyRequest;
import com.li.MyTomcat.http.MyResponse;
import com.li.MyTomcat.servlet.MyHttpServlet;

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());

            MyRequest myRequest = new MyRequest(socket.getInputStream());

            //这里我们可以通过myResponse对象返回数据给客户端
            MyResponse myResponse = new MyResponse(socket.getOutputStream());

            //得到浏览器发送的http的uri,作为key,去查找容器里该servletName
            //然后去另一容器里找实例,如有就调用,如果没有就返回404
            //1.得到uri=>就是servletUrlMapping的ur-pattern
            String uri = myRequest.getUri();
            String servletName = MyTomcatV3.servletUrlMapping.get(uri);
            if (servletName == null) {
                servletName = "";
            }
            //2.通过uri->servletName->servlet的实例
            //注意:这里myHttpServlet的编译类型是MyHttpServlet,但是运行类型是MyHttpServlet的子类
            MyHttpServlet myHttpServlet = MyTomcatV3.servletMapping.get(servletName);
            //3.调用service方法,通过动态绑定机制,调用运行类型的doGet或doPost方法
            if (myHttpServlet != null) {//如果找到到该servlet了
                myHttpServlet.service(myRequest, myResponse);
            } else {
                //没有这个servlet,返回404
                String resp = MyResponse.respHeader + "<h1>404 Not Found</h1>";
                OutputStream outputStream = myResponse.getOutputStream();
                outputStream.write(resp.getBytes());
                outputStream.flush();
                outputStream.close();
            }

            socket.close();

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //一定要确保socket关闭
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

为了测试,在MyCalServlet类中增加提示信息:

day03-实现02-小白菜博客

其他类保持不变

3.4.2测试

运行MyTomcatV3,在浏览器输入 http://localhost:8080/myCalServlet?num1=99&num2=1

浏览器显示如下:

day03-实现02-小白菜博客

在地址栏中输入不存在的资源,返回404NotFound

day03-实现02-小白菜博客

后台输出:

day03-实现02-小白菜博客

4.练习

分析html等静态资源,完成通过页面提交数据进行计算,浏览器请求 http://localhost:8080/hspCalServlet, 提交数据,完成计算任务,如果该servlet 不存在,返回 404

day03-实现02-小白菜博客
day03-实现02-小白菜博客
day03-实现02-小白菜博客

思路:在线程类中,拿到浏览器请求的uri的时候,增加新的业务逻辑:
(1)判断uri是什么资源
(2)如果是静态资源,就读取该资源,并返回给浏览器(注意设置Content-Type text/html)
(3)因为是自定义的tomcat,所以maven项目的target不会自动更新
(4)需要自己将静态文件等拷贝到该目录下,浏览器才能访问到(这里把读取的静态资源放到target/classes/下)

练习

  1. 读取的静态资源放到target/classes/下-cal.html:
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>计算器</title>
</head>
<body>
<h1>计算器</h1>
<form action="/myCalServlet" method="get">
    num1:<input type="text" name="num1"/><br/>
    num2:<input type="text" name="num2"/><br/>
    <input type="submit" value="提交">
</form>
</body>
</html>
day03-实现02-小白菜博客
  1. 在工具类中增加如下方法
//1.判断uri是不是html文件
public static boolean isHtml(String uri) {
    //endsWith() 方法用于测试字符串是否以指定的后缀结束
    return uri.endsWith(".html");
}

//2.根据文件名来读取该文件-->String
public static String readHtml(String fileName) {
    ////path为程序实际运行的根目录
    //path=/D:/IDEA-workspace/li_tomcat/target/classes/
    String path = WebUtils.class.getResource("/").getPath();
    //使用StringBuilder,便于对字符串的追加
    StringBuilder stringBuilder = new StringBuilder();
    try {
        BufferedReader bufferedReader =
                new BufferedReader(new FileReader(path + fileName));
        //读取文件
        String buff = "";
        while ((buff = bufferedReader.readLine()) != null) {
            stringBuilder.append(buff);
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
    return stringBuilder.toString();
}
  1. 在线程类中的run方法中,在容器中寻找servlet前,先使用浏览器请求的uri在目录下寻找静态资源,如果有就返回,并且结束线程
if (WebUtils.isHtml(uri)) {//如果是静态资源
    String context = WebUtils.readHtml(uri.substring(1));//uri最后的/要拿掉
    //得到outputstream,返回信息给浏览器
    String resp = MyResponse.respHeader + context;
    OutputStream outputStream = myResponse.getOutputStream();
    outputStream.write(resp.getBytes());
    outputStream.flush();
    outputStream.close();
    socket.close();
    return;//结束run方法运行,这之前先关闭socket
}
  1. 测试

    在浏览器中输入http://localhost:8080/cal.html,显示访问资源成功

    day03-实现02-小白菜博客

    输入数据,点击提交,成功访问到对应的servlet资源

    day03-实现02-小白菜博客