技术教程 编程教程 day03-实现02 正文

day03-实现02

2023-02-16

实现02

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

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，回车，浏览器显示如下：

3.4容器设计

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

一个问题：Servlet应该在哪里被实例化，以及如何去管理呢？

思路：

将来的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容器实现

    首先在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拷贝修改即可。所有报红都忽略

    注意在pom.xml文件中导入dom4j的jar包：
<!--导入dom4j-->

<dependency>

    <groupId>dom4j</groupId>

    <artifactId>dom4j</artifactId>

    <version>1.1</version>

</dependency>

    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类中增加提示信息：

其他类保持不变

3.4.2测试

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

浏览器显示如下：

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

后台输出：

4.练习

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

练习

思路：在线程类中，拿到浏览器请求的uri的时候，增加新的业务逻辑：

(1)判断uri是什么资源

(2)如果是静态资源，就读取该资源，并返回给浏览器（注意设置Content-Type text/html）

(3)因为是自定义的tomcat，所以maven项目的target不会自动更新

(4)需要自己将静态文件等拷贝到该目录下，浏览器才能访问到(这里把读取的静态资源放到target/classes/下)

day03-实现02的相关教程结束。

《day03-实现02.doc》

下载本文的Word格式文档，以方便收藏与打印。

Copyright 2023. 昆居客 - IT编程,互联网信息技术文档大全!